CounterMap (deeplearning4j-nn 0.9.0 API)

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

All Implemented Interfaces:

Serializable
```
public class CounterMap<K,V>
extends Object
implements 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.

Author:

Dan Klein

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,Float> 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,Float> mf)`
`boolean`	`containsKey(K key)`
`protected Counter<V>`	`ensureCounter(K key)`
`Float`	`getCount(K key)` Gets the total count of the given key, or zero if that key is not present.
`Float`	`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.
`Collection<Counter<V>>`	`getCounters()`
`Set<Map.Entry<K,Counter<V>>>`	`getEntrySet()`
`Iterator<Pair<K,V>>`	`getPairIterator()`
`void`	`incrementAll(CounterMap<K,V> cMap)`
`void`	`incrementAll(Map<K,V> map, Float count)`
`void`	`incrementCount(K key, V value, Float 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)`
`Set<K>`	`keySet()` Returns the keys that have been inserted into this CounterMap.
`void`	`normalize()`
`void`	`normalizeWithDiscount(Float discount)`
`static <K,V> CounterMap<K,V>`	`parallelCounterMap()` Returns a thread safe counter map
`void`	`removeKey(K oldIndex)`
`static <V> CounterMap<V,V>`	`runPairWise(List<V> items, CounterMap.CountFunction<V> countFunction)` Build a counter map by iterating pairwise over the list.
`void`	`scale(Float scaleFactor)` Scale all entries in `CounterMap` by `scaleFactor`
`void`	`setCount(K key, V value, Float count)` Sets the count for a particular (key, value) pair.
`void`	`setCounter(K newIndex, Counter<V> counter)`
`void`	`setDefault(Float defltVal)`
`int`	`size()` The number of keys in this CounterMap (not the number of key-value entries -- use totalSize() for that)
`String`	`toString()`
`String`	`toString(Collection<String> keyFilter)`
`String`	`toString(int maxValsPerKey)`
`Float`	`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,Float> innerMF)
```
  - CounterMap
```
public CounterMap(boolean identityHashMap)
```
- Method Detail
  - runPairWise
```
public static <V> CounterMap<V,V> runPairWise(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 Collection<Counter<V>> getCounters()
```
  - buildCounter
```
protected Counter<V> buildCounter(MapFactory<V,Float> mf)
```
    Returns:
  - keySet
```
public Set<K> keySet()
```
    Returns the keys that have been inserted into this CounterMap.
  - setCount
```
public void setCount(K key,
                     V value,
                     Float count)
```
    Sets the count for a particular (key, value) pair.
  - incrementCount
```
public void incrementCount(K key,
                           V value,
                           Float count)
```
    Increments the count for a particular (key, value) pair.
  - getCount
```
public Float 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(Map<K,V> map,
                         Float count)
```
  - incrementAll
```
public void incrementAll(CounterMap<K,V> cMap)
```
  - getCount
```
public Float 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 Float 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 String toString(int maxValsPerKey)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(Collection<String> keyFilter)
```
  - isEqualTo
```
public boolean isEqualTo(CounterMap<K,V> map)
```
  - normalize
```
public void normalize()
```
  - normalizeWithDiscount
```
public void normalizeWithDiscount(Float 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(Float scaleFactor)
```
    Scale all entries in CounterMap by scaleFactor
    
    Parameters:
    
    scaleFactor -
  - containsKey
```
public boolean containsKey(K key)
```
  - getPairIterator
```
public Iterator<Pair<K,V>> getPairIterator()
```
  - getEntrySet
```
public Set<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(Float 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

normalize

normalizeWithDiscount

invert

scale

containsKey

getPairIterator

getEntrySet

removeKey

setCounter

setDefault