def testMaxSegmentsPerCellGetter(self): tm = TemporalMemory( columnDimensions=[64,64], cellsPerColumn=32, maxSegmentsPerCell=200 ) self.assertEqual(tm.getMaxSegmentsPerCell(), 200)
def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2, minThreshold=2, predictedSegmentDecrement=0.004) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, matchingSegments, matchingCells) = tm.computePredictiveCells(activeCells, connections) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(matchingSegments, set([0, 1])) self.assertEqual(matchingCells, set([0, 1]))
def testMaxSynapsesPerSegmentGetter(self): tm = TemporalMemory( columnDimensions=[32,32], cellsPerColumn=16, maxSynapsesPerSegment=150 ) self.assertEqual(tm.getMaxSynapsesPerSegment(), 150)
def testBestMatchingSegment(self): tm = TemporalMemory( connectedPermanence=0.50, minThreshold=1 ) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(0) connections.createSynapse(1, 49, 0.9) connections.createSynapse(1, 3, 0.8) connections.createSegment(1) connections.createSynapse(2, 733, 0.7) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) activeCells = set([23, 37, 49, 733]) self.assertEqual(tm.bestMatchingSegment(0, activeCells), (0, 2)) self.assertEqual(tm.bestMatchingSegment(1, activeCells), (2, 1)) self.assertEqual(tm.bestMatchingSegment(8, activeCells), (None, None)) self.assertEqual(tm.bestMatchingSegment(100, activeCells), (None, None))
def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2, minThreshold=2, predictedSegmentDecrement=0.004) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, matchingSegments, matchingCells) = tm.computePredictiveCells(activeCells) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(matchingSegments, set([0,1])) self.assertEqual(matchingCells, set([0,1]))
def testDestroyWeakSynapseOnWrongPrediction(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.02, seed=42) previousActiveColumns = [0] previousActiveCells = [0, 1, 2, 3] activeColumns = [2] expectedActiveCells = [5] activeSegment = tm.connections.createSegment(expectedActiveCells[0]) tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) weakActiveSynapse = tm.connections.createSynapse(activeSegment, previousActiveCells[3], .015) tm.compute(previousActiveColumns, True) tm.compute(activeColumns, True) self.assertTrue(tm.connections.dataForSynapse(weakActiveSynapse).destroyed)
def testNoGrowthOnCorrectlyActiveSegments(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.02, seed=42) previousActiveColumns = [0] previousActiveCells = [0,1,2,3] activeColumns = [1] activeCell = 5 activeSegment = tm.connections.createSegment(activeCell) tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) tm.compute(previousActiveColumns, True) tm.compute(activeColumns, True) self.assertEqual(3, len(tm.connections.synapsesForSegment(activeSegment)))
def testCellsForColumn2D(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) expectedCells = set([256, 257, 258, 259]) self.assertEqual(tm.cellsForColumn(64), expectedCells)
def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, numActiveSynapsesForSegment) = tm.computePredictiveCells( activeCells, connections) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(numActiveSynapsesForSegment, {0: 2, 1: 2, 2: 1})
def testCellsForColumn1D(self): tm = TemporalMemory( columnDimensions=[2048], cellsPerColumn=5 ) expectedCells = set([5, 6, 7, 8, 9]) self.assertEqual(tm.cellsForColumn(1), expectedCells)
def __init__(self, config): # Calculate the size of input and col space inputsize = np.array(config['inputDimensions']).prod() colsize = np.array(config['columnDimensions']).prod() # save colsize and data type self.colsize = colsize self.datatype = config['uintType'] self.numIterations = config['numIterations'] # setup the pooler and reference to active column holder self.sp = SpatialPooler( inputDimensions=config['inputDimensions'], columnDimensions=config['columnDimensions'], potentialRadius=int(config['potentialRadius'] * inputsize), numActiveColumnsPerInhArea=math.ceil( config['amountActiveCols'] * colsize), globalInhibition=config['inhibition'] ) # reference to active columns set that is output of the spatial pooler self.activeColumns = np.zeros(colsize, config['uintType']) # setup the temporal pooler self.tm = TemporalMemory( columnDimensions=config['columnDimensions'], cellsPerColumn=config['cellsPerColumn'] )
def testWriteRead(self): tm1 = TemporalMemory(columnDimensions=(32, ), cellsPerColumn=4, activationThreshold=3, initialPermanence=0.21, connectedPermanence=0.50, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=0.1, permanenceDecrement=0.1, predictedSegmentDecrement=0.0, seed=42) self.serializationTestPrepare(tm1) 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) self.assertEqual(tm1, tm2) self.serializationTestVerify(tm2)
def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeSynapsesForSegment = {0: set([0, 1]), 1: set([3, 4]), 2: set([5])} (activeSegments, predictiveCells) = tm.computePredictiveCells(activeSynapsesForSegment, connections) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0]))
def testDestroySegmentsWithTooFewSynapsesToBeMatching(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.02, seed=42) prevActiveColumns = [0] prevActiveCells = [0, 1, 2, 3] activeColumns = [2] expectedActiveCell = 5 matchingSegment = tm.connections.createSegment(expectedActiveCell) tm.connections.createSynapse(matchingSegment, prevActiveCells[0], .015) tm.connections.createSynapse(matchingSegment, prevActiveCells[1], .015) tm.connections.createSynapse(matchingSegment, prevActiveCells[2], .015) tm.connections.createSynapse(matchingSegment, prevActiveCells[3], .015) tm.compute(prevActiveColumns, True) tm.compute(activeColumns, True) self.assertEqual(0, tm.connections.numSegments(expectedActiveCell))
def testDestroyWeakSynapseOnActiveReinforce(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.02, seed=42) previousActiveColumns = [0] previousActiveCells = [0, 1, 2, 3] activeColumns = [2] activeCell = 5 activeSegment = tm.connections.createSegment(activeCell) tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) # Weak inactive synapse. tm.connections.createSynapse(activeSegment, previousActiveCells[3], .009) tm.compute(previousActiveColumns, True) tm.compute(activeColumns, True) self.assertEqual(3, tm.connections.numSynapses(activeSegment))
def testReinforceCorrectlyActiveSegments(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.08, predictedSegmentDecrement=0.02, seed=42) prevActiveColumns = [0] prevActiveCells = [0,1,2,3] activeColumns = [1] activeCell = 5 activeSegment = tm.connections.createSegment(activeCell) as1 = tm.connections.createSynapse(activeSegment, prevActiveCells[0], .5) as2 = tm.connections.createSynapse(activeSegment, prevActiveCells[1], .5) as3 = tm.connections.createSynapse(activeSegment, prevActiveCells[2], .5) is1 = tm.connections.createSynapse(activeSegment, 81, .5) #inactive synapse tm.compute(prevActiveColumns, True) tm.compute(activeColumns, True) self.assertAlmostEqual(.6, tm.connections.dataForSynapse(as1).permanence) self.assertAlmostEqual(.6, tm.connections.dataForSynapse(as2).permanence) self.assertAlmostEqual(.6, tm.connections.dataForSynapse(as3).permanence) self.assertAlmostEqual(.42, tm.connections.dataForSynapse(is1).permanence)
def testWriteRead(self): tm1 = TemporalMemory( columnDimensions=(32,), cellsPerColumn=4, activationThreshold=3, initialPermanence=0.21, connectedPermanence=0.50, minThreshold=2, maxNewSynapseCount=3, permanenceIncrement=0.1, permanenceDecrement=0.1, predictedSegmentDecrement=0.0, seed=42 ) self.serializationTestPrepare(tm1) 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) self.assertEqual(tm1, tm2) self.serializationTestVerify(tm2)
def testLearnOnSegments(self): tm = TemporalMemory(maxNewSynapseCount=2) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSegment(8) connections.createSynapse(2, 486, 0.9) connections.createSegment(100) prevActiveSegments = set([0, 2]) learningSegments = set([1, 3]) prevActiveCells = set([23, 37, 733]) winnerCells = set([0]) prevWinnerCells = set([10, 11, 12, 13, 14]) predictedInactiveCells = set() prevMatchingSegments = set() tm.learnOnSegments(prevActiveSegments, learningSegments, prevActiveCells, winnerCells, prevWinnerCells, connections, predictedInactiveCells, prevMatchingSegments) # Check segment 0 synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 0.7) synapseData = connections.dataForSynapse(1) self.assertAlmostEqual(synapseData.permanence, 0.5) synapseData = connections.dataForSynapse(2) self.assertAlmostEqual(synapseData.permanence, 0.8) # Check segment 1 synapseData = connections.dataForSynapse(3) self.assertAlmostEqual(synapseData.permanence, 0.8) self.assertEqual(len(connections.synapsesForSegment(1)), 2) # Check segment 2 synapseData = connections.dataForSynapse(4) self.assertAlmostEqual(synapseData.permanence, 0.9) self.assertEqual(len(connections.synapsesForSegment(2)), 1) # Check segment 3 self.assertEqual(len(connections.synapsesForSegment(3)), 2)
def testColumnForCell1D(self): tm = TemporalMemory( columnDimensions=[2048], cellsPerColumn=5 ) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(4), 0) self.assertEqual(tm.columnForCell(5), 1) self.assertEqual(tm.columnForCell(10239), 2047)
def testMapCellsToColumns(self): tm = TemporalMemory( columnDimensions=[100], cellsPerColumn=4 ) columnsForCells = tm.mapCellsToColumns(set([0, 1, 2, 5, 399])) self.assertEqual(columnsForCells[0], set([0, 1, 2])) self.assertEqual(columnsForCells[1], set([5])) self.assertEqual(columnsForCells[99], set([399]))
def testColumnForCell2D(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(3), 0) self.assertEqual(tm.columnForCell(4), 1) self.assertEqual(tm.columnForCell(16383), 4095)
def testLeastUsedCell(self): tm = TemporalMemory(columnDimensions=[2], cellsPerColumn=2, seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 3, 0.3) for _ in range(100): # Never pick cell 0, always pick cell 1 self.assertEqual(tm.leastUsedCell(tm.cellsForColumn(0)), 1)
def testLearnOnSegments(self): tm = TemporalMemory(maxNewSynapseCount=2) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSegment(8) connections.createSynapse(2, 486, 0.9) connections.createSegment(100) prevActiveSegments = set([0, 2]) learningSegments = set([1, 3]) prevActiveSynapsesForSegment = {0: set([0, 1]), 1: set([3])} winnerCells = set([0]) prevWinnerCells = set([10, 11, 12, 13, 14]) tm.learnOnSegments(prevActiveSegments, learningSegments, prevActiveSynapsesForSegment, winnerCells, prevWinnerCells, connections) # Check segment 0 (_, _, permanence) = connections.dataForSynapse(0) self.assertAlmostEqual(permanence, 0.7) (_, _, permanence) = connections.dataForSynapse(1) self.assertAlmostEqual(permanence, 0.5) (_, _, permanence) = connections.dataForSynapse(2) self.assertAlmostEqual(permanence, 0.8) # Check segment 1 (_, _, permanence) = connections.dataForSynapse(3) self.assertAlmostEqual(permanence, 0.8) self.assertEqual(len(connections.synapsesForSegment(1)), 2) # Check segment 2 (_, _, permanence) = connections.dataForSynapse(4) self.assertAlmostEqual(permanence, 0.9) self.assertEqual(len(connections.synapsesForSegment(2)), 1) # Check segment 3 self.assertEqual(len(connections.synapsesForSegment(3)), 2)
def testPickCellsToLearnOnAvoidDuplicates(self): tm = TemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) winnerCells = set([23]) # Ensure that no additional (duplicate) cells were picked self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells), set())
def testAdaptSegmentToMin(self): tm = TemporalMemory() connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.1) connections.createSynapse(0, 1, 0.3) tm.adaptSegment(connections, [], tm.permanenceIncrement, tm.permanenceDecrement, 0) synapses = connections.synapsesForSegment(0) self.assertFalse(0 in synapses)
def testCellsForColumnInvalidColumn(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) try: tm.cellsForColumn(4095) except IndexError: self.fail("IndexError raised unexpectedly") args = [4096] self.assertRaises(IndexError, tm.cellsForColumn, *args) args = [-1] self.assertRaises(IndexError, tm.cellsForColumn, *args)
def testColumnForCellInvalidCell(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) try: tm.columnForCell(16383) except IndexError: self.fail("IndexError raised unexpectedly") args = [16384] self.assertRaises(IndexError, tm.columnForCell, *args) args = [-1] self.assertRaises(IndexError, tm.columnForCell, *args)
def testWrite(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(tm1.activeCells, tm2.activeCells) self.assertEqual(tm1.predictiveCells, tm2.predictiveCells) self.assertEqual(tm1.winnerCells, tm2.winnerCells) self.assertEqual(tm1.connections, tm2.connections) tm1.compute(self.patternMachine.get(3)) tm2.compute(self.patternMachine.get(3)) self.assertEqual(tm1.activeCells, tm2.activeCells) self.assertEqual(tm1.predictiveCells, tm2.predictiveCells) self.assertEqual(tm1.winnerCells, tm2.winnerCells) self.assertEqual(tm1.connections, tm2.connections)
def testActivateCorrectlyPredictiveCells(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] expectedActiveCells = [4] activeSegment = tm.connections.createSegment(expectedActiveCells[0]) tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[3], .5) tm.compute(previousActiveColumns, True) self.assertEqual(expectedActiveCells, tm.getPredictiveCells()) tm.compute(activeColumns, True) self.assertEqual(expectedActiveCells, tm.getActiveCells())
def testLeastUsedCell(self): tm = TemporalMemory( columnDimensions=[2], cellsPerColumn=2, seed=42 ) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 3, 0.3) for _ in range(100): # Never pick cell 0, always pick cell 1 self.assertEqual(tm.leastUsedCell(tm.cellsForColumn(0)), 1)
def testBestMatchingCell(self): tm = TemporalMemory(connectedPermanence=0.50, minThreshold=1, seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(0) connections.createSynapse(1, 49, 0.9) connections.createSynapse(1, 3, 0.8) connections.createSegment(1) connections.createSynapse(2, 733, 0.7) connections.createSegment(108) connections.createSynapse(3, 486, 0.9) activeCells = set([23, 37, 49, 733]) self.assertEqual( tm.bestMatchingCell(tm.cellsForColumn(0), activeCells), (0, 0)) self.assertEqual( tm.bestMatchingCell( tm.cellsForColumn(3), # column containing cell 108 activeCells), (103, None)) # Random cell from column self.assertEqual( tm.bestMatchingCell(tm.cellsForColumn(999), activeCells), (31979, None)) # Random cell from column
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 testPickCellsToLearnOn(self): tm = TemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) winnerCells = set([4, 47, 58, 93]) self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells), set([4, 93])) # randomly picked self.assertEqual(tm.pickCellsToLearnOn(100, 0, winnerCells), set([4, 47, 58, 93])) self.assertEqual(tm.pickCellsToLearnOn(0, 0, winnerCells), set())
def initModules(self, categories, inputIdx): modulesNames = {'generalSP', 'generalTM'} nWords = len(categories[inputIdx['wordInput']]) nActions = len(categories[inputIdx['actionInput']]) inputDimensions = max( self.wordEncoder.getWidth(), self.actionEncoder.getWidth() ) columnDimensions = (max((nWords + nActions), len(self.trainingData)) * 2, ) defaultGeneralSPParams = { 'inputDimensions': inputDimensions, 'columnDimensions': columnDimensions, 'seed': self.spSeed } defaultGeneralTMParams = { 'columnDimensions': columnDimensions, 'seed': self.tmSeed } if (self.modulesParams is not None) and\ (set(self.modulesParams) == modulesNames): self.modulesParams['generalSP'].update(defaultGeneralSPParams) self.modulesParams['generalTM'].update(defaultGeneralTMParams) self.generalSP = SpatialPooler(**self.modulesParams['generalSP']) self.generalTM = TemporalMemory(**self.modulesParams['generalTM']) print("Using external Parameters!") else: self.generalSP = SpatialPooler(**defaultGeneralSPParams) self.generalTM = TemporalMemory(**defaultGeneralTMParams) print("External parameters invalid or not found, using"\ " the default ones") self.classifier = CLAClassifierCond( steps=[1, 2], alpha=0.1, actValueAlpha=0.3, verbosity=0 )
def testCellsForColumnInvalidColumn(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) try: tm.cellsForColumn(4095) except IndexError: self.fail("IndexError raised unexpectedly") args = [4096] self.assertRaises(IndexError, tm.cellsForColumn, *args) args = [-1] self.assertRaises(IndexError, tm.cellsForColumn, *args)
def testColumnForCellInvalidCell(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) try: tm.columnForCell(16383) except IndexError: self.fail("IndexError raised unexpectedly") args = [16384] self.assertRaises(IndexError, tm.columnForCell, *args) args = [-1] self.assertRaises(IndexError, tm.columnForCell, *args)
def testPickCellsToLearnOn(self): tm = TemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) winnerCells = set([4, 47, 58, 93]) self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells), set([4, 58])) # randomly picked self.assertEqual(tm.pickCellsToLearnOn(100, 0, winnerCells), set([4, 47, 58, 93])) self.assertEqual(tm.pickCellsToLearnOn(0, 0, winnerCells), set())
def learnOnApicalSegments(self, prevActiveSegments, learningSegments, prevActiveCells, winnerCells, connections, predictedInactiveCells, prevMatchingSegments): """ Phase 3: Perform learning by adapting segments. Pseudocode: - (learning) for each prev active or learning segment - if learning segment or from winner cell - strengthen active synapses - weaken inactive synapses - if learning segment - add some synapses to the segment - subsample from prev winner cells @param prevActiveSegments (set) Indices of active segments in `t-1` @param learningSegments (set) Indices of learning segments in `t` @param prevActiveCells (set) Indices of active cells in `t-1` @param winnerCells (set) Indices of winner cells in `t` @param connections (Connections) Connectivity of layer @param predictedInactiveCells (set) Indices of predicted inactive cells @param prevMatchingSegments (set) Indices of segments with """ for winnerCell in winnerCells: winnerSegments = connections.segmentsForCell(winnerCell) if len(winnerSegments & (prevActiveSegments | learningSegments)) == 0: maxActiveSynapses = 0 winnerSegment = None for segment in winnerSegments: activeSynapses = TemporalMemory.activeSynapsesForSegment( segment, prevActiveCells, connections) numActiveSynapses = len(activeSynapses) if numActiveSynapses > maxActiveSynapses: maxActiveSynapses = numActiveSynapses winnerSegment = segment if winnerSegment is not None: learningSegments.add(winnerSegment) for segment in prevActiveSegments | learningSegments: isLearningSegment = segment in learningSegments isFromWinnerCell = connections.cellForSegment( segment) in winnerCells activeSynapses = self.activeSynapsesForSegment( segment, prevActiveCells, connections) if isLearningSegment or isFromWinnerCell: self.adaptSegment(segment, activeSynapses, connections, self.permanenceIncrement, self.permanenceDecrement) if isLearningSegment: n = self.maxNewSynapseCount - len(activeSynapses) for presynapticCell in self.pickCellsToLearnOn( n, segment, prevActiveCells, connections): connections.createSynapse(segment, presynapticCell, self.initialPermanence)
def testGetBestMatchingSegment(self): tm = TemporalMemory( connectedPermanence=0.50, minThreshold=1 ) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(0) connections.createSynapse(1, 49, 0.9) connections.createSynapse(1, 3, 0.8) connections.createSegment(1) connections.createSynapse(2, 733, 0.7) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) activeSynapsesForSegment = { 0: set([0, 1]), 1: set([3]), 2: set([5]) } self.assertEqual(tm.getBestMatchingSegment(0, activeSynapsesForSegment, connections), (0, set([0, 1]))) self.assertEqual(tm.getBestMatchingSegment(1, activeSynapsesForSegment, connections), (2, set([5]))) self.assertEqual(tm.getBestMatchingSegment(8, activeSynapsesForSegment, connections), (None, None)) self.assertEqual(tm.getBestMatchingSegment(100, activeSynapsesForSegment, connections), (None, None))
def testPunishMatchingSegmentsInInactiveColumns(self): tm = TemporalMemory( columnDimensions=[32], cellsPerColumn=4, activationThreshold=3, initialPermanence=.2, connectedPermanence=.50, minThreshold=2, maxNewSynapseCount=4, permanenceIncrement=.10, permanenceDecrement=.10, predictedSegmentDecrement=0.02, seed=42) previousActiveColumns = [0] previousActiveCells = [0, 1, 2, 3] activeColumns = [1] previousInactiveCell = 81 activeSegment = tm.connections.createSegment(42) as1 = tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) as2 = tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) as3 = tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) is1 = tm.connections.createSynapse(activeSegment, previousInactiveCell, .5) matchingSegment = tm.connections.createSegment(43) as4 = tm.connections.createSynapse(matchingSegment, previousActiveCells[0], .5) as5 = tm.connections.createSynapse(matchingSegment, previousActiveCells[1], .5) is2 = tm.connections.createSynapse(matchingSegment, previousInactiveCell, .5) tm.compute(previousActiveColumns, True) tm.compute(activeColumns, True) self.assertAlmostEqual(.48, tm.connections.dataForSynapse(as1).permanence) self.assertAlmostEqual(.48, tm.connections.dataForSynapse(as2).permanence) self.assertAlmostEqual(.48, tm.connections.dataForSynapse(as3).permanence) self.assertAlmostEqual(.48, tm.connections.dataForSynapse(as4).permanence) self.assertAlmostEqual(.48, tm.connections.dataForSynapse(as5).permanence) self.assertAlmostEqual(.50, tm.connections.dataForSynapse(is1).permanence) self.assertAlmostEqual(.50, tm.connections.dataForSynapse(is2).permanence)
def initTM(self, overrides=None): params = self.defaultTMParams params.update(overrides or {}) self.tm = TemporalMemory(**params) print "Initialized new TM with parameters:" print pprint.pformat(params) print
def testReadTestFile(self): with open("TemporalMemorySerializationWrite.tmp", "r") as f: proto = TemporalMemoryProto_capnp.TemporalMemoryProto.read(f) # Load the deserialized proto tm = TemporalMemory.read(proto) self.serializationTestVerify(tm)
def testBurstColumns(self): tm = TemporalMemory( cellsPerColumn=4, connectedPermanence=0.50, minThreshold=1, seed=42 ) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.4) connections.createSynapse(0, 477, 0.9) connections.createSegment(0) connections.createSynapse(1, 49, 0.9) connections.createSynapse(1, 3, 0.8) connections.createSegment(1) connections.createSynapse(2, 733, 0.7) connections.createSegment(108) connections.createSynapse(3, 486, 0.9) activeColumns = set([0, 1, 26]) predictedColumns = set([26]) prevActiveSynapsesForSegment = { 0: set([0, 1]), 1: set([3]), 2: set([5]) } (activeCells, winnerCells, learningSegments) = tm.burstColumns(activeColumns, predictedColumns, prevActiveSynapsesForSegment, connections) self.assertEqual(activeCells, set([0, 1, 2, 3, 4, 5, 6, 7])) self.assertEqual(winnerCells, set([0, 6])) # 6 is randomly chosen cell self.assertEqual(learningSegments, set([0, 4])) # 4 is new segment created # Check that new segment was added to winner cell (6) in column 1 self.assertEqual(connections.segmentsForCell(6), set([4]))
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 testActivateCorrectlyPredictiveCells(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] expectedActiveCells = [4] activeSegment = tm.connections.createSegment(expectedActiveCells[0]) tm.connections.createSynapse(activeSegment, previousActiveCells[0], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[1], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[2], .5) tm.connections.createSynapse(activeSegment, previousActiveCells[3], .5) tm.compute(previousActiveColumns, True) self.assertEqual(expectedActiveCells, tm.getPredictiveCells()) tm.compute(activeColumns, True) self.assertEqual(expectedActiveCells, tm.getActiveCells())
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)