def init(self, overrides=None):
"""
Initialize Temporal Memory, and other member variables.
:param overrides: overrides for default Temporal Memory parameters
"""
params = self._computeTMParams(overrides)
self.tm = TemporalMemory(**params)
self.patternMachine = self.PATTERN_MACHINE
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
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)
class AbstractTemporalMemoryTest(unittest.TestCase):
VERBOSITY = 1
DEFAULT_TM_PARAMS = {}
PATTERN_MACHINE = None
def setUp(self):
self.tm = None
self.patternMachine = None
self.sequenceMachine = None
self.tmTestMachine = None
def init(self, overrides=None):
"""
Initialize Temporal Memory, and other member variables.
:param overrides: overrides for default Temporal Memory parameters
"""
params = self._computeTMParams(overrides)
self.tm = TemporalMemory(**params)
self.patternMachine = self.PATTERN_MACHINE
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
def feedTM(self, sequence, learn=True, num=1):
repeatedSequence = sequence * num
results = self.tmTestMachine.feedSequence(repeatedSequence, learn=learn)
detailedResults = self.tmTestMachine.computeDetailedResults(
results,
repeatedSequence)
return detailedResults
# ==============================
# Helper functions
# ==============================
def _computeTMParams(self, overrides):
params = dict(self.DEFAULT_TM_PARAMS)
params.update(overrides or {})
return params
class AbstractTemporalMemoryTest(unittest.TestCase):
VERBOSITY = 1
DEFAULT_TM_PARAMS = {}
PATTERN_MACHINE = None
def setUp(self):
self.tm = None
self.patternMachine = None
self.sequenceMachine = None
self.tmTestMachine = None
def init(self, overrides=None):
"""
Initialize Temporal Memory, and other member variables.
:param overrides: overrides for default Temporal Memory parameters
"""
params = self._computeTMParams(overrides)
self.tm = TemporalMemory(**params)
self.patternMachine = self.PATTERN_MACHINE
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
def feedTM(self, sequence, learn=True, num=1):
repeatedSequence = sequence * num
results = self.tmTestMachine.feedSequence(repeatedSequence,
learn=learn)
detailedResults = self.tmTestMachine.computeDetailedResults(
results, repeatedSequence)
return detailedResults
# ==============================
# Helper functions
# ==============================
def _computeTMParams(self, overrides):
params = dict(self.DEFAULT_TM_PARAMS)
params.update(overrides or {})
return params
def init(self, overrides=None):
"""
Initialize Temporal Memory, and other member variables.
:param overrides: overrides for default Temporal Memory parameters
"""
params = self._computeTMParams(overrides)
self.tm = TemporalMemory(**params)
self.patternMachine = self.PATTERN_MACHINE
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
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)
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 finishSetUp(self, patternMachine): self.patternMachine = patternMachine self.sequenceMachine = SequenceMachine(self.patternMachine) self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
class AbstractTemporalMemoryTest(unittest.TestCase):
def setUp(self):
self.defaultTMParams = None
self.tm = None
self.patternMachine = None
self.sequenceMachine = None
self.tmTestMachine = None
print ("\n"
"======================================================\n"
"Test: {0} \n"
"{1}\n"
"======================================================\n"
).format(self.id(), self.shortDescription())
def initTM(self, overrides=None):
params = self.defaultTMParams
params.update(overrides or {})
self.tm = TemporalMemory(**params)
print "Initialized new TM with parameters:"
print pprint.pformat(params)
print
def finishSetUp(self, patternMachine):
self.patternMachine = patternMachine
self.sequenceMachine = SequenceMachine(self.patternMachine)
self.tmTestMachine = TemporalMemoryTestMachine(self.tm)
# ==============================
# Helper functions
# ==============================
def feedTM(self, sequence, learn=True, num=1):
self.showInput(sequence, learn=learn, num=num)
repeatedSequence = sequence * num
results = self.tmTestMachine.feedSequence(repeatedSequence, learn=learn)
detailedResults = self.tmTestMachine.computeDetailedResults(
results,
repeatedSequence)
print self.tmTestMachine.prettyPrintDetailedResults(detailedResults,
repeatedSequence,
self.patternMachine,
verbosity=VERBOSITY)
print
if learn:
print self.tmTestMachine.prettyPrintConnections()
return detailedResults
def showInput(self, sequence, learn=True, num=1):
sequenceText = self.sequenceMachine.prettyPrintSequence(sequence,
verbosity=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.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
