def mmClearHistory(self):
        super(SpatialPoolerMonitorMixin, self).mmClearHistory()

        self._mmTraces["activeColumns"] = IndicesTrace(self, "active columns")
        self._mmTraces["activeInputs"] = IndicesTrace(self, "active inputs")
        self._mmTraces["numConnections"] = CountsTrace(self, "connections")
        self._mmTraces["learn"] = BoolsTrace(self, "learn")

        initialPermanence = numpy.zeros((self._numColumns, self._numInputs),
                                        dtype=realDType)
        for c in range(self._numColumns):
            self.getPermanence(c, initialPermanence[c, :])

        self._mmData["initialPermanence"] = initialPermanence
    def mmClearHistory(self):
        super(TemporalMemoryMonitorMixin, self).mmClearHistory()

        self._mmTraces["predictedCells"] = IndicesTrace(
            self, "predicted cells")
        self._mmTraces["activeColumns"] = IndicesTrace(self, "active columns")
        self._mmTraces["predictiveCells"] = IndicesTrace(
            self, "predictive cells")
        self._mmTraces["numSegments"] = CountsTrace(self, "# segments")
        self._mmTraces["numSynapses"] = CountsTrace(self, "# synapses")
        self._mmTraces["sequenceLabels"] = StringsTrace(
            self, "sequence labels")
        self._mmTraces["resets"] = BoolsTrace(self, "resets")

        self._mmTransitionTracesStale = True
Beispiel #3
0
class IndicesTraceTest(unittest.TestCase):
    def setUp(self):
        self.trace = IndicesTrace(self, "active cells")
        self.trace.data.append(set([1, 2, 3]))
        self.trace.data.append(set([4, 5]))
        self.trace.data.append(set([6]))
        self.trace.data.append(set([]))

    def testMakeCountsTrace(self):
        countsTrace = self.trace.makeCountsTrace()
        self.assertEqual(countsTrace.title, "# active cells")
        self.assertEqual(countsTrace.data, [3, 2, 1, 0])

    def testMakeCumCountsTrace(self):
        countsTrace = self.trace.makeCumCountsTrace()
        self.assertEqual(countsTrace.title, "# (cumulative) active cells")
        self.assertEqual(countsTrace.data, [3, 5, 6, 6])
  def mmClearHistory(self):
    super(TemporalPoolerMonitorMixin, self).mmClearHistory()

    self._mmTraces["activeCells"] = IndicesTrace(self, "active cells")
    self._mmTraces["sequenceLabels"] = StringsTrace(self, "sequence labels")
    self._mmTraces["resets"] = BoolsTrace(self, "resets")

    self._sequenceRepresentationDataStale = True
Beispiel #5
0
class IndicesTraceTest(unittest.TestCase):
    def setUp(self):
        self.trace = IndicesTrace(self, "active cells")
        self.trace.data.append(set([1, 2, 3]))
        self.trace.data.append(set([4, 5]))
        self.trace.data.append(set([6]))
        self.trace.data.append(set([]))

    def testMakeCountsTrace(self):
        countsTrace = self.trace.makeCountsTrace()
        self.assertEqual(countsTrace.title, "# active cells")
        self.assertEqual(countsTrace.data, [3, 2, 1, 0])

    def testMakeCumCountsTrace(self):
        countsTrace = self.trace.makeCumCountsTrace()
        self.assertEqual(countsTrace.title, "# (cumulative) active cells")
        self.assertEqual(countsTrace.data, [3, 5, 6, 6])
  def mmClearHistory(self):
    super(UnionTemporalPoolerMonitorMixin, self).mmClearHistory()

    self._mmTraces["unionSDR"] = IndicesTrace(self, "union SDR")
    self._mmTraces["sequenceLabels"] = StringsTrace(self, "sequence labels")
    self._mmTraces["resets"] = BoolsTrace(self, "resets")
    self._mmTraces["connectionsPerColumnMetric"] = MetricsTrace(
      self, "connections per column (metric)")

    self._mmData["unionSDRDutyCycle"] = numpy.zeros(self.getNumColumns(), dtype=realDType)
    self._mmData["persistenceDutyCycle"] = numpy.zeros(self.getNumColumns(), dtype=realDType)

    self._mmTraces["numConnections"] = CountsTrace(self, "connections")

    self._sequenceRepresentationDataStale = True
Beispiel #7
0
    def mmClearHistory(self):
        super(ColumnPoolerMonitorMixin, self).mmClearHistory()

        self._mmTraces["activeCells"] = IndicesTrace(self, "active cells")
        self._mmTraces["numDistalSegments"] = CountsTrace(
            self, "# distal segments")
        self._mmTraces["numDistalSynapses"] = CountsTrace(
            self, "# distal synapses")
        self._mmTraces["numConnectedDistalSynapses"] = CountsTrace(
            self, "# connected distal synapses")
        self._mmTraces["numProximalSynapses"] = CountsTrace(
            self, "# proximal synapses")
        self._mmTraces["numConnectedProximalSynapses"] = CountsTrace(
            self, "# connected proximal synapses")
        self._mmTraces["sequenceLabels"] = StringsTrace(
            self, "sequence labels")
        self._mmTraces["resets"] = BoolsTrace(self, "resets")
        self._mmTransitionTracesStale = True
    def _mmComputeTransitionTraces(self):
        """
    Computes the transition traces, if necessary.

    Transition traces are the following:

        predicted => active cells
        predicted => inactive cells
        predicted => active columns
        predicted => inactive columns
        unpredicted => active columns
    """
        if not self._mmTransitionTracesStale:
            return

        self._mmData["predictedActiveCellsForSequence"] = defaultdict(set)

        self._mmTraces["predictedActiveCells"] = IndicesTrace(
            self, "predicted => active cells (correct)")
        self._mmTraces["predictedInactiveCells"] = IndicesTrace(
            self, "predicted => inactive cells (extra)")
        self._mmTraces["predictedActiveColumns"] = IndicesTrace(
            self, "predicted => active columns (correct)")
        self._mmTraces["predictedInactiveColumns"] = IndicesTrace(
            self, "predicted => inactive columns (extra)")
        self._mmTraces["unpredictedActiveColumns"] = IndicesTrace(
            self, "unpredicted => active columns (bursting)")

        predictedCellsTrace = self._mmTraces["predictedCells"]

        for i, activeColumns in enumerate(self.mmGetTraceActiveColumns().data):
            predictedActiveCells = set()
            predictedInactiveCells = set()
            predictedActiveColumns = set()
            predictedInactiveColumns = set()

            for predictedCell in predictedCellsTrace.data[i]:
                predictedColumn = self.columnForCell(predictedCell)

                if predictedColumn in activeColumns:
                    predictedActiveCells.add(predictedCell)
                    predictedActiveColumns.add(predictedColumn)

                    sequenceLabel = self.mmGetTraceSequenceLabels().data[i]
                    if sequenceLabel is not None:
                        self._mmData["predictedActiveCellsForSequence"][
                            sequenceLabel].add(predictedCell)
                else:
                    predictedInactiveCells.add(predictedCell)
                    predictedInactiveColumns.add(predictedColumn)

            unpredictedActiveColumns = activeColumns - predictedActiveColumns

            self._mmTraces["predictedActiveCells"].data.append(
                predictedActiveCells)
            self._mmTraces["predictedInactiveCells"].data.append(
                predictedInactiveCells)
            self._mmTraces["predictedActiveColumns"].data.append(
                predictedActiveColumns)
            self._mmTraces["predictedInactiveColumns"].data.append(
                predictedInactiveColumns)
            self._mmTraces["unpredictedActiveColumns"].data.append(
                unpredictedActiveColumns)

        self._mmTransitionTracesStale = False
Beispiel #9
0
 def setUp(self):
   self.trace = IndicesTrace(self, "active cells")
   self.trace.data.append(set([1, 2, 3]))
   self.trace.data.append(set([4, 5]))
   self.trace.data.append(set([6]))
   self.trace.data.append(set([]))
Beispiel #10
0
 def setUp(self):
   self.trace = IndicesTrace(self, "active cells")
   self.trace.data.append(set([1, 2, 3]))
   self.trace.data.append(set([4, 5]))
   self.trace.data.append(set([6]))
   self.trace.data.append(set([]))
  def mmClearHistory(self):
    super(SpatialPoolerMonitorMixin, self).mmClearHistory()

    self._mmTraces["activeColumns"] = IndicesTrace(self, "active columns")
    self._mmTraces["numConnections"] = CountsTrace(self, "connections")