def testCheckpointMiddleOfSequence(self): # Create a model and give it some inputs to learn. tm1 = BacktrackingTM(numberOfCols=100, cellsPerColumn=12, verbosity=VERBOSITY) sequences = [self.generateSequence() for _ in xrange(5)] train = list(itertools.chain.from_iterable(sequences[:3] + [sequences[3][:5]])) for bottomUpInput in train: if bottomUpInput is None: tm1.reset() else: tm1.compute(bottomUpInput, True, True) # Serialize and deserialized the TM. checkpointPath = os.path.join(self._tmpDir, 'a') tm1.saveToFile(checkpointPath) tm2 = pickle.loads(pickle.dumps(tm1)) tm2.loadFromFile(checkpointPath) # Check that the TMs are the same. self.assertTMsEqual(tm1, tm2) # Feed some data into the models. test = list(itertools.chain.from_iterable([sequences[3][5:]] + sequences[3:])) for bottomUpInput in test: if bottomUpInput is None: tm1.reset() tm2.reset() else: result1 = tm1.compute(bottomUpInput, True, True) result2 = tm2.compute(bottomUpInput, True, True) self.assertTMsEqual(tm1, tm2) self.assertTrue(numpy.array_equal(result1, result2))
def test_cpp_py_tms(self): # Create cpp tm tm = BacktrackingTMCPP(numberOfCols=10, cellsPerColumn=1, verbosity=VERBOSITY) tm.cells4.setCellSegmentOrder(True) # Create Python tm from same characteristics tmPy = BacktrackingTM(numberOfCols=tm.numberOfCols, cellsPerColumn=tm.cellsPerColumn, initialPerm=tm.initialPerm, connectedPerm=tm.connectedPerm, minThreshold=tm.minThreshold, newSynapseCount=tm.newSynapseCount, permanenceInc=tm.permanenceInc, permanenceDec=tm.permanenceDec, permanenceMax=tm.permanenceMax, globalDecay=tm.globalDecay, activationThreshold=tm.activationThreshold, doPooling=tm.doPooling, segUpdateValidDuration=tm.segUpdateValidDuration, pamLength=tm.pamLength, maxAge=tm.maxAge, maxSeqLength=tm.maxSeqLength, maxSegmentsPerCell=tm.maxSegmentsPerCell, maxSynapsesPerSegment=tm.maxSynapsesPerSegment, seed=tm.seed, verbosity=tm.verbosity) # Check if both tm's are equal self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY, False)) # Build up sequences numPatterns = 1 numRepetitions = 1 activity = 1 sequence = fdrutils.generateCoincMatrix(nCoinc=numPatterns, length=tm.numberOfCols, activity=activity) # print(sequence) sequence_row = sequence.getRow(0) y1 = tm.learn(sequence_row) y2 = tmPy.learn(sequence_row) num_segments_cpp = tm.getNumSegments() num_segments_py = tmPy.getNumSegments() # fails since num_segments_cpp = 0 and num_segments_py = 1 self.assertTrue(num_segments_cpp=num_segments_py) # Check if both tm's are equal # self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY, False)) return
def reset(self): """ Overrides :meth:`nupic.algorithms.backtracking_tm.BacktrackingTM.reset`. """ if self.verbosity >= 3: print "TM Reset" self._setStatePointers() self.cells4.reset() BacktrackingTM.reset(self)
def reset(self): """ Reset the state of all cells. This is normally used between sequences while training. All internal states are reset to 0. """ if self.verbosity >= 3: print "TM Reset" self._setStatePointers() self.cells4.reset() BacktrackingTM.reset(self)
def testCheckpointMiddleOfSequence2(self): """More complex test of checkpointing in the middle of a sequence.""" tm1 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') tm2 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') with open(resource_filename(__name__, 'data/tm_input.csv'), 'r') as fin: reader = csv.reader(fin) records = [] for bottomUpInStr in fin: bottomUpIn = numpy.array(eval('[' + bottomUpInStr.strip() + ']'), dtype='int32') records.append(bottomUpIn) i = 1 for r in records[:250]: print i i += 1 output1 = tm1.compute(r, True, True) output2 = tm2.compute(r, True, True) self.assertTrue(numpy.array_equal(output1, output2)) print 'Serializing and deserializing models.' savePath1 = os.path.join(self._tmpDir, 'tm1.bin') tm1.saveToFile(savePath1) tm3 = pickle.loads(pickle.dumps(tm1)) tm3.loadFromFile(savePath1) savePath2 = os.path.join(self._tmpDir, 'tm2.bin') tm2.saveToFile(savePath2) tm4 = pickle.loads(pickle.dumps(tm2)) tm4.loadFromFile(savePath2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4) for r in records[250:]: print i i += 1 out1 = tm1.compute(r, True, True) out2 = tm2.compute(r, True, True) out3 = tm3.compute(r, True, True) out4 = tm4.compute(r, True, True) self.assertTrue(numpy.array_equal(out1, out2)) self.assertTrue(numpy.array_equal(out1, out3)) self.assertTrue(numpy.array_equal(out1, out4)) self.assertTMsEqual(tm1, tm2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4)
def read(cls, proto): """Deserialize from proto instance. :param proto: (BacktrackingTMCppProto) the proto instance to read from """ # Use base class to create initial class from proto.baseTM # (BacktrackingTMProto) obj = BacktrackingTM.read(proto.baseTM) obj.__class__ = cls # Additional CPP-specific deserialization newCells4 = Cells4.read(proto.cells4) print(newCells4) obj.cells4 = newCells4 obj.makeCells4Ephemeral = proto.makeCells4Ephemeral obj.seed = proto.seed obj.checkSynapseConsistency = proto.checkSynapseConsistency obj._initArgsDict = json.loads(proto.initArgs) # Convert unicode to str obj._initArgsDict["outputType"] = str(obj._initArgsDict["outputType"]) # Initialize ephemeral attributes obj.allocateStatesInCPP = False obj.retrieveLearningStates = False obj._setStatePointers() return obj
def read(cls, proto): """Deserialize from proto instance. :param proto: (BacktrackingTMCppProto) the proto instance to read from """ # Use base class to create initial class from proto.baseTM # (BacktrackingTMProto) obj = BacktrackingTM.read(proto.baseTM) obj.__class__ = cls # Additional CPP-specific deserialization newCells4 = Cells4.read(proto.cells4) print newCells4 obj.cells4 = newCells4 obj.makeCells4Ephemeral = proto.makeCells4Ephemeral obj.seed = proto.seed obj.checkSynapseConsistency = proto.checkSynapseConsistency obj._initArgsDict = json.loads(proto.initArgs) # Convert unicode to str obj._initArgsDict["outputType"] = str(obj._initArgsDict["outputType"]) # Initialize ephemeral attributes obj.allocateStatesInCPP = False obj.retrieveLearningStates = False obj._setStatePointers() return obj
def _getEphemeralMembers(self): """ List of our member variables that we don't need to be saved """ e = BacktrackingTM._getEphemeralMembers(self) if self.makeCells4Ephemeral: e.extend(['cells4']) return e
def _initEphemerals(self): """ Initialize all ephemeral members after being restored to a pickled state. """ BacktrackingTM._initEphemerals(self) #--------------------------------------------------------------------------------- # cells4 specific initialization # If True, let C++ allocate memory for activeState, predictedState, and # learnState. In this case we can retrieve copies of these states but can't # set them directly from Python. If False, Python can allocate them as # numpy arrays and we can pass pointers to the C++ using setStatePointers self.allocateStatesInCPP = False # Set this to true for debugging or accessing learning states self.retrieveLearningStates = False if self.makeCells4Ephemeral: self.cells4 = Cells4(self.numberOfCols, self.cellsPerColumn, self.activationThreshold, self.minThreshold, self.newSynapseCount, self.segUpdateValidDuration, self.initialPerm, self.connectedPerm, self.permanenceMax, self.permanenceDec, self.permanenceInc, self.globalDecay, self.doPooling, self.seed, self.allocateStatesInCPP, self.checkSynapseConsistency) self.cells4.setVerbosity(self.verbosity) self.cells4.setPamLength(self.pamLength) self.cells4.setMaxAge(self.maxAge) self.cells4.setMaxInfBacktrack(self.maxInfBacktrack) self.cells4.setMaxLrnBacktrack(self.maxLrnBacktrack) self.cells4.setMaxSeqLength(self.maxSeqLength) self.cells4.setMaxSegmentsPerCell(self.maxSegmentsPerCell) self.cells4.setMaxSynapsesPerCell(self.maxSynapsesPerSegment) self._setStatePointers()
def _initEphemerals(self): """ Initialize all ephemeral members after being restored to a pickled state. """ BacktrackingTM._initEphemerals(self) #--------------------------------------------------------------------------------- # cells4 specific initialization # If True, let C++ allocate memory for activeState, predictedState, and # learnState. In this case we can retrieve copies of these states but can't # set them directly from Python. If False, Python can allocate them as # numpy arrays and we can pass pointers to the C++ using setStatePointers self.allocateStatesInCPP = False # Set this to true for debugging or accessing learning states self.retrieveLearningStates = False if self.makeCells4Ephemeral: self._initCells4()
def _createTMs(numCols, cellsPerColumn=4, checkSynapseConsistency=True): """Create TM and BacktrackingTMCPP instances with identical parameters. """ # Keep these fixed for both TM's: minThreshold = 4 activationThreshold = 4 newSynapseCount = 5 initialPerm = 0.6 connectedPerm = 0.5 permanenceInc = 0.1 permanenceDec = 0.001 globalDecay = 0.0 if VERBOSITY > 1: print "Creating BacktrackingTMCPP instance" cppTm = BacktrackingTMCPP(numberOfCols=numCols, cellsPerColumn=cellsPerColumn, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=SEED, verbosity=VERBOSITY, checkSynapseConsistency=checkSynapseConsistency, pamLength=1000) if VERBOSITY > 1: print "Creating PY TM instance" pyTm = BacktrackingTM(numberOfCols=numCols, cellsPerColumn=cellsPerColumn, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=SEED, verbosity=VERBOSITY, pamLength=1000) return cppTm, pyTm
def _createTms(numCols): """Create two instances of temporal poolers (backtracking_tm.py and backtracking_tm_cpp.py) with identical parameter settings.""" # Keep these fixed: minThreshold = 4 activationThreshold = 5 newSynapseCount = 7 initialPerm = 0.3 connectedPerm = 0.5 permanenceInc = 0.1 permanenceDec = 0.05 globalDecay = 0 cellsPerColumn = 1 cppTm = BacktrackingTMCPP(numberOfCols=numCols, cellsPerColumn=cellsPerColumn, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=_SEED, verbosity=VERBOSITY, checkSynapseConsistency=True, pamLength=1000) # Ensure we are copying over learning states for TMDiff cppTm.retrieveLearningStates = True pyTm = BacktrackingTM(numberOfCols=numCols, cellsPerColumn=cellsPerColumn, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=_SEED, verbosity=VERBOSITY, pamLength=1000) return cppTm, pyTm
def testSerializationMiddleOfSequence(self): # Create a model and give it some inputs to learn. tm1 = BacktrackingTM(numberOfCols=100, cellsPerColumn=12, verbosity=VERBOSITY) sequences = [self.generateSequence() for _ in range(5)] train = list( itertools.chain.from_iterable(sequences[:3] + [sequences[3][:5]])) for bottomUpInput in train: if bottomUpInput is None: tm1.reset() else: tm1.compute(bottomUpInput, True, True) # Serialize and deserialized the TM. tmProto = BacktrackingTM.getSchema().new_message() tm1.write(tmProto) checkpointPath = os.path.join(self._tmpDir, 'a') with open(checkpointPath, "wb") as f: tmProto.write(f) with open(checkpointPath, "rb") as f: tmProto = BacktrackingTM.getSchema().read(f) tm2 = BacktrackingTM.read(tmProto) # Check that the TMs are the same. self.assertTMsEqual(tm1, tm2) # Feed some data into the models. test = list( itertools.chain.from_iterable([sequences[3][5:]] + sequences[3:])) for bottomUpInput in test: if bottomUpInput is None: tm1.reset() tm2.reset() else: result1 = tm1.compute(bottomUpInput, True, True) result2 = tm2.compute(bottomUpInput, True, True) self.assertTMsEqual(tm1, tm2) self.assertTrue(numpy.array_equal(result1, result2))
def __init__( self, numberOfCols=500, cellsPerColumn=10, initialPerm=0.11, # TODO: check perm numbers with Ron connectedPerm=0.50, minThreshold=8, newSynapseCount=15, permanenceInc=0.10, permanenceDec=0.10, permanenceMax=1.0, # never exceed this value globalDecay=0.10, activationThreshold=12, # 3/4 of newSynapseCount TODO make fraction doPooling=False, # allows to turn off pooling segUpdateValidDuration=5, burnIn=2, # Used for evaluating the prediction score collectStats=False, # If true, collect training and inference stats seed=42, verbosity=VERBOSITY, checkSynapseConsistency=False, pamLength=1, maxInfBacktrack=10, maxLrnBacktrack=5, maxAge=100000, maxSeqLength=32, # Fixed size mode params maxSegmentsPerCell=-1, maxSynapsesPerSegment=-1, # Output control outputType='normal', ): #--------------------------------------------------------------------------------- # Save our __init__ args for debugging self._initArgsDict = _extractCallingMethodArgs() #--------------------------------------------------------------------------------- # These two variables are for testing # If set to True, Cells4 will perform (time consuming) invariance checks self.checkSynapseConsistency = checkSynapseConsistency # If set to False, Cells4 will *not* be treated as an ephemeral member # and full BacktrackingTMCPP pickling is possible. This is useful for testing # pickle/unpickle without saving Cells4 to an external file self.makeCells4Ephemeral = True #--------------------------------------------------------------------------------- # Init the base class BacktrackingTM.__init__( self, numberOfCols=numberOfCols, cellsPerColumn=cellsPerColumn, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, permanenceMax=permanenceMax, # never exceed this value globalDecay=globalDecay, activationThreshold=activationThreshold, doPooling=doPooling, segUpdateValidDuration=segUpdateValidDuration, burnIn=burnIn, collectStats=collectStats, seed=seed, verbosity=verbosity, pamLength=pamLength, maxInfBacktrack=maxInfBacktrack, maxLrnBacktrack=maxLrnBacktrack, maxAge=maxAge, maxSeqLength=maxSeqLength, maxSegmentsPerCell=maxSegmentsPerCell, maxSynapsesPerSegment=maxSynapsesPerSegment, outputType=outputType, )
def __init__(self, numberOfCols = 500, cellsPerColumn = 10, initialPerm = 0.11, # TODO: check perm numbers with Ron connectedPerm = 0.50, minThreshold = 8, newSynapseCount = 15, permanenceInc = 0.10, permanenceDec = 0.10, permanenceMax = 1.0, # never exceed this value globalDecay = 0.10, activationThreshold = 12, # 3/4 of newSynapseCount TODO make fraction doPooling = False, # allows to turn off pooling segUpdateValidDuration = 5, burnIn = 2, # Used for evaluating the prediction score collectStats = False, # If true, collect training and inference stats seed = 42, verbosity = VERBOSITY, checkSynapseConsistency = False, pamLength = 1, maxInfBacktrack = 10, maxLrnBacktrack = 5, maxAge = 100000, maxSeqLength = 32, # Fixed size mode params maxSegmentsPerCell = -1, maxSynapsesPerSegment = -1, # Output control outputType = 'normal', ): #--------------------------------------------------------------------------------- # Save our __init__ args for debugging self._initArgsDict = _extractCallingMethodArgs() #--------------------------------------------------------------------------------- # These two variables are for testing # If set to True, Cells4 will perform (time consuming) invariance checks self.checkSynapseConsistency = checkSynapseConsistency # If set to False, Cells4 will *not* be treated as an ephemeral member # and full BacktrackingTMCPP pickling is possible. This is useful for testing # pickle/unpickle without saving Cells4 to an external file self.makeCells4Ephemeral = True #--------------------------------------------------------------------------------- # Init the base class BacktrackingTM.__init__(self, numberOfCols = numberOfCols, cellsPerColumn = cellsPerColumn, initialPerm = initialPerm, connectedPerm = connectedPerm, minThreshold = minThreshold, newSynapseCount = newSynapseCount, permanenceInc = permanenceInc, permanenceDec = permanenceDec, permanenceMax = permanenceMax, # never exceed this value globalDecay = globalDecay, activationThreshold = activationThreshold, doPooling = doPooling, segUpdateValidDuration = segUpdateValidDuration, burnIn = burnIn, collectStats = collectStats, seed = seed, verbosity = verbosity, pamLength = pamLength, maxInfBacktrack = maxInfBacktrack, maxLrnBacktrack = maxLrnBacktrack, maxAge = maxAge, maxSeqLength = maxSeqLength, maxSegmentsPerCell = maxSegmentsPerCell, maxSynapsesPerSegment = maxSynapsesPerSegment, outputType = outputType, )
def basicTest2(self, tm, numPatterns=100, numRepetitions=3, activity=15, testTrimming=False, testRebuild=False): """Basic test (basic run of learning and inference)""" # Create PY TM object that mirrors the one sent in. tmPy = BacktrackingTM(numberOfCols=tm.numberOfCols, cellsPerColumn=tm.cellsPerColumn, initialPerm=tm.initialPerm, connectedPerm=tm.connectedPerm, minThreshold=tm.minThreshold, newSynapseCount=tm.newSynapseCount, permanenceInc=tm.permanenceInc, permanenceDec=tm.permanenceDec, permanenceMax=tm.permanenceMax, globalDecay=tm.globalDecay, activationThreshold=tm.activationThreshold, doPooling=tm.doPooling, segUpdateValidDuration=tm.segUpdateValidDuration, pamLength=tm.pamLength, maxAge=tm.maxAge, maxSeqLength=tm.maxSeqLength, maxSegmentsPerCell=tm.maxSegmentsPerCell, maxSynapsesPerSegment=tm.maxSynapsesPerSegment, seed=tm.seed, verbosity=tm.verbosity) # Ensure we are copying over learning states for TMDiff tm.retrieveLearningStates = True verbosity = VERBOSITY # Learn # Build up sequences sequence = fdrutils.generateCoincMatrix(nCoinc=numPatterns, length=tm.numberOfCols, activity=activity) for r in xrange(numRepetitions): for i in xrange(sequence.nRows()): #if i > 11: # setVerbosity(6, tm, tmPy) if i % 10 == 0: tm.reset() tmPy.reset() if verbosity >= 2: print "\n\n ===================================\nPattern:", print i, "Round:", r, "input:", sequence.getRow(i) y1 = tm.learn(sequence.getRow(i)) y2 = tmPy.learn(sequence.getRow(i)) # Ensure everything continues to work well even if we continuously # rebuild outSynapses structure if testRebuild: tm.cells4.rebuildOutSynapses() if testTrimming: tm.trimSegments() tmPy.trimSegments() if verbosity > 2: print "\n ------ CPP states ------ ", tm.printStates() print "\n ------ PY states ------ ", tmPy.printStates() if verbosity > 6: print "C++ cells: " tm.printCells() print "PY cells: " tmPy.printCells() if verbosity >= 3: print "Num segments in PY and C++", tmPy.getNumSegments(), \ tm.getNumSegments() # Check if the two TM's are identical or not. This check is slow so # we do it every other iteration. Make it every iteration for debugging # as needed. self.assertTrue(fdrutils.tmDiff2(tm, tmPy, verbosity, False)) # Check that outputs are identical self.assertLess(abs((y1 - y2).sum()), 3) print "Learning completed" self.assertTrue(fdrutils.tmDiff2(tm, tmPy, verbosity)) # TODO: Need to check - currently failing this #checkCell0(tmPy) # Remove unconnected synapses and check TM's again # Test rebuild out synapses print "Rebuilding outSynapses" tm.cells4.rebuildOutSynapses() self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY)) print "Trimming segments" tm.trimSegments() tmPy.trimSegments() self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY)) # Save and reload after learning print "Pickling and unpickling" tm.makeCells4Ephemeral = False pickle.dump(tm, open("test_tm_cpp.pkl", "wb")) tm2 = pickle.load(open("test_tm_cpp.pkl")) self.assertTrue(fdrutils.tmDiff2(tm, tm2, VERBOSITY, checkStates=False)) # Infer print "Testing inference" # Setup for inference tm.reset() tmPy.reset() setVerbosity(INFERENCE_VERBOSITY, tm, tmPy) patterns = numpy.zeros((40, tm.numberOfCols), dtype='uint32') for i in xrange(4): _RGEN.initializeUInt32Array(patterns[i], 2) for i, x in enumerate(patterns): x = numpy.zeros(tm.numberOfCols, dtype='uint32') _RGEN.initializeUInt32Array(x, 2) y = tm.infer(x) yPy = tmPy.infer(x) self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY, checkLearn=False)) if abs((y - yPy).sum()) > 0: print "C++ output", y print "Py output", yPy assert False if i > 0: tm.checkPrediction2(patterns) tmPy.checkPrediction2(patterns) print "Inference completed" print "====================================" return tm, tmPy
def testSerializationLearned(self): # Create a model and give it some inputs to learn. tm1 = BacktrackingTM(numberOfCols=100, cellsPerColumn=12, verbosity=VERBOSITY) sequences = [self.generateSequence() for _ in xrange(5)] train = list(itertools.chain.from_iterable(sequences[:3])) for bottomUpInput in train: if bottomUpInput is None: tm1.reset() else: tm1.compute(bottomUpInput, True, True) # Serialize and deserialized the TM. tmProto = BacktrackingTM.getSchema().new_message() tm1.write(tmProto) checkpointPath = os.path.join(self._tmpDir, 'a') with open(checkpointPath, "wb") as f: tmProto.write(f) with open(checkpointPath, "rb") as f: tmProto = BacktrackingTM.getSchema().read(f) tm2 = BacktrackingTM.read(tmProto) # Check that the TMs are the same. self.assertTMsEqual(tm1, tm2) # Feed some data into the models. test = list(itertools.chain.from_iterable(sequences[3:])) for bottomUpInput in test: if bottomUpInput is None: tm1.reset() tm2.reset() else: result1 = tm1.compute(bottomUpInput, True, True) result2 = tm2.compute(bottomUpInput, True, True) self.assertTMsEqual(tm1, tm2) self.assertTrue(numpy.array_equal(result1, result2))
def testSerializationMiddleOfSequence2(self): """More complex test of checkpointing in the middle of a sequence.""" tm1 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') tm2 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') with open(resource_filename(__name__, 'data/tm_input.csv'), 'r') as fin: reader = csv.reader(fin) records = [] for bottomUpInStr in fin: bottomUpIn = numpy.array(eval('[' + bottomUpInStr.strip() + ']'), dtype='int32') records.append(bottomUpIn) i = 1 for r in records[:250]: print(i) i += 1 output1 = tm1.compute(r, True, True) output2 = tm2.compute(r, True, True) self.assertTrue(numpy.array_equal(output1, output2)) print('Serializing and deserializing models.') savePath1 = os.path.join(self._tmpDir, 'tm1.bin') tmProto1 = BacktrackingTM.getSchema().new_message() tm1.write(tmProto1) with open(savePath1, "wb") as f: tmProto1.write(f) with open(savePath1, "rb") as f: tmProto3 = BacktrackingTM.getSchema().read(f) tm3 = BacktrackingTM.read(tmProto3) savePath2 = os.path.join(self._tmpDir, 'tm2.bin') tmProto2 = BacktrackingTM.getSchema().new_message() tm2.write(tmProto2) with open(savePath2, "wb") as f: tmProto2.write(f) with open(savePath2, "rb") as f: tmProto4 = BacktrackingTM.getSchema().read(f) tm4 = BacktrackingTM.read(tmProto4) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4) for r in records[250:]: print(i) i += 1 out1 = tm1.compute(r, True, True) out2 = tm2.compute(r, True, True) out3 = tm3.compute(r, True, True) out4 = tm4.compute(r, True, True) self.assertTrue(numpy.array_equal(out1, out2)) self.assertTrue(numpy.array_equal(out1, out3)) self.assertTrue(numpy.array_equal(out1, out4)) self.assertTMsEqual(tm1, tm2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4)
def _createTMs(self, numCols, fixedResources=False, checkSynapseConsistency=True): """Create an instance of the appropriate temporal memory. We isolate all parameters as constants specified here.""" # Keep these fixed: minThreshold = 4 activationThreshold = 8 newSynapseCount = 15 initialPerm = 0.3 connectedPerm = 0.5 permanenceInc = 0.1 permanenceDec = 0.05 if fixedResources: permanenceDec = 0.1 maxSegmentsPerCell = 5 maxSynapsesPerSegment = 15 globalDecay = 0 maxAge = 0 else: permanenceDec = 0.05 maxSegmentsPerCell = -1 maxSynapsesPerSegment = -1 globalDecay = 0.0001 maxAge = 1 if g_testCPPTM: if g_options.verbosity > 1: print("Creating BacktrackingTMCPP instance") cppTM = BacktrackingTMCPP( numberOfCols=numCols, cellsPerColumn=4, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, maxAge=maxAge, burnIn=1, seed=g_options.seed, verbosity=g_options.verbosity, checkSynapseConsistency=checkSynapseConsistency, pamLength=1000, maxSegmentsPerCell=maxSegmentsPerCell, maxSynapsesPerSegment=maxSynapsesPerSegment, ) # Ensure we are copying over learning states for TMDiff cppTM.retrieveLearningStates = True else: cppTM = None if g_options.verbosity > 1: print("Creating PY TM instance") pyTM = BacktrackingTM( numberOfCols=numCols, cellsPerColumn=4, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, maxAge=maxAge, burnIn=1, seed=g_options.seed, verbosity=g_options.verbosity, pamLength=1000, maxSegmentsPerCell=maxSegmentsPerCell, maxSynapsesPerSegment=maxSynapsesPerSegment, ) return cppTM, pyTM
def createTMs(includeCPP=True, includePy=True, numCols=100, cellsPerCol=4, activationThreshold=3, minThreshold=3, newSynapseCount=3, initialPerm=0.6, permanenceInc=0.1, permanenceDec=0.0, globalDecay=0.0, pamLength=0, checkSynapseConsistency=True, maxInfBacktrack=0, maxLrnBacktrack=0, **kwargs): """Create one or more TM instances, placing each into a dict keyed by name. Parameters: ------------------------------------------------------------------ retval: tms - dict of TM instances """ # Keep these fixed: connectedPerm = 0.5 tms = dict() if includeCPP: if VERBOSITY >= 2: print "Creating BacktrackingTMCPP instance" cpp_tm = BacktrackingTMCPP( numberOfCols=numCols, cellsPerColumn=cellsPerCol, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=SEED, verbosity=VERBOSITY, checkSynapseConsistency=checkSynapseConsistency, collectStats=True, pamLength=pamLength, maxInfBacktrack=maxInfBacktrack, maxLrnBacktrack=maxLrnBacktrack, ) # Ensure we are copying over learning states for TMDiff cpp_tm.retrieveLearningStates = True tms['CPP'] = cpp_tm if includePy: if VERBOSITY >= 2: print "Creating PY TM instance" py_tm = BacktrackingTM( numberOfCols=numCols, cellsPerColumn=cellsPerCol, initialPerm=initialPerm, connectedPerm=connectedPerm, minThreshold=minThreshold, newSynapseCount=newSynapseCount, permanenceInc=permanenceInc, permanenceDec=permanenceDec, activationThreshold=activationThreshold, globalDecay=globalDecay, burnIn=1, seed=SEED, verbosity=VERBOSITY, collectStats=True, pamLength=pamLength, maxInfBacktrack=maxInfBacktrack, maxLrnBacktrack=maxLrnBacktrack, ) tms['PY '] = py_tm return tms
def testCheckpointMiddleOfSequence(self): # Create a model and give it some inputs to learn. tm1 = BacktrackingTM(numberOfCols=100, cellsPerColumn=12, verbosity=VERBOSITY) sequences = [self.generateSequence() for _ in range(5)] train = list( itertools.chain.from_iterable(sequences[:3] + [sequences[3][:5]])) for bottomUpInput in train: if bottomUpInput is None: tm1.reset() else: tm1.compute(bottomUpInput, True, True) # Serialize and deserialized the TM. checkpointPath = os.path.join(self._tmpDir, 'a') tm1.saveToFile(checkpointPath) tm2 = pickle.loads(pickle.dumps(tm1)) tm2.loadFromFile(checkpointPath) # Check that the TMs are the same. self.assertTMsEqual(tm1, tm2) # Feed some data into the models. test = list( itertools.chain.from_iterable([sequences[3][5:]] + sequences[3:])) for bottomUpInput in test: if bottomUpInput is None: tm1.reset() tm2.reset() else: result1 = tm1.compute(bottomUpInput, True, True) result2 = tm2.compute(bottomUpInput, True, True) self.assertTMsEqual(tm1, tm2) self.assertTrue(numpy.array_equal(result1, result2))
def testCheckpointMiddleOfSequence2(self): """More complex test of checkpointing in the middle of a sequence.""" tm1 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') tm2 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') with open(resource_filename(__name__, 'data/tm_input.csv'), 'r') as fin: reader = csv.reader(fin) records = [] for bottomUpInStr in fin: bottomUpIn = numpy.array(eval('[' + bottomUpInStr.strip() + ']'), dtype='int32') records.append(bottomUpIn) i = 1 for r in records[:250]: print(i) i += 1 output1 = tm1.compute(r, True, True) output2 = tm2.compute(r, True, True) self.assertTrue(numpy.array_equal(output1, output2)) print('Serializing and deserializing models.') savePath1 = os.path.join(self._tmpDir, 'tm1.bin') tm1.saveToFile(savePath1) tm3 = pickle.loads(pickle.dumps(tm1)) tm3.loadFromFile(savePath1) savePath2 = os.path.join(self._tmpDir, 'tm2.bin') tm2.saveToFile(savePath2) tm4 = pickle.loads(pickle.dumps(tm2)) tm4.loadFromFile(savePath2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4) for r in records[250:]: print(i) i += 1 out1 = tm1.compute(r, True, True) out2 = tm2.compute(r, True, True) out3 = tm3.compute(r, True, True) out4 = tm4.compute(r, True, True) self.assertTrue(numpy.array_equal(out1, out2)) self.assertTrue(numpy.array_equal(out1, out3)) self.assertTrue(numpy.array_equal(out1, out4)) self.assertTMsEqual(tm1, tm2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4)
def testInitDefaultTM(self): self.assertTrue(isinstance(BacktrackingTM(), BacktrackingTM))
def basicTest2(self, tm, numPatterns=100, numRepetitions=3, activity=15, testTrimming=False, testRebuild=False): """Basic test (basic run of learning and inference)""" # Create PY TM object that mirrors the one sent in. tmPy = BacktrackingTM(numberOfCols=tm.numberOfCols, cellsPerColumn=tm.cellsPerColumn, initialPerm=tm.initialPerm, connectedPerm=tm.connectedPerm, minThreshold=tm.minThreshold, newSynapseCount=tm.newSynapseCount, permanenceInc=tm.permanenceInc, permanenceDec=tm.permanenceDec, permanenceMax=tm.permanenceMax, globalDecay=tm.globalDecay, activationThreshold=tm.activationThreshold, doPooling=tm.doPooling, segUpdateValidDuration=tm.segUpdateValidDuration, pamLength=tm.pamLength, maxAge=tm.maxAge, maxSeqLength=tm.maxSeqLength, maxSegmentsPerCell=tm.maxSegmentsPerCell, maxSynapsesPerSegment=tm.maxSynapsesPerSegment, seed=tm.seed, verbosity=tm.verbosity) # Ensure we are copying over learning states for TMDiff tm.retrieveLearningStates = True verbosity = VERBOSITY # Learn # Build up sequences sequence = fdrutils.generateCoincMatrix(nCoinc=numPatterns, length=tm.numberOfCols, activity=activity) for r in xrange(numRepetitions): for i in xrange(sequence.nRows()): #if i > 11: # setVerbosity(6, tm, tmPy) if i % 10 == 0: tm.reset() tmPy.reset() if verbosity >= 2: print "\n\n ===================================\nPattern:", print i, "Round:", r, "input:", sequence.getRow(i) y1 = tm.learn(sequence.getRow(i)) y2 = tmPy.learn(sequence.getRow(i)) # Ensure everything continues to work well even if we continuously # rebuild outSynapses structure if testRebuild: tm.cells4.rebuildOutSynapses() if testTrimming: tm.trimSegments() tmPy.trimSegments() if verbosity > 2: print "\n ------ CPP states ------ ", tm.printStates() print "\n ------ PY states ------ ", tmPy.printStates() if verbosity > 6: print "C++ cells: " tm.printCells() print "PY cells: " tmPy.printCells() if verbosity >= 3: print "Num segments in PY and C++", tmPy.getNumSegments(), \ tm.getNumSegments() # Check if the two TM's are identical or not. This check is slow so # we do it every other iteration. Make it every iteration for debugging # as needed. self.assertTrue(fdrutils.tmDiff2(tm, tmPy, verbosity, False)) # Check that outputs are identical self.assertLess(abs((y1 - y2).sum()), 3) print "Learning completed" self.assertTrue(fdrutils.tmDiff2(tm, tmPy, verbosity)) # TODO: Need to check - currently failing this #checkCell0(tmPy) # Remove unconnected synapses and check TM's again # Test rebuild out synapses print "Rebuilding outSynapses" tm.cells4.rebuildOutSynapses() self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY)) print "Trimming segments" tm.trimSegments() tmPy.trimSegments() self.assertTrue(fdrutils.tmDiff2(tm, tmPy, VERBOSITY)) # Save and reload after learning print "Pickling and unpickling" tm.makeCells4Ephemeral = False pickle.dump(tm, open("test_tm_cpp.pkl", "wb")) tm2 = pickle.load(open("test_tm_cpp.pkl")) self.assertTrue(fdrutils.tmDiff2(tm, tm2, VERBOSITY, checkStates=False)) # Infer print "Testing inference" # Setup for inference tm.reset() tmPy.reset() setVerbosity(INFERENCE_VERBOSITY, tm, tmPy) patterns = numpy.zeros((40, tm.numberOfCols), dtype='uint32') for i in xrange(4): _RGEN.initializeUInt32Array(patterns[i], 2) for i, x in enumerate(patterns): x = numpy.zeros(tm.numberOfCols, dtype='uint32') _RGEN.initializeUInt32Array(x, 2) y = tm.infer(x) yPy = tmPy.infer(x) self.assertTrue( fdrutils.tmDiff2(tm, tmPy, VERBOSITY, checkLearn=False)) if abs((y - yPy).sum()) > 0: print "C++ output", y print "Py output", yPy assert False if i > 0: tm._checkPrediction(patterns) tmPy._checkPrediction(patterns) print "Inference completed" print "====================================" return tm, tmPy
def testSerializationMiddleOfSequence2(self): """More complex test of checkpointing in the middle of a sequence.""" tm1 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') tm2 = BacktrackingTM(2048, 32, 0.21, 0.5, 11, 20, 0.1, 0.1, 1.0, 0.0, 14, False, 5, 2, False, 1960, 0, False, 3, 10, 5, 0, 32, 128, 32, 'normal') with open(resource_filename(__name__, 'data/tm_input.csv'), 'r') as fin: reader = csv.reader(fin) records = [] for bottomUpInStr in fin: bottomUpIn = numpy.array(eval('[' + bottomUpInStr.strip() + ']'), dtype='int32') records.append(bottomUpIn) i = 1 for r in records[:250]: print i i += 1 output1 = tm1.compute(r, True, True) output2 = tm2.compute(r, True, True) self.assertTrue(numpy.array_equal(output1, output2)) print 'Serializing and deserializing models.' savePath1 = os.path.join(self._tmpDir, 'tm1.bin') tmProto1 = BacktrackingTM.getSchema().new_message() tm1.write(tmProto1) with open(savePath1, "wb") as f: tmProto1.write(f) with open(savePath1, "rb") as f: tmProto3 = BacktrackingTM.getSchema().read(f) tm3 = BacktrackingTM.read(tmProto3) savePath2 = os.path.join(self._tmpDir, 'tm2.bin') tmProto2 = BacktrackingTM.getSchema().new_message() tm2.write(tmProto2) with open(savePath2, "wb") as f: tmProto2.write(f) with open(savePath2, "rb") as f: tmProto4 = BacktrackingTM.getSchema().read(f) tm4 = BacktrackingTM.read(tmProto4) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4) for r in records[250:]: print i i += 1 out1 = tm1.compute(r, True, True) out2 = tm2.compute(r, True, True) out3 = tm3.compute(r, True, True) out4 = tm4.compute(r, True, True) self.assertTrue(numpy.array_equal(out1, out2)) self.assertTrue(numpy.array_equal(out1, out3)) self.assertTrue(numpy.array_equal(out1, out4)) self.assertTMsEqual(tm1, tm2) self.assertTMsEqual(tm1, tm3) self.assertTMsEqual(tm2, tm4)