org.deeplearning4j.berkeley

Class Counter<E>

java.lang.Object

org.deeplearning4j.berkeley.Counter<E>

All Implemented Interfaces:

Serializable

public class Counter<E>
extends Object
implements Serializable

A map from objects to doubles. Includes convenience methods for getting, setting, and incrementing element counts. Objects not in the counter will return a count of zero. The counter is backed by a HashMap (unless specified otherwise with the MapFactory constructor).

Author:

Dan Klein

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
Counter()
Counter(boolean identityHashMap)
Counter(Collection<? extends E> collection)
Counter(Counter<? extends E> counter)
Counter(Map<? extends E,Double> mapCounts)
Counter(MapFactory<E,Double> mf)

Method Summary

Methods

Modifier and Type	Method and Description
boolean	approxEquals(Counter<E> other, double tol)
E	argMax() Finds the key with maximum count.
PriorityQueue<E>	asMinPriorityQueue() Warning: all priorities are the negative of their counts in the counter here
PriorityQueue<E>	asPriorityQueue() Builds a priority queue whose elements are the counter's elements, and whose priorities are those elements' counts in the counter.
void	clear()
boolean	containsKey(E key) Returns whether the counter contains the given key.
Counter<E>	difference(Counter<E> counter)
double	dotProduct(Counter<E> other)
Set<Map.Entry<E,Double>>	entrySet()
double	getCount(E key) Get the count of the element, or zero if the element is not in the counter.
double	getDeflt()
Set<Map.Entry<E,Double>>	getEntrySet()
double	getProbability(E key) I know, I know, this should be wrapped in a Distribution class, but it's such a common use...why not.
List<E>	getSortedKeys()
void	incrementAll(Collection<? extends E> collection, double count) Increment each element in a given collection by a given amount.
<T extends E> void	incrementAll(Counter<T> counter)
double	incrementCount(E key, double increment) Increment a key's count by the given amount.
boolean	isEmpty() True if there are no entries in the counter (false does not mean totalCount > 0)
boolean	isEqualTo(Counter<E> counter)
void	keepBottomNKeys(int keepN)
void	keepTopNKeys(int keepN)
Set<E>	keySet() The elements in the counter.
static void	main(String[] args)
double	max()
double	min()
void	normalize() Destructively normalize this Counter in place.
void	pruneKeysBelowThreshold(double cutoff)
void	put(E key, double count, boolean keepHigher) Set the count for the given key if it is larger than the previous one;
void	removeKey(E key)
protected void	removeKeyFromEntries(E key)
E	sample() Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0
E	sample(Random rand) Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0
void	scale(double c)
Counter<E>	scaledClone(double c)
void	setAllCounts(double val) Sets all counts to the given value, but does not remove any keys
void	setCount(E key, double count) Set the count for the given key, clobbering any previous count.
void	setDeflt(double deflt)
void	setDirty(boolean dirty)
void	setMaxCount(E key, double val) Set's the key's count to the maximum of the current count and val.
void	setMinCount(E key, double val) Set's the key's count to the minimum of the current count and val.
int	size() The number of entries in the counter (not the total count -- use totalCount() instead).
Counter<E>	toLogSpace()
String	toString() Returns a string representation with the keys ordered by decreasing counts.
String	toString(int maxKeysToPrint) Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts.
String	toString(int maxKeysToPrint, boolean multiline) Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts and optionally prints one element per line.
String	toStringSortedByKeys()
String	toStringTabSeparated()
double	totalCount() Finds the total of all counts in the counter.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Counter

public Counter()

Counter

public Counter(boolean identityHashMap)

Counter

public Counter(MapFactory<E,Double> mf)

Counter

public Counter(Map<? extends E,Double> mapCounts)

Counter

public Counter(Counter<? extends E> counter)

Counter

public Counter(Collection<? extends E> collection)

Method Detail

getDeflt

public double getDeflt()

setDeflt

public void setDeflt(double deflt)

keySet

public Set<E> keySet()

The elements in the counter.

Returns:

set of keys

entrySet

public Set<Map.Entry<E,Double>> entrySet()

size

public int size()

The number of entries in the counter (not the total count -- use totalCount() instead).

isEmpty

public boolean isEmpty()

True if there are no entries in the counter (false does not mean totalCount > 0)

containsKey

public boolean containsKey(E key)

