CounterMap

java.lang.Object
- org.deeplearning4j.berkeley.CounterMap<K,V>

All Implemented Interfaces:

java.io.Serializable
```
public class CounterMap<K,V>
extends java.lang.Object
implements java.io.Serializable
```
Maintains counts of (key, value) pairs. The map is structured so that for every key, one can getFromOrigin a counter over values. Example usage: keys might be words with values being POS tags, and the count being the number of occurences of that word/tag pair. The sub-counters returned by getCounter(word) would be count distributions over tags for that word.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface CounterMap.CountFunction<V>

Nested Classes
Modifier and Type	Class and Description
`static interface`	`CounterMap.CountFunction<V>`

Constructor Summary

Constructors
Constructor and Description
`CounterMap()`
`CounterMap(boolean identityHashMap)`
`CounterMap(CounterMap<K,V> cm)`
`CounterMap(MapFactory<K,Counter<V>> outerMF, MapFactory<V,java.lang.Double> innerMF)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Pair<K,V>`	`argMax()` Finds the key with maximum count.
`protected Counter<V>`	`buildCounter(MapFactory<V,java.lang.Double> mf)`
`boolean`	`containsKey(K key)`
`protected Counter<V>`	`ensureCounter(K key)`
`double`	`getCount(K key)` Gets the total count of the given key, or zero if that key is not present.
`double`	`getCount(K key, V value)` Gets the count of the given (key, value) entry, or zero if that entry is not present.
`Counter<V>`	`getCounter(K key)` Gets the sub-counter for the given key.
`java.util.Collection<Counter<V>>`	`getCounters()`
`java.util.Set<java.util.Map.Entry<K,Counter<V>>>`	`getEntrySet()`
`java.util.Iterator<Pair<K,V>>`	`getPairIterator()`
`void`	`incrementAll(CounterMap<K,V> cMap)`
`void`	`incrementAll(java.util.Map<K,V> map, double count)`
`void`	`incrementCount(K key, V value, double count)` Increments the count for a particular (key, value) pair.
`CounterMap<V,K>`	`invert()` Constructs reverse CounterMap where the count of a pair (k,v) is the count of (v,k) in the current CounterMap
`boolean`	`isEmpty()` True if there are no entries in the CounterMap (false does not mean totalCount > 0)
`boolean`	`isEqualTo(CounterMap<K,V> map)`
`java.util.Set<K>`	`keySet()` Returns the keys that have been inserted into this CounterMap.
`static void`	`main(java.lang.String[] args)`
`void`	`normalize()`
`void`	`normalizeWithDiscount(double discount)`
`static <K,V> CounterMap<K,V>`	`parallelCounterMap()` Returns a thread safe counter map
`void`	`removeKey(K oldIndex)`
`static <V> CounterMap<V,V>`	`runPairWise(java.util.List<V> items, CounterMap.CountFunction<V> countFunction)` Build a counter map by iterating pairwise over the list.
`void`	`scale(double scaleFactor)` Scale all entries in `CounterMap` by `scaleFactor`
`void`	`setCount(K key, V value, double count)` Sets the count for a particular (key, value) pair.
`void`	`setCounter(K newIndex, Counter<V> counter)`
`void`	`setDefault(double defltVal)`
`int`	`size()` The number of keys in this CounterMap (not the number of key-value entries -- use totalSize() for that)
`java.lang.String`	`toString()`
`java.lang.String`	`toString(java.util.Collection<java.lang.String> keyFilter)`
`java.lang.String`	`toString(int maxValsPerKey)`
`double`	`totalCount()` Returns the total of all counts in sub-counters.
`int`	`totalSize()` Returns the total number of (key, value) entries in the CounterMap (not their total counts).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - CounterMap
```
public CounterMap(CounterMap<K,V> cm)
```
  - CounterMap
```
public CounterMap()
```
  - CounterMap
```
public CounterMap(MapFactory<K,Counter<V>> outerMF,
                  MapFactory<V,java.lang.Double> innerMF)
```
  - CounterMap
```
public CounterMap(boolean identityHashMap)
```
- Method Detail
  - runPairWise
```
public static <V> CounterMap<V,V> runPairWise(java.util.List<V> items,
                                              CounterMap.CountFunction<V> countFunction)
```
    Build a counter map by iterating pairwise over the list. This assumes that the given pair wise items are the same symmetrically. (The relation at i and i + 1 are the same) It creates a counter map such that the pairs are: count(v1,v2) and count(v2,v1) are the same
    
    Type Parameters:
    
    V - the type to count
    
    Parameters:
    
    items - the items to iterate over
    
    countFunction - the function to count
    
    Returns:
    
    the counter map pairwise
  - parallelCounterMap
