def __init__(self, debugSensor=False, debugMotor=False, **kwargs):
"""
@param debugSensor (bool) Controls whether sensor encodings are contiguous
@param debugMotor (bool) Controls whether motor encodings are contiguous
"""
super(OneDUniverse, self).__init__(**kwargs)
self.debugSensor = debugSensor
self.debugMotor = debugMotor
self.sensorPatternMachine = ConsecutivePatternMachine(
self.nSensor, self.wSensor)
self.sensorEncoder = SDRCategoryEncoder(self.nSensor,
self.wSensor,
forced=True)
self.motorPatternMachine = ConsecutivePatternMachine(
self.nMotor, self.wMotor)
self.motorEncoder = SDRCategoryEncoder(self.nMotor,
self.wMotor,
forced=True)
# This pool is a human friendly representation of sensory values
self.elementCodes = (
range(0x0041, 0x005A + 1) + # A-Z
range(0x0061, 0x007A + 1) + # a-z
range(0x0030, 0x0039 + 1) + # 0-9
range(0x00C0, 0x036F + 1) # Many others
)
self.numDecodedElements = len(self.elementCodes)
class SequenceMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
def testGenerateFromNumbers(self):
numbers = range(0, 10) + [None] + range(10, 19)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
self.assertEqual(len(sequence), 20)
self.assertEqual(sequence[0], self.patternMachine.get(0))
self.assertEqual(sequence[10], None)
self.assertEqual(sequence[11], self.patternMachine.get(10))
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = InspectTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
class SequenceMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
def testGenerateFromNumbers(self):
numbers = range(0, 10) + [None] + range(10, 19)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
self.assertEqual(len(sequence), 20)
self.assertEqual(sequence[0], self.patternMachine.get(0))
self.assertEqual(sequence[10], None)
self.assertEqual(sequence[11], self.patternMachine.get(10))
class ConsecutivePatternMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
def testGet(self):
pattern = self.patternMachine.get(18)
self.assertEqual(len(pattern), 5)
self.assertEqual(pattern, set([90, 91, 92, 93, 94]))
pattern = self.patternMachine.get(19)
self.assertEqual(len(pattern), 5)
self.assertEqual(pattern, set([95, 96, 97, 98, 99]))
def testGetOutOfBounds(self):
args = [20]
self.assertRaises(IndexError, self.patternMachine.get, *args)
class ConsecutivePatternMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
def testGet(self):
pattern = self.patternMachine.get(18)
self.assertEqual(len(pattern), 5)
self.assertEqual(pattern, set([90, 91, 92, 93, 94]))
pattern = self.patternMachine.get(19)
self.assertEqual(len(pattern), 5)
self.assertEqual(pattern, set([95, 96, 97, 98, 99]))
def testGetOutOfBounds(self):
args = [20]
self.assertRaises(IndexError, self.patternMachine.get, *args)
def testD(self):
"""Endlessly repeating sequence of 2 elements"""
self.initTM({"columnDimensions": [2]})
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
for _ in xrange(7):
self.feedTM(sequence)
self.feedTM(sequence, num=50)
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = InspectTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testG(self):
"""A single endlessly repeating pattern"""
self.initTM({"columnDimensions": [1]})
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = [self.patternMachine.get(0)]
for _ in xrange(4):
self.feedTM(sequence)
for _ in xrange(2):
self.feedTM(sequence, num=10)
def testE(self):
"""Endlessly repeating sequence of 2 elements with maxNewSynapseCount=1"""
self.initTM({"columnDimensions": [2],
"maxNewSynapseCount": 1,
"cellsPerColumn": 10})
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
for _ in xrange(7):
self.feedTM(sequence)
self.feedTM(sequence, num=100)
def testF(self):
"""Long repeating sequence with novel pattern at the end"""
self.initTM({"columnDimensions": [3]})
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
sequence *= 10
sequence += [self.patternMachine.get(2), None]
for _ in xrange(4):
self.feedTM(sequence)
self.feedTM(sequence, num=10)
def testB(self):
"""High order sequences (in order)"""
self.initTM()
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequenceA = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
sequenceB = self.sequenceMachine.generateFromNumbers([4, 1, 2, 5, None])
self.feedTM(sequenceA, num=5)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequenceA,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
self.feedTM(sequenceB)
self.feedTM(sequenceB, num=2)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequenceB,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[1]), 1)
self.feedTM(sequenceB, num=3)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequenceB,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[2]), 1)
self.feedTM(sequenceB, num=3)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequenceB,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
(_, _, predictedActiveColumnsList,
predictedInactiveColumnsList, _) = self.feedTM(sequenceA,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
self.assertEqual(len(predictedInactiveColumnsList[3]), 1)
self.feedTM(sequenceA, num=10)
(_, _, predictedActiveColumnsList,
predictedInactiveColumnsList, _) = self.feedTM(sequenceA,
learn=False)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
def testA(self):
"""Basic first order sequences"""
self.initTM()
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequence)
self.assertEqual(len(predictedActiveColumnsList[3]), 0)
self.feedTM(sequence, num=2)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequence)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
self.feedTM(sequence, num=4)
(_, _, predictedActiveColumnsList, _, _) = self.feedTM(sequence)
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
def testC(self):
"""High order sequences (alternating)"""
self.initTM()
self.finishSetUp(ConsecutivePatternMachine(
self.tm.connections.numberOfColumns(), 1))
sequence = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
sequence += self.sequenceMachine.generateFromNumbers([4, 1, 2, 5, None])
self.feedTM(sequence)
self.feedTM(sequence, num=10)
(_, _, predictedActiveColumnsList,
predictedInactiveColumnsList, _) = self.feedTM(sequence,
learn=False)
# TODO: Requires some form of synaptic decay to forget the
# ABC=>Y and XBC=>D transitions that are initially formed
self.assertEqual(len(predictedActiveColumnsList[3]), 1)
# self.assertEqual(len(predictedInactiveColumnsList[3]), 0)
self.assertEqual(len(predictedActiveColumnsList[8]), 1)
class InspectTemporalMemoryTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = InspectTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testFeedSequence(self):
sequence = self._generateSequence()
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
self._feedSequence(sequence, sequenceLabel="Test")
self.assertEqual(len(self.tm.patterns), len(sequence))
self.assertEqual(len(self.tm.sequenceLabels), len(sequence))
self.assertEqual(len(self.tm.predictedActiveCellsList), len(sequence))
self.assertEqual(len(self.tm.predictedInactiveCellsList),
len(sequence))
self.assertEqual(len(self.tm.predictedActiveColumnsList),
len(sequence))
self.assertEqual(len(self.tm.predictedInactiveColumnsList),
len(sequence))
self.assertEqual(len(self.tm.unpredictedActiveColumnsList),
len(sequence))
self.assertEqual(self.tm.patterns[-2], self.patternMachine.get(4))
self.assertEqual(self.tm.sequenceLabels[-2], "Test")
self.assertEqual(len(self.tm.predictedActiveCellsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveCellsList[-2]), 5)
self.assertEqual(len(self.tm.predictedActiveColumnsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveColumnsList[-2]), 5)
self.assertEqual(len(self.tm.unpredictedActiveColumnsList[-2]), 5)
def testComputeStatistics(self):
sequence = self._generateSequence()
self._feedSequence(sequence) # train
self.tm.clearHistory()
self._feedSequence(sequence) # test
stats = self.tm.getStatistics()
self.assertEqual(len(stats), 5)
self.assertEqual(stats.predictedInactiveCells.sum, 0)
self.assertEqual(stats.predictedInactiveColumns.sum, 0)
self.assertEqual(stats.unpredictedActiveColumns.sum, 0)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
def _feedSequence(self, sequence, sequenceLabel=None):
for pattern in sequence:
if pattern is None:
self.tm.reset()
else:
self.tm.compute(pattern, sequenceLabel=sequenceLabel)
class TutorialTemporalMemoryTest(AbstractTemporalMemoryTest):
VERBOSITY = 1
DEFAULT_TM_PARAMS = {
"columnDimensions": [6],
"cellsPerColumn": 4,
"initialPermanence": 0.3,
"connectedPermanence": 0.5,
"minThreshold": 1,
"maxNewSynapseCount": 6,
"permanenceIncrement": 0.1,
"permanenceDecrement": 0.05,
"activationThreshold": 1
}
PATTERN_MACHINE = ConsecutivePatternMachine(6, 1)
def testFirstOrder(self):
"""Basic first order sequences"""
self.init()
sequence = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
self.feedTM(sequence)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 0)
self.feedTM(sequence, num=2)
self.feedTM(sequence)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
self.feedTM(sequence, num=4)
self.feedTM(sequence)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
def testHighOrder(self):
"""High order sequences (in order)"""
self.init()
sequenceA = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
sequenceB = self.sequenceMachine.generateFromNumbers([4, 1, 2, 5, None])
self.feedTM(sequenceA, num=5)
self.feedTM(sequenceA, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
self.feedTM(sequenceB)
self.feedTM(sequenceB, num=2)
self.feedTM(sequenceB, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[1]), 1)
self.feedTM(sequenceB, num=3)
self.feedTM(sequenceB, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[2]), 1)
self.feedTM(sequenceB, num=3)
self.feedTM(sequenceB, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
self.feedTM(sequenceA, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
self.assertEqual(len(self.tm.mmGetTracePredictedInactiveColumns().data[3]), 1)
self.feedTM(sequenceA, num=10)
self.feedTM(sequenceA, learn=False)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
# TODO: Requires some form of synaptic decay to forget the ABC=>Y
# transition that's initially formed
# self.assertEqual(len(self.tm.mmGetTracePredictedInactiveColumns().data[3]), 0)
def testHighOrderAlternating(self):
"""High order sequences (alternating)"""
self.init()
sequence = self.sequenceMachine.generateFromNumbers([0, 1, 2, 3, None])
sequence += self.sequenceMachine.generateFromNumbers([4, 1, 2, 5, None])
self.feedTM(sequence)
self.feedTM(sequence, num=10)
self.feedTM(sequence, learn=False)
# TODO: Requires some form of synaptic decay to forget the
# ABC=>Y and XBC=>D transitions that are initially formed
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[3]), 1)
# self.assertEqual(len(self.tm.mmGetTracePredictedInactiveColumns().data[3]), 0)
self.assertEqual(len(self.tm.mmGetTracePredictedActiveColumns().data[7]), 1)
# self.assertEqual(len(self.tm.mmGetTracePredictedInactiveColumns().data[7]), 0)
def testEndlesslyRepeating(self):
"""Endlessly repeating sequence of 2 elements"""
self.init({"columnDimensions": [2]})
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
for _ in xrange(7):
self.feedTM(sequence)
self.feedTM(sequence, num=50)
def testEndlesslyRepeatingWithNoNewSynapses(self):
"""Endlessly repeating sequence of 2 elements with maxNewSynapseCount=1"""
self.init({"columnDimensions": [2],
"maxNewSynapseCount": 1,
"cellsPerColumn": 10})
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
for _ in xrange(7):
self.feedTM(sequence)
self.feedTM(sequence, num=100)
def testLongRepeatingWithNovelEnding(self):
"""Long repeating sequence with novel pattern at the end"""
self.init({"columnDimensions": [3]})
sequence = self.sequenceMachine.generateFromNumbers([0, 1])
sequence *= 10
sequence += [self.patternMachine.get(2), None]
for _ in xrange(4):
self.feedTM(sequence)
self.feedTM(sequence, num=10)
def testSingleEndlesslyRepeating(self):
"""A single endlessly repeating pattern"""
self.init({"columnDimensions": [1]})
sequence = [self.patternMachine.get(0)]
for _ in xrange(4):
self.feedTM(sequence)
for _ in xrange(2):
self.feedTM(sequence, num=10)
# ==============================
# Overrides
# ==============================
def setUp(self):
super(TutorialTemporalMemoryTest, self).setUp()
print ("\n"
"======================================================\n"
"Test: {0} \n"
"{1}\n"
"======================================================\n"
).format(self.id(), self.shortDescription())
def init(self, *args, **kwargs):
super(TutorialTemporalMemoryTest, self).init(*args, **kwargs)
print "Initialized new TM with parameters:"
print pprint.pformat(self._computeTMParams(kwargs.get("overrides")))
print
def feedTM(self, sequence, learn=True, num=1):
self._showInput(sequence, learn=learn, num=num)
super(TutorialTemporalMemoryTest, self).feedTM(
sequence, learn=learn, num=num)
print self.tm.mmPrettyPrintTraces(self.tm.mmGetDefaultTraces(verbosity=2),
breakOnResets=self.tm.mmGetTraceResets())
print
if learn:
print self.tm.mmPrettyPrintConnections()
# ==============================
# Helper functions
# ==============================
def _showInput(self, sequence, learn=True, num=1):
sequenceText = self.sequenceMachine.prettyPrintSequence(
sequence,
verbosity=self.VERBOSITY)
learnText = "(learning {0})".format("enabled" if learn else "disabled")
numText = " [{0} times]".format(num) if num > 1 else ""
print "Feeding sequence {0}{1}:\n{2}".format(
learnText, numText, sequenceText)
print
class TemporalMemoryTestMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = TemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.4,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
def testFeedSequence(self):
sequence = self._generateSequence()
results = self.tmTestMachine.feedSequence(sequence)
self.assertEqual(len(results), len(sequence))
self.assertEqual(len(results[-2]), 5)
self.assertEqual(len(results[-1]), 0)
def testComputeDetailedResults(self):
sequence = self._generateSequence()
# Replace last pattern with an unpredicted one
sequence[-1] = self.patternMachine.get(4)
results = self.tmTestMachine.feedSequence(sequence)
detailedResults = self.tmTestMachine.computeDetailedResults(results,
sequence)
(
predictedActiveCellsList,
predictedInactiveCellsList,
predictedActiveColumnsList,
predictedInactiveColumnsList,
unpredictedActiveColumnsList
) = detailedResults
self.assertEqual(len(predictedActiveCellsList), len(sequence))
self.assertEqual(len(predictedInactiveCellsList), len(sequence))
self.assertEqual(len(predictedActiveColumnsList), len(sequence))
self.assertEqual(len(predictedInactiveColumnsList), len(sequence))
self.assertEqual(len(unpredictedActiveColumnsList), len(sequence))
self.assertEqual(len(predictedActiveCellsList[-1]), 0)
self.assertEqual(len(predictedInactiveCellsList[-1]), 5)
self.assertEqual(len(predictedActiveColumnsList[-1]), 0)
self.assertEqual(len(predictedInactiveColumnsList[-1]), 5)
self.assertEqual(len(unpredictedActiveColumnsList[-1]), 5)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence = ([None] + sequence) * 3
return sequence
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5) self.sequenceMachine = SequenceMachine(self.patternMachine)
class TemporalMemoryMonitorMixinTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = MonitoredTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testFeedSequence(self):
sequence = self._generateSequence()
sequenceLength = len(sequence) - 3 # without resets
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
self._feedSequence(sequence, sequenceLabel="Test")
activeColumnsTrace = self.tm.mmGetTraceActiveColumns()
predictiveCellsTrace = self.tm.mmGetTracePredictiveCells()
sequenceLabelsTrace = self.tm.mmGetTraceSequenceLabels()
resetsTrace = self.tm.mmGetTraceResets()
predictedActiveCellsTrace = self.tm.mmGetTracePredictedActiveCells()
predictedInactiveCellsTrace = self.tm.mmGetTracePredictedInactiveCells()
predictedActiveColumnsTrace = self.tm.mmGetTracePredictedActiveColumns()
predictedInactiveColumnsTrace = self.tm.mmGetTracePredictedInactiveColumns()
unpredictedActiveColumnsTrace = self.tm.mmGetTraceUnpredictedActiveColumns()
self.assertEqual(len(activeColumnsTrace.data), sequenceLength)
self.assertEqual(len(predictiveCellsTrace.data), sequenceLength)
self.assertEqual(len(sequenceLabelsTrace.data), sequenceLength)
self.assertEqual(len(resetsTrace.data), sequenceLength)
self.assertEqual(len(predictedActiveCellsTrace.data), sequenceLength)
self.assertEqual(len(predictedInactiveCellsTrace.data), sequenceLength)
self.assertEqual(len(predictedActiveColumnsTrace.data), sequenceLength)
self.assertEqual(len(predictedInactiveColumnsTrace.data), sequenceLength)
self.assertEqual(len(unpredictedActiveColumnsTrace.data), sequenceLength)
self.assertEqual(activeColumnsTrace.data[-1], self.patternMachine.get(4))
self.assertEqual(sequenceLabelsTrace.data[-1], "Test")
self.assertEqual(resetsTrace.data[0], True)
self.assertEqual(resetsTrace.data[1], False)
self.assertEqual(resetsTrace.data[10], True)
self.assertEqual(resetsTrace.data[-1], False)
self.assertEqual(len(predictedActiveCellsTrace.data[-2]), 5)
self.assertEqual(len(predictedActiveCellsTrace.data[-1]), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data[-2]), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data[-1]), 5)
self.assertEqual(len(predictedActiveColumnsTrace.data[-2]), 5)
self.assertEqual(len(predictedActiveColumnsTrace.data[-1]), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data[-2]), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data[-1]), 5)
self.assertEqual(len(unpredictedActiveColumnsTrace.data[-2]), 0)
self.assertEqual(len(unpredictedActiveColumnsTrace.data[-1]), 5)
def testClearHistory(self):
sequence = self._generateSequence()
self._feedSequence(sequence, sequenceLabel="Test")
self.tm.mmClearHistory()
activeColumnsTrace = self.tm.mmGetTraceActiveColumns()
predictiveCellsTrace = self.tm.mmGetTracePredictiveCells()
sequenceLabelsTrace = self.tm.mmGetTraceSequenceLabels()
resetsTrace = self.tm.mmGetTraceResets()
predictedActiveCellsTrace = self.tm.mmGetTracePredictedActiveCells()
predictedInactiveCellsTrace = self.tm.mmGetTracePredictedInactiveCells()
predictedActiveColumnsTrace = self.tm.mmGetTracePredictedActiveColumns()
predictedInactiveColumnsTrace = self.tm.mmGetTracePredictedInactiveColumns()
unpredictedActiveColumnsTrace = self.tm.mmGetTraceUnpredictedActiveColumns()
self.assertEqual(len(activeColumnsTrace.data), 0)
self.assertEqual(len(predictiveCellsTrace.data), 0)
self.assertEqual(len(sequenceLabelsTrace.data), 0)
self.assertEqual(len(resetsTrace.data), 0)
self.assertEqual(len(predictedActiveCellsTrace.data), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data), 0)
self.assertEqual(len(predictedActiveColumnsTrace.data), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data), 0)
self.assertEqual(len(unpredictedActiveColumnsTrace.data), 0)
def testSequencesMetrics(self):
sequence = self._generateSequence()
self._feedSequence(sequence, "Test1")
sequence.reverse()
sequence.append(sequence.pop(0)) # Move None (reset) to the end
self._feedSequence(sequence, "Test2")
sequencesPredictedActiveCellsPerColumnMetric = \
self.tm.mmGetMetricSequencesPredictedActiveCellsPerColumn()
sequencesPredictedActiveCellsSharedMetric = \
self.tm.mmGetMetricSequencesPredictedActiveCellsShared()
self.assertEqual(sequencesPredictedActiveCellsPerColumnMetric.mean, 1)
self.assertEqual(sequencesPredictedActiveCellsSharedMetric.mean, 1)
self._feedSequence(sequence, "Test3")
sequencesPredictedActiveCellsPerColumnMetric = \
self.tm.mmGetMetricSequencesPredictedActiveCellsPerColumn()
sequencesPredictedActiveCellsSharedMetric = \
self.tm.mmGetMetricSequencesPredictedActiveCellsShared()
self.assertEqual(sequencesPredictedActiveCellsPerColumnMetric.mean, 1)
self.assertTrue(sequencesPredictedActiveCellsSharedMetric.mean > 1)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
def _feedSequence(self, sequence, sequenceLabel=None):
for pattern in sequence:
if pattern is None:
self.tm.reset()
else:
self.tm.compute(pattern, sequenceLabel=sequenceLabel)
class InspectTemporalMemoryTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = InspectTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testFeedSequence(self):
sequence = self._generateSequence()
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
self._feedSequence(sequence)
self.assertEqual(len(self.tm.predictedActiveCellsList), len(sequence))
self.assertEqual(len(self.tm.predictedInactiveCellsList), len(sequence))
self.assertEqual(len(self.tm.predictedActiveColumnsList), len(sequence))
self.assertEqual(len(self.tm.predictedInactiveColumnsList), len(sequence))
self.assertEqual(len(self.tm.unpredictedActiveColumnsList), len(sequence))
self.assertEqual(len(self.tm.predictedActiveCellsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveCellsList[-2]), 5)
self.assertEqual(len(self.tm.predictedActiveColumnsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveColumnsList[-2]), 5)
self.assertEqual(len(self.tm.unpredictedActiveColumnsList[-2]), 5)
def testComputeStatistics(self):
sequence = self._generateSequence()
self._feedSequence(sequence) # train
self.tm.clearHistory()
self._feedSequence(sequence) # test
stats = self.tm.getStatistics()
self.assertEqual(len(stats), 5)
self.assertEqual(stats[1][2], 0)
self.assertEqual(stats[3][2], 0)
self.assertEqual(stats[4][2], 0)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
def _feedSequence(self, sequence):
for pattern in sequence:
if pattern is None:
self.tm.reset()
else:
self.tm.compute(pattern)
class InspectTemporalMemoryTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = InspectTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testFeedSequence(self):
sequence = self._generateSequence()
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
self._feedSequence(sequence, sequenceLabel="Test")
self.assertEqual(len(self.tm.patterns), len(sequence))
self.assertEqual(len(self.tm.sequenceLabels), len(sequence))
self.assertEqual(len(self.tm.predictedActiveCellsList), len(sequence))
self.assertEqual(len(self.tm.predictedInactiveCellsList), len(sequence))
self.assertEqual(len(self.tm.predictedActiveColumnsList), len(sequence))
self.assertEqual(len(self.tm.predictedInactiveColumnsList), len(sequence))
self.assertEqual(len(self.tm.unpredictedActiveColumnsList), len(sequence))
self.assertEqual(self.tm.patterns[-2], self.patternMachine.get(4))
self.assertEqual(self.tm.sequenceLabels[-2], "Test")
self.assertEqual(len(self.tm.predictedActiveCellsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveCellsList[-2]), 5)
self.assertEqual(len(self.tm.predictedActiveColumnsList[-2]), 0)
self.assertEqual(len(self.tm.predictedInactiveColumnsList[-2]), 5)
self.assertEqual(len(self.tm.unpredictedActiveColumnsList[-2]), 5)
self.assertTrue("Test" in self.tm.predictedActiveCellsForSequenceDict)
predictedActiveCells = reduce(lambda x, y: x | y,
self.tm.predictedActiveCellsList)
self.assertEqual(self.tm.predictedActiveCellsForSequenceDict["Test"],
predictedActiveCells)
sequence.reverse()
sequence.append(sequence.pop(0)) # Move None (reset) to the end
self._feedSequence(sequence, sequenceLabel="Test2")
self.assertTrue("Test" in self.tm.predictedActiveCellsForSequenceDict)
self.assertEqual(self.tm.predictedActiveCellsForSequenceDict["Test"],
predictedActiveCells)
self.assertTrue("Test2" in self.tm.predictedActiveCellsForSequenceDict)
self.assertNotEqual(self.tm.predictedActiveCellsForSequenceDict["Test"],
self.tm.predictedActiveCellsForSequenceDict["Test2"])
def testFeedSequenceNoSequenceLabel(self):
sequence = self._generateSequence()
self._feedSequence(sequence)
self.assertEqual(len(self.tm.predictedActiveCellsForSequenceDict), 0)
def testComputeStatistics(self):
sequence = self._generateSequence()
self._feedSequence(sequence) # train
self.tm.clearHistory()
self._feedSequence(sequence) # test
stats = self.tm.getStatistics()
self.assertEqual(len(stats), 7)
self.assertEqual(stats.predictedInactiveCells.sum, 0)
self.assertEqual(stats.predictedInactiveColumns.sum, 0)
self.assertEqual(stats.unpredictedActiveColumns.sum, 0)
self.assertEqual(stats.sequencesPredictedActiveCellsPerColumn.sum, None)
self.assertEqual(stats.sequencesPredictedActiveCellsShared.sum, None)
def testComputeStatisticsSequenceStatistics(self):
sequence = self._generateSequence()
self._feedSequence(sequence, "Test1")
sequence.reverse()
sequence.append(sequence.pop(0)) # Move None (reset) to the end
self._feedSequence(sequence, "Test2")
stats = self.tm.getStatistics()
self.assertEqual(stats.sequencesPredictedActiveCellsPerColumn.average, 1)
self.assertEqual(stats.sequencesPredictedActiveCellsShared.average, 1)
self._feedSequence(sequence, "Test3")
stats = self.tm.getStatistics()
self.assertEqual(stats.sequencesPredictedActiveCellsPerColumn.average, 1)
self.assertTrue(stats.sequencesPredictedActiveCellsShared.average > 1)
def testMapCellsToColumns(self):
columnsForCells = self.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]))
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
def _feedSequence(self, sequence, sequenceLabel=None):
for pattern in sequence:
if pattern is None:
self.tm.reset()
else:
self.tm.compute(pattern, sequenceLabel=sequenceLabel)
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5)
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5) self.sequenceMachine = SequenceMachine(self.patternMachine)
class OneDUniverse(AbstractUniverse):
def __init__(self, debugSensor=False, debugMotor=False, **kwargs):
"""
@param debugSensor (bool) Controls whether sensor encodings are contiguous
@param debugMotor (bool) Controls whether motor encodings are contiguous
"""
super(OneDUniverse, self).__init__(**kwargs)
self.debugSensor = debugSensor
self.debugMotor = debugMotor
self.sensorPatternMachine = ConsecutivePatternMachine(
self.nSensor, self.wSensor)
self.sensorEncoder = SDRCategoryEncoder(self.nSensor,
self.wSensor,
forced=True)
self.motorPatternMachine = ConsecutivePatternMachine(
self.nMotor, self.wMotor)
self.motorEncoder = SDRCategoryEncoder(self.nMotor,
self.wMotor,
forced=True)
# This pool is a human friendly representation of sensory values
self.elementCodes = (
range(0x0041, 0x005A + 1) + # A-Z
range(0x0061, 0x007A + 1) + # a-z
range(0x0030, 0x0039 + 1) + # 0-9
range(0x00C0, 0x036F + 1) # Many others
)
self.numDecodedElements = len(self.elementCodes)
def encodeSensorValue(self, sensorValue):
"""
@param sensorValue (object) Sensor value
@return (set) Sensor pattern
"""
if self.debugSensor:
return self.sensorPatternMachine.get(sensorValue)
else:
return set(self.sensorEncoder.encode(sensorValue).nonzero()[0])
def decodeSensorValue(self, sensorValue):
"""
@param sensorValue (object) Sensor value
@return (string) Human viewable representation of sensorValue
"""
if sensorValue < len(self.elementCodes):
return unichr(self.elementCodes[sensorValue])
else:
return unichr(0x003F) # Character: ?
def encodeMotorValue(self, motorValue):
"""
@param motorValue (object) Motor value
@return (set) Motor pattern
"""
if self.debugMotor:
numMotorValues = self.nMotor / self.wMotor
motorRadius = (numMotorValues - 1) / 2
return self.motorPatternMachine.get(motorValue + motorRadius)
else:
return set(self.motorEncoder.encode(motorValue).nonzero()[0])
class TemporalMemoryMonitorMixinTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tm = MonitoredTemporalMemory(columnDimensions=[100],
cellsPerColumn=4,
initialPermanence=0.6,
connectedPermanence=0.5,
minThreshold=1,
maxNewSynapseCount=6,
permanenceIncrement=0.1,
permanenceDecrement=0.05,
activationThreshold=1)
def testFeedSequence(self):
sequence = self._generateSequence()
sequenceLength = len(sequence) - 3 # without resets
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
self._feedSequence(sequence, sequenceLabel="Test")
activeColumnsTrace = self.tm.getTraceActiveColumns()
predictiveCellsTrace = self.tm.getTracePredictiveCells()
sequenceLabelsTrace = self.tm.getTraceSequenceLabels()
resetsTrace = self.tm.getTraceResets()
predictedActiveCellsTrace = self.tm.getTracePredictedActiveCells()
predictedInactiveCellsTrace = self.tm.getTracePredictedInactiveCells()
predictedActiveColumnsTrace = self.tm.getTracePredictedActiveColumns()
predictedInactiveColumnsTrace = self.tm.getTracePredictedInactiveColumns()
unpredictedActiveColumnsTrace = self.tm.getTraceUnpredictedActiveColumns()
self.assertEqual(len(activeColumnsTrace.data), sequenceLength)
self.assertEqual(len(predictiveCellsTrace.data), sequenceLength)
self.assertEqual(len(sequenceLabelsTrace.data), sequenceLength)
self.assertEqual(len(resetsTrace.data), sequenceLength)
self.assertEqual(len(predictedActiveCellsTrace.data), sequenceLength)
self.assertEqual(len(predictedInactiveCellsTrace.data), sequenceLength)
self.assertEqual(len(predictedActiveColumnsTrace.data), sequenceLength)
self.assertEqual(len(predictedInactiveColumnsTrace.data), sequenceLength)
self.assertEqual(len(unpredictedActiveColumnsTrace.data), sequenceLength)
self.assertEqual(activeColumnsTrace.data[-1], self.patternMachine.get(4))
self.assertEqual(sequenceLabelsTrace.data[-1], "Test")
self.assertEqual(resetsTrace.data[0], True)
self.assertEqual(resetsTrace.data[1], False)
self.assertEqual(resetsTrace.data[10], True)
self.assertEqual(resetsTrace.data[-1], False)
self.assertEqual(len(predictedActiveCellsTrace.data[-2]), 5)
self.assertEqual(len(predictedActiveCellsTrace.data[-1]), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data[-2]), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data[-1]), 5)
self.assertEqual(len(predictedActiveColumnsTrace.data[-2]), 5)
self.assertEqual(len(predictedActiveColumnsTrace.data[-1]), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data[-2]), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data[-1]), 5)
self.assertEqual(len(unpredictedActiveColumnsTrace.data[-2]), 0)
self.assertEqual(len(unpredictedActiveColumnsTrace.data[-1]), 5)
def testClearHistory(self):
sequence = self._generateSequence()
self._feedSequence(sequence, sequenceLabel="Test")
self.tm.clearHistory()
activeColumnsTrace = self.tm.getTraceActiveColumns()
predictiveCellsTrace = self.tm.getTracePredictiveCells()
sequenceLabelsTrace = self.tm.getTraceSequenceLabels()
resetsTrace = self.tm.getTraceResets()
predictedActiveCellsTrace = self.tm.getTracePredictedActiveCells()
predictedInactiveCellsTrace = self.tm.getTracePredictedInactiveCells()
predictedActiveColumnsTrace = self.tm.getTracePredictedActiveColumns()
predictedInactiveColumnsTrace = self.tm.getTracePredictedInactiveColumns()
unpredictedActiveColumnsTrace = self.tm.getTraceUnpredictedActiveColumns()
self.assertEqual(len(activeColumnsTrace.data), 0)
self.assertEqual(len(predictiveCellsTrace.data), 0)
self.assertEqual(len(sequenceLabelsTrace.data), 0)
self.assertEqual(len(resetsTrace.data), 0)
self.assertEqual(len(predictedActiveCellsTrace.data), 0)
self.assertEqual(len(predictedInactiveCellsTrace.data), 0)
self.assertEqual(len(predictedActiveColumnsTrace.data), 0)
self.assertEqual(len(predictedInactiveColumnsTrace.data), 0)
self.assertEqual(len(unpredictedActiveColumnsTrace.data), 0)
def testSequencesMetrics(self):
sequence = self._generateSequence()
self._feedSequence(sequence, "Test1")
sequence.reverse()
sequence.append(sequence.pop(0)) # Move None (reset) to the end
self._feedSequence(sequence, "Test2")
sequencesPredictedActiveCellsPerColumnMetric = \
self.tm.getMetricSequencesPredictedActiveCellsPerColumn()
sequencesPredictedActiveCellsSharedMetric = \
self.tm.getMetricSequencesPredictedActiveCellsShared()
self.assertEqual(sequencesPredictedActiveCellsPerColumnMetric.mean, 1)
self.assertEqual(sequencesPredictedActiveCellsSharedMetric.mean, 1)
self._feedSequence(sequence, "Test3")
sequencesPredictedActiveCellsPerColumnMetric = \
self.tm.getMetricSequencesPredictedActiveCellsPerColumn()
sequencesPredictedActiveCellsSharedMetric = \
self.tm.getMetricSequencesPredictedActiveCellsShared()
self.assertEqual(sequencesPredictedActiveCellsPerColumnMetric.mean, 1)
self.assertTrue(sequencesPredictedActiveCellsSharedMetric.mean > 1)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
def _feedSequence(self, sequence, sequenceLabel=None):
for pattern in sequence:
if pattern is None:
self.tm.reset()
else:
self.tm.compute(pattern, sequenceLabel=sequenceLabel)
class SequenceMachineTest(unittest.TestCase):
def setUp(self):
self.patternMachine = ConsecutivePatternMachine(100, 5)
self.sequenceMachine = SequenceMachine(self.patternMachine)
def testGenerateFromNumbers(self):
numbers = range(0, 10) + [None] + range(10, 19)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
self.assertEqual(len(sequence), 20)
self.assertEqual(sequence[0], self.patternMachine.get(0))
self.assertEqual(sequence[10], None)
self.assertEqual(sequence[11], self.patternMachine.get(10))
def testAddSpatialNoise(self):
patternMachine = PatternMachine(10000, 1000, num=100)
sequenceMachine = SequenceMachine(patternMachine)
numbers = range(0, 100)
numbers.append(None)
sequence = sequenceMachine.generateFromNumbers(numbers)
noisy = sequenceMachine.addSpatialNoise(sequence, 0.5)
overlap = len(noisy[0] & patternMachine.get(0))
self.assertTrue(400 < overlap < 600)
sequence = sequenceMachine.generateFromNumbers(numbers)
noisy = sequenceMachine.addSpatialNoise(sequence, 0.0)
overlap = len(noisy[0] & patternMachine.get(0))
self.assertEqual(overlap, 1000)
def testGenerateNumbers(self):
numbers = self.sequenceMachine.generateNumbers(1, 100)
self.assertEqual(numbers[-1], None)
self.assertEqual(len(numbers), 101)
self.assertFalse(numbers[:-1] == range(0, 100))
self.assertEqual(sorted(numbers[:-1]), range(0, 100))
def testGenerateNumbersMultipleSequences(self):
numbers = self.sequenceMachine.generateNumbers(3, 100)
self.assertEqual(len(numbers), 303)
self.assertEqual(sorted(numbers[0:100]), range(0, 100))
self.assertEqual(sorted(numbers[101:201]), range(100, 200))
self.assertEqual(sorted(numbers[202:302]), range(200, 300))
def testGenerateNumbersWithShared(self):
numbers = self.sequenceMachine.generateNumbers(3, 100, (20, 35))
self.assertEqual(len(numbers), 303)
shared = range(300, 315)
self.assertEqual(numbers[20:35], shared)
self.assertEqual(numbers[20+101:35+101], shared)
self.assertEqual(numbers[20+202:35+202], shared)
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5)
class TemporalMemoryTestMachineTest(unittest.TestCase):
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 testFeedSequence(self):
sequence = self._generateSequence()
results = self.tmTestMachine.feedSequence(sequence)
self.assertEqual(len(results), len(sequence))
self.assertEqual(len(results[-3]), 5)
self.assertEqual(len(results[-2]), 0)
def testComputeDetailedResults(self):
sequence = self._generateSequence()
# Replace last pattern (before the None) with an unpredicted one
sequence[-2] = self.patternMachine.get(4)
results = self.tmTestMachine.feedSequence(sequence)
detailedResults = self.tmTestMachine.computeDetailedResults(
results, sequence)
(predictedActiveCellsList, predictedInactiveCellsList,
predictedActiveColumnsList, predictedInactiveColumnsList,
unpredictedActiveColumnsList) = detailedResults
self.assertEqual(len(predictedActiveCellsList), len(sequence))
self.assertEqual(len(predictedInactiveCellsList), len(sequence))
self.assertEqual(len(predictedActiveColumnsList), len(sequence))
self.assertEqual(len(predictedInactiveColumnsList), len(sequence))
self.assertEqual(len(unpredictedActiveColumnsList), len(sequence))
self.assertEqual(len(predictedActiveCellsList[-2]), 0)
self.assertEqual(len(predictedInactiveCellsList[-2]), 5)
self.assertEqual(len(predictedActiveColumnsList[-2]), 0)
self.assertEqual(len(predictedInactiveColumnsList[-2]), 5)
self.assertEqual(len(unpredictedActiveColumnsList[-2]), 5)
def testComputeStatistics(self):
sequence = self._generateSequence()
self.tmTestMachine.feedSequence(sequence) # train
results = self.tmTestMachine.feedSequence(sequence) # test
detailedResults = self.tmTestMachine.computeDetailedResults(
results, sequence)
stats = self.tmTestMachine.computeStatistics(detailedResults, sequence)
self.assertEqual(len(stats), 5)
self.assertEqual(stats[1][2], 0)
self.assertEqual(stats[3][2], 0)
self.assertEqual(stats[4][2], 0)
# ==============================
# Helper functions
# ==============================
def _generateSequence(self):
numbers = range(0, 10)
sequence = self.sequenceMachine.generateFromNumbers(numbers)
sequence.append(None)
sequence *= 3
return sequence
