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])
