class Counter(dict): """ A counter keeps track of counts for a set of keys. The counter class is an extension of the standard python dictionary type. It is specialized to have number values (integers or floats), and includes a handful of additional functions to ease the task of counting data. In particular, all keys are defaulted to have value 0. Using a dictionary: a = {} print a['test'] would give an error, while the Counter class analogue: >>> a = Counter() >>> print a.getCount('test') 0 returns the default 0 value. Note that to reference a key that you know is contained in the counter, you can still use the dictionary syntax: >>> a = Counter() >>> a['test'] = 2 >>> print a['test'] 2 The counter also includes additional functionality useful in implementing the classifiers for this assignment. Two counters can be added, subtracted or multiplied together. See below for details. They can also be normalized and their total count and arg max can be extracted. """ def incrementCount(self, key, count): """ Increases the count of key by the specified count. If the counter does not contain the key, then the count for key will be set to count. Return the counter as well. >>> a = Counter() >>> a.incrementCount('test', 1) >>> a.getCount('hello') 0 >>> a.getCount('test') 1 """ if key in self: self[key] += count else: self[key] = count return self def incrementAll(self, keys, count): """ Increments all elements of keys by the same count. Return the counter as well. >>> a = Counter() >>> a.incrementAll(['one','two', 'three'], 1) >>> a.getCount('one') 1 >>> a.getCount('two') 1 """ for key in keys: self.incrementCount(key, count) return self def setCount(self, key, count): """ Sets the count of key to the specified count and return the counter. """ self[key] = count return self def getCount(self, key): """ Returns the count of key, defaulting to zero. >>> a = Counter() >>> print a.getCount('test') 0 >>> a['test'] = 2 >>> print a.getCount('test') 2 """ if key in self: return self[key] else: return 0 def argMax(self): """ Returns the key with the highest value. """ all = self.items() values = [x[1] for x in all] maxIndex = values.index(max(values)) return all[maxIndex][0] def sortedKeys(self): """ Returns a list of keys sorted by their values. Keys with the highest values will appear first. >>> a = Counter() >>> a['first'] = -2 >>> a['second'] = 4 >>> a['third'] = 1 >>> a.sortedKeys() ['second', 'third', 'first'] """ sortedItems = self.items() compare = lambda x, y: sign(y[1] - x[1]) sortedItems.sort(cmp=compare) return [x[0] for x in sortedItems] def totalCount(self): """ Returns the sum of counts for all keys. """ return sum(self.values()) def normalize(self): """ Edits the counter such that the total count of all keys sums to 1. The ratio of counts for all keys will remain the same. Note that normalizing an empty Counter will result in an error. Return the counter as well. """ total = float(self.totalCount()) for key in self.keys(): self[key] = self[key] / total return self def multiplyAll(self, multiplier): """ Multiply all counts by multiplier in place and return counter. """ multiplier = float(multiplier) for key in self: self[key] *= multiplier return self def divideAll(self, divisor): """ Divides all counts by divisor in-place and return counter. """ divisor = float(divisor) for key in self: self[key] /= divisor return self def componentwiseMultiply(self, counter): """ Return a new counter which is obtained by the componentwise multiplication of the two counters. """ result = Counter() for key in self: if not (key in counter): continue result[key] = self[key]*counter[key] return result def __mul__(self, y ): """ Multiplying two counters gives the dot product of their vectors where each unique label is a vector element. >>> a = Counter() >>> b = Counter() >>> a['first'] = -2 >>> a['second'] = 4 >>> b['first'] = 3 >>> b['second'] = 5 >>> a['third'] = 1.5 >>> a['fourth'] = 2.5 >>> a * b 14 """ sum = 0 for key in self: if not (key in y): continue sum += self[key] * y[key] return sum def __iadd__(self, y): """ Adding another counter to a counter increments the current counter by the values stored in the second counter. >>> a = Counter() >>> b = Counter() >>> a['first'] = -2 >>> a['second'] = 4 >>> b['first'] = 3 >>> b['third'] = 1 >>> a += b >>> a.getCount('first') 1 """ for key, value in y.items(): self.incrementCount(key, value) return self def __add__( self, y ): """ Adding two counters gives a counter with the union of all keys and counts of the second added to counts of the first. >>> a = Counter() >>> b = Counter() >>> a['first'] = -2 >>> a['second'] = 4 >>> b['first'] = 3 >>> b['third'] = 1 >>> (a + b).getCount('first') 1 """ addend = Counter() for key in self: if key in y: addend[key] = self[key] + y[key] else: addend[key] = self[key] for key in y: if key in self: continue addend[key] = y[key] return addend def __sub__( self, y ): """ Subtracting a counter from another gives a counter with the union of all keys and counts of the second subtracted from counts of the first. >>> a = Counter() >>> b = Counter() >>> a['first'] = -2 >>> a['second'] = 4 >>> b['first'] = 3 >>> b['third'] = 1 >>> (a - b).getCount('first') -5 """ addend = Counter() for key in self: if key in y: addend[key] = self[key] - y[key] else: addend[key] = self[key] for key in y: if key in self: continue addend[key] = -1 * y[key] return addend def sign( x ): """ Returns 1 or -1 depending on the sign of x """ if( x >= 0 ): return 1 else: return -1 def arrayInvert(array): """ Inverts a matrix stored as a list of lists. """ result = [[] for i in array] for outer in array: for inner in range(len(outer)): result[inner].append(outer[inner]) return result def pause(): """ Pauses the output stream awaiting user feedback. """ print "" raw_input() def _test(): import doctest doctest.testmod() # Test the interactive sessions in function comments if __name__ == "__main__": _test()