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 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 testNoChangeToMatchingSegmentsInPredictedActiveColumn(self):
tm = TemporalMemory(columnDimensions=[32],
cellsPerColumn=4,
activationThreshold=3,
initialPermanence=.21,
connectedPermanence=.50,
minThreshold=2,
maxNewSynapseCount=3,
permanenceIncrement=.10,
permanenceDecrement=.10,
predictedSegmentDecrement=0.0,
seed=42)
previousActiveColumns = [0]
activeColumns = [1]
previousActiveCells = [0, 1, 2, 3]
expectedActiveCells = [4]
otherburstingCells = [5, 6, 7]
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)
matchingSegmentOnSameCell = tm.connections.createSegment(
expectedActiveCells[0])
s1 = tm.connections.createSynapse(matchingSegmentOnSameCell,
previousActiveCells[0], .3)
s2 = tm.connections.createSynapse(matchingSegmentOnSameCell,
previousActiveCells[1], .3)
matchingSegmentOnOtherCell = tm.connections.createSegment(
otherburstingCells[0])
s3 = tm.connections.createSynapse(matchingSegmentOnOtherCell,
previousActiveCells[0], .3)
s4 = tm.connections.createSynapse(matchingSegmentOnOtherCell,
previousActiveCells[1], .3)
tm.compute(previousActiveColumns, True)
self.assertEqual(expectedActiveCells, tm.getPredictiveCells())
tm.compute(activeColumns, True)
self.assertAlmostEqual(.3,
tm.connections.dataForSynapse(s1).permanence)
self.assertAlmostEqual(.3,
tm.connections.dataForSynapse(s2).permanence)
self.assertAlmostEqual(.3,
tm.connections.dataForSynapse(s3).permanence)
self.assertAlmostEqual(.3,
tm.connections.dataForSynapse(s4).permanence)
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 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])
tm.learnOnSegments(prevActiveSegments, learningSegments,
prevActiveCells, 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 initModules(self, categories, inputIdx):
modulesNames = {
'wordSP', 'wordTM', 'actionSP', 'actionTM', 'generalTM'
}
if (self.modulesParams is not None) and\
(set(self.modulesParams) == modulesNames):
self.modulesParams['wordSP'].update(self.defaultWordSPParams)
self.modulesParams['wordTM'].update(self.defaultWordTMParams)
self.modulesParams['actionSP'].update(self.defaultActionSPParams)
self.modulesParams['actionTM'].update(self.defaultActionTMParams)
self.wordSP = SpatialPooler(**self.modulesParams['wordSP'])
self.wordTM = TemporalMemory(**self.modulesParams['wordTM'])
self.actionSP = SpatialPooler(**self.modulesParams['actionSP'])
self.actionTM = TemporalMemory(**self.modulesParams['actionTM'])
defaultGeneralTMParams = {
'columnDimensions': (2,
max(self.wordTM.numberOfCells(),
self.actionTM.numberOfCells())),
'seed':
self.tmSeed
}
self.modulesParams['generalTM'].update(defaultGeneralTMParams)
self.generalTM = TemporalMemory(**self.modulesParams['generalTM'])
print("Using external Parameters!")
else:
self.wordSP = SpatialPooler(**self.defaultWordSPParams)
self.wordTM = TemporalMemory(**self.defaultWordTMParams)
self.actionSP = SpatialPooler(**self.defaultActionSPParams)
self.actionTM = TemporalMemory(**self.defaultActionTMParams)
print("External parameters invalid or not found, using"\
" the default ones")
defaultGeneralTMParams = {
'columnDimensions': (2,
max(self.wordTM.numberOfCells(),
self.actionTM.numberOfCells())),
'seed':
self.tmSeed
}
self.generalTM = TemporalMemory(**defaultGeneralTMParams)
self.classifier = CLAClassifierCond(steps=[1, 2, 3],
alpha=0.1,
actValueAlpha=0.3,
verbosity=0)
self.startPointOverlap = CommonOverlap('==',
1,
self.actionTM.columnDimensions,
threshold=0.5)
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 setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = TemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
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 testRecycleLeastRecentlyActiveSegmentToMakeRoomForNewSegment(self):
tm = TemporalMemory(
columnDimensions=[32],
cellsPerColumn=1,
activationThreshold=3,
initialPermanence=.50,
connectedPermanence=.50,
minThreshold=2,
maxNewSynapseCount=3,
permanenceIncrement=.02,
permanenceDecrement=.02,
predictedSegmentDecrement=0.0,
seed=42,
maxSegmentsPerCell=2)
prevActiveColumns1 = [0, 1, 2]
prevActiveColumns2 = [3, 4, 5]
prevActiveColumns3 = [6, 7, 8]
activeColumns = [9]
tm.compute(prevActiveColumns1)
tm.compute(activeColumns)
self.assertEqual(1, tm.connections.numSegments(9))
oldestSegment = list(tm.connections.segmentsForCell(9))[0]
tm.reset()
tm.compute(prevActiveColumns2)
tm.compute(activeColumns)
self.assertEqual(2, tm.connections.numSegments(9))
oldPresynaptic = \
set(synapse.presynapticCell
for synapse in tm.connections.synapsesForSegment(oldestSegment))
tm.reset()
tm.compute(prevActiveColumns3)
tm.compute(activeColumns)
self.assertEqual(2, tm.connections.numSegments(9))
# Verify none of the segments are connected to the cells the old
# segment was connected to.
for segment in tm.connections.segmentsForCell(9):
newPresynaptic = set(synapse.presynapticCell
for synapse
in tm.connections.synapsesForSegment(segment))
self.assertEqual([], list(oldPresynaptic & newPresynaptic))
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 testRecycleLeastRecentlyActiveSegmentToMakeRoomForNewSegment(self):
tm = TemporalMemory(columnDimensions=[32],
cellsPerColumn=1,
activationThreshold=3,
initialPermanence=.50,
connectedPermanence=.50,
minThreshold=2,
maxNewSynapseCount=3,
permanenceIncrement=.02,
permanenceDecrement=.02,
predictedSegmentDecrement=0.0,
seed=42,
maxSegmentsPerCell=2)
prevActiveColumns1 = [0, 1, 2]
prevActiveColumns2 = [3, 4, 5]
prevActiveColumns3 = [6, 7, 8]
activeColumns = [9]
tm.compute(prevActiveColumns1)
tm.compute(activeColumns)
self.assertEqual(1, len(tm.connections.segmentsForCell(9)))
oldestSegment = sorted(tm.connections.segmentsForCell(9))[0]
tm.reset()
tm.compute(prevActiveColumns2)
tm.compute(activeColumns)
self.assertEqual(2, len(tm.connections.segmentsForCell(9)))
tm.reset()
tm.compute(prevActiveColumns3)
tm.compute(activeColumns)
self.assertEqual(2, len(tm.connections.segmentsForCell(9)))
synapses = tm.connections.synapsesForSegment(oldestSegment)
self.assertEqual(3, len(synapses))
presynapticCells = set()
for synapse in synapses:
synapseData = tm.connections.dataForSynapse(synapse)
presynapticCells.add(synapseData.presynapticCell)
expected = set([6, 7, 8])
self.assertEqual(expected, presynapticCells)
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 testReinforceSelectedMatchingSegmentInBurstingColumn(self):
tm = TemporalMemory(columnDimensions=[32],
cellsPerColumn=4,
activationThreshold=3,
initialPermanence=.21,
connectedPermanence=.50,
minThreshold=2,
maxNewSynapseCount=3,
permanenceIncrement=.10,
permanenceDecrement=.08,
predictedSegmentDecrement=0.0,
seed=42)
previousActiveColumns = [0]
previousActiveCells = [0, 1, 2, 3]
activeColumns = [1]
burstingCells = [4, 5, 6, 7]
selectedMatchingSegment = tm.connections.createSegment(
burstingCells[0])
as1 = tm.connections.createSynapse(selectedMatchingSegment,
previousActiveCells[0], .3)
as2 = tm.connections.createSynapse(selectedMatchingSegment,
previousActiveCells[1], .3)
as3 = tm.connections.createSynapse(selectedMatchingSegment,
previousActiveCells[2], .3)
is1 = tm.connections.createSynapse(selectedMatchingSegment, 81, .3)
otherMatchingSegment = tm.connections.createSegment(burstingCells[1])
tm.connections.createSynapse(otherMatchingSegment,
previousActiveCells[0], .3)
tm.connections.createSynapse(otherMatchingSegment,
previousActiveCells[1], .3)
tm.connections.createSynapse(otherMatchingSegment, 81, .3)
tm.compute(previousActiveColumns, True)
tm.compute(activeColumns, True)
self.assertAlmostEqual(.4,
tm.connections.dataForSynapse(as1).permanence)
self.assertAlmostEqual(.4,
tm.connections.dataForSynapse(as2).permanence)
self.assertAlmostEqual(.4,
tm.connections.dataForSynapse(as3).permanence)
self.assertAlmostEqual(.22,
tm.connections.dataForSynapse(is1).permanence)
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 testAdaptSegmentToMax(self):
tm = TemporalMemory()
connections = tm.connections
connections.createSegment(0)
connections.createSynapse(0, 23, 0.9)
tm.adaptSegment(connections, [23], tm.permanenceIncrement,
tm.permanenceDecrement, 0)
synapseData = connections.dataForSynapse(0)
self.assertAlmostEqual(synapseData.permanence, 1.0)
# Now permanence should be at max
tm.adaptSegment(connections, [23], tm.permanenceIncrement,
tm.permanenceDecrement, 0)
synapseData = connections.dataForSynapse(0)
self.assertAlmostEqual(synapseData.permanence, 1.0)
def testBestMatchingCellFewestSegments(self):
tm = TemporalMemory(columnDimensions=[2],
cellsPerColumn=2,
connectedPermanence=0.50,
minThreshold=1,
seed=42)
connections = tm.connections
connections.createSegment(0)
connections.createSynapse(0, 3, 0.3)
activeSynapsesForSegment = set([])
for _ in range(100):
# Never pick cell 0, always pick cell 1
(cell, _) = tm.bestMatchingCell(tm.cellsForColumn(0),
activeSynapsesForSegment)
self.assertEqual(cell, 1)
def testWriteTestFile(self):
tm = 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(tm)
proto = TemporalMemoryProto_capnp.TemporalMemoryProto.new_message()
tm.write(proto)
with open("TemporalMemorySerializationWrite.tmp", "w") as f:
proto.write(f)
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,
connections),
(0, 2))
self.assertEqual(tm.bestMatchingSegment(1,
activeCells,
connections),
(2, 1))
self.assertEqual(tm.bestMatchingSegment(8,
activeCells,
connections),
(None, None))
self.assertEqual(tm.bestMatchingSegment(100,
activeCells,
connections),
(None, None))
def testGetBestMatchingCell(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)
activeSynapsesForSegment = {
0: set([0, 1]),
1: set([3]),
2: set([5])
}
self.assertEqual(tm.getBestMatchingCell(connections.cellsForColumn(0),
activeSynapsesForSegment,
connections),
(0, 0))
self.assertEqual(tm.getBestMatchingCell(connections.cellsForColumn(3), # column containing cell 108
activeSynapsesForSegment,
connections),
(96, None)) # Random cell from column
self.assertEqual(tm.getBestMatchingCell(connections.cellsForColumn(999),
activeSynapsesForSegment,
connections),
(31972, None)) # Random cell from column
def testBurstUnpredictedColumns(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)
activeColumns = [0]
burstingCells = [0, 1, 2, 3]
tm.compute(activeColumns, True)
self.assertEqual(burstingCells, tm.getActiveCells())
def testConnectionsNeverChangeWhenLearningDisabled(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 = [1, 2] #1 is predicted, 2 is bursting
prevInactiveCell = 81
expectedActiveCells = [4]
correctActiveSegment = tm.connections.createSegment(
expectedActiveCells[0])
tm.connections.createSynapse(correctActiveSegment, prevActiveCells[0],
.5)
tm.connections.createSynapse(correctActiveSegment, prevActiveCells[1],
.5)
tm.connections.createSynapse(correctActiveSegment, prevActiveCells[2],
.5)
wrongMatchingSegment = tm.connections.createSegment(43)
tm.connections.createSynapse(wrongMatchingSegment, prevActiveCells[0],
.5)
tm.connections.createSynapse(wrongMatchingSegment, prevActiveCells[1],
.5)
tm.connections.createSynapse(wrongMatchingSegment, prevInactiveCell,
.5)
before = copy.deepcopy(tm.connections)
tm.compute(prevActiveColumns, False)
tm.compute(activeColumns, False)
self.assertEqual(before, tm.connections)
def testNoNewSegmentIfNotEnoughWinnerCells(self):
tm = TemporalMemory(columnDimensions=[32],
cellsPerColumn=4,
activationThreshold=3,
initialPermanence=.21,
connectedPermanence=.50,
minThreshold=2,
maxNewSynapseCount=3,
permanenceIncrement=.10,
permanenceDecrement=.10,
predictedSegmentDecrement=0.0,
seed=42)
zeroColumns = []
activeColumns = [0]
tm.compute(zeroColumns, True)
tm.compute(activeColumns, True)
self.assertEqual(0, tm.connections.numSegments())
def testAdaptSegment(self):
tm = TemporalMemory()
connections = tm.connections
connections.createSegment(0)
connections.createSynapse(0, 23, 0.6)
connections.createSynapse(0, 37, 0.4)
connections.createSynapse(0, 477, 0.9)
tm.adaptSegment(connections, [23, 37], tm.permanenceIncrement,
tm.permanenceDecrement, 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)
def setUp(self):
self.tm = TemporalMemory(columnDimensions=[2048],
cellsPerColumn=32,
initialPermanence=0.5,
connectedPermanence=0.8,
minThreshold=10,
maxNewSynapseCount=12,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=15)
self.tp = TP(numberOfCols=2048,
cellsPerColumn=32,
initialPerm=0.5,
connectedPerm=0.8,
minThreshold=10,
newSynapseCount=12,
permanenceInc=0.1,
permanenceDec=0.05,
activationThreshold=15,
globalDecay=0,
burnIn=1,
checkSynapseConsistency=False,
pamLength=1)
self.tp10x2 = TP10X2(numberOfCols=2048,
cellsPerColumn=32,
initialPerm=0.5,
connectedPerm=0.8,
minThreshold=10,
newSynapseCount=12,
permanenceInc=0.1,
permanenceDec=0.05,
activationThreshold=15,
globalDecay=0,
burnIn=1,
checkSynapseConsistency=False,
pamLength=1)
self.patternMachine = PatternMachine(2048, 40, num=100)
self.sequenceMachine = SequenceMachine(self.patternMachine)
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 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,
connections),
(0, 0))
self.assertEqual(tm.bestMatchingCell(tm.cellsForColumn(3), # column containing cell 108
activeCells,
connections),
(103, None)) # Random cell from column
self.assertEqual(tm.bestMatchingCell(tm.cellsForColumn(999),
activeCells,
connections),
(31979, None)) # Random cell from column
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 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())