```
public static <K,V> CounterMap<K,V> parallelCounterMap()
```
    Returns a thread safe counter map
    
    Returns:
  - ensureCounter
```
protected Counter<V> ensureCounter(K key)
```
  - getCounters
```
public java.util.Collection<Counter<V>> getCounters()
```
  - buildCounter
```
protected Counter<V> buildCounter(MapFactory<V,java.lang.Double> mf)
```
    Returns:
  - keySet
```
public java.util.Set<K> keySet()
```
    Returns the keys that have been inserted into this CounterMap.
  - setCount
```
public void setCount(K key,
                     V value,
                     double count)
```
    Sets the count for a particular (key, value) pair.
  - incrementCount
```
public void incrementCount(K key,
                           V value,
                           double count)
```
    Increments the count for a particular (key, value) pair.
  - getCount
```
public double getCount(K key,
                       V value)
```
    Gets the count of the given (key, value) entry, or zero if that entry is not present. Does not createComplex any objects.
  - getCounter
```
public Counter<V> getCounter(K key)
```
    Gets the sub-counter for the given key. If there is none, a counter is created for that key, and installed in the CounterMap. You can, for example, add to the returned empty counter directly (though you shouldn't). This is so whether the key is present or not, modifying the returned counter has the same effect (but don't do it).
  - incrementAll
```
public void incrementAll(java.util.Map<K,V> map,
                         double count)
```
  - incrementAll
```
public void incrementAll(CounterMap<K,V> cMap)
```
  - getCount
```
public double getCount(K key)
```
    Gets the total count of the given key, or zero if that key is not present. Does not createComplex any objects.
  - totalCount
```
public double totalCount()
```
    Returns the total of all counts in sub-counters. This implementation is linear; it recalculates the total each time.
  - totalSize
```
public int totalSize()
```
    Returns the total number of (key, value) entries in the CounterMap (not their total counts).
  - size
```
public int size()
```
    The number of keys in this CounterMap (not the number of key-value entries -- use totalSize() for that)
  - isEmpty
```
public boolean isEmpty()
```
    True if there are no entries in the CounterMap (false does not mean totalCount > 0)
  - argMax
```
public Pair<K,V> argMax()
```
    Finds the key with maximum count. This is a linear operation, and ties are broken arbitrarily.
    
    Returns:
    
    a key with minumum count
  - toString
```
public java.lang.String toString(int maxValsPerKey)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(java.util.Collection<java.lang.String> keyFilter)
```
  - isEqualTo
```
public boolean isEqualTo(CounterMap<K,V> map)
```
  - main
```
public static void main(java.lang.String[] args)
```
  - normalize
```
public void normalize()
```
  - normalizeWithDiscount
```
public void normalizeWithDiscount(double discount)
```
  - invert
```
public CounterMap<V,K> invert()
```
    Constructs reverse CounterMap where the count of a pair (k,v) is the count of (v,k) in the current CounterMap
    
    Returns:
  - scale
```
public void scale(double scaleFactor)
```
    Scale all entries in CounterMap by scaleFactor
    
    Parameters:
    
    scaleFactor -
  - containsKey
```
public boolean containsKey(K key)
```
  - getPairIterator
```
public java.util.Iterator<Pair<K,V>> getPairIterator()
```
  - getEntrySet
```
public java.util.Set<java.util.Map.Entry<K,Counter<V>>> getEntrySet()
```
  - removeKey
```
public void removeKey(K oldIndex)
```
  - setCounter
```
public void setCounter(K newIndex,
                       Counter<V> counter)
```
  - setDefault
```
public void setDefault(double defltVal)
```

Class CounterMap<K,V>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CounterMap

CounterMap

CounterMap

CounterMap

Method Detail

runPairWise

parallelCounterMap

ensureCounter

getCounters

buildCounter

keySet

setCount

incrementCount

getCount

getCounter

incrementAll

incrementAll

getCount

totalCount

totalSize

size

isEmpty

argMax

toString

toString

toString

isEqualTo

main

normalize

normalizeWithDiscount

invert

scale

containsKey

getPairIterator

getEntrySet

removeKey

setCounter

setDefault