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 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 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 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)
# 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])
# Send each vector to the TM, with learning turned off
tm.compute(activeColumns, learn=False)
# The following print statements prints out the active cells, predictive
# cells, active segments and winner cells.
#
# 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])
# Send each vector to the TM, with learning turned off
tm.compute(activeColumns, learn = False)
# The following print statements prints out the active cells, predictive
# cells, active segments and winner cells.
# sorted_cells = sorted(cell_activation_dict.iteritems(), key=lambda (k,v): (v,k), reverse=False) # pickle.dump(sorted_cells, open( "1Cells.p", "wb" ) ) # for i in range(len(num_data)): for i in range(2000): # print([str(x) for x in num_data_np[i]]) # print(num_data[i]) # print_num(num_data[i], inactive_char='-') # print 'The answer is ',answers[i] # print(cell_activation_dict) learn_num(num_data[i], answers[i], i) ret_tp.reset() print(float(sum(col_guesses)) / float(len(col_guesses))) # col_guesses = col_guesses[2500:] performance = [] for i in range(len(col_guesses)): performance.append(float(sum(col_guesses[:i])) / float(i+1)) plt.plot(performance) plt.show() # plt.plot(cell_guesses) # plt.show()