Returns whether the counter contains the given key. Note that this is the way to distinguish keys which are in the counter with count zero, and those which are not in the counter (and will therefore return count zero from getCount().

Parameters:

key -

Returns:

whether the counter contains the key

getCount

public double getCount(E key)

Get the count of the element, or zero if the element is not in the counter.

Parameters:

key -

Returns:

getProbability

public double getProbability(E key)

I know, I know, this should be wrapped in a Distribution class, but it's such a common use...why not. Returns the MLE prob. Assumes all the counts are >= 0.0 and totalCount > 0.0. If the latter is false, return 0.0 (i.e. 0/0 == 0)

Parameters:

key -

Returns:

MLE prob of the key

normalize

public void normalize()

Destructively normalize this Counter in place.

setCount

public void setCount(E key,
            double count)

Set the count for the given key, clobbering any previous count.

Parameters:

key -

count -

put

public void put(E key,
       double count,
       boolean keepHigher)

Set the count for the given key if it is larger than the previous one;

Parameters:

key -

count -

sample

public E sample(Random rand)

Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0

Returns:

sample

public E sample()

Will return a sample from the counter, will throw exception if any of the counts are < 0.0 or if the totalCount() <= 0.0

Returns:

removeKey

public void removeKey(E key)

removeKeyFromEntries

protected void removeKeyFromEntries(E key)

Parameters:

key -

setMaxCount

public void setMaxCount(E key,
               double val)

Set's the key's count to the maximum of the current count and val. Always sets to val if key is not yet present.

Parameters:

key -

increment -

setMinCount

public void setMinCount(E key,
               double val)

Set's the key's count to the minimum of the current count and val. Always sets to val if key is not yet present.

Parameters:

key -

increment -

incrementCount

public double incrementCount(E key,
                    double increment)

Increment a key's count by the given amount.

Parameters:

key -

increment -

incrementAll

public void incrementAll(Collection<? extends E> collection,
                double count)

Increment each element in a given collection by a given amount.

incrementAll

public <T extends E> void incrementAll(Counter<T> counter)

totalCount

public double totalCount()

Finds the total of all counts in the counter. This implementation iterates through the entire counter every time this method is called.

Returns:

the counter's total

getSortedKeys

public List<E> getSortedKeys()

argMax

public E argMax()

Finds the key with maximum count. This is a linear operation, and ties are broken arbitrarily.

Returns:

a key with minumum count

min

public double min()

max

public double max()

toString

public String toString()

Returns a string representation with the keys ordered by decreasing counts.

Overrides:

toString in class Object

Returns:

string representation

toStringSortedByKeys

public String toStringSortedByKeys()

toString

public String toString(int maxKeysToPrint)

Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts.

Parameters:

maxKeysToPrint -

Returns:

partial string representation

toString

public String toString(int maxKeysToPrint,
              boolean multiline)

Returns a string representation which includes no more than the maxKeysToPrint elements with largest counts and optionally prints one element per line.

Parameters:

maxKeysToPrint -

Returns:

partial string representation

asPriorityQueue

public PriorityQueue<E> asPriorityQueue()

Builds a priority queue whose elements are the counter's elements, and whose priorities are those elements' counts in the counter.

asMinPriorityQueue

public PriorityQueue<E> asMinPriorityQueue()

Warning: all priorities are the negative of their counts in the counter here

Returns:

pruneKeysBelowThreshold

public void pruneKeysBelowThreshold(double cutoff)

getEntrySet

public Set<Map.Entry<E,Double>> getEntrySet()

isEqualTo

public boolean isEqualTo(Counter<E> counter)

main

public static void main(String[] args)

clear

public void clear()

keepTopNKeys

public void keepTopNKeys(int keepN)

keepBottomNKeys

public void keepBottomNKeys(int keepN)

setAllCounts

public void setAllCounts(double val)

Sets all counts to the given value, but does not remove any keys

dotProduct

public double dotProduct(Counter<E> other)

scale

public void scale(double c)

scaledClone

public Counter<E> scaledClone(double c)

difference

public Counter<E> difference(Counter<E> counter)

toLogSpace

public Counter<E> toLogSpace()

approxEquals

public boolean approxEquals(Counter<E> other,
                   double tol)

setDirty

public void setDirty(boolean dirty)

toStringTabSeparated

public String toStringTabSeparated()