def setUp(self): print ("\n" "======================================================\n" "Test: {0} \n" "{1}\n" "======================================================\n" ).format(self.id(), self.shortDescription()) self.patternMachine = PatternMachine(1024, 20, num=100) self.sequenceMachine = SequenceMachine(self.patternMachine) self.tm = MonitoredTemporalMemory( mmName="TM", columnDimensions=[1024], cellsPerColumn=16, initialPermanence=0.5, connectedPermanence=0.7, minThreshold=20, maxNewSynapseCount=30, permanenceIncrement=0.1, permanenceDecrement=0.02, activationThreshold=20) self.tp = MonitoredTemporalPooler( inputDimensions=[1024, 16], columnDimensions=[1024], mmName="TP") self._showInternalStatePlots(appendTitle=" (initial)")
def generateSequences(patternDimensionality, patternCardinality, sequenceLength, sequenceCount): patternAlphabetSize = sequenceLength * sequenceCount patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) return generatedSequences
def generateSequences(patternDimensionality, patternCardinality, sequenceLength, sequenceCount): patternAlphabetSize = sequenceLength * sequenceCount patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) return generatedSequences
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 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 patternMachine = PatternMachine(100, 4) sequenceMachine = SequenceMachine(patternMachine) sequence = 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(patternMachine.get(0)) tm2.compute(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(patternMachine.get(3)) tm2.compute(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 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 setUp(self): self.tmPy = TemporalMemoryPy(columnDimensions=[2048], cellsPerColumn=32, initialPermanence=0.5, connectedPermanence=0.8, minThreshold=10, maxNewSynapseCount=12, permanenceIncrement=0.1, permanenceDecrement=0.05, activationThreshold=15) self.tmCPP = TemporalMemoryCPP(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 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 generateSequences(n=2048, w=40, sequenceLength=5, sequenceCount=2, sharedRange=None, seed=42): """ Generate high order sequences using SequenceMachine """ # Lots of room for noise sdrs patternAlphabetSize = 10*(sequenceLength * sequenceCount) patternMachine = PatternMachine(n, w, patternAlphabetSize, seed) sequenceMachine = SequenceMachine(patternMachine, seed) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength, sharedRange=sharedRange ) generatedSequences = sequenceMachine.generateFromNumbers(numbers) return sequenceMachine, generatedSequences, numbers
def setUp(self): print ("\n" "======================================================\n" "Test: {0} \n" "{1}\n" "======================================================\n" ).format(self.id(), self.shortDescription()) self.patternMachine = PatternMachine(1024, 20, num=100) self.sequenceMachine = SequenceMachine(self.patternMachine) self.tm = MonitoredTemporalMemory( mmName="TM", columnDimensions=[1024], cellsPerColumn=16, initialPermanence=0.5, connectedPermanence=0.7, minThreshold=20, maxNewSynapseCount=30, permanenceIncrement=0.1, permanenceDecrement=0.02, activationThreshold=20) self.tp = MonitoredTemporalPooler( inputDimensions=[1024, 16], columnDimensions=[1024], mmName="TP") self._showInternalStatePlots(appendTitle=" (initial)")
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 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 = MonitoredTemporalMemory(**params) self.patternMachine = self.PATTERN_MACHINE self.sequenceMachine = SequenceMachine(self.patternMachine)
def generateSequences(patternDimensionality, patternCardinality, sequenceLength, sequenceCount): # Generate a sequence list and an associated labeled list # (both containing a set of sequences separated by None) print "Generating sequences..." patternAlphabetSize = sequenceLength * sequenceCount patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [ str(numbers[i + i * sequenceLength: i + (i + 1) * sequenceLength]) for i in xrange(sequenceCount)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) return generatedSequences, labeledSequences
def generateSequences(patternCardinality, patternDimensionality, numberOfSequences, sequenceLength, consoleVerbosity): patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) inputSequences = sequenceMachine.generateFromNumbers(numbers) inputCategories = [] for i in xrange(numberOfSequences): for _ in xrange(sequenceLength): inputCategories.append(i) inputCategories.append(None) if consoleVerbosity > 1: for i in xrange(len(inputSequences)): if inputSequences[i] is None: print else: print "{0} {1}".format(inputSequences[i], inputCategories[i]) return inputSequences, inputCategories
def generateSequences(patternDimensionality, patternCardinality, sequenceLength, sequenceCount): # Generate a sequence list and an associated labeled list # (both containing a set of sequences separated by None) print "Generating sequences..." patternAlphabetSize = sequenceLength * sequenceCount patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [ str(numbers[i + i * sequenceLength: i + (i + 1) * sequenceLength]) for i in xrange(sequenceCount)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) return generatedSequences, labeledSequences
def generateSequences(patternCardinality, patternDimensionality, numberOfSequences, sequenceLength, consoleVerbosity): patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) inputSequences = sequenceMachine.generateFromNumbers(numbers) inputCategories = [] for i in xrange(numberOfSequences): for _ in xrange(sequenceLength): inputCategories.append(i) inputCategories.append(None) if consoleVerbosity > 1: for i in xrange(len(inputSequences)): if inputSequences[i] is None: print else: print "{0} {1}".format(inputSequences[i], inputCategories[i]) return inputSequences, inputCategories
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 setUp(self): self.tmPy = TemporalMemoryPy(columnDimensions=[2048], cellsPerColumn=32, initialPermanence=0.5, connectedPermanence=0.8, minThreshold=10, maxNewSynapseCount=12, permanenceIncrement=0.1, permanenceDecrement=0.05, activationThreshold=15) self.tmCPP = TemporalMemoryCPP(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 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)
class SpatialTemporalPoolerTest(unittest.TestCase): def setUp(self): print ("\n" "======================================================\n" "Test: {0} \n" "{1}\n" "======================================================\n" ).format(self.id(), self.shortDescription()) self.patternMachine = PatternMachine(1024, 20, num=100) self.sequenceMachine = SequenceMachine(self.patternMachine) self.tm = MonitoredTemporalMemory( mmName="TM", columnDimensions=[1024], cellsPerColumn=16, initialPermanence=0.5, connectedPermanence=0.7, minThreshold=20, maxNewSynapseCount=30, permanenceIncrement=0.1, permanenceDecrement=0.02, activationThreshold=20) self.tp = MonitoredTemporalPooler( inputDimensions=[1024, 16], columnDimensions=[1024], mmName="TP") self._showInternalStatePlots(appendTitle=" (initial)") def testBasic(self): """Two basic sequences""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15] ] labels = ["A", "B"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) def testOverlapping(self): """Overlapping sequences""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [ 0, 16, 17, 18, 19, 20, 21, 7], [22, 23, 24, 11, 12, 25, 26, 27] ] labels = ["A", "B", "C", "D"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) def testMerged(self): """Two distinct sequences, and merged""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] ] labels = ["A", "B", "AB"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) # TO DO: assert C columns contain some A and some B columns, and assert # the split is about equal between A and B def tearDown(self): self._printInfo() self._showActivityPlots() self._showInternalStatePlots(appendTitle=" (final)") @classmethod def tearDownClass(cls): if PLOT >= 1: print raw_input("Press any key to exit...") def _feedSequences(self, sequences, tmLearn=True, tpLearn=True, sequenceLabels=None): for i in xrange(len(sequences)): sequence = sequences[i] label = sequenceLabels[i] if sequenceLabels is not None else None for pattern in sequence: self._feedPattern(pattern, tmLearn=tmLearn, tpLearn=tpLearn, sequenceLabel=label) self.tm.reset() self.tp.reset() def _printInfo(self): if VERBOSITY >= 2: print MonitorMixinBase.mmPrettyPrintTraces( self.tp.mmGetDefaultTraces(verbosity=3) + self.tm.mmGetDefaultTraces(verbosity=3), breakOnResets=self.tm.mmGetTraceResets()) print if VERBOSITY >= 1: print MonitorMixinBase.mmPrettyPrintMetrics( self.tp.mmGetDefaultMetrics() + self.tm.mmGetDefaultMetrics()) print def _showActivityPlots(self): if PLOT >= 1: title = self.shortDescription() self.tp.mmGetCellActivityPlot(showReset=True, title=title) def _showInternalStatePlots(self, appendTitle=None): if PLOT >= 1: title = self.shortDescription() if appendTitle: title += appendTitle self.tp.mmGetPermanencesPlot(title=title) def _feedPattern(self, pattern, tmLearn=True, tpLearn=True, sequenceLabel=None): # Feed the TM predictedCells = self.tm.predictiveCells self.tm.compute(pattern, learn=tmLearn, sequenceLabel=sequenceLabel) # If requested, feed the TP if tpLearn is not None: tpInputVector, correctlyPredictedCells = ( self._formatInputForTP(predictedCells)) activeArray = numpy.zeros(self.tp.getNumColumns()) self.tp.compute(tpInputVector, tpLearn, activeArray, None, # not needed correctlyPredictedCells, sequenceLabel=sequenceLabel) def _formatInputForTP(self, predictedCells): """ Given an instance of the TM, format the information we need to send to the TP. """ # all currently active cells in layer 4 tpInputVector = numpy.zeros( self.tm.numberOfCells()).astype(realDType) tpInputVector[list(self.tm.activeCells)] = 1 # correctly predicted cells in layer 4 correctlyPredictedCells = numpy.zeros( self.tm.numberOfCells()).astype(realDType) correctlyPredictedCells[list(predictedCells & self.tm.activeCells)] = 1 return tpInputVector, correctlyPredictedCells
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5) self.sequenceMachine = SequenceMachine(self.patternMachine)
def run(params, paramDir, outputDir, plotVerbosity=0, consoleVerbosity=0): """ Runs the union overlap experiment. :param params: A dict of experiment parameters :param paramDir: Path of parameter file :param outputDir: Output will be written to this path :param plotVerbosity: Plotting verbosity :param consoleVerbosity: Console output verbosity """ print "Running SDR overlap experiment...\n" print "Params dir: {0}".format(paramDir) print "Output dir: {0}\n".format(outputDir) # Dimensionality of sequence patterns patternDimensionality = params["patternDimensionality"] # Cardinality (ON / true bits) of sequence patterns patternCardinality = params["patternCardinality"] # TODO If this parameter is to be supported, the sequence generation code # below must change # Number of unique patterns from which sequences are built # patternAlphabetSize = params["patternAlphabetSize"] # Length of sequences shown to network sequenceLength = params["sequenceLength"] # Number of sequences used. Sequences may share common elements. numberOfSequences = params["numberOfSequences"] # Number of sequence passes for training the TM. Zero => no training. trainingPasses = params["trainingPasses"] tmParamOverrides = params["temporalMemoryParams"] upParamOverrides = params["unionPoolerParams"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) start = time.time() print "\nGenerating sequences..." patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength]) for i in xrange(numberOfSequences)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) # Set up the Temporal Memory and Union Pooler network print "\nCreating network..." experiment = UnionTemporalPoolerExperiment(tmParamOverrides, upParamOverrides) # Train only the Temporal Memory on the generated sequences if trainingPasses > 0: print "\nTraining Temporal Memory..." if consoleVerbosity > 0: print "\nPass\tBursting Columns Mean\tStdDev\tMax" for i in xrange(trainingPasses): experiment.runNetworkOnSequences(generatedSequences, labeledSequences, tmLearn=True, upLearn=None, verbosity=consoleVerbosity, progressInterval=_SHOW_PROGRESS_INTERVAL) if consoleVerbosity > 0: stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2]) # Reset the TM monitor mixin's records accrued during this training pass experiment.tm.mmClearHistory() print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics()) print if plotVerbosity >= 2: plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Training") print "\nRunning test phase..." experiment.runNetworkOnSequences(generatedSequences, labeledSequences, tmLearn=False, upLearn=False, verbosity=consoleVerbosity, progressInterval=_SHOW_PROGRESS_INTERVAL) print "\nPass\tBursting Columns Mean\tStdDev\tMax" stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(0, stats[0], stats[1], stats[2]) if trainingPasses > 0 and stats[0] > 0: print "***WARNING! MEAN BURSTING COLUMNS IN TEST PHASE IS GREATER THAN 0***" print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics()) print plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Testing") elapsed = int(time.time() - start) print "Total time: {0:2} seconds.".format(elapsed) # Write Union SDR trace metricName = "activeCells" outputFileName = "unionSdrTrace_{0}learningPasses.csv".format(trainingPasses) writeMetricTrace(experiment, metricName, outputDir, outputFileName) if plotVerbosity >= 1: raw_input("Press any key to exit...")
# Length of sequences shown to network sequenceLength = params["sequenceLength"] # Number of sequences used. Sequences may share common elements. numberOfSequences = params["numberOfSequences"] # Number of sequence passes for training the TM. Zero => no training. trainingPasses = params["trainingPasses"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) print "\nGenerating sequences..." patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [ str(numbers[i + i * sequenceLength:i + (i + 1) * sequenceLength]) for i in xrange(numberOfSequences) ] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) def initializeNetwork():
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 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 ExtendedTemporalMemoryTest(unittest.TestCase): def setUp(self): self.tm = ExtendedTemporalMemory(learnOnOneCell=False) def testInitInvalidParams(self): # Invalid columnDimensions kwargs = {"columnDimensions": [], "cellsPerColumn": 32} self.assertRaises(ValueError, ExtendedTemporalMemory, **kwargs) # Invalid cellsPerColumn kwargs = {"columnDimensions": [2048], "cellsPerColumn": 0} self.assertRaises(ValueError, ExtendedTemporalMemory, **kwargs) kwargs = {"columnDimensions": [2048], "cellsPerColumn": -10} self.assertRaises(ValueError, ExtendedTemporalMemory, **kwargs) def testlearnOnOneCellParam(self): tm = self.tm self.assertFalse(tm.learnOnOneCell) tm = ExtendedTemporalMemory(learnOnOneCell=True) self.assertTrue(tm.learnOnOneCell) def testActivateCorrectlyPredictiveCells(self): tm = self.tm prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns ) self.assertEqual(activeCells, set([1026, 26337, 26339])) self.assertEqual(winnerCells, set([1026, 26337, 26339])) self.assertEqual(predictedColumns, set([32, 823])) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsEmpty(self): tm = self.tm # No previous predictive cells, no active columns prevPredictiveCells = set() activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns ) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No previous predictive cells, with active columns prevPredictiveCells = set() activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns ) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No active columns, with previously predictive cells prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns ) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsOrphan(self): tm = self.tm tm.predictedSegmentDecrement = 0.001 prevPredictiveCells = set([]) activeColumns = set([32, 47, 823]) prevMatchingCells = set([32, 47]) (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns ) self.assertEqual(activeCells, set([])) self.assertEqual(winnerCells, set([])) self.assertEqual(predictedColumns, set([])) self.assertEqual(predictedInactiveCells, set([32, 47])) def testBurstColumns(self): tm = ExtendedTemporalMemory(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]) prevActiveCells = set([23, 37, 49, 733]) prevWinnerCells = set([23, 37, 49, 733]) prevActiveApicalCells = set() learnOnOneCell = False chosenCellForColumn = {} (activeCells, winnerCells, learningSegments, apicalLearningSegments, chosenCellForColumn) = tm.burstColumns( activeColumns, predictedColumns, prevActiveCells, prevActiveApicalCells, prevWinnerCells, learnOnOneCell, chosenCellForColumn, connections, tm.apicalConnections, ) self.assertEqual(activeCells, set([0, 1, 2, 3, 4, 5, 6, 7])) randomWinner = 4 # 4 should be randomly chosen cell self.assertEqual(winnerCells, set([0, randomWinner])) 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(randomWinner), set([4])) def testBurstColumnsEmpty(self): tm = self.tm activeColumns = set() predictedColumns = set() prevActiveCells = set() prevWinnerCells = set() connections = tm.connections prevActiveApicalCells = set() learnOnOneCell = False chosenCellForColumn = {} (activeCells, winnerCells, learningSegments, apicalLearningSegments, chosenCellForColumn) = tm.burstColumns( activeColumns, predictedColumns, prevActiveCells, prevActiveApicalCells, prevWinnerCells, learnOnOneCell, chosenCellForColumn, connections, tm.apicalConnections, ) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(learningSegments, set()) self.assertEqual(apicalLearningSegments, set()) def testLearnOnSegments(self): tm = ExtendedTemporalMemory(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]) predictedInactiveCells = set() prevMatchingSegments = set() tm.learnOnSegments( prevActiveSegments, learningSegments, prevActiveCells, winnerCells, prevWinnerCells, connections, predictedInactiveCells, prevMatchingSegments, ) # Check segment 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) # Check segment 1 synapseData = connections.dataForSynapse(3) self.assertAlmostEqual(synapseData.permanence, 0.8) self.assertEqual(len(connections.synapsesForSegment(1)), 2) # Check segment 2 synapseData = connections.dataForSynapse(4) self.assertAlmostEqual(synapseData.permanence, 0.9) self.assertEqual(len(connections.synapsesForSegment(2)), 1) # Check segment 3 self.assertEqual(len(connections.synapsesForSegment(3)), 2) def testComputePredictiveCells(self): tm = ExtendedTemporalMemory(activationThreshold=2, minThreshold=2, predictedSegmentDecrement=0.004) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, matchingSegments, matchingCells) = tm.computePredictiveCells( activeCells, connections ) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(matchingSegments, set([0, 1])) self.assertEqual(matchingCells, set([0, 1])) def testBestMatchingCell(self): tm = ExtendedTemporalMemory(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]) activeApicalCells = set() self.assertEqual( tm.bestMatchingCell( tm.cellsForColumn(0), activeCells, activeApicalCells, connections, tm.apicalConnections ), (0, 0, None), ) self.assertEqual( tm.bestMatchingCell( tm.cellsForColumn(3), activeCells, activeApicalCells, connections, tm.apicalConnections ), (103, None, None), ) # Random cell from column self.assertEqual( tm.bestMatchingCell( tm.cellsForColumn(999), activeCells, activeApicalCells, connections, tm.apicalConnections ), (31979, None, None), ) # Random cell from column def testBestMatchingCellFewestSegments(self): tm = ExtendedTemporalMemory( 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([]) activeApicalCells = set() for _ in range(100): # Never pick cell 0, always pick cell 1 (cell, _, _) = tm.bestMatchingCell( tm.cellsForColumn(0), activeSynapsesForSegment, activeApicalCells, connections, tm.apicalConnections ) self.assertEqual(cell, 1) def testBestMatchingSegment(self): tm = ExtendedTemporalMemory(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 testLeastUsedCell(self): tm = ExtendedTemporalMemory(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), connections), 1) def testAdaptSegment(self): tm = self.tm 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(0, set([0, 1]), connections, tm.permanenceIncrement, tm.permanenceDecrement) 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 testAdaptSegmentToMax(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.9) tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) # Now permanence should be at max tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) def testAdaptSegmentToMin(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.1) tm.adaptSegment(0, set(), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapses = connections.synapsesForSegment(0) self.assertFalse(0 in synapses) def testPickCellsToLearnOn(self): tm = ExtendedTemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) winnerCells = set([4, 47, 58, 93]) self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells, connections), set([4, 93])) # randomly picked self.assertEqual(tm.pickCellsToLearnOn(100, 0, winnerCells, connections), set([4, 47, 58, 93])) self.assertEqual(tm.pickCellsToLearnOn(0, 0, winnerCells, connections), set()) def testPickCellsToLearnOnAvoidDuplicates(self): tm = ExtendedTemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) winnerCells = set([23]) # Ensure that no additional (duplicate) cells were picked self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells, connections), set()) def testColumnForCell1D(self): tm = ExtendedTemporalMemory(columnDimensions=[2048], cellsPerColumn=5) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(4), 0) self.assertEqual(tm.columnForCell(5), 1) self.assertEqual(tm.columnForCell(10239), 2047) def testColumnForCell2D(self): tm = ExtendedTemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(3), 0) self.assertEqual(tm.columnForCell(4), 1) self.assertEqual(tm.columnForCell(16383), 4095) def testColumnForCellInvalidCell(self): tm = ExtendedTemporalMemory(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 testCellsForColumn1D(self): tm = ExtendedTemporalMemory(columnDimensions=[2048], cellsPerColumn=5) expectedCells = set([5, 6, 7, 8, 9]) self.assertEqual(tm.cellsForColumn(1), expectedCells) def testCellsForColumn2D(self): tm = ExtendedTemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) expectedCells = set([256, 257, 258, 259]) self.assertEqual(tm.cellsForColumn(64), expectedCells) def testCellsForColumnInvalidColumn(self): tm = ExtendedTemporalMemory(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 testNumberOfColumns(self): tm = ExtendedTemporalMemory(columnDimensions=[64, 64], cellsPerColumn=32) self.assertEqual(tm.numberOfColumns(), 64 * 64) def testNumberOfCells(self): tm = ExtendedTemporalMemory(columnDimensions=[64, 64], cellsPerColumn=32) self.assertEqual(tm.numberOfCells(), 64 * 64 * 32) def testMapCellsToColumns(self): tm = ExtendedTemporalMemory(columnDimensions=[100], cellsPerColumn=4) columnsForCells = 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])) def testCalculatePredictiveCells(self): tm = ExtendedTemporalMemory(columnDimensions=[4], cellsPerColumn=5) predictiveDistalCells = set([2, 3, 5, 8, 10, 12, 13, 14]) predictiveApicalCells = set([1, 5, 7, 11, 14, 15, 17]) self.assertEqual(tm.calculatePredictiveCells(predictiveDistalCells, predictiveApicalCells), set([2, 3, 5, 14])) def testCompute(self): tm = ExtendedTemporalMemory( columnDimensions=[4], cellsPerColumn=10, learnOnOneCell=False, initialPermanence=0.2, connectedPermanence=0.7, activationThreshold=1, ) seg1 = tm.connections.createSegment(0) seg2 = tm.connections.createSegment(20) seg3 = tm.connections.createSegment(25) try: tm.connections.createSynapse(seg1, 15, 0.9) tm.connections.createSynapse(seg2, 35, 0.9) tm.connections.createSynapse(seg2, 45, 0.9) # external cell tm.connections.createSynapse(seg3, 35, 0.9) tm.connections.createSynapse(seg3, 50, 0.9) # external cell except IndexError: self.fail("IndexError raised unexpectedly for distal segments") aSeg1 = tm.apicalConnections.createSegment(1) aSeg2 = tm.apicalConnections.createSegment(25) try: tm.apicalConnections.createSynapse(aSeg1, 3, 0.9) tm.apicalConnections.createSynapse(aSeg2, 1, 0.9) except IndexError: self.fail("IndexError raised unexpectedly for apical segments") activeColumns = set([1, 3]) activeExternalCells = set([5, 10, 15]) activeApicalCells = set([1, 2, 3, 4]) tm.compute( activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, learn=False ) activeColumns = set([0, 2]) tm.compute(activeColumns, activeExternalCells=set(), activeApicalCells=set()) self.assertEqual(tm.activeCells, set([0, 20, 25])) def testLearning(self): tm = ExtendedTemporalMemory( columnDimensions=[4], cellsPerColumn=10, learnOnOneCell=False, initialPermanence=0.5, connectedPermanence=0.6, activationThreshold=1, minThreshold=1, maxNewSynapseCount=2, permanenceDecrement=0.05, permanenceIncrement=0.2, ) seg1 = tm.connections.createSegment(0) seg2 = tm.connections.createSegment(10) seg3 = tm.connections.createSegment(20) seg4 = tm.connections.createSegment(30) try: tm.connections.createSynapse(seg1, 10, 0.9) tm.connections.createSynapse(seg2, 20, 0.9) tm.connections.createSynapse(seg3, 30, 0.9) tm.connections.createSynapse(seg3, 41, 0.9) tm.connections.createSynapse(seg3, 25, 0.9) tm.connections.createSynapse(seg4, 0, 0.9) except IndexError: self.fail("IndexError raised unexpectedly for distal segments") aSeg1 = tm.apicalConnections.createSegment(0) aSeg2 = tm.apicalConnections.createSegment(20) try: tm.apicalConnections.createSynapse(aSeg1, 42, 0.8) tm.apicalConnections.createSynapse(aSeg2, 43, 0.8) except IndexError: self.fail("IndexError raised unexpectedly for apical segments") activeColumns = set([1, 3]) activeExternalCells = set([1]) # will be re-indexed to 41 activeApicalCells = set([2, 3]) # will be re-indexed to 42, 43 tm.compute( activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, learn=False ) activeColumns = set([0, 2]) tm.compute(activeColumns, activeExternalCells=None, activeApicalCells=None, learn=True) self.assertEqual(tm.activeCells, set([0, 20])) # distal learning synapse = list(tm.connections.synapsesForSegment(seg1))[0] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 1.0) synapse = list(tm.connections.synapsesForSegment(seg2))[0] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 0.9) synapse = list(tm.connections.synapsesForSegment(seg3))[0] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 1.0) synapse = list(tm.connections.synapsesForSegment(seg3))[1] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 1.0) synapse = list(tm.connections.synapsesForSegment(seg3))[2] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 0.85) synapse = list(tm.connections.synapsesForSegment(seg4))[0] self.assertEqual(tm.connections.dataForSynapse(synapse).permanence, 0.9) # apical learning synapse = list(tm.apicalConnections.synapsesForSegment(aSeg1))[0] self.assertEqual(tm.apicalConnections.dataForSynapse(synapse).permanence, 1.0) synapse = list(tm.apicalConnections.synapsesForSegment(aSeg2))[0] self.assertEqual(tm.apicalConnections.dataForSynapse(synapse).permanence, 1.0) @unittest.skipUnless(capnp is not None, "No serialization available for ETM") def testWriteRead(self): tm1 = ExtendedTemporalMemory( 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 = ExtendedTemporalMemory.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)
class TemporalMemoryPerformanceTest(unittest.TestCase): def setUp(self): self.tmPy = TemporalMemoryPy(columnDimensions=[2048], cellsPerColumn=32, initialPermanence=0.5, connectedPermanence=0.8, minThreshold=10, maxNewSynapseCount=12, permanenceIncrement=0.1, permanenceDecrement=0.05, activationThreshold=15) self.tmCPP = TemporalMemoryCPP(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 testSingleSequence(self): print "Test: Single sequence" sequence = self.sequenceMachine.generateFromNumbers(range(50)) times = self._feedAll(sequence) self.assertTrue(times[1] < times[0]) self.assertTrue(times[3] < times[2]) # ============================== # Helper functions # ============================== def _feedAll(self, sequence, learn=True, num=1): repeatedSequence = sequence * num times = [] def tmComputeFn(pattern, instance): instance.compute(pattern, learn) def tpComputeFn(pattern, instance): array = self._patternToNumpyArray(pattern) instance.compute(array, enableLearn=learn, computeInfOutput=True) elapsed = self._feedOne(repeatedSequence, self.tmPy, tmComputeFn) times.append(elapsed) print "TM (py):\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tmCPP, tmComputeFn) times.append(elapsed) print "TM (C++):\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tp, tpComputeFn) times.append(elapsed) print "TP:\t\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tp10x2, tpComputeFn) times.append(elapsed) print "TP10X2:\t\t{0}s".format(elapsed) return times @staticmethod def _feedOne(sequence, instance, computeFn): start = time.clock() for pattern in sequence: if pattern == None: instance.reset() else: computeFn(pattern, instance) elapsed = time.clock() - start return elapsed @staticmethod def _patternToNumpyArray(pattern): array = numpy.zeros(2048, dtype='int32') array[list(pattern)] = 1 return array
class TemporalMemoryPerformanceTest(unittest.TestCase): def setUp(self): self.tmPy = TemporalMemoryPy(columnDimensions=[2048], cellsPerColumn=32, initialPermanence=0.5, connectedPermanence=0.8, minThreshold=10, maxNewSynapseCount=12, permanenceIncrement=0.1, permanenceDecrement=0.05, activationThreshold=15) self.tmCPP = TemporalMemoryCPP(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 testSingleSequence(self): print "Test: Single sequence" sequence = self.sequenceMachine.generateFromNumbers(range(50)) times = self._feedAll(sequence) self.assertTrue(times[1] < times[0]) self.assertTrue(times[3] < times[2]) # ============================== # Helper functions # ============================== def _feedAll(self, sequence, learn=True, num=1): repeatedSequence = sequence * num times = [] def tmComputeFn(pattern, instance): instance.compute(pattern, learn) def tpComputeFn(pattern, instance): array = self._patternToNumpyArray(pattern) instance.compute(array, enableLearn=learn, computeInfOutput=True) elapsed = self._feedOne(repeatedSequence, self.tmPy, tmComputeFn) times.append(elapsed) print "TM (py):\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tmCPP, tmComputeFn) times.append(elapsed) print "TM (C++):\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tp, tpComputeFn) times.append(elapsed) print "TP:\t\t{0}s".format(elapsed) elapsed = self._feedOne(repeatedSequence, self.tp10x2, tpComputeFn) times.append(elapsed) print "TP10X2:\t\t{0}s".format(elapsed) return times @staticmethod def _feedOne(sequence, instance, computeFn): start = time.clock() for pattern in sequence: if pattern == None: instance.reset() else: computeFn(pattern, instance) elapsed = time.clock() - start return elapsed @staticmethod def _patternToNumpyArray(pattern): array = numpy.zeros(2048, dtype='int32') array[list(pattern)] = 1 return array
# Length of sequences shown to network sequenceLength = params["sequenceLength"] # Number of sequences used. Sequences may share common elements. numberOfSequences = params["numberOfSequences"] # Number of sequence passes for training the TM. Zero => no training. trainingPasses = params["trainingPasses"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) print "\nGenerating sequences..." patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength]) for i in xrange(numberOfSequences)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) def initializeNetwork(): tmParamOverrides = params["temporalMemoryParams"] upParamOverrides = params["unionPoolerParams"]
def setUp(self): self.tm = None self.patternMachine = self.getPatternMachine() self.sequenceMachine = SequenceMachine(self.patternMachine)
def run(params, paramDir, outputDir, plotVerbosity=0, consoleVerbosity=0): """ Runs the noise robustness experiment. :param params: A dict containing the following experiment parameters: patternDimensionality - Dimensionality of sequence patterns patternCardinality - Cardinality (# ON bits) of sequence patterns sequenceLength - Length of sequences shown to network sequenceCount - Number of unique sequences used trainingPasses - Number of times Temporal Memory is trained on each sequence testPresentations - Number of sequences presented in test phase perturbationChance - Chance of sequence perturbations during test phase temporalMemoryParams - A dict of Temporal Memory parameter overrides unionPoolerParams - A dict of Union Pooler parameter overrides :param paramDir: Path of parameter file :param outputDir: Output will be written to this path :param plotVerbosity: Plotting verbosity :param consoleVerbosity: Console output verbosity """ print "Running Noise robustness experiment...\n" print "Params dir: {0}".format(os.path.join(os.path.dirname(__file__), paramDir)) print "Output dir: {0}\n".format(os.path.join(os.path.dirname(__file__), outputDir)) patternDimensionality = params["patternDimensionality"] patternCardinality = params["patternCardinality"] sequenceLength = params["sequenceLength"] sequenceCount = params["numberOfSequences"] trainingPasses = params["trainingPasses"] testPresentations = params["testPresentations"] perturbationChance = params["perturbationChance"] tmParamOverrides = params["temporalMemoryParams"] upParamOverrides = params["unionPoolerParams"] # TODO If this parameter is to be supported, the sequence generation # code below must change # Number of unique patterns from which sequences are built # patternAlphabetSize = params["patternAlphabetSize"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) start = time.time() print "Generating sequences..." patternAlphabetSize = sequenceLength * sequenceCount patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(sequenceCount, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength]) for i in xrange(sequenceCount)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) # Set up the Temporal Memory and Union Pooler network print "\nCreating network..." experiment = UnionPoolerExperiment(tmParamOverrides, upParamOverrides) # Train only the Temporal Memory on the generated sequences if trainingPasses > 0: print "\nTraining Temporal Memory..." if consoleVerbosity > 0: print "\nPass\tMean\t\tStdDev\t\tMax\t\t(Bursting Columns)" for i in xrange(trainingPasses): experiment.runNetworkOnSequence(generatedSequences, labeledSequences, tmLearn=True, upLearn=None, verbosity=consoleVerbosity, progressInterval=_SHOW_PROGRESS_INTERVAL) if consoleVerbosity > 0: stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2]) # Reset the TM monitor mixin's records accrued during this training pass # experiment.tm.mmClearHistory() print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics()) print if plotVerbosity >= 2: plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Training") print "\nRunning test phase..." # Input sequence pattern by pattern. Sequence-to-sequence # progression is randomly selected. At each step there is a chance of # perturbation. Specifically the following # perturbations may occur: # Establish a baseline without noise # Establish a baseline adding the following perturbations one-by-one # 1) substitution of some other pattern for the normal expected pattern # 2) skipping expected pattern and presenting next pattern in sequence # 3) addition of some other pattern putting off expected pattern one time step # Finally measure performance on more complex perturbation # TODO 4) Jump to another sequence randomly (Random jump to start or random # position?) runTestPhase(experiment, generatedSequences, sequenceCount, sequenceLength, testPresentations, perturbationChance) print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics()) print # plotNetworkState(experiment, plotVerbosity, trainingPasses, phase="Testing") elapsed = int(time.time() - start) print "Total time: {0:2} seconds.".format(elapsed) ## Write Union SDR trace # metricName = "activeCells" # outputFileName = "unionSdrTrace_{0}learningPasses.csv".format(trainingPasses) # writeMetricTrace(experiment, metricName, outputDir, outputFileName) if plotVerbosity >= 1: raw_input("\nPress any key to exit...")
class TemporalMemoryTest(unittest.TestCase): def setUp(self): self.tm = TemporalMemory() def testInitInvalidParams(self): # Invalid columnDimensions kwargs = {"columnDimensions": [], "cellsPerColumn": 32} self.assertRaises(ValueError, TemporalMemory, **kwargs) # Invalid cellsPerColumn kwargs = {"columnDimensions": [2048], "cellsPerColumn": 0} self.assertRaises(ValueError, TemporalMemory, **kwargs) kwargs = {"columnDimensions": [2048], "cellsPerColumn": -10} self.assertRaises(ValueError, TemporalMemory, **kwargs) def testActivateCorrectlyPredictiveCells(self): tm = self.tm prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set([1026, 26337, 26339])) self.assertEqual(winnerCells, set([1026, 26337, 26339])) self.assertEqual(predictedColumns, set([32, 823])) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsEmpty(self): tm = self.tm # No previous predictive cells, no active columns prevPredictiveCells = set() activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No previous predictive cells, with active columns prevPredictiveCells = set() activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No active columns, with previously predictive cells prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsOrphan(self): tm = self.tm tm.predictedSegmentDecrement = 0.001 prevPredictiveCells = set([]) activeColumns = set([32, 47, 823]) prevMatchingCells = set([32, 47]) (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells( prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set([])) self.assertEqual(winnerCells, set([])) self.assertEqual(predictedColumns, set([])) self.assertEqual(predictedInactiveCells, set([32, 47])) 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]) prevActiveCells = set([23, 37, 49, 733]) prevWinnerCells = set([23, 37, 49, 733]) (activeCells, winnerCells, learningSegments) = tm.burstColumns(activeColumns, predictedColumns, prevActiveCells, prevWinnerCells, 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 testBurstColumnsEmpty(self): tm = self.tm activeColumns = set() predictedColumns = set() prevActiveCells = set() prevWinnerCells = set() connections = tm.connections (activeCells, winnerCells, learningSegments) = tm.burstColumns(activeColumns, predictedColumns, prevActiveCells, prevWinnerCells, connections) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(learningSegments, set()) 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]) predictedInactiveCells = set() prevMatchingSegments = set() tm.learnOnSegments(prevActiveSegments, learningSegments, prevActiveCells, winnerCells, prevWinnerCells, connections, predictedInactiveCells, prevMatchingSegments) # Check segment 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) # Check segment 1 synapseData = connections.dataForSynapse(3) self.assertAlmostEqual(synapseData.permanence, 0.8) self.assertEqual(len(connections.synapsesForSegment(1)), 2) # Check segment 2 synapseData = connections.dataForSynapse(4) self.assertAlmostEqual(synapseData.permanence, 0.9) self.assertEqual(len(connections.synapsesForSegment(2)), 1) # Check segment 3 self.assertEqual(len(connections.synapsesForSegment(3)), 2) def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2, minThreshold=2, predictedSegmentDecrement=0.004) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, matchingSegments, matchingCells) = tm.computePredictiveCells(activeCells, connections) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(matchingSegments, set([0, 1])) self.assertEqual(matchingCells, set([0, 1])) 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), (96, None)) # Random cell from column self.assertEqual( tm.bestMatchingCell(tm.cellsForColumn(999), activeCells, connections), (31972, None)) # Random cell from column 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, connections) self.assertEqual(cell, 1) 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 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), connections), 1) def testAdaptSegment(self): tm = self.tm 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(0, set([0, 1]), connections, tm.permanenceIncrement, tm.permanenceDecrement) 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 testAdaptSegmentToMax(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.9) tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) # Now permanence should be at max tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) def testAdaptSegmentToMin(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.1) tm.adaptSegment(0, set(), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapses = connections.synapsesForSegment(0) self.assertFalse(0 in synapses) 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, connections), set([4, 58])) # randomly picked self.assertEqual( tm.pickCellsToLearnOn(100, 0, winnerCells, connections), set([4, 47, 58, 93])) self.assertEqual(tm.pickCellsToLearnOn(0, 0, winnerCells, connections), set()) def testPickCellsToLearnOnAvoidDuplicates(self): tm = TemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) winnerCells = set([23]) # Ensure that no additional (duplicate) cells were picked self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells, connections), set()) def testColumnForCell1D(self): tm = TemporalMemory(columnDimensions=[2048], cellsPerColumn=5) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(4), 0) self.assertEqual(tm.columnForCell(5), 1) self.assertEqual(tm.columnForCell(10239), 2047) def testColumnForCell2D(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(3), 0) self.assertEqual(tm.columnForCell(4), 1) self.assertEqual(tm.columnForCell(16383), 4095) 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 testCellsForColumn1D(self): tm = TemporalMemory(columnDimensions=[2048], cellsPerColumn=5) expectedCells = set([5, 6, 7, 8, 9]) self.assertEqual(tm.cellsForColumn(1), expectedCells) def testCellsForColumn2D(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=4) expectedCells = set([256, 257, 258, 259]) self.assertEqual(tm.cellsForColumn(64), expectedCells) 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 testNumberOfColumns(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=32) self.assertEqual(tm.numberOfColumns(), 64 * 64) def testNumberOfCells(self): tm = TemporalMemory(columnDimensions=[64, 64], cellsPerColumn=32) self.assertEqual(tm.numberOfCells(), 64 * 64 * 32) def testMapCellsToColumns(self): tm = TemporalMemory(columnDimensions=[100], cellsPerColumn=4) columnsForCells = 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])) 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 experiment1(): paramDir = 'params/1024_baseline/5_trainingPasses.yaml' outputDir = 'results/' params = yaml.safe_load(open(paramDir, 'r')) options = {'plotVerbosity': 2, 'consoleVerbosity': 2} plotVerbosity = 2 consoleVerbosity = 1 print "Running SDR overlap experiment...\n" print "Params dir: {0}".format(paramDir) print "Output dir: {0}\n".format(outputDir) # Dimensionality of sequence patterns patternDimensionality = params["patternDimensionality"] # Cardinality (ON / true bits) of sequence patterns patternCardinality = params["patternCardinality"] # TODO If this parameter is to be supported, the sequence generation code # below must change # Number of unique patterns from which sequences are built # patternAlphabetSize = params["patternAlphabetSize"] # Length of sequences shown to network sequenceLength = params["sequenceLength"] # Number of sequences used. Sequences may share common elements. numberOfSequences = params["numberOfSequences"] # Number of sequence passes for training the TM. Zero => no training. trainingPasses = params["trainingPasses"] tmParamOverrides = params["temporalMemoryParams"] upParamOverrides = params["unionPoolerParams"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) start = time.time() print "\nGenerating sequences..." patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [str(numbers[i + i*sequenceLength: i + (i+1)*sequenceLength]) for i in xrange(numberOfSequences)] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) # Set up the Temporal Memory and Union Pooler network print "\nCreating network..." experiment = UnionTemporalPoolerExperiment(tmParamOverrides, upParamOverrides) # Train only the Temporal Memory on the generated sequences if trainingPasses > 0: print "\nTraining Temporal Memory..." if consoleVerbosity > 0: print "\nPass\tBursting Columns Mean\tStdDev\tMax" for i in xrange(trainingPasses): experiment.runNetworkOnSequences(generatedSequences, labeledSequences, tmLearn=True, upLearn=None, verbosity=consoleVerbosity, progressInterval=_SHOW_PROGRESS_INTERVAL) if consoleVerbosity > 0: stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2]) # Reset the TM monitor mixin's records accrued during this training pass # experiment.tm.mmClearHistory() print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics()) print experiment.tm.mmClearHistory() experiment.up.mmClearHistory() print "\nRunning test phase..." inputSequences = generatedSequences inputCategories = labeledSequences tmLearn = True upLearn = False classifierLearn = False currentTime = time.time() experiment.tm.reset() experiment.up.reset() poolingActivationTrace = numpy.zeros((experiment.up._numColumns, 1)) activeCellsTrace = numpy.zeros((experiment.up._numColumns, 1)) activeSPTrace = numpy.zeros((experiment.up._numColumns, 1)) for _ in xrange(trainingPasses): experiment.tm.reset() for i in xrange(len(inputSequences)): sensorPattern = inputSequences[i] inputCategory = inputCategories[i] if sensorPattern is None: pass else: experiment.tm.compute(sensorPattern, learn=tmLearn, sequenceLabel=inputCategory) if upLearn is not None: activeCells, predActiveCells, burstingCols, = experiment.getUnionTemporalPoolerInput() experiment.up.compute(activeCells, predActiveCells, learn=upLearn, sequenceLabel=inputCategory) currentPoolingActivation = experiment.up._poolingActivation currentPoolingActivation = experiment.up._poolingActivation.reshape((experiment.up._numColumns, 1)) poolingActivationTrace = numpy.concatenate((poolingActivationTrace, currentPoolingActivation), 1) currentUnionSDR = numpy.zeros((experiment.up._numColumns, 1)) currentUnionSDR[experiment.up._unionSDR] = 1 activeCellsTrace = numpy.concatenate((activeCellsTrace, currentUnionSDR), 1) currentSPSDR = numpy.zeros((experiment.up._numColumns, 1)) currentSPSDR[experiment.up._activeCells] = 1 activeSPTrace = numpy.concatenate((activeSPTrace, currentSPSDR), 1) print "\nPass\tBursting Columns Mean\tStdDev\tMax" stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(0, stats[0], stats[1], stats[2]) print print MonitorMixinBase.mmPrettyPrintMetrics(\ experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics()) print experiment.tm.mmClearHistory() # estimate fraction of shared bits across adjacent time point unionSDRshared = experiment.up._mmComputeUnionSDRdiff() bitLifeList = experiment.up._mmComputeBitLifeStats() bitLife = numpy.array(bitLifeList) # Plot SP outputs, UP persistence and UP outputs in testing phase def showSequenceStartLine(ax, trainingPasses, sequenceLength): for i in xrange(trainingPasses): ax.vlines(i*sequenceLength, 0, 100, linestyles='--') plt.figure() ncolShow = 100 f, (ax1, ax2, ax3) = plt.subplots(nrows=1,ncols=3) ax1.imshow(activeSPTrace[1:ncolShow,:], cmap=cm.Greys,interpolation="nearest",aspect='auto') showSequenceStartLine(ax1, trainingPasses, sequenceLength) ax1.set_title('SP SDR') ax1.set_ylabel('Columns') ax2.imshow(poolingActivationTrace[1:100,:], cmap=cm.Greys, interpolation="nearest",aspect='auto') showSequenceStartLine(ax2, trainingPasses, sequenceLength) ax2.set_title('Persistence') ax3.imshow(activeCellsTrace[1:ncolShow,:], cmap=cm.Greys, interpolation="nearest",aspect='auto') showSequenceStartLine(ax3, trainingPasses, sequenceLength) plt.title('Union SDR') ax2.set_xlabel('Time (steps)') pp = PdfPages('results/UnionPoolingOnLearnedTM_Experiment1.pdf') pp.savefig() pp.close() f, (ax1, ax2, ax3) = plt.subplots(nrows=3,ncols=1) ax1.plot((sum(activeCellsTrace))/experiment.up._numColumns*100) ax1.set_ylabel('Union SDR size (%)') ax1.set_xlabel('Time (steps)') ax1.set_ylim(0,25) ax2.plot(unionSDRshared) ax2.set_ylabel('Shared Bits') ax2.set_xlabel('Time (steps)') ax3.hist(bitLife) ax3.set_xlabel('Life duration for each bit') pp = PdfPages('results/UnionSDRproperty_Experiment1.pdf') pp.savefig() pp.close()
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)
class SpatialTemporalPoolerTest(unittest.TestCase): def setUp(self): print ("\n" "======================================================\n" "Test: {0} \n" "{1}\n" "======================================================\n" ).format(self.id(), self.shortDescription()) self.patternMachine = PatternMachine(1024, 20, num=100) self.sequenceMachine = SequenceMachine(self.patternMachine) self.tm = MonitoredTemporalMemory( mmName="TM", columnDimensions=[1024], cellsPerColumn=16, initialPermanence=0.5, connectedPermanence=0.7, minThreshold=20, maxNewSynapseCount=30, permanenceIncrement=0.1, permanenceDecrement=0.02, activationThreshold=20) self.tp = MonitoredTemporalPooler( inputDimensions=[1024, 16], columnDimensions=[1024], mmName="TP") self._showInternalStatePlots(appendTitle=" (initial)") def testBasic(self): """Two basic sequences""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15] ] labels = ["A", "B"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) def testOverlapping(self): """Overlapping sequences""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [ 0, 16, 17, 18, 19, 20, 21, 7], [22, 23, 24, 11, 12, 25, 26, 27] ] labels = ["A", "B", "C", "D"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) def testMerged(self): """Two distinct sequences, and merged""" sequences = [ [ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] ] labels = ["A", "B", "AB"] sequences = [self.sequenceMachine.generateFromNumbers(s) for s in sequences] for _ in xrange(10): self._feedSequences(sequences, sequenceLabels=labels) # TO DO: assert C columns contain some A and some B columns, and assert # the split is about equal between A and B def tearDown(self): self._printInfo() self._showActivityPlots() self._showInternalStatePlots(appendTitle=" (final)") @classmethod def tearDownClass(cls): if PLOT >= 1: print raw_input("Press any key to exit...") def _feedSequences(self, sequences, tmLearn=True, tpLearn=True, sequenceLabels=None): for i in xrange(len(sequences)): sequence = sequences[i] label = sequenceLabels[i] if sequenceLabels is not None else None for pattern in sequence: self._feedPattern(pattern, tmLearn=tmLearn, tpLearn=tpLearn, sequenceLabel=label) self.tm.reset() self.tp.reset() def _printInfo(self): if VERBOSITY >= 2: print MonitorMixinBase.mmPrettyPrintTraces( self.tp.mmGetDefaultTraces(verbosity=3) + self.tm.mmGetDefaultTraces(verbosity=3), breakOnResets=self.tm.mmGetTraceResets()) print if VERBOSITY >= 1: print MonitorMixinBase.mmPrettyPrintMetrics( self.tp.mmGetDefaultMetrics() + self.tm.mmGetDefaultMetrics()) print def _showActivityPlots(self): if PLOT >= 1: title = self.shortDescription() self.tp.mmGetCellActivityPlot(showReset=True, title=title) def _showInternalStatePlots(self, appendTitle=None): if PLOT >= 1: title = self.shortDescription() if appendTitle: title += appendTitle self.tp.mmGetPermanencesPlot(title=title) def _feedPattern(self, pattern, tmLearn=True, tpLearn=True, sequenceLabel=None): # Feed the TM predictedCells = self.tm.predictiveCells self.tm.compute(pattern, learn=tmLearn, sequenceLabel=sequenceLabel) # If requested, feed the TP if tpLearn is not None: tpInputVector, correctlyPredictedCells = ( self._formatInputForTP(predictedCells)) activeArray = numpy.zeros(self.tp.getNumColumns()) self.tp.compute(tpInputVector, tpLearn, activeArray, None, # not needed correctlyPredictedCells, sequenceLabel=sequenceLabel) def _formatInputForTP(self, predictedCells): """ Given an instance of the TM, format the information we need to send to the TP. """ # all currently active cells in layer 4 tpInputVector = numpy.zeros( self.tm.numberOfCells()).astype(realDType) tpInputVector[list(self.tm.activeCells)] = 1 # correctly predicted cells in layer 4 correctlyPredictedCells = numpy.zeros( self.tm.numberOfCells()).astype(realDType) correctlyPredictedCells[list(predictedCells & self.tm.activeCells)] = 1 return tpInputVector, correctlyPredictedCells
def setUp(self): self.patternMachine = ConsecutivePatternMachine(100, 5) self.sequenceMachine = SequenceMachine(self.patternMachine)
class TemporalMemoryTest(unittest.TestCase): def setUp(self): self.tm = TemporalMemory() def testInitInvalidParams(self): # Invalid columnDimensions kwargs = {"columnDimensions": [], "cellsPerColumn": 32} self.assertRaises(ValueError, TemporalMemory, **kwargs) # Invalid cellsPerColumn kwargs = {"columnDimensions": [2048], "cellsPerColumn": 0} self.assertRaises(ValueError, TemporalMemory, **kwargs) kwargs = {"columnDimensions": [2048], "cellsPerColumn": -10} self.assertRaises(ValueError, TemporalMemory, **kwargs) def testActivateCorrectlyPredictiveCells(self): tm = self.tm prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells(prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set([1026, 26337, 26339])) self.assertEqual(winnerCells, set([1026, 26337, 26339])) self.assertEqual(predictedColumns, set([32, 823])) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsEmpty(self): tm = self.tm # No previous predictive cells, no active columns prevPredictiveCells = set() activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells(prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No previous predictive cells, with active columns prevPredictiveCells = set() activeColumns = set([32, 47, 823]) prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells(prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) # No active columns, with previously predictive cells prevPredictiveCells = set([0, 237, 1026, 26337, 26339, 55536]) activeColumns = set() prevMatchingCells = set() (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells(prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(predictedColumns, set()) self.assertEqual(predictedInactiveCells, set()) def testActivateCorrectlyPredictiveCellsOrphan(self): tm = self.tm prevPredictiveCells = set([]) activeColumns = set([32, 47, 823]) prevMatchingCells = set([32, 47]) (activeCells, winnerCells, predictedColumns, predictedInactiveCells) = tm.activateCorrectlyPredictiveCells(prevPredictiveCells, prevMatchingCells, activeColumns) self.assertEqual(activeCells, set([])) self.assertEqual(winnerCells, set([])) self.assertEqual(predictedColumns, set([])) self.assertEqual(predictedInactiveCells, set([32,47])) 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]) prevActiveCells = set([23, 37, 49, 733]) prevWinnerCells = set([23, 37, 49, 733]) (activeCells, winnerCells, learningSegments) = tm.burstColumns(activeColumns, predictedColumns, prevActiveCells, prevWinnerCells, 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 testBurstColumnsEmpty(self): tm = self.tm activeColumns = set() predictedColumns = set() prevActiveCells = set() prevWinnerCells = set() connections = tm.connections (activeCells, winnerCells, learningSegments) = tm.burstColumns(activeColumns, predictedColumns, prevActiveCells, prevWinnerCells, connections) self.assertEqual(activeCells, set()) self.assertEqual(winnerCells, set()) self.assertEqual(learningSegments, set()) 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]) predictedInactiveCells = set() prevMatchingSegments = set() tm.learnOnSegments(prevActiveSegments, learningSegments, prevActiveCells, winnerCells, prevWinnerCells, connections, predictedInactiveCells, prevMatchingSegments) # Check segment 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) # Check segment 1 synapseData = connections.dataForSynapse(3) self.assertAlmostEqual(synapseData.permanence, 0.8) self.assertEqual(len(connections.synapsesForSegment(1)), 2) # Check segment 2 synapseData = connections.dataForSynapse(4) self.assertAlmostEqual(synapseData.permanence, 0.9) self.assertEqual(len(connections.synapsesForSegment(2)), 1) # Check segment 3 self.assertEqual(len(connections.synapsesForSegment(3)), 2) def testComputePredictiveCells(self): tm = TemporalMemory(activationThreshold=2, minThreshold=2) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) connections.createSynapse(0, 37, 0.5) connections.createSynapse(0, 477, 0.9) connections.createSegment(1) connections.createSynapse(1, 733, 0.7) connections.createSynapse(1, 733, 0.4) connections.createSegment(1) connections.createSynapse(2, 974, 0.9) connections.createSegment(8) connections.createSynapse(3, 486, 0.9) connections.createSegment(100) activeCells = set([23, 37, 733, 974]) (activeSegments, predictiveCells, matchingSegments, matchingCells) = tm.computePredictiveCells(activeCells, connections) self.assertEqual(activeSegments, set([0])) self.assertEqual(predictiveCells, set([0])) self.assertEqual(matchingSegments, set([0,1])) self.assertEqual(matchingCells, set([0,1])) 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), (96, None)) # Random cell from column self.assertEqual(tm.bestMatchingCell(tm.cellsForColumn(999), activeCells, connections), (31972, None)) # Random cell from column 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, connections) self.assertEqual(cell, 1) 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 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), connections), 1) def testAdaptSegment(self): tm = self.tm 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(0, set([0, 1]), connections, tm.permanenceIncrement, tm.permanenceDecrement) 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 testAdaptSegmentToMax(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.9) tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) # Now permanence should be at max tm.adaptSegment(0, set([0]), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 1.0) def testAdaptSegmentToMin(self): tm = self.tm connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.1) tm.adaptSegment(0, set(), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 0.0) # Now permanence should be at min tm.adaptSegment(0, set(), connections, tm.permanenceIncrement, tm.permanenceDecrement) synapseData = connections.dataForSynapse(0) self.assertAlmostEqual(synapseData.permanence, 0.0) 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, connections), set([4, 58])) # randomly picked self.assertEqual(tm.pickCellsToLearnOn(100, 0, winnerCells, connections), set([4, 47, 58, 93])) self.assertEqual(tm.pickCellsToLearnOn(0, 0, winnerCells, connections), set()) def testPickCellsToLearnOnAvoidDuplicates(self): tm = TemporalMemory(seed=42) connections = tm.connections connections.createSegment(0) connections.createSynapse(0, 23, 0.6) winnerCells = set([23]) # Ensure that no additional (duplicate) cells were picked self.assertEqual(tm.pickCellsToLearnOn(2, 0, winnerCells, connections), set()) def testColumnForCell1D(self): tm = TemporalMemory( columnDimensions=[2048], cellsPerColumn=5 ) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(4), 0) self.assertEqual(tm.columnForCell(5), 1) self.assertEqual(tm.columnForCell(10239), 2047) def testColumnForCell2D(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) self.assertEqual(tm.columnForCell(0), 0) self.assertEqual(tm.columnForCell(3), 0) self.assertEqual(tm.columnForCell(4), 1) self.assertEqual(tm.columnForCell(16383), 4095) 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 testCellsForColumn1D(self): tm = TemporalMemory( columnDimensions=[2048], cellsPerColumn=5 ) expectedCells = set([5, 6, 7, 8, 9]) self.assertEqual(tm.cellsForColumn(1), expectedCells) def testCellsForColumn2D(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=4 ) expectedCells = set([256, 257, 258, 259]) self.assertEqual(tm.cellsForColumn(64), expectedCells) 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 testNumberOfColumns(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=32 ) self.assertEqual(tm.numberOfColumns(), 64 * 64) def testNumberOfCells(self): tm = TemporalMemory( columnDimensions=[64, 64], cellsPerColumn=32 ) self.assertEqual(tm.numberOfCells(), 64 * 64 * 32) def testMapCellsToColumns(self): tm = TemporalMemory( columnDimensions=[100], cellsPerColumn=4 ) columnsForCells = 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])) 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 experiment1(): paramDir = 'params/1024_baseline/5_trainingPasses.yaml' outputDir = 'results/' params = yaml.safe_load(open(paramDir, 'r')) options = {'plotVerbosity': 2, 'consoleVerbosity': 2} plotVerbosity = 2 consoleVerbosity = 1 print "Running SDR overlap experiment...\n" print "Params dir: {0}".format(paramDir) print "Output dir: {0}\n".format(outputDir) # Dimensionality of sequence patterns patternDimensionality = params["patternDimensionality"] # Cardinality (ON / true bits) of sequence patterns patternCardinality = params["patternCardinality"] # TODO If this parameter is to be supported, the sequence generation code # below must change # Number of unique patterns from which sequences are built # patternAlphabetSize = params["patternAlphabetSize"] # Length of sequences shown to network sequenceLength = params["sequenceLength"] # Number of sequences used. Sequences may share common elements. numberOfSequences = params["numberOfSequences"] # Number of sequence passes for training the TM. Zero => no training. trainingPasses = params["trainingPasses"] tmParamOverrides = params["temporalMemoryParams"] upParamOverrides = params["unionPoolerParams"] # Generate a sequence list and an associated labeled list (both containing a # set of sequences separated by None) start = time.time() print "\nGenerating sequences..." patternAlphabetSize = sequenceLength * numberOfSequences patternMachine = PatternMachine(patternDimensionality, patternCardinality, patternAlphabetSize) sequenceMachine = SequenceMachine(patternMachine) numbers = sequenceMachine.generateNumbers(numberOfSequences, sequenceLength) generatedSequences = sequenceMachine.generateFromNumbers(numbers) sequenceLabels = [ str(numbers[i + i * sequenceLength:i + (i + 1) * sequenceLength]) for i in xrange(numberOfSequences) ] labeledSequences = [] for label in sequenceLabels: for _ in xrange(sequenceLength): labeledSequences.append(label) labeledSequences.append(None) # Set up the Temporal Memory and Union Pooler network print "\nCreating network..." experiment = UnionTemporalPoolerExperiment(tmParamOverrides, upParamOverrides) # Train only the Temporal Memory on the generated sequences if trainingPasses > 0: print "\nTraining Temporal Memory..." if consoleVerbosity > 0: print "\nPass\tBursting Columns Mean\tStdDev\tMax" for i in xrange(trainingPasses): experiment.runNetworkOnSequences( generatedSequences, labeledSequences, tmLearn=True, upLearn=None, verbosity=consoleVerbosity, progressInterval=_SHOW_PROGRESS_INTERVAL) if consoleVerbosity > 0: stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(i, stats[0], stats[1], stats[2]) # Reset the TM monitor mixin's records accrued during this training pass # experiment.tm.mmClearHistory() print print MonitorMixinBase.mmPrettyPrintMetrics( experiment.tm.mmGetDefaultMetrics()) print experiment.tm.mmClearHistory() experiment.up.mmClearHistory() print "\nRunning test phase..." inputSequences = generatedSequences inputCategories = labeledSequences tmLearn = True upLearn = False classifierLearn = False currentTime = time.time() experiment.tm.reset() experiment.up.reset() poolingActivationTrace = numpy.zeros((experiment.up._numColumns, 1)) activeCellsTrace = numpy.zeros((experiment.up._numColumns, 1)) activeSPTrace = numpy.zeros((experiment.up._numColumns, 1)) for _ in xrange(trainingPasses): experiment.tm.reset() for i in xrange(len(inputSequences)): sensorPattern = inputSequences[i] inputCategory = inputCategories[i] if sensorPattern is None: pass else: experiment.tm.compute(sensorPattern, learn=tmLearn, sequenceLabel=inputCategory) if upLearn is not None: activeCells, predActiveCells, burstingCols, = experiment.getUnionTemporalPoolerInput( ) experiment.up.compute(activeCells, predActiveCells, learn=upLearn, sequenceLabel=inputCategory) currentPoolingActivation = experiment.up._poolingActivation currentPoolingActivation = experiment.up._poolingActivation.reshape( (experiment.up._numColumns, 1)) poolingActivationTrace = numpy.concatenate( (poolingActivationTrace, currentPoolingActivation), 1) currentUnionSDR = numpy.zeros( (experiment.up._numColumns, 1)) currentUnionSDR[experiment.up._unionSDR] = 1 activeCellsTrace = numpy.concatenate( (activeCellsTrace, currentUnionSDR), 1) currentSPSDR = numpy.zeros((experiment.up._numColumns, 1)) currentSPSDR[experiment.up._activeCells] = 1 activeSPTrace = numpy.concatenate( (activeSPTrace, currentSPSDR), 1) print "\nPass\tBursting Columns Mean\tStdDev\tMax" stats = experiment.getBurstingColumnsStats() print "{0}\t{1}\t{2}\t{3}".format(0, stats[0], stats[1], stats[2]) print print MonitorMixinBase.mmPrettyPrintMetrics(\ experiment.tm.mmGetDefaultMetrics() + experiment.up.mmGetDefaultMetrics()) print experiment.tm.mmClearHistory() # estimate fraction of shared bits across adjacent time point unionSDRshared = experiment.up._mmComputeUnionSDRdiff() bitLifeList = experiment.up._mmComputeBitLifeStats() bitLife = numpy.array(bitLifeList) # Plot SP outputs, UP persistence and UP outputs in testing phase def showSequenceStartLine(ax, trainingPasses, sequenceLength): for i in xrange(trainingPasses): ax.vlines(i * sequenceLength, 0, 100, linestyles='--') plt.figure() ncolShow = 100 f, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3) ax1.imshow(activeSPTrace[1:ncolShow, :], cmap=cm.Greys, interpolation="nearest", aspect='auto') showSequenceStartLine(ax1, trainingPasses, sequenceLength) ax1.set_title('SP SDR') ax1.set_ylabel('Columns') ax2.imshow(poolingActivationTrace[1:100, :], cmap=cm.Greys, interpolation="nearest", aspect='auto') showSequenceStartLine(ax2, trainingPasses, sequenceLength) ax2.set_title('Persistence') ax3.imshow(activeCellsTrace[1:ncolShow, :], cmap=cm.Greys, interpolation="nearest", aspect='auto') showSequenceStartLine(ax3, trainingPasses, sequenceLength) plt.title('Union SDR') ax2.set_xlabel('Time (steps)') pp = PdfPages('results/UnionPoolingOnLearnedTM_Experiment1.pdf') pp.savefig() pp.close() f, (ax1, ax2, ax3) = plt.subplots(nrows=3, ncols=1) ax1.plot((sum(activeCellsTrace)) / experiment.up._numColumns * 100) ax1.set_ylabel('Union SDR size (%)') ax1.set_xlabel('Time (steps)') ax1.set_ylim(0, 25) ax2.plot(unionSDRshared) ax2.set_ylabel('Shared Bits') ax2.set_xlabel('Time (steps)') ax3.hist(bitLife) ax3.set_xlabel('Life duration for each bit') pp = PdfPages('results/UnionSDRproperty_Experiment1.pdf') pp.savefig() pp.close()