def _buildArgs(f, self=None, kwargs={}): """ Get the default arguments from the function and assign as instance vars. Return a list of 3-tuples with (name, description, defaultValue) for each argument to the function. Assigns all arguments to the function as instance variables of CLARegion. If the argument was not provided, uses the default value. Pops any values from kwargs that go to the function. """ # Get the name, description, and default value for each argument argTuples = getArgumentDescriptions(f) argTuples = argTuples[1:] # Remove 'self' # Get the names of the parameters to our own constructor and remove them # Check for _originial_init first, because if LockAttributesMixin is used, # __init__'s signature will be just (self, *args, **kw), but # _original_init is created with the original signature #init = getattr(self, '_original_init', self.__init__) init = CLARegion.__init__ ourArgNames = [t[0] for t in getArgumentDescriptions(init)] # Also remove a few other names that aren't in our constructor but are # computed automatically (e.g. numberOfCols for the TP) ourArgNames += [ 'numberOfCols', # TP 'cellsPerColumn', # TP 'nCells', # FDRSTemporal 'cloneMap', # FDRSTemporal / FDRCSpatial 'numCloneMasters', # FDRSTemporal / FDRCSpatial 'whichCellsClass', # FDRSTemporal ] for argTuple in argTuples[:]: if argTuple[0] in ourArgNames: argTuples.remove(argTuple) # Build the dictionary of arguments if self: for argTuple in argTuples: argName = argTuple[0] if argName in kwargs: # Argument was provided argValue = kwargs.pop(argName) else: # Argument was not provided; use the default value if there is one, and # raise an exception otherwise if len(argTuple) == 2: # No default value raise TypeError("Must provide '%s'" % argName) argValue = argTuple[2] # Set as an instance variable if 'self' was passed in setattr(self, argName, argValue) return argTuples
def _buildArgs(f, self=None, kwargs={}): """ Get the default arguments from the function and assign as instance vars. Return a list of 3-tuples with (name, description, defaultValue) for each argument to the function. Assigns all arguments to the function as instance variables of SPRegion. If the argument was not provided, uses the default value. Pops any values from kwargs that go to the function. """ # Get the name, description, and default value for each argument argTuples = getArgumentDescriptions(f) argTuples = argTuples[1:] # Remove 'self' # Get the names of the parameters to our own constructor and remove them # Check for _originial_init first, because if LockAttributesMixin is used, # __init__'s signature will be just (self, *args, **kw), but # _original_init is created with the original signature #init = getattr(self, '_original_init', self.__init__) init = SPRegion.__init__ ourArgNames = [t[0] for t in getArgumentDescriptions(init)] # Also remove a few other names that aren't in our constructor but are # computed automatically (e.g. numberOfCols for the TP) # TODO: where does numberOfCols come into SPRegion? ourArgNames += [ 'numberOfCols', ] for argTuple in argTuples[:]: if argTuple[0] in ourArgNames: argTuples.remove(argTuple) # Build the dictionary of arguments if self: for argTuple in argTuples: argName = argTuple[0] if argName in kwargs: # Argument was provided argValue = kwargs.pop(argName) else: # Argument was not provided; use the default value if there is one, and # raise an exception otherwise if len(argTuple) == 2: # No default value raise TypeError("Must provide value for '%s'" % argName) argValue = argTuple[2] # Set as an instance variable if 'self' was passed in setattr(self, argName, argValue) return argTuples
def _buildArgs(tmClass, self=None, kwargs={}): """ Get the default arguments from the function and assign as instance vars. Return a list of 3-tuples with (name, description, defaultValue) for each argument to the function. Assigns all arguments to the function as instance variables of TMRegion. If the argument was not provided, uses the default value. Pops any values from kwargs that go to the function. """ # Get the name, description, and default value for each argument argTuples = getArgumentDescriptions(tmClass.__init__) argTuples = argTuples[1:] # Remove "self" # Get the names of the parameters to our own constructor and remove them init = TMRegion.__init__ ourArgNames = [t[0] for t in getArgumentDescriptions(init)] # Also remove a few other names that aren't in our constructor but are # computed automatically #ourArgNames += [ # "inputDimensions", # TODO: CHECK IF WE NEED TO DO THIS #] for argTuple in argTuples[:]: if argTuple[0] in ourArgNames: argTuples.remove(argTuple) # Build the dictionary of arguments if self: for argTuple in argTuples: argName = argTuple[0] if argName in kwargs: # Argument was provided argValue = kwargs.pop(argName) else: # Argument was not provided; use the default value if there is one, and # raise an exception otherwise if len(argTuple) == 2: # No default value raise TypeError("Must provide value for '%s'" % argName) argValue = argTuple[2] # Set as an instance variable if "self" was passed in setattr(self, argName, argValue) return argTuples
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set(numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # General temporal memory self._tm.compute(activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells so we # always compute it explicitly self.activeState[:] = 0 self.activeState[self._tm.getActiveCells()] = 1 predictedActiveCells = self.activeState*self.previouslyPredictedCells self.previouslyPredictedCells[:] = 0 self.previouslyPredictedCells[self._tm.getPredictiveCells()] = 1 # Copy numpy values into the various outputs # outputs['bottomUpOut'][:] = self.activeState outputs['bottomUpOut'][:] = predictedActiveCells outputs['predictiveCells'][:] = self.previouslyPredictedCells outputs['predictedActiveCells'][:] = predictedActiveCells # Handle reset after current input has been processed if 'resetIn' in inputs: assert len(inputs['resetIn']) == 1 if inputs['resetIn'][0] != 0: self.reset()
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = inputs["bottomUpIn"].nonzero()[0] if "externalInput" in inputs: activeExternalCells = inputs["externalInput"].nonzero()[0] else: activeExternalCells = () if "topDownIn" in inputs: activeApicalCells = inputs["topDownIn"].nonzero()[0] else: activeApicalCells = () # Figure out if our class is one of the "extended types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # Extended temporal memory self._tm.compute( activeColumns, activeCellsExternalBasal=activeExternalCells, activeCellsExternalApical=activeApicalCells, reinforceCandidatesExternalBasal=self.prevActiveExternalCells, reinforceCandidatesExternalApical=self.prevActiveApicalCells, growthCandidatesExternalBasal=self.prevActiveExternalCells, growthCandidatesExternalApical=self.prevActiveApicalCells, learn=self.learningMode) self.prevActiveExternalCells = activeExternalCells self.prevActiveApicalCells = activeApicalCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Extract the active / predictive cells and put them into binary arrays. outputs["activeCells"][:] = 0 outputs["activeCells"][self._tm.getActiveCells()] = 1 outputs["predictedCells"][:] = 0 outputs["predictedCells"][self.prevPredictiveCells] = 1 outputs["predictedActiveCells"][:] = (outputs["activeCells"] * outputs["predictedActiveCells"]) predictiveCells = self._tm.getPredictiveCells() outputs["predictiveCells"][:] = 0 outputs["predictiveCells"][predictiveCells] = 0 self.prevPredictiveCells = predictiveCells # Select appropriate output for bottomUpOut if self.defaultOutputType == "active": outputs["bottomUpOut"][:] = outputs["activeCells"] elif self.defaultOutputType == "predictive": outputs["bottomUpOut"][:] = outputs["predictiveCells"] elif self.defaultOutputType == "predictedActiveCells": outputs["bottomUpOut"][:] = outputs["predictedActiveCells"] else: raise Exception("Unknown outputType: " + self.defaultOutputType) # Handle reset after current input has been processed if "resetIn" in inputs: assert len(inputs["resetIn"]) == 1 if inputs["resetIn"][0] != 0: self.reset()
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. The guts of the compute are contained in the self._tmClass compute() call """ # Handle reset input if 'resetIn' in inputs: assert len(inputs['resetIn']) == 1 if inputs['resetIn'][0] != 0: self.reset() activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set(numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # General temporal memory self._tm.compute(activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) predictedActiveCells = self._tm.predictedActiveCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells predictedActiveCells = self._tm.activeCells & self.previouslyPredictedCells self.previouslyPredictedCells = self._tm.predictiveCells # Set the various outputs # HACK HACK: temporary until accessors are in place. activeCells = list(self._tm.activeCells) if isinstance(activeCells[0], ConnectionsCell): activeCells = self._tm.getCellIndices(self._tm.activeCells) predictiveCells = self._tm.getCellIndices(self._tm.predictiveCells) predictedActiveCells = self._tm.getCellIndices(predictedActiveCells) else: predictiveCells = list(self._tm.predictiveCells) predictedActiveCells = list(predictedActiveCells) outputs['bottomUpOut'][:] = 0 outputs['bottomUpOut'][activeCells] = 1 outputs['predictiveCells'][:] = 0 outputs['predictiveCells'][predictiveCells] = 1 outputs['predictedActiveCells'][:] = 0 outputs['predictedActiveCells'][predictedActiveCells] = 1
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. The guts of the compute are contained in the self._tmClass compute() call """ # Handle reset input if 'resetIn' in inputs: assert len(inputs['resetIn']) == 1 if inputs['resetIn'][0] != 0: self.reset() activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set( numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # General temporal memory self._tm.compute( activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) predictedActiveCells = self._tm.predictedActiveCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells predictedActiveCells = self._tm.activeCells & self.previouslyPredictedCells self.previouslyPredictedCells = self._tm.predictiveCells # Set the various outputs # HACK HACK: temporary until accessors are in place. activeCells = list(self._tm.activeCells) if isinstance(activeCells[0], ConnectionsCell): activeCells = self._tm.getCellIndices(self._tm.activeCells) predictiveCells = self._tm.getCellIndices(self._tm.predictiveCells) predictedActiveCells = self._tm.getCellIndices( predictedActiveCells) else: predictiveCells = list(self._tm.predictiveCells) predictedActiveCells = list(predictedActiveCells) outputs['bottomUpOut'][:] = 0 outputs['bottomUpOut'][activeCells] = 1 outputs['predictiveCells'][:] = 0 outputs['predictiveCells'][predictiveCells] = 1 outputs['predictedActiveCells'][:] = 0 outputs['predictedActiveCells'][predictedActiveCells] = 1
def _buildArgs(f, self=None, kwargs={}): """ Get the default arguments from the function and assign as instance vars. Return a list of 3-tuples with (name, description, defaultValue) for each argument to the function. Assigns all arguments to the function as instance variables of SPRegion. If the argument was not provided, uses the default value. Pops any values from kwargs that go to the function. """ # Get the name, description, and default value for each argument argTuples = getArgumentDescriptions(f) argTuples = argTuples[1:] # Remove 'self' # Get the names of the parameters to our own constructor and remove them # Check for _originial_init first, because if LockAttributesMixin is used, # __init__'s signature will be just (self, *args, **kw), but # _original_init is created with the original signature #init = getattr(self, '_original_init', self.__init__) init = SPRegion.__init__ ourArgNames = [t[0] for t in getArgumentDescriptions(init)] # Also remove a few other names that aren't in our constructor but are # computed automatically (e.g. numberOfCols for the TP) # TODO: where does numberOfCols come into SPRegion? ourArgNames += [ 'numberOfCols', ] for argTuple in argTuples[:]: if argTuple[0] in ourArgNames: argTuples.remove(argTuple) # Build the dictionary of arguments if self: for argTuple in argTuples: argName = argTuple[0] if argName in kwargs: # Argument was provided argValue = kwargs.pop(argName) else: # Argument was not provided; use the default value if there is one, and # raise an exception otherwise if len(argTuple) == 2: # No default value raise TypeError("Must provide value for '%s'" % argName) argValue = argTuple[2] # Set as an instance variable if 'self' was passed in setattr(self, argName, argValue) # Translate some parameters for backward compatibility if kwargs.has_key('numActivePerInhArea'): setattr(self, 'numActiveColumnsPerInhArea', kwargs['numActivePerInhArea']) kwargs.pop('numActivePerInhArea') if kwargs.has_key('coincInputPoolPct'): setattr(self, 'potentialPct', kwargs['coincInputPoolPct']) kwargs.pop('coincInputPoolPct') return argTuples
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set( numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # Extended temporal memory self._tm.compute( activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells so we # always compute it explicitly self.activeState[:] = 0 self.activeState[self._tm.getActiveCells()] = 1 predictedActiveCells = self.activeState * self.previouslyPredictedCells self.previouslyPredictedCells[:] = 0 self.previouslyPredictedCells[self._tm.getPredictiveCells()] = 1 # Copy numpy values into the various outputs outputs["activeCells"][:] = self.activeState outputs["predictiveCells"][:] = self.previouslyPredictedCells outputs["predictedActiveCells"][:] = predictedActiveCells # Select appropriate output for bottomUpOut if self.defaultOutputType == "active": outputs["bottomUpOut"][:] = self.activeState elif self.defaultOutputType == "predictive": outputs["bottomUpOut"][:] = self.previouslyPredictedCells elif self.defaultOutputType == "predictedActiveCells": outputs["bottomUpOut"][:] = predictedActiveCells else: raise Exception("Unknown outputType: " + self.defaultOutputType) # Handle reset after current input has been processed if "resetIn" in inputs: assert len(inputs["resetIn"]) == 1 if inputs["resetIn"][0] != 0: self.reset()
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set( numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # General temporal memory self._tm.compute( activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) predictedActiveCells = self._tm.predictedActiveCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells predictedActiveCells = self._tm.activeCells & self.previouslyPredictedCells self.previouslyPredictedCells = self._tm.predictiveCells # Set the various outputs # HACK HACK: temporary until accessors are in place. activeCells = list(self._tm.activeCells) if isinstance(activeCells[0], ConnectionsCell): activeCells = self._tm.getCellIndices(self._tm.activeCells) predictiveCells = self._tm.getCellIndices(self._tm.predictiveCells) predictedActiveCells = self._tm.getCellIndices( predictedActiveCells) else: predictiveCells = list(self._tm.predictiveCells) predictedActiveCells = list(predictedActiveCells) outputs['bottomUpOut'][:] = 0 outputs['bottomUpOut'][activeCells] = 1 outputs['predictiveCells'][:] = 0 outputs['predictiveCells'][predictiveCells] = 1 outputs['predictedActiveCells'][:] = 0 outputs['predictedActiveCells'][predictedActiveCells] = 1 # Handle reset after current input has been processed if 'resetIn' in inputs: assert len(inputs['resetIn']) == 1 if inputs['resetIn'][0] != 0: self.reset()
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = set(numpy.where(inputs["bottomUpIn"] == 1)[0]) if "externalInput" in inputs: activeExternalCells = set(numpy.where(inputs["externalInput"] == 1)[0]) else: activeExternalCells = None if "topDownIn" in inputs: activeApicalCells = set(numpy.where(inputs["topDownIn"] == 1)[0]) else: activeApicalCells = None # Figure out if our class is one of the "general types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # General temporal memory self._tm.compute(activeColumns, activeExternalCells=activeExternalCells, activeApicalCells=activeApicalCells, formInternalConnections=self.formInternalConnections, learn=self.learningMode) predictedActiveCells = self._tm.predictedActiveCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Normal temporal memory doesn't compute predictedActiveCells predictedActiveCells = self._tm.activeCells & self.previouslyPredictedCells self.previouslyPredictedCells = self._tm.predictiveCells # Set the various outputs # HACK HACK: temporary until accessors are in place. activeCells = list(self._tm.activeCells) if isinstance(activeCells[0], ConnectionsCell): activeCells = self._tm.getCellIndices(self._tm.activeCells) predictiveCells = self._tm.getCellIndices(self._tm.predictiveCells) predictedActiveCells = self._tm.getCellIndices(predictedActiveCells) else: predictiveCells = list(self._tm.predictiveCells) predictedActiveCells = list(predictedActiveCells) outputs['bottomUpOut'][:] = 0 outputs['bottomUpOut'][activeCells] = 1 outputs['predictiveCells'][:] = 0 outputs['predictiveCells'][predictiveCells] = 1 outputs['predictedActiveCells'][:] = 0 outputs['predictedActiveCells'][predictedActiveCells] = 1 # Handle reset after current input has been processed if 'resetIn' in inputs: assert len(inputs['resetIn']) == 1 if inputs['resetIn'][0] != 0: self.reset()
def compute(self, inputs, outputs): """ Run one iteration of TM's compute. Note that if the reset signal is True (1) we assume this iteration represents the *end* of a sequence. The output will contain the TM representation to this point and any history will then be reset. The output at the next compute will start fresh, presumably with bursting columns. """ activeColumns = inputs["bottomUpIn"].nonzero()[0] if "externalInput" in inputs: activeExternalCells = inputs["externalInput"].nonzero()[0] else: activeExternalCells = () if "topDownIn" in inputs: activeApicalCells = inputs["topDownIn"].nonzero()[0] else: activeApicalCells = () # Figure out if our class is one of the "extended types" args = getArgumentDescriptions(self._tm.compute) if len(args) > 3: # Extended temporal memory self._tm.compute( activeColumns, activeCellsExternalBasal=activeExternalCells, activeCellsExternalApical=activeApicalCells, reinforceCandidatesExternalBasal=self.prevActiveExternalCells, reinforceCandidatesExternalApical=self.prevActiveApicalCells, growthCandidatesExternalBasal=self.prevActiveExternalCells, growthCandidatesExternalApical=self.prevActiveApicalCells, learn=self.learningMode, ) self.prevActiveExternalCells = activeExternalCells self.prevActiveApicalCells = activeApicalCells else: # Plain old temporal memory self._tm.compute(activeColumns, learn=self.learningMode) # Extract the active / predictive cells and put them into binary arrays. outputs["activeCells"][:] = 0 outputs["activeCells"][self._tm.getActiveCells()] = 1 outputs["predictedCells"][:] = 0 outputs["predictedCells"][self.prevPredictiveCells] = 1 outputs["predictedActiveCells"][:] = outputs["activeCells"] * outputs["predictedActiveCells"] predictiveCells = self._tm.getPredictiveCells() outputs["predictiveCells"][:] = 0 outputs["predictiveCells"][predictiveCells] = 0 self.prevPredictiveCells = predictiveCells # Select appropriate output for bottomUpOut if self.defaultOutputType == "active": outputs["bottomUpOut"][:] = outputs["activeCells"] elif self.defaultOutputType == "predictive": outputs["bottomUpOut"][:] = outputs["predictiveCells"] elif self.defaultOutputType == "predictedActiveCells": outputs["bottomUpOut"][:] = outputs["predictedActiveCells"] else: raise Exception("Unknown outputType: " + self.defaultOutputType) # Handle reset after current input has been processed if "resetIn" in inputs: assert len(inputs["resetIn"]) == 1 if inputs["resetIn"][0] != 0: self.reset()