def testZeroActiveColumns(self): tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.5, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0] previousActiveCells = [0, 1, 2, 3] expectedActiveCells = [4] segment = tm.connections.createSegment(expectedActiveCells[0]) tm.connections.createSynapse(segment, previousActiveCells[0], .5) tm.connections.createSynapse(segment, previousActiveCells[1], .5) tm.connections.createSynapse(segment, previousActiveCells[2], .5) tm.connections.createSynapse(segment, previousActiveCells[3], .5) tm.compute(previousActiveColumns, True) self.assertFalse(len(tm.getActiveCells()) == 0) self.assertFalse(len(tm.getWinnerCells()) == 0) self.assertFalse(len(tm.getPredictiveCells()) == 0) zeroColumns = [] tm.compute(zeroColumns, True) self.assertTrue(len(tm.getActiveCells()) == 0) self.assertTrue(len(tm.getWinnerCells()) == 0) self.assertTrue(len(tm.getPredictiveCells()) == 0)
def testZeroActiveColumns(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.5, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0] previousActiveCells = [0, 1, 2, 3] expectedActiveCells = [4] segment = tm.connections.createSegment(expectedActiveCells[0]) tm.connections.createSynapse(segment, previousActiveCells[0], .5) tm.connections.createSynapse(segment, previousActiveCells[1], .5) tm.connections.createSynapse(segment, previousActiveCells[2], .5) tm.connections.createSynapse(segment, previousActiveCells[3], .5) tm.compute(previousActiveColumns, True) self.assertFalse(len(tm.getActiveCells()) == 0) self.assertFalse(len(tm.getWinnerCells()) == 0) self.assertFalse(len(tm.getPredictiveCells()) == 0) zeroColumns = [] tm.compute(zeroColumns, True) self.assertTrue(len(tm.getActiveCells()) == 0) self.assertTrue(len(tm.getWinnerCells()) == 0) self.assertTrue(len(tm.getPredictiveCells()) == 0)
def testNewSegmentAddSynapsesToSubsetOfWinnerCells(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=2, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1, 2] activeColumns = [4] tm.compute(previousActiveColumns, True) prevWinnerCells = tm.getWinnerCells() #[0, 8, 7] self.assertEqual(3, len(prevWinnerCells)) tm.compute(activeColumns, True) winnerCells = tm.getWinnerCells() #[18] self.assertEqual(1, len(winnerCells)) segments = list(tm.connections.segmentsForCell(winnerCells[0])) self.assertEqual(1, len(segments)) synapses = list(tm.connections.synapsesForSegment(segments[0])) self.assertEqual(2, len(synapses)) for synapse in synapses: synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell in prevWinnerCells)
def testNewSegmentAddSynapsesToSubsetOfWinnerCells(self): tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=2, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1, 2] activeColumns = [4] tm.compute(previousActiveColumns, True) prevWinnerCells = tm.getWinnerCells() #[0, 8, 7] self.assertEqual(3, len(prevWinnerCells)) tm.compute(activeColumns, True) winnerCells = tm.getWinnerCells() #[18] self.assertEqual(1, len(winnerCells)) segments = tm.connections.segmentsForCell(winnerCells[0]) self.assertEqual(1, len(segments)) synapses = tm.connections.synapsesForSegment(segments[0]) self.assertEqual(2, len(synapses)) for synapse in synapses: synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell in prevWinnerCells)
def testWriteRead(self): tm1 = TemporalMemory( columnDimensions=[100], cellsPerColumn=4, activationThreshold=7, initialPermanence=0.37, connectedPermanence=0.58, minThreshold=4, maxNewSynapseCount=18, permanenceIncrement=0.23, permanenceDecrement=0.08, seed=91 ) # Run some data through before serializing self.patternMachine = PatternMachine(100, 4) self.sequenceMachine = SequenceMachine(self.patternMachine) sequence = self.sequenceMachine.generateFromNumbers(range(5)) for _ in range(3): for pattern in sequence: tm1.compute(pattern) proto1 = TemporalMemoryProto_capnp.TemporalMemoryProto.new_message() tm1.write(proto1) # Write the proto to a temp file and read it back into a new proto with tempfile.TemporaryFile() as f: proto1.write(f) f.seek(0) proto2 = TemporalMemoryProto_capnp.TemporalMemoryProto.read(f) # Load the deserialized proto tm2 = TemporalMemory.read(proto2) # Check that the two temporal memory objects have the same attributes self.assertEqual(tm1, tm2) # Run a couple records through after deserializing and check results match tm1.compute(self.patternMachine.get(0)) tm2.compute(self.patternMachine.get(0)) self.assertEqual(set(tm1.getActiveCells()), set(tm2.getActiveCells())) self.assertEqual(set(tm1.getPredictiveCells()), set(tm2.getPredictiveCells())) self.assertEqual(set(tm1.getWinnerCells()), set(tm2.getWinnerCells())) self.assertEqual(tm1.connections, tm2.connections) tm1.compute(self.patternMachine.get(3)) tm2.compute(self.patternMachine.get(3)) self.assertEqual(set(tm1.getActiveCells()), set(tm2.getActiveCells())) self.assertEqual(set(tm1.getPredictiveCells()), set(tm2.getPredictiveCells())) self.assertEqual(set(tm1.getWinnerCells()), set(tm2.getWinnerCells())) self.assertEqual(tm1.connections, tm2.connections)
def testWriteRead(self): tm1 = TemporalMemory(columnDimensions=[100], cellsPerColumn=4, activationThreshold=7, initialPermanence=0.37, connectedPermanence=0.58, minThreshold=4, maxNewSynapseCount=18, permanenceIncrement=0.23, permanenceDecrement=0.08, seed=91) # Run some data through before serializing self.patternMachine = PatternMachine(100, 4) self.sequenceMachine = SequenceMachine(self.patternMachine) sequence = self.sequenceMachine.generateFromNumbers(range(5)) for _ in range(3): for pattern in sequence: tm1.compute(pattern) proto1 = TemporalMemoryProto_capnp.TemporalMemoryProto.new_message() tm1.write(proto1) # Write the proto to a temp file and read it back into a new proto with tempfile.TemporaryFile() as f: proto1.write(f) f.seek(0) proto2 = TemporalMemoryProto_capnp.TemporalMemoryProto.read(f) # Load the deserialized proto tm2 = TemporalMemory.read(proto2) # Check that the two temporal memory objects have the same attributes self.assertEqual(tm1, tm2) # Run a couple records through after deserializing and check results match tm1.compute(self.patternMachine.get(0)) tm2.compute(self.patternMachine.get(0)) self.assertEqual(set(tm1.getActiveCells()), set(tm2.getActiveCells())) self.assertEqual(set(tm1.getPredictiveCells()), set(tm2.getPredictiveCells())) self.assertEqual(set(tm1.getWinnerCells()), set(tm2.getWinnerCells())) self.assertEqual(tm1.connections, tm2.connections) tm1.compute(self.patternMachine.get(3)) tm2.compute(self.patternMachine.get(3)) self.assertEqual(set(tm1.getActiveCells()), set(tm2.getActiveCells())) self.assertEqual(set(tm1.getPredictiveCells()), set(tm2.getPredictiveCells())) self.assertEqual(set(tm1.getWinnerCells()), set(tm2.getWinnerCells())) self.assertEqual(tm1.connections, tm2.connections)
def testMatchingSegmentAddSynapsesToAllWinnerCells(self): tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1] prevWinnerCells = [0, 1] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 0, .5) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns) synapses = tm.connections.synapsesForSegment(matchingSegment) self.assertEqual(2, len(synapses)) synapseData = tm.connections.dataForSynapse(synapses[1]) self.assertAlmostEqual(.21, synapseData.permanence) self.assertEqual(prevWinnerCells[1], synapseData.presynapticCell)
def testRecycleWeakestSynapseToMakeRoomForNewSynapse(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.02, permanenceDecrement=.02, predictedSegmentDecrement=0.0, seed=42, maxSynapsesPerSegment=3) prevActiveColumns = [0, 1, 2] prevWinnerCells = [0, 1, 2] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 81, .6) weakestSynapse = tm.connections.createSynapse(matchingSegment, 0, .11) tm.compute(prevActiveColumns) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns) synapseData = tm.connections.dataForSynapse(weakestSynapse) self.assertNotEqual(0, synapseData.presynapticCell) self.assertFalse(synapseData._destroyed) self.assertAlmostEqual(.21, synapseData.permanence)
def testPredictedActiveCellsAreAlwaysWinners(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.5, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0] activeColumns = [1] previousActiveCells = [0, 1, 2, 3] expectedWinnerCells = [4, 6] activeSegment1 = tm.connections.createSegment(expectedWinnerCells[0]) tm.connections.createSynapse(activeSegment1, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment1, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment1, previousActiveCells[2], .5) activeSegment2 = tm.connections.createSegment(expectedWinnerCells[1]) tm.connections.createSynapse(activeSegment2, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment2, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment2, previousActiveCells[2], .5) tm.compute(previousActiveColumns, False) tm.compute(activeColumns, False) self.assertEqual(expectedWinnerCells, tm.getWinnerCells())
def testMatchingSegmentAddSynapsesToSubsetOfWinnerCells(self): tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1, 2, 3] prevWinnerCells = [0, 1, 2, 3] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 0, .5) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns, True) synapses = tm.connections.synapsesForSegment(matchingSegment) self.assertEqual(3, len(synapses)) synapses = sorted(synapses)[ 1:] # only test the synapses added by compute for synapse in synapses: synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell in prevWinnerCells)
def testRecycleWeakestSynapseToMakeRoomForNewSynapse(self): tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.02, permanenceDecrement=.02, predictedSegmentDecrement=0.0, seed=42, maxSynapsesPerSegment=3) prevActiveColumns = [0, 1, 2] prevWinnerCells = [0, 1, 2] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 81, .6) weakestSynapse = tm.connections.createSynapse(matchingSegment, 0, .11) tm.compute(prevActiveColumns) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns) synapseData = tm.connections.dataForSynapse(weakestSynapse) self.assertNotEqual(0, synapseData.presynapticCell) self.assertFalse(synapseData.destroyed) self.assertAlmostEqual(.21, synapseData.permanence)
def testRecycleWeakestSynapseToMakeRoomForNewSynapse(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.02, permanenceDecrement=.02, predictedSegmentDecrement=0.0, seed=42, maxSynapsesPerSegment=3) prevActiveColumns = [0, 1, 2] prevWinnerCells = [0, 1, 2] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 81, .6) weakestSynapse = tm.connections.createSynapse(matchingSegment, 0, .11) tm.compute(prevActiveColumns) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns) synapses = tm.connections.synapsesForSegment(matchingSegment) self.assertEqual(3, len(synapses)) presynapticCells = set(synapse.presynapticCell for synapse in synapses) self.assertFalse(0 in presynapticCells)
def testMatchingSegmentAddSynapsesToAllWinnerCells(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1] prevWinnerCells = [0, 1] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 0, .5) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns) synapses = tm.connections.synapsesForSegment(matchingSegment) self.assertEqual(2, len(synapses)) for synapse in synapses: synapseData = tm.connections.dataForSynapse(synapse) if synapseData.presynapticCell != 0: self.assertAlmostEqual(.21, synapseData.permanence) self.assertEqual(prevWinnerCells[1], synapseData.presynapticCell)
def testMatchingSegmentAddSynapsesToSubsetOfWinnerCells(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=1, activationThreshold=3, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0, 1, 2, 3] prevWinnerCells = [0, 1, 2, 3] activeColumns = [4] matchingSegment = tm.connections.createSegment(4) tm.connections.createSynapse(matchingSegment, 0, .5) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns, True) synapses = list(tm.connections.synapsesForSegment(matchingSegment)) self.assertEqual(3, len(synapses)) synapses = synapses[1:] # only test the synapses added by compute for synapse in synapses: synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell == prevWinnerCells[1] or synapseData.presynapticCell == prevWinnerCells[2] or synapseData.presynapticCell == prevWinnerCells[3])
def testPredictedActiveCellsAreAlwaysWinners(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.21, connectedPermanence=.5, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) previousActiveColumns = [0] activeColumns = [1] previousActiveCells = [0, 1, 2, 3] expectedWinnerCells = [4, 6] activeSegment1 = tm.connections.createSegment(expectedWinnerCells[0]) tm.connections.createSynapse(activeSegment1, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment1, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment1, previousActiveCells[2], .5) activeSegment2 = tm.connections.createSegment(expectedWinnerCells[1]) tm.connections.createSynapse(activeSegment2, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment2, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment2, previousActiveCells[2], .5) tm.compute(previousActiveColumns, False) tm.compute(activeColumns, False) self.assertEqual(expectedWinnerCells, tm.getWinnerCells())
def testActiveSegmentGrowSynapsesAccordingToPotentialOverlap(self): """ When a segment becomes active, grow synapses to previous winner cells. The number of grown synapses is calculated from the "matching segment" overlap, not the "active segment" overlap. """ tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=1, activationThreshold=2, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) # Use 1 cell per column so that we have easy control over the winner cells. previousActiveColumns = [0, 1, 2, 3, 4] prevWinnerCells = [0, 1, 2, 3, 4] activeColumns = [5] activeSegment = tm.connections.createSegment(5) tm.connections.createSynapse(activeSegment, 0, .5) tm.connections.createSynapse(activeSegment, 1, .5) tm.connections.createSynapse(activeSegment, 2, .2) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns, True) synapses = tm.connections.synapsesForSegment(activeSegment) self.assertEqual(4, len(synapses)) synapse = synapses[3]; synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell == prevWinnerCells[3] or synapseData.presynapticCell == prevWinnerCells[4])
def testActiveSegmentGrowSynapsesAccordingToPotentialOverlap(self): """ When a segment becomes active, grow synapses to previous winner cells. The number of grown synapses is calculated from the "matching segment" overlap, not the "active segment" overlap. """ tm = TemporalMemory(columnDimensions=[32], cellsPerColumn=1, activationThreshold=2, initialPermanence=.21, connectedPermanence=.50, minThreshold=1, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.0, seed=42) # Use 1 cell per column so that we have easy control over the winner cells. previousActiveColumns = [0, 1, 2, 3, 4] prevWinnerCells = [0, 1, 2, 3, 4] activeColumns = [5] activeSegment = tm.connections.createSegment(5) tm.connections.createSynapse(activeSegment, 0, .5) tm.connections.createSynapse(activeSegment, 1, .5) tm.connections.createSynapse(activeSegment, 2, .2) tm.compute(previousActiveColumns, True) self.assertEqual(prevWinnerCells, tm.getWinnerCells()) tm.compute(activeColumns, True) synapses = tm.connections.synapsesForSegment(activeSegment) self.assertEqual(4, len(synapses)) synapse = synapses[3] synapseData = tm.connections.dataForSynapse(synapse) self.assertAlmostEqual(.21, synapseData.permanence) self.assertTrue(synapseData.presynapticCell == prevWinnerCells[3] or synapseData.presynapticCell == prevWinnerCells[4])
for i in range(10): # Send each letter in the sequence in order for j in range(5): activeColumns = set([i for i, j in zip(count(), x[j]) if j == 1]) # The compute method performs one step of learning and/or inference. Note: # here we just perform learning but you can perform prediction/inference and # learning in the same step if you want (online learning). tm.compute(activeColumns, learn=True) # The following print statements can be ignored. # Useful for tracing internal states print("active cells " + str(tm.getActiveCells())) print("predictive cells " + str(tm.getPredictiveCells())) print("winner cells " + str(tm.getWinnerCells())) print("# of active segments " + str(tm.connections.numSegments())) # The reset command tells the TP that a sequence just ended and essentially # zeros out all the states. It is not strictly necessary but it's a bit # messier without resets, and the TP learns quicker with resets. tm.reset() ####################################################################### # # Step 3: send the same sequence of vectors and look at predictions made by # temporal memory for j in range(5): print "\n\n--------", "ABCDE"[j], "-----------" print "Raw input vector : " + formatRow(x[j]) activeColumns = set([i for i, j in zip(count(), x[j]) if j == 1])
for i in range(10): # Send each letter in the sequence in order for j in range(5): activeColumns = set([i for i, j in zip(count(), x[j]) if j == 1]) # The compute method performs one step of learning and/or inference. Note: # here we just perform learning but you can perform prediction/inference and # learning in the same step if you want (online learning). tm.compute(activeColumns, learn = True) # The following print statements can be ignored. # Useful for tracing internal states print("active cells " + str(tm.getActiveCells())) print("predictive cells " + str(tm.getPredictiveCells())) print("winner cells " + str(tm.getWinnerCells())) print("# of active segments " + str(tm.connections.numSegments())) # The reset command tells the TP that a sequence just ended and essentially # zeros out all the states. It is not strictly necessary but it's a bit # messier without resets, and the TP learns quicker with resets. tm.reset() ####################################################################### # # Step 3: send the same sequence of vectors and look at predictions made by # temporal memory for j in range(5): print "\n\n--------","ABCDE"[j],"-----------" print "Raw input vector : " + formatRow(x[j])