def mmGetMetricDutyCycles(self):
"""
@return (Metric) duty cycle metric
"""
dutyCycles = self.mmGetDataDutyCycles()
return Metric(self, "total column duty cycles", dutyCycles)
def mmGetMetricBitlife(self):
"""
See `mmGetDataBitlife` for description of bitlife.
@return (Metric) bitlife metric
"""
data = self._mmComputeBitLifeStats()
return Metric(self, "Union SDR bitlife", data)
def mmGetMetricDistinctnessConfusion(self):
"""
For each iteration that doesn't follow a reset, looks at every other
iteration for every other world that doesn't follow a reset, and computes
the number of bits that show up in both sets of active cells those that
iteration. This metric returns the distribution of those numbers.
@return (Metric) Distinctness confusion metric
"""
self._mmComputeSequenceRepresentationData()
numbers = self._mmData["distinctnessConfusion"]
return Metric(self, "distinctness confusion", numbers)
def mmGetMetricEntropy(self):
"""
@return (Metric) entropy
"""
dutyCycles = self.mmGetDataDutyCycles()
MIN_ACTIVATION_PROB = 0.000001
dutyCycles[dutyCycles < MIN_ACTIVATION_PROB] = MIN_ACTIVATION_PROB
dutyCycles = dutyCycles / numpy.sum(dutyCycles)
entropy = -numpy.dot(dutyCycles, numpy.log2(dutyCycles))
return Metric(self, "entropy", entropy)
def mmGetMetricStabilityConfusion(self):
"""
For each iteration that doesn't follow a reset, looks at every other
iteration for the same world that doesn't follow a reset, and computes the
number of bits that show up in one or the other set of active cells for
that iteration, but not both. This metric returns the distribution of those
numbers.
@return (Metric) Stability confusion metric
"""
self._mmComputeSequenceRepresentationData()
numbers = self._mmData["stabilityConfusion"]
return Metric(self, "stability confusion", numbers)
def mmGetMetricDistinctnessConfusion(self):
"""
Returns metric made of values from the distinctness confusion matrix
(excluding diagonals). (See `mmGetDataDistinctnessConfusion`.)
@return (Metric) Distinctness confusion metric
"""
data, _ = self.mmGetDataDistinctnessConfusion()
numbers = []
for i in xrange(len(data)):
for j in xrange(len(data[i])):
if i != j: # Ignoring diagonal
numbers.append(data[i][j])
return Metric(self, "distinctness confusion", numbers)
def mmGetMetricStabilityConfusion(self):
"""
Returns metric made of values from the stability confusion matrix.
(See `mmGetDataStabilityConfusion`.)
@return (Metric) Stability confusion metric
"""
data = self.mmGetDataStabilityConfusion()
numbers = []
for matrix in data.values():
for i in xrange(len(matrix)):
for j in xrange(len(matrix[i])):
if i != j: # Ignoring diagonal
numbers.append(matrix[i][j])
return Metric(self, "stability confusion", numbers)
def mmGetMetricSequencesPredictedActiveCellsPerColumn(self):
"""
Metric for number of predicted => active cells per column for each sequence
@return (Metric) metric
"""
self._mmComputeTransitionTraces()
numCellsPerColumn = []
for predictedActiveCells in (
self._mmData["predictedActiveCellsForSequence"].values()):
cellsForColumn = self.mapCellsToColumns(predictedActiveCells)
numCellsPerColumn += [len(x) for x in cellsForColumn.values()]
return Metric(
self, "# predicted => active cells per column for each sequence",
numCellsPerColumn)
def mmGetMetricSequencesPredictedActiveCellsShared(self):
"""
Metric for number of sequences each predicted => active cell appears in
Note: This metric is flawed when it comes to high-order sequences.
@return (Metric) metric
"""
self._mmComputeTransitionTraces()
numSequencesForCell = defaultdict(lambda: 0)
for predictedActiveCells in (
self._mmData["predictedActiveCellsForSequence"].values()):
for cell in predictedActiveCells:
numSequencesForCell[cell] += 1
return Metric(self,
"# sequences each predicted => active cells appears in",
numSequencesForCell.values())
def compute(self, *args, **kwargs):
sequenceLabel = None
if "sequenceLabel" in kwargs:
sequenceLabel = kwargs["sequenceLabel"]
del kwargs["sequenceLabel"]
activeColumns = super(TemporalPoolerMonitorMixin, self).compute(*args,
**kwargs)
activeColumns = set(activeColumns)
activeCells = activeColumns # TODO: Update when moving to a cellular TP
self._mmTraces["activeCells"].data.append(activeCells)
self._mmTraces["sequenceLabels"].data.append(sequenceLabel)
self._mmTraces["resets"].data.append(self._mmResetActive)
self._mmResetActive = False
self._mmTraces["connectionsPerColumnMetric"].data.append(
Metric(self, "connections per column", self._connectedCounts.tolist()))
self._sequenceRepresentationDataStale = True
def compute(self, *args, **kwargs):
sequenceLabel = kwargs.pop("sequenceLabel", None)
unionSDR = super(UnionTemporalPoolerMonitorMixin, self).compute(*args,
**kwargs)
### From spatial pooler
# total number of connections
connectedCounts = numpy.zeros(self.getNumColumns(), dtype=uintType)
self.getConnectedCounts(connectedCounts)
numConnections = numpy.sum(connectedCounts)
self._mmTraces["unionSDR"].data.append(set(unionSDR))
self._mmTraces["numConnections"].data.append(numConnections)
self._mmTraces["sequenceLabels"].data.append(sequenceLabel)
self._mmTraces["resets"].data.append(self._mmResetActive)
self._mmResetActive = False
self._mmTraces["connectionsPerColumnMetric"].data.append(
Metric(self, "connections per column", self._connectedCounts.tolist()))
self._sequenceRepresentationDataStale = True
self._mmUpdateDutyCycles()
def mmGetMetricPersistenceDutyCycle(self): """ @return (Metric) duty cycle metric for persistences """ data = self.mmGetDataPersistenceDutyCycle() return Metric(self, "Persistence duty cycle", data)
def mmGetMetricUnionSDRDutyCycle(self): """ @return (Metric) duty cycle metric for union SDR bits """ data = self.mmGetDataUnionSDRDutyCycle() return Metric(self, "Union SDR duty cycle", data)
def mmGetMetricConnectedCounts(self): data = self.mmGetDataConnectedCounts() return Metric(self, "Connected synapse counts", data)
