def test_growSynapses(self): for (name, cells, growingSegments, presynapticInputs, activeInputs, initialPermanence, connectedPermanence, expected) in (("Basic test", [1, 2, 3], [0, 2], [42, 43, 44], [42, 43], 0.55, 0.5, [2, 0, 2]), ("No segments selected", [1, 2, 3], [], [42, 43, 44], [42, 43], 0.55, 0.5, [0, 0, 0]), ("No inputs selected", [1, 2, 3], [0, 2], [], [42, 43], 0.55, 0.5, [0, 0, 0]) ): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments[growingSegments], presynapticInputs, initialPermanence) overlaps = connections.computeActivity(activeInputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name)
def test_adjustActiveSynapses(self): for (name, cells, inputs, adjustedSegments, activeInputs, initialPermanence, delta, connectedPermanence, expected) in (("Basic test", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.45, 0.1, 0.5, [2, 0, 2]), ("Negative increment", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.55, -0.1, 0.5, [1, 3, 1]), ("No segments", [1, 2, 3], [42, 43, 44], [], [42, 44], 0.45, 0.1, 0.5, [0, 0, 0]), ("No active synapses", [1, 2, 3], [42, 43, 44], [0, 2], [], 0.45, 0.1, 0.5, [0, 0, 0]), ("Delta of zero", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.55, 0.0, 0.5, [3, 3, 3])): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments, inputs, initialPermanence) connections.adjustActiveSynapses(segments[adjustedSegments], activeInputs, delta) overlaps = connections.computeActivity(inputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name)
def test_computeActivity(self): for (name, cells, inputs, activeInputs, initialPermanence, expected) in (("Basic test", [1, 2, 3], [42, 43, 44], [42, 44], 0.45, [2, 2, 2]), ("Small permanence", [1, 2, 3], [42, 43, 44], [42, 44], 0.01, [2, 2, 2]), ("No segments", [], [42, 43, 44], [42, 44], 0.45, []), ("No active inputs", [1, 2, 3], [42, 43, 44], [], 0.45, [0, 0, 0]) ): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments, inputs, initialPermanence) overlaps = connections.computeActivity(activeInputs) np.testing.assert_equal(overlaps[segments], expected, name)
class SegmentedForwardModel(object): """ A forward model that uses dendrite segments. Every cell has a set of segments. Every segment has a set of synapses. The cell fires when the number of active synapses on one of its segments reaches a threshold. """ def __init__(self, cellCount, inputSize, threshold): self.proximalConnections = SparseMatrixConnections(cellCount, inputSize) self.threshold = threshold self.activeCells = np.empty(0, dtype='uint32') self.activeSegments = np.empty(0, dtype='uint32') def associate(self, activeCells, activeInput): self.activeCells = activeCells self.activeSegments = self.proximalConnections.createSegments( activeCells) self.proximalConnections.matrix.setZerosOnOuter( self.activeSegments, activeInput, 1.0) def infer(self, activeInput): overlaps = self.proximalConnections.computeActivity(activeInput) self.activeSegments = np.where(overlaps >= self.threshold)[0] self.activeCells = self.proximalConnections.mapSegmentsToCells( self.activeSegments) self.activeCells.sort()
def test_computeActivity_thresholded(self): for (name, cells, inputs, activeInputs, initialPermanence, connectedPermanence, expected) in (("Accepted", [1, 2, 3], [42, 43, 44], [42, 44], 0.55, 0.5, [2, 2, 2]), ("Rejected", [1, 2, 3], [42, 43, 44], [42, 44], 0.55, 0.6, [0, 0, 0]), ("No segments", [], [42, 43, 44], [42, 44], 0.55, 0.5, []), ("No active inputs", [1, 2, 3], [42, 43, 44], [], 0.55, 0.5, [0, 0, 0]) ): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments, inputs, initialPermanence) overlaps = connections.computeActivity(activeInputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name)
def test_adjustSynapses(self): for (name, cells, inputs, adjustedSegments, activeInputs, initialPermanence, activeDelta, inactiveDelta, connectedPermanence, expected) in (("Basic test", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.45, 0.1, -0.1, 0.5, [2, 0, 2]), ("Reward inactive", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.45, -0.1, 0.1, 0.5, [1, 0, 1]), ("No segments", [1, 2, 3], [42, 43, 44], [], [42, 44], 0.45, 0.1, -0.1, 0.5, [0, 0, 0]), ("No active synapses", [1, 2, 3], [42, 43, 44], [0, 2], [], 0.45, 0.1, -0.1, 0.5, [0, 0, 0]), ("Delta of zero", [1, 2, 3], [42, 43, 44], [0, 2], [42, 44], 0.55, 0.0, 0.0, 0.5, [3, 3, 3]) ): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments, inputs, initialPermanence) connections.adjustSynapses(segments[adjustedSegments], activeInputs, activeDelta, inactiveDelta) overlaps = connections.computeActivity(inputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name)
def test_clipPermanences(self): connections = SparseMatrixConnections(2048, 2048) # Destroy synapses with permanences <= 0.0 segments = connections.createSegments([1, 2, 3]) connections.growSynapses(segments, [42, 43, 44], 0.05) connections.growSynapses(segments, [45, 46], 0.1) connections.adjustInactiveSynapses(segments, [], -0.1) connections.clipPermanences(segments) np.testing.assert_equal( connections.mapSegmentsToSynapseCounts(segments), [0, 0, 0]) # Clip permanences to 1.0 connections.growSynapses(segments, [42, 43, 44], 0.95) connections.adjustInactiveSynapses(segments, [], 0.50) connections.clipPermanences(segments) np.testing.assert_equal( connections.mapSegmentsToSynapseCounts(segments), [3, 3, 3]) connections.adjustInactiveSynapses(segments, [], -0.5) overlaps1 = connections.computeActivity([42, 43, 44], 0.49) overlaps2 = connections.computeActivity([42, 43, 44], 0.51) np.testing.assert_equal(overlaps1, [3, 3, 3]) np.testing.assert_equal(overlaps2, [0, 0, 0])
def test_clipPermanences(self): connections = SparseMatrixConnections(2048, 2048) # Destroy synapses with permanences <= 0.0 segments = connections.createSegments([1, 2, 3]) connections.growSynapses(segments, [42, 43, 44], 0.05) connections.growSynapses(segments, [45, 46], 0.1) connections.adjustInactiveSynapses(segments, [], -0.1) connections.clipPermanences(segments) np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments), [0, 0, 0]) # Clip permanences to 1.0 connections.growSynapses(segments, [42, 43, 44], 0.95) connections.adjustInactiveSynapses(segments, [], 0.50) connections.clipPermanences(segments) np.testing.assert_equal(connections.mapSegmentsToSynapseCounts(segments), [3, 3, 3]) connections.adjustInactiveSynapses(segments, [], -0.5) overlaps1 = connections.computeActivity([42, 43, 44], 0.49) overlaps2 = connections.computeActivity([42, 43, 44], 0.51) np.testing.assert_equal(overlaps1, [3, 3, 3]) np.testing.assert_equal(overlaps2, [0, 0, 0])
class SensorToSpecificObjectModule(object): """ Represents the sensor location relative to a specific object. Typically these modules are arranged in an array, and the combined population SDR is used to predict a feature-location pair. This class has two sets of connections. Both of them compute the "sensor's location relative to a specific object" in different ways. The "metric connections" compute it from the "body's location relative to a specific object" and the "sensor's location relative to body" These connections are learned once and then never need to be updated. They might be genetically hardcoded. They're initialized externally, e.g. in BodyToSpecificObjectModule2D. The "anchor connections" compute it from the sensory input. Whenever a cortical column learns a feature-location pair, this layer forms reciprocal connections with the feature-location pair layer. These segments receive input at different times. The metric connections receive input first, and they activate a set of cells. This set of cells is used externally to predict a feature-location pair. Then this feature-location pair is the input to the anchor connections. """ def __init__(self, cellDimensions, anchorInputSize, activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, seed=42): """ @param cellDimensions (sequence of ints) @param anchorInputSize (int) @param activationThreshold (int) """ self.activationThreshold = activationThreshold self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) self.cellCount = np.prod(cellDimensions) cellCountBySource = { "bodyToSpecificObject": self.cellCount, "sensorToBody": self.cellCount, } self.metricConnections = Multiconnections(self.cellCount, cellCountBySource) self.anchorConnections = SparseMatrixConnections( self.cellCount, anchorInputSize) def reset(self): self.activeCells = np.empty(0, dtype="int") def metricCompute(self, sensorToBody, bodyToSpecificObject): """ Compute the "sensor's location relative to a specific object" from the "body's location relative to a specific object" and the "sensor's location relative to body" @param sensorToBody (numpy array) Active cells of a single module that represents the sensor's location relative to the body @param bodyToSpecificObject (numpy array) Active cells of a single module that represents the body's location relative to a specific object """ overlaps = self.metricConnections.computeActivity({ "bodyToSpecificObject": bodyToSpecificObject, "sensorToBody": sensorToBody, }) self.activeMetricSegments = np.where(overlaps >= 2)[0] self.activeCells = np.unique( self.metricConnections.mapSegmentsToCells( self.activeMetricSegments)) def anchorCompute(self, anchorInput, learn): """ Compute the "sensor's location relative to a specific object" from the feature-location pair. @param anchorInput (numpy array) Active cells in the feature-location pair layer @param learn (bool) If true, maintain current cell activity and learn this input on the currently active cells """ if learn: self._anchorComputeLearningMode(anchorInput) else: overlaps = self.anchorConnections.computeActivity( anchorInput, self.connectedPermanence) self.activeSegments = np.where( overlaps >= self.activationThreshold)[0] self.activeCells = np.unique( self.anchorConnections.mapSegmentsToCells(self.activeSegments)) def _anchorComputeLearningMode(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.anchorConnections.computeActivity( anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.anchorConnections.computeActivity(anchorInput) matchingSegments = np.where( potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.anchorConnections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[np.in1d( cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.anchorConnections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.anchorConnections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[np.in1d( cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.anchorConnections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.anchorConnections.createSegments(newSegmentCells) self.anchorConnections.growSynapsesToSample(newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells
class Superficial2DLocationModule(object): """ A model of a location module. It's similar to a grid cell module, but it uses squares rather than triangles. The cells are arranged into a m*n rectangle which is tiled onto 2D space. Each cell represents a small rectangle in each tile. +------+------+------++------+------+------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #1 | #2 | #3 || #1 | #2 | #3 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #4 | #5 | #6 || #4 | #5 | #6 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #7 | #8 | #9 || #7 | #8 | #9 | | | | || | | | +------+------+------++------+------+------+ We assume that path integration works *somehow*. This model receives a "delta location" vector, and it shifts the active cells accordingly. The model stores intermediate coordinates of active cells. Whenever sensory cues activate a cell, the model adds this cell to the list of coordinates being shifted. Whenever sensory cues cause a cell to become inactive, that cell is removed from the list of coordinates. (This model doesn't attempt to propose how "path integration" works. It attempts to show how locations are anchored to sensory cues.) When orientation is set to 0 degrees, the displacement is a [di, dj], moving di cells "down" and dj cells "right". When orientation is set to 90 degrees, the displacement is essentially a [dx, dy], applied in typical x,y coordinates with the origin on the bottom left. Usage: - When the sensor moves, call movementCompute. - When the sensor senses something, call sensoryCompute. The "anchor input" is typically a feature-location pair SDR. To specify how points are tracked, pass anchoringMethod = "corners", "narrowing" or "discrete". "discrete" will cause the network to operate in a fully discrete space, where uncertainty is impossible as long as movements are integers. "narrowing" is designed to narrow down uncertainty of initial locations of sensory stimuli. "corners" is designed for noise-tolerance, and will activate all cells that are possible outcomes of path integration. """ def __init__(self, cellDimensions, moduleMapDimensions, orientation, anchorInputSize, cellCoordinateOffsets=(0.5, ), activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, anchoringMethod="narrowing", rotationMatrix=None, seed=42): """ @param cellDimensions (tuple(int, int)) Determines the number of cells. Determines how space is divided between the cells. @param moduleMapDimensions (tuple(float, float)) Determines the amount of world space covered by all of the cells combined. In grid cell terminology, this is equivalent to the "scale" of a module. A module with a scale of "5cm" would have moduleMapDimensions=(5.0, 5.0). @param orientation (float) The rotation of this map, measured in radians. @param anchorInputSize (int) The number of input bits in the anchor input. @param cellCoordinateOffsets (list of floats) These must each be between 0.0 and 1.0. Every time a cell is activated by anchor input, this class adds a "phase" which is shifted in subsequent motions. By default, this phase is placed at the center of the cell. This parameter allows you to control where the point is placed and whether multiple are placed. For example, with value [0.2, 0.8], when cell [2, 3] is activated it will place 4 phases, corresponding to the following points in cell coordinates: [2.2, 3.2], [2.2, 3.8], [2.8, 3.2], [2.8, 3.8] """ self.cellDimensions = np.asarray(cellDimensions, dtype="int") self.moduleMapDimensions = np.asarray(moduleMapDimensions, dtype="float") self.phasesPerUnitDistance = 1.0 / self.moduleMapDimensions if rotationMatrix is None: self.orientation = orientation self.rotationMatrix = np.array( [[math.cos(orientation), -math.sin(orientation)], [math.sin(orientation), math.cos(orientation)]]) if anchoringMethod == "discrete": # Need to convert matrix to have integer values nonzeros = self.rotationMatrix[np.where( np.abs(self.rotationMatrix) > 0)] smallestValue = np.amin(nonzeros) self.rotationMatrix /= smallestValue self.rotationMatrix = np.ceil(self.rotationMatrix) else: self.rotationMatrix = rotationMatrix self.cellCoordinateOffsets = cellCoordinateOffsets # Phase is measured as a number in the range [0.0, 1.0) self.activePhases = np.empty((0, 2), dtype="float") self.cellsForActivePhases = np.empty(0, dtype="int") self.phaseDisplacement = np.empty((0, 2), dtype="float") self.activeCells = np.empty(0, dtype="int") self.activeSegments = np.empty(0, dtype="uint32") self.connections = SparseMatrixConnections(np.prod(cellDimensions), anchorInputSize) self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.anchoringMethod = anchoringMethod self.rng = Random(seed) def reset(self): """ Clear the active cells. """ self.activePhases = np.empty((0, 2), dtype="float") self.phaseDisplacement = np.empty((0, 2), dtype="float") self.cellsForActivePhases = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") def _computeActiveCells(self): # Round each coordinate to the nearest cell. activeCellCoordinates = np.floor(self.activePhases * self.cellDimensions).astype("int") # Convert coordinates to cell numbers. self.cellsForActivePhases = (np.ravel_multi_index( activeCellCoordinates.T, self.cellDimensions)) self.activeCells = np.unique(self.cellsForActivePhases) def activateRandomLocation(self): """ Set the location to a random point. """ self.activePhases = np.array([np.random.random(2)]) if self.anchoringMethod == "discrete": # Need to place the phase in the middle of a cell self.activePhases = np.floor( self.activePhases * self.cellDimensions) / self.cellDimensions self._computeActiveCells() def movementCompute(self, displacement, noiseFactor=0): """ Shift the current active cells by a vector. @param displacement (pair of floats) A translation vector [di, dj]. """ if noiseFactor != 0: displacement = copy.deepcopy(displacement) xnoise = np.random.normal(0, noiseFactor) ynoise = np.random.normal(0, noiseFactor) displacement[0] += xnoise displacement[1] += ynoise # Calculate delta in the module's coordinates. phaseDisplacement = (np.matmul(self.rotationMatrix, displacement) * self.phasesPerUnitDistance) # Shift the active coordinates. np.add(self.activePhases, phaseDisplacement, out=self.activePhases) # In Python, (x % 1.0) can return 1.0 because of floating point goofiness. # Generally this doesn't cause problems, it's just confusing when you're # debugging. np.round(self.activePhases, decimals=9, out=self.activePhases) np.mod(self.activePhases, 1.0, out=self.activePhases) self._computeActiveCells() self.phaseDisplacement = phaseDisplacement def _sensoryComputeInferenceMode(self, anchorInput): """ Infer the location from sensory input. Activate any cells with enough active synapses to this sensory input. Deactivate all other cells. @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ if len(anchorInput) == 0: return overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] sensorySupportedCells = np.unique( self.connections.mapSegmentsToCells(activeSegments)) inactivated = np.setdiff1d(self.activeCells, sensorySupportedCells) inactivatedIndices = np.in1d(self.cellsForActivePhases, inactivated).nonzero()[0] if inactivatedIndices.size > 0: self.activePhases = np.delete(self.activePhases, inactivatedIndices, axis=0) activated = np.setdiff1d(sensorySupportedCells, self.activeCells) # Find centers of point clouds if "corners" in self.anchoringMethod: activatedCoordsBase = np.transpose( np.unravel_index(sensorySupportedCells, self.cellDimensions)).astype('float') else: activatedCoordsBase = np.transpose( np.unravel_index(activated, self.cellDimensions)).astype('float') # Generate points to add activatedCoords = np.concatenate([ activatedCoordsBase + [iOffset, jOffset] for iOffset in self.cellCoordinateOffsets for jOffset in self.cellCoordinateOffsets ]) if "corners" in self.anchoringMethod: self.activePhases = activatedCoords / self.cellDimensions else: if activatedCoords.size > 0: self.activePhases = np.append(self.activePhases, activatedCoords / self.cellDimensions, axis=0) self._computeActiveCells() self.activeSegments = activeSegments def _sensoryComputeLearningMode(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.connections.computeActivity(anchorInput) matchingSegments = np.where( potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.connections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[np.in1d( cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.connections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.connections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[np.in1d( cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.connections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.connections.createSegments(newSegmentCells) self.connections.growSynapsesToSample(newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments def sensoryCompute(self, anchorInput, anchorGrowthCandidates, learn): if learn: self._sensoryComputeLearningMode(anchorGrowthCandidates) else: self._sensoryComputeInferenceMode(anchorInput) @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells def numberOfCells(self): return np.prod(self.cellDimensions)
class SingleLayerLocationMemory(object): """ A layer of cells which learns how to take a "delta location" (e.g. a motor command or a proprioceptive delta) and update its active cells to represent the new location. Its active cells might represent a union of locations. As the location changes, the featureLocationInput causes this union to narrow down until the location is inferred. This layer receives absolute proprioceptive info as proximal input. For now, we assume that there's a one-to-one mapping between absolute proprioceptive input and the location SDR. So rather than modeling proximal synapses, we'll just relay the proprioceptive SDR. In the future we might want to consider a many-to-one mapping of proprioceptive inputs to location SDRs. After this layer is trained, it no longer needs the proprioceptive input. The delta location will drive the layer. The current active cells and the other distal connections will work together with this delta location to activate a new set of cells. When no cells are active, activate a large union of possible locations. With subsequent inputs, the union will narrow down to a single location SDR. """ def __init__(self, cellCount, deltaLocationInputSize, featureLocationInputSize, activationThreshold=13, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.1, maxSynapsesPerSegment=-1, seed=42): # For transition learning, every segment is split into two parts. # For the segment to be active, both parts must be active. self.internalConnections = SparseMatrixConnections( cellCount, cellCount) self.deltaConnections = SparseMatrixConnections( cellCount, deltaLocationInputSize) # Distal segments that receive input from the layer that represents # feature-locations. self.featureLocationConnections = SparseMatrixConnections( cellCount, featureLocationInputSize) self.activeCells = np.empty(0, dtype="uint32") self.activeDeltaSegments = np.empty(0, dtype="uint32") self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) def reset(self): """ Deactivate all cells. """ self.activeCells = np.empty(0, dtype="uint32") self.activeDeltaSegments = np.empty(0, dtype="uint32") self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") def compute(self, deltaLocation=(), newLocation=(), featureLocationInput=(), featureLocationGrowthCandidates=(), learn=True): """ Run one time step of the Location Memory algorithm. @param deltaLocation (sorted numpy array) @param newLocation (sorted numpy array) @param featureLocationInput (sorted numpy array) @param featureLocationGrowthCandidates (sorted numpy array) """ prevActiveCells = self.activeCells self.activeDeltaSegments = np.where( (self.internalConnections.computeActivity( prevActiveCells, self.connectedPermanence ) >= self.activationThreshold) & (self.deltaConnections.computeActivity( deltaLocation, self.connectedPermanence ) >= self.activationThreshold))[0] # When we're moving, the feature-location input has no effect. if len(deltaLocation) == 0: self.activeFeatureLocationSegments = np.where( self.featureLocationConnections.computeActivity( featureLocationInput, self.connectedPermanence ) >= self.activationThreshold)[0] else: self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") if len(newLocation) > 0: # Drive activations by relaying this location SDR. self.activeCells = newLocation if learn: # Learn the delta. self._learnTransition(prevActiveCells, deltaLocation, newLocation) # Learn the featureLocationInput. self._learnFeatureLocationPair(newLocation, featureLocationInput, featureLocationGrowthCandidates) elif len(prevActiveCells) > 0: if len(deltaLocation) > 0: # Drive activations by applying the deltaLocation to the current location. # Completely ignore the featureLocationInput. It's outdated, associated # with the previous location. cellsForDeltaSegments = self.internalConnections.mapSegmentsToCells( self.activeDeltaSegments) self.activeCells = np.unique(cellsForDeltaSegments) else: # Keep previous active cells active. # Modulate with the featureLocationInput. if len(self.activeFeatureLocationSegments) > 0: cellsForFeatureLocationSegments = ( self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments)) self.activeCells = np.intersect1d(prevActiveCells, cellsForFeatureLocationSegments) else: self.activeCells = prevActiveCells elif len(featureLocationInput) > 0: # Drive activations with the featureLocationInput. cellsForFeatureLocationSegments = ( self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments)) self.activeCells = np.unique(cellsForFeatureLocationSegments) def _learnTransition(self, prevActiveCells, deltaLocation, newLocation): """ For each cell in the newLocation SDR, learn the transition of prevLocation (i.e. prevActiveCells) + deltaLocation. The transition might be already known. In that case, just reinforce the existing segments. """ prevLocationPotentialOverlaps = self.internalConnections.computeActivity( prevActiveCells) deltaPotentialOverlaps = self.deltaConnections.computeActivity( deltaLocation) matchingDeltaSegments = np.where( (prevLocationPotentialOverlaps >= self.learningThreshold) & (deltaPotentialOverlaps >= self.learningThreshold))[0] # Cells with a active segment pair: reinforce the segment cellsForActiveSegments = self.internalConnections.mapSegmentsToCells( self.activeDeltaSegments) learningActiveDeltaSegments = self.activeDeltaSegments[ np.in1d(cellsForActiveSegments, newLocation)] remainingCells = np.setdiff1d(newLocation, cellsForActiveSegments) # Remaining cells with a matching segment pair: reinforce the best matching # segment pair. candidateSegments = self.internalConnections.filterSegmentsByCell( matchingDeltaSegments, remainingCells) cellsForCandidateSegments = self.internalConnections.mapSegmentsToCells( candidateSegments) candidateSegments = matchingDeltaSegments[ np.in1d(cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( prevLocationPotentialOverlaps[candidateSegments] + deltaPotentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingDeltaSegments = candidateSegments[onePerCellFilter] newDeltaSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveDeltaSegments, learningMatchingDeltaSegments): self._learn(self.internalConnections, self.rng, learningSegments, prevActiveCells, prevActiveCells, prevLocationPotentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) self._learn(self.deltaConnections, self.rng, learningSegments, deltaLocation, deltaLocation, deltaPotentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) numNewLocationSynapses = len(prevActiveCells) numNewDeltaSynapses = len(deltaLocation) if self.sampleSize != -1: numNewLocationSynapses = min(numNewLocationSynapses, self.sampleSize) numNewDeltaSynapses = min(numNewDeltaSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewLocationSynapses = min(numNewLocationSynapses, self.maxSynapsesPerSegment) numNewDeltaSynapses = min(numNewLocationSynapses, self.maxSynapsesPerSegment) newPrevLocationSegments = self.internalConnections.createSegments( newDeltaSegmentCells) newDeltaSegments = self.deltaConnections.createSegments( newDeltaSegmentCells) assert np.array_equal(newPrevLocationSegments, newDeltaSegments) self.internalConnections.growSynapsesToSample( newPrevLocationSegments, prevActiveCells, numNewLocationSynapses, self.initialPermanence, self.rng) self.deltaConnections.growSynapsesToSample( newDeltaSegments, deltaLocation, numNewDeltaSynapses, self.initialPermanence, self.rng) def _learnFeatureLocationPair(self, newLocation, featureLocationInput, featureLocationGrowthCandidates): """ Grow / reinforce synapses between the location layer's dendrites and the input layer's active cells. """ potentialOverlaps = self.featureLocationConnections.computeActivity( featureLocationInput) matchingSegments = np.where(potentialOverlaps > self.learningThreshold)[0] # Cells with a active segment pair: reinforce the segment cellsForActiveSegments = self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments) learningActiveSegments = self.activeFeatureLocationSegments[ np.in1d(cellsForActiveSegments, newLocation)] remainingCells = np.setdiff1d(newLocation, cellsForActiveSegments) # Remaining cells with a matching segment pair: reinforce the best matching # segment pair. candidateSegments = self.featureLocationConnections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.featureLocationConnections.mapSegmentsToCells( candidateSegments)) candidateSegments = candidateSegments[ np.in1d(cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti(potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.featureLocationConnections, self.rng, learningSegments, featureLocationInput, featureLocationGrowthCandidates, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) numNewSynapses = len(featureLocationInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.featureLocationConnections.createSegments( newSegmentCells) self.featureLocationConnections.growSynapsesToSample( newSegments, featureLocationGrowthCandidates, numNewSynapses, self.initialPermanence, self.rng) @staticmethod def _learn(connections, rng, learningSegments, activeInput, growthCandidates, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param growthCandidates (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(growthCandidates) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, growthCandidates, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells
class Thalamus(object): """ A simple discrete time thalamus. This thalamus has a 2D TRN layer and a 2D relay cell layer. L6 cells project to the dendrites of TRN cells - these connections are learned. TRN cells project to the dendrites of relay cells in a fixed fan-out pattern. A 2D feed forward input source projects to the relay cells in a fixed fan-out pattern. The output of the thalamus is the activity of each relay cell. This activity can be in one of three states: inactive, active (tonic), and active (burst). TRN cells control whether the relay cells will burst. If any dendrite on a TRN cell recognizes the current L6 pattern, it de-inactivates the T-type CA2+ channels on the dendrites of any relay cell it projects to. These relay cells are then in "burst-ready mode". Feed forward activity is in the form of a binary vector corresponding to active/spiking axons (e.g. from ganglion cells). Any relay cells that receive input from an axon will either output tonic or burst activity depending on the state of the T-type CA2+ channels on their dendrites. Relay cells that don't receive input will remain inactive, regardless of their dendritic state. Usage: 1. Train the TRN cells on a bunch of L6 patterns: learnL6Pattern() 2. De-inactivate relay cells by sending in an L6 pattern: deInactivateCells() 3. Compute feed forward activity for an input: computeFeedForwardActivity() 4. reset() 5. Goto 2 """ def __init__(self, trnCellShape=(32, 32), relayCellShape=(32, 32), inputShape=(32, 32), l6CellCount=1024, trnThreshold=10, relayThreshold=1, seed=42): """ :param trnCellShape: a 2D shape for the TRN :param relayCellShape: a 2D shape for the relay cells :param l6CellCount: number of L6 cells :param trnThreshold: dendritic threshold for TRN cells. This is the min number of active L6 cells on a dendrite for the TRN cell to recognize a pattern on that dendrite. :param relayThreshold: dendritic threshold for relay cells. This is the min number of active TRN cells on a dendrite for the relay cell to recognize a pattern on that dendrite. :param seed: Seed for the random number generator. """ self.trnCellShape = trnCellShape self.trnWidth = trnCellShape[0] self.trnHeight = trnCellShape[1] self.relayCellShape = relayCellShape self.relayWidth = relayCellShape[0] self.relayHeight = relayCellShape[1] self.l6CellCount = l6CellCount self.trnThreshold = trnThreshold self.relayThreshold = relayThreshold self.inputShape = inputShape self.seed = seed self.rng = Random(seed) self.trnActivationThreshold = 5 self.trnConnections = SparseMatrixConnections( trnCellShape[0]*trnCellShape[1], l6CellCount) self.relayConnections = SparseMatrixConnections( relayCellShape[0]*relayCellShape[1], trnCellShape[0]*trnCellShape[1]) # Initialize/reset variables that are updated with calls to compute self.reset() self._initializeTRNToRelayCellConnections() def learnL6Pattern(self, l6Pattern, cellsToLearnOn): """ Learn the given l6Pattern on TRN cell dendrites. The TRN cells to learn are given in cellsTeLearnOn. Each of these cells will learn this pattern on a single dendritic segment. :param l6Pattern: An SDR from L6. List of indices corresponding to L6 cells. :param cellsToLearnOn: Each cell index is (x,y) corresponding to the TRN cells that should learn this pattern. For each cell, create a new dendrite that stores this pattern. The SDR is stored on this dendrite """ cellIndices = [self.trnCellIndex(x) for x in cellsToLearnOn] newSegments = self.trnConnections.createSegments(cellIndices) self.trnConnections.growSynapses(newSegments, l6Pattern, 1.0) # print("Learning L6 SDR:", l6Pattern, # "new segments: ", newSegments, # "cells:", self.trnConnections.mapSegmentsToCells(newSegments)) def deInactivateCells(self, l6Input): """ Activate trnCells according to the l6Input. These in turn will impact bursting mode in relay cells that are connected to these trnCells. Given the feedForwardInput, compute which cells will be silent, tonic, or bursting. :param l6Input: :return: nothing """ # Figure out which TRN cells recognize the L6 pattern. self.trnOverlaps = self.trnConnections.computeActivity(l6Input, 0.5) self.activeTRNSegments = np.flatnonzero( self.trnOverlaps >= self.trnActivationThreshold) self.activeTRNCellIndices = self.trnConnections.mapSegmentsToCells( self.activeTRNSegments) # print("trnOverlaps:", self.trnOverlaps, # "active segments:", self.activeTRNSegments) for s, idx in zip(self.activeTRNSegments, self.activeTRNCellIndices): print(self.trnOverlaps[s], idx, self.trnIndextoCoord(idx)) # Figure out which relay cells have dendrites in de-inactivated state self.relayOverlaps = self.relayConnections.computeActivity( self.activeTRNCellIndices, 0.5 ) self.activeRelaySegments = np.flatnonzero( self.relayOverlaps >= self.relayThreshold) self.burstReadyCellIndices = self.relayConnections.mapSegmentsToCells( self.activeRelaySegments) self.burstReadyCells.reshape(-1)[self.burstReadyCellIndices] = 1 def computeFeedForwardActivity(self, feedForwardInput): """ Activate trnCells according to the l6Input. These in turn will impact bursting mode in relay cells that are connected to these trnCells. Given the feedForwardInput, compute which cells will be silent, tonic, or bursting. :param feedForwardInput: a numpy matrix of shape relayCellShape containing 0's and 1's :return: feedForwardInput is modified to contain 0, 1, or 2. A "2" indicates bursting cells. """ feedForwardInput += self.burstReadyCells * feedForwardInput def reset(self): """ Set everything back to zero """ self.trnOverlaps = [] self.activeTRNSegments = [] self.activeTRNCellIndices = [] self.relayOverlaps = [] self.activeRelaySegments = [] self.burstReadyCellIndices = [] self.burstReadyCells = np.zeros((self.relayWidth, self.relayHeight)) def trnCellIndex(self, coord): """ Map a 2D coordinate to 1D cell index. :param coord: a 2D coordinate :return: integer index """ return coord[1] * self.trnWidth + coord[0] def trnIndextoCoord(self, i): """ Map 1D cell index to a 2D coordinate :param i: integer 1D cell index :return: (x, y), a 2D coordinate """ x = i % self.trnWidth y = i / self.trnWidth return x, y def relayCellIndex(self, coord): """ Map a 2D coordinate to 1D cell index. :param coord: a 2D coordinate :return: integer index """ return coord[1] * self.relayWidth + coord[0] def relayIndextoCoord(self, i): """ Map 1D cell index to a 2D coordinate :param i: integer 1D cell index :return: (x, y), a 2D coordinate """ x = i % self.relayWidth y = i / self.relayWidth return x, y def _initializeTRNToRelayCellConnections(self): """ Initialize TRN to relay cell connectivity. For each relay cell, create a dendritic segment for each TRN cell it connects to. """ for x in range(self.relayWidth): for y in range(self.relayHeight): # Create one dendrite for each trn cell that projects to this relay cell # This dendrite contains one synapse corresponding to this TRN->relay # connection. relayCellIndex = self.relayCellIndex((x,y)) trnCells = self._preSynapticTRNCells(x, y) for trnCell in trnCells: newSegment = self.relayConnections.createSegments([relayCellIndex]) self.relayConnections.growSynapses(newSegment, [self.trnCellIndex(trnCell)], 1.0) def _preSynapticTRNCells(self, i, j): """ Given a relay cell at the given coordinate, return a list of the (x,y) coordinates of all TRN cells that project to it. :param relayCellCoordinate: :return: """ xmin = max(i - 1, 0) xmax = min(i + 2, self.trnWidth) ymin = max(j - 1, 0) ymax = min(j + 2, self.trnHeight) trnCells = [ (x, y) for x in range(xmin, xmax) for y in range(ymin, ymax) ] return trnCells
class SuperficialLocationModule2D(object): """ A model of a location module. It's similar to a grid cell module, but it uses squares rather than triangles. The cells are arranged into a m*n rectangle which is tiled onto 2D space. Each cell represents a small rectangle in each tile. +------+------+------++------+------+------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #1 | #2 | #3 || #1 | #2 | #3 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #4 | #5 | #6 || #4 | #5 | #6 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #7 | #8 | #9 || #7 | #8 | #9 | | | | || | | | +------+------+------++------+------+------+ We assume that path integration works *somehow*. This model receives a "delta location" vector, and it shifts the active cells accordingly. The model stores intermediate coordinates of active cells. Whenever sensory cues activate a cell, the model adds this cell to the list of coordinates being shifted. Whenever sensory cues cause a cell to become inactive, that cell is removed from the list of coordinates. (This model doesn't attempt to propose how "path integration" works. It attempts to show how locations are anchored to sensory cues.) When orientation is set to 0 degrees, the deltaLocation is a [di, dj], moving di cells "down" and dj cells "right". When orientation is set to 90 degrees, the deltaLocation is essentially a [dx, dy], applied in typical x,y coordinates with the origin on the bottom left. Usage: Adjust the location in response to motor input: lm.shift([di, dj]) Adjust the location in response to sensory input: lm.anchor(anchorInput) Learn an anchor input for the current location: lm.learn(anchorInput) The "anchor input" is typically a feature-location pair SDR. During inference, you'll typically call: lm.shift(...) # Consume lm.getActiveCells() # ... lm.anchor(...) During learning, you'll do the same, but you'll call lm.learn() instead of lm.anchor(). """ def __init__(self, cellDimensions, moduleMapDimensions, orientation, anchorInputSize, pointOffsets=(0.5, ), activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, seed=42): """ @param cellDimensions (tuple(int, int)) Determines the number of cells. Determines how space is divided between the cells. @param moduleMapDimensions (tuple(float, float)) Determines the amount of world space covered by all of the cells combined. In grid cell terminology, this is equivalent to the "scale" of a module. A module with a scale of "5cm" would have moduleMapDimensions=(5.0, 5.0). @param orientation (float) The rotation of this map, measured in radians. @param anchorInputSize (int) The number of input bits in the anchor input. @param pointOffsets (list of floats) These must each be between 0.0 and 1.0. Every time a cell is activated by anchor input, this class adds a "point" which is shifted in subsequent motions. By default, this point is placed at the center of the cell. This parameter allows you to control where the point is placed and whether multiple are placed. For example, With value [0.2, 0.8], it will place 4 points: [0.2, 0.2], [0.2, 0.8], [0.8, 0.2], [0.8, 0.8] """ self.cellDimensions = np.asarray(cellDimensions, dtype="int") self.moduleMapDimensions = np.asarray(moduleMapDimensions, dtype="float") self.cellFieldsPerUnitDistance = self.cellDimensions / self.moduleMapDimensions self.orientation = orientation self.rotationMatrix = np.array( [[math.cos(orientation), -math.sin(orientation)], [math.sin(orientation), math.cos(orientation)]]) self.pointOffsets = pointOffsets # These coordinates are in units of "cell fields". self.activePoints = np.empty((0, 2), dtype="float") self.cellsForActivePoints = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") self.activeSegments = np.empty(0, dtype="uint32") self.connections = SparseMatrixConnections(np.prod(cellDimensions), anchorInputSize) self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) def reset(self): """ Clear the active cells. """ self.activePoints = np.empty((0, 2), dtype="float") self.cellsForActivePoints = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") def _computeActiveCells(self): # Round each coordinate to the nearest cell. flooredActivePoints = np.floor(self.activePoints).astype("int") # Convert coordinates to cell numbers. self.cellsForActivePoints = (np.ravel_multi_index( flooredActivePoints.T, self.cellDimensions)) self.activeCells = np.unique(self.cellsForActivePoints) def activateRandomLocation(self): """ Set the location to a random point. """ self.activePoints = np.array( [np.random.random(2) * self.cellDimensions]) self._computeActiveCells() def shift(self, deltaLocation): """ Shift the current active cells by a vector. @param deltaLocation (pair of floats) A translation vector [di, dj]. """ # Calculate delta in the module's coordinates. deltaLocationInCellFields = ( np.matmul(self.rotationMatrix, deltaLocation) * self.cellFieldsPerUnitDistance) # Shift the active coordinates. np.add(self.activePoints, deltaLocationInCellFields, out=self.activePoints) np.mod(self.activePoints, self.cellDimensions, out=self.activePoints) self._computeActiveCells() def anchor(self, anchorInput): """ Infer the location from sensory input. Activate any cells with enough active synapses to this sensory input. Deactivate all other cells. @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ if len(anchorInput) == 0: return overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] sensorySupportedCells = np.unique( self.connections.mapSegmentsToCells(activeSegments)) inactivated = np.setdiff1d(self.activeCells, sensorySupportedCells) inactivatedIndices = np.in1d(self.cellsForActivePoints, inactivated).nonzero()[0] if inactivatedIndices.size > 0: self.activePoints = np.delete(self.activePoints, inactivatedIndices, axis=0) activated = np.setdiff1d(sensorySupportedCells, self.activeCells) activatedCoordsBase = np.transpose( np.unravel_index(activated, self.cellDimensions)).astype('float') activatedCoords = np.concatenate([ activatedCoordsBase + [iOffset, jOffset] for iOffset in self.pointOffsets for jOffset in self.pointOffsets ]) if activatedCoords.size > 0: self.activePoints = np.append(self.activePoints, activatedCoords, axis=0) self._computeActiveCells() self.activeSegments = activeSegments def learn(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.connections.computeActivity(anchorInput) matchingSegments = np.where( potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.connections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[np.in1d( cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.connections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.connections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[np.in1d( cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.connections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.connections.createSegments(newSegmentCells) self.connections.growSynapsesToSample(newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells def numberOfCells(self): return np.prod(self.cellDimensions)
def test_growSynapsesToSample_multi(self): rng = Random() for (name, cells, growingSegments, initialConnectedInputs, presynapticInputs, activeInputs, initialPermanence, connectedPermanence, sampleSizes, expected) in (("Basic test", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [2, 3], [2, 0, 3]), ("One already connected", [1, 2, 3], [0, 2], [42], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [1, 2], [2, 0, 3]), ("Higher sample size than axon count", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [5, 10], [4, 0, 4]), ("Higher sample size than available axon count", [1, 2, 3], [0, 2], [42, 43], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [3, 3], [4, 0, 4])): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments[growingSegments], initialConnectedInputs, initialPermanence) connections.growSynapsesToSample(segments[growingSegments], presynapticInputs, sampleSizes, initialPermanence, rng) overlaps = connections.computeActivity(activeInputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name) for (name, cells, growingSegments, initialConnectedInputs, presynapticInputs, activeInputs, initialPermanence, connectedPermanence, sampleSizes) in (("Basic randomness test", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43], 0.55, 0.5, [2, 3]), ): # Activate a subset of the inputs. The resulting overlaps should # differ on various trials. firstResult = None differingResults = False for _ in range(20): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses(segments[growingSegments], initialConnectedInputs, initialPermanence) connections.growSynapsesToSample(segments[growingSegments], presynapticInputs, sampleSizes, initialPermanence, rng) overlaps = connections.computeActivity(activeInputs, connectedPermanence) if firstResult is None: firstResult = overlaps[segments] else: differingResults = not np.array_equal( overlaps[segments], firstResult) if differingResults: break self.assertTrue(differingResults, name)
class SuperficialLocationModule2D(object): """ A model of a location module. It's similar to a grid cell module, but it uses squares rather than triangles. The cells are arranged into a m*n rectangle which is tiled onto 2D space. Each cell represents a small rectangle in each tile. +------+------+------++------+------+------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #1 | #2 | #3 || #1 | #2 | #3 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #4 | #5 | #6 || #4 | #5 | #6 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #7 | #8 | #9 || #7 | #8 | #9 | | | | || | | | +------+------+------++------+------+------+ We assume that path integration works *somehow*. This model receives a "delta location" vector, and it shifts the active cells accordingly. The model stores intermediate coordinates of active cells. Whenever sensory cues activate a cell, the model adds this cell to the list of coordinates being shifted. Whenever sensory cues cause a cell to become inactive, that cell is removed from the list of coordinates. (This model doesn't attempt to propose how "path integration" works. It attempts to show how locations are anchored to sensory cues.) When orientation is set to 0 degrees, the deltaLocation is a [di, dj], moving di cells "down" and dj cells "right". When orientation is set to 90 degrees, the deltaLocation is essentially a [dx, dy], applied in typical x,y coordinates with the origin on the bottom left. Usage: Adjust the location in response to motor input: lm.shift([di, dj]) Adjust the location in response to sensory input: lm.anchor(anchorInput) Learn an anchor input for the current location: lm.learn(anchorInput) The "anchor input" is typically a feature-location pair SDR. During inference, you'll typically call: lm.shift(...) # Consume lm.getActiveCells() # ... lm.anchor(...) During learning, you'll do the same, but you'll call lm.learn() instead of lm.anchor(). """ def __init__(self, cellDimensions, moduleMapDimensions, orientation, anchorInputSize, pointOffsets=(0.5,), activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, seed=42): """ @param cellDimensions (tuple(int, int)) Determines the number of cells. Determines how space is divided between the cells. @param moduleMapDimensions (tuple(float, float)) Determines the amount of world space covered by all of the cells combined. In grid cell terminology, this is equivalent to the "scale" of a module. A module with a scale of "5cm" would have moduleMapDimensions=(5.0, 5.0). @param orientation (float) The rotation of this map, measured in radians. @param anchorInputSize (int) The number of input bits in the anchor input. @param pointOffsets (list of floats) These must each be between 0.0 and 1.0. Every time a cell is activated by anchor input, this class adds a "point" which is shifted in subsequent motions. By default, this point is placed at the center of the cell. This parameter allows you to control where the point is placed and whether multiple are placed. For example, With value [0.2, 0.8], it will place 4 points: [0.2, 0.2], [0.2, 0.8], [0.8, 0.2], [0.8, 0.8] """ self.cellDimensions = np.asarray(cellDimensions, dtype="int") self.moduleMapDimensions = np.asarray(moduleMapDimensions, dtype="float") self.cellFieldsPerUnitDistance = self.cellDimensions / self.moduleMapDimensions self.orientation = orientation self.rotationMatrix = np.array( [[math.cos(orientation), -math.sin(orientation)], [math.sin(orientation), math.cos(orientation)]]) self.pointOffsets = pointOffsets # These coordinates are in units of "cell fields". self.activePoints = np.empty((0,2), dtype="float") self.cellsForActivePoints = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") self.activeSegments = np.empty(0, dtype="uint32") self.connections = SparseMatrixConnections(np.prod(cellDimensions), anchorInputSize) self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) def reset(self): """ Clear the active cells. """ self.activePoints = np.empty((0,2), dtype="float") self.cellsForActivePoints = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") def _computeActiveCells(self): # Round each coordinate to the nearest cell. flooredActivePoints = np.floor(self.activePoints).astype("int") # Convert coordinates to cell numbers. self.cellsForActivePoints = ( np.ravel_multi_index(flooredActivePoints.T, self.cellDimensions)) self.activeCells = np.unique(self.cellsForActivePoints) def activateRandomLocation(self): """ Set the location to a random point. """ self.activePoints = np.array([np.random.random(2) * self.cellDimensions]) self._computeActiveCells() def shift(self, deltaLocation): """ Shift the current active cells by a vector. @param deltaLocation (pair of floats) A translation vector [di, dj]. """ # Calculate delta in the module's coordinates. deltaLocationInCellFields = (np.matmul(self.rotationMatrix, deltaLocation) * self.cellFieldsPerUnitDistance) # Shift the active coordinates. np.add(self.activePoints, deltaLocationInCellFields, out=self.activePoints) np.mod(self.activePoints, self.cellDimensions, out=self.activePoints) self._computeActiveCells() def anchor(self, anchorInput): """ Infer the location from sensory input. Activate any cells with enough active synapses to this sensory input. Deactivate all other cells. @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ if len(anchorInput) == 0: return overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] sensorySupportedCells = np.unique( self.connections.mapSegmentsToCells(activeSegments)) inactivated = np.setdiff1d(self.activeCells, sensorySupportedCells) inactivatedIndices = np.in1d(self.cellsForActivePoints, inactivated).nonzero()[0] if inactivatedIndices.size > 0: self.activePoints = np.delete(self.activePoints, inactivatedIndices, axis=0) activated = np.setdiff1d(sensorySupportedCells, self.activeCells) activatedCoordsBase = np.transpose( np.unravel_index(activated, self.cellDimensions)).astype('float') activatedCoords = np.concatenate( [activatedCoordsBase + [iOffset, jOffset] for iOffset in self.pointOffsets for jOffset in self.pointOffsets] ) if activatedCoords.size > 0: self.activePoints = np.append(self.activePoints, activatedCoords, axis=0) self._computeActiveCells() self.activeSegments = activeSegments def learn(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.connections.computeActivity(anchorInput) matchingSegments = np.where(potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.connections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[ np.in1d(cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.connections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.connections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[ np.in1d(cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti(potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.connections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.connections.createSegments(newSegmentCells) self.connections.growSynapsesToSample( newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells def numberOfCells(self): return np.prod(self.cellDimensions)
class Superficial2DLocationModule(object): """ A model of a location module. It's similar to a grid cell module, but it uses squares rather than triangles. The cells are arranged into a m*n rectangle which is tiled onto 2D space. Each cell represents a small rectangle in each tile. +------+------+------++------+------+------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #1 | #2 | #3 || #1 | #2 | #3 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #4 | #5 | #6 || #4 | #5 | #6 | | | | || | | | +--------------------++--------------------+ | Cell | Cell | Cell || Cell | Cell | Cell | | #7 | #8 | #9 || #7 | #8 | #9 | | | | || | | | +------+------+------++------+------+------+ We assume that path integration works *somehow*. This model receives a "delta location" vector, and it shifts the active cells accordingly. The model stores intermediate coordinates of active cells. Whenever sensory cues activate a cell, the model adds this cell to the list of coordinates being shifted. Whenever sensory cues cause a cell to become inactive, that cell is removed from the list of coordinates. (This model doesn't attempt to propose how "path integration" works. It attempts to show how locations are anchored to sensory cues.) When orientation is set to 0 degrees, the displacement is a [di, dj], moving di cells "down" and dj cells "right". When orientation is set to 90 degrees, the displacement is essentially a [dx, dy], applied in typical x,y coordinates with the origin on the bottom left. Usage: - When the sensor moves, call movementCompute. - When the sensor senses something, call sensoryCompute. The "anchor input" is typically a feature-location pair SDR. To specify how points are tracked, pass anchoringMethod = "corners", "narrowing" or "discrete". "discrete" will cause the network to operate in a fully discrete space, where uncertainty is impossible as long as movements are integers. "narrowing" is designed to narrow down uncertainty of initial locations of sensory stimuli. "corners" is designed for noise-tolerance, and will activate all cells that are possible outcomes of path integration. """ def __init__(self, cellDimensions, moduleMapDimensions, orientation, anchorInputSize, cellCoordinateOffsets=(0.5,), activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, anchoringMethod="narrowing", rotationMatrix = None, seed=42): """ @param cellDimensions (tuple(int, int)) Determines the number of cells. Determines how space is divided between the cells. @param moduleMapDimensions (tuple(float, float)) Determines the amount of world space covered by all of the cells combined. In grid cell terminology, this is equivalent to the "scale" of a module. A module with a scale of "5cm" would have moduleMapDimensions=(5.0, 5.0). @param orientation (float) The rotation of this map, measured in radians. @param anchorInputSize (int) The number of input bits in the anchor input. @param cellCoordinateOffsets (list of floats) These must each be between 0.0 and 1.0. Every time a cell is activated by anchor input, this class adds a "phase" which is shifted in subsequent motions. By default, this phase is placed at the center of the cell. This parameter allows you to control where the point is placed and whether multiple are placed. For example, with value [0.2, 0.8], when cell [2, 3] is activated it will place 4 phases, corresponding to the following points in cell coordinates: [2.2, 3.2], [2.2, 3.8], [2.8, 3.2], [2.8, 3.8] """ self.cellDimensions = np.asarray(cellDimensions, dtype="int") self.moduleMapDimensions = np.asarray(moduleMapDimensions, dtype="float") self.phasesPerUnitDistance = 1.0 / self.moduleMapDimensions if rotationMatrix is None: self.orientation = orientation self.rotationMatrix = np.array( [[math.cos(orientation), -math.sin(orientation)], [math.sin(orientation), math.cos(orientation)]]) if anchoringMethod == "discrete": # Need to convert matrix to have integer values nonzeros = self.rotationMatrix[np.where(np.abs(self.rotationMatrix)>0)] smallestValue = np.amin(nonzeros) self.rotationMatrix /= smallestValue self.rotationMatrix = np.ceil(self.rotationMatrix) else: self.rotationMatrix = rotationMatrix self.cellCoordinateOffsets = cellCoordinateOffsets # Phase is measured as a number in the range [0.0, 1.0) self.activePhases = np.empty((0,2), dtype="float") self.cellsForActivePhases = np.empty(0, dtype="int") self.phaseDisplacement = np.empty((0,2), dtype="float") self.activeCells = np.empty(0, dtype="int") self.activeSegments = np.empty(0, dtype="uint32") self.connections = SparseMatrixConnections(np.prod(cellDimensions), anchorInputSize) self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.anchoringMethod = anchoringMethod self.rng = Random(seed) def reset(self): """ Clear the active cells. """ self.activePhases = np.empty((0,2), dtype="float") self.phaseDisplacement = np.empty((0,2), dtype="float") self.cellsForActivePhases = np.empty(0, dtype="int") self.activeCells = np.empty(0, dtype="int") def _computeActiveCells(self): # Round each coordinate to the nearest cell. activeCellCoordinates = np.floor( self.activePhases * self.cellDimensions).astype("int") # Convert coordinates to cell numbers. self.cellsForActivePhases = ( np.ravel_multi_index(activeCellCoordinates.T, self.cellDimensions)) self.activeCells = np.unique(self.cellsForActivePhases) def activateRandomLocation(self): """ Set the location to a random point. """ self.activePhases = np.array([np.random.random(2)]) if self.anchoringMethod == "discrete": # Need to place the phase in the middle of a cell self.activePhases = np.floor( self.activePhases * self.cellDimensions)/self.cellDimensions self._computeActiveCells() def movementCompute(self, displacement, noiseFactor = 0): """ Shift the current active cells by a vector. @param displacement (pair of floats) A translation vector [di, dj]. """ if noiseFactor != 0: displacement = copy.deepcopy(displacement) xnoise = np.random.normal(0, noiseFactor) ynoise = np.random.normal(0, noiseFactor) displacement[0] += xnoise displacement[1] += ynoise # Calculate delta in the module's coordinates. phaseDisplacement = (np.matmul(self.rotationMatrix, displacement) * self.phasesPerUnitDistance) # Shift the active coordinates. np.add(self.activePhases, phaseDisplacement, out=self.activePhases) # In Python, (x % 1.0) can return 1.0 because of floating point goofiness. # Generally this doesn't cause problems, it's just confusing when you're # debugging. np.round(self.activePhases, decimals=9, out=self.activePhases) np.mod(self.activePhases, 1.0, out=self.activePhases) self._computeActiveCells() self.phaseDisplacement = phaseDisplacement def _sensoryComputeInferenceMode(self, anchorInput): """ Infer the location from sensory input. Activate any cells with enough active synapses to this sensory input. Deactivate all other cells. @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ if len(anchorInput) == 0: return overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] sensorySupportedCells = np.unique( self.connections.mapSegmentsToCells(activeSegments)) inactivated = np.setdiff1d(self.activeCells, sensorySupportedCells) inactivatedIndices = np.in1d(self.cellsForActivePhases, inactivated).nonzero()[0] if inactivatedIndices.size > 0: self.activePhases = np.delete(self.activePhases, inactivatedIndices, axis=0) activated = np.setdiff1d(sensorySupportedCells, self.activeCells) # Find centers of point clouds if "corners" in self.anchoringMethod: activatedCoordsBase = np.transpose( np.unravel_index(sensorySupportedCells, self.cellDimensions)).astype('float') else: activatedCoordsBase = np.transpose( np.unravel_index(activated, self.cellDimensions)).astype('float') # Generate points to add activatedCoords = np.concatenate( [activatedCoordsBase + [iOffset, jOffset] for iOffset in self.cellCoordinateOffsets for jOffset in self.cellCoordinateOffsets] ) if "corners" in self.anchoringMethod: self.activePhases = activatedCoords / self.cellDimensions else: if activatedCoords.size > 0: self.activePhases = np.append(self.activePhases, activatedCoords / self.cellDimensions, axis=0) self._computeActiveCells() self.activeSegments = activeSegments def _sensoryComputeLearningMode(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.connections.computeActivity(anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.connections.computeActivity(anchorInput) matchingSegments = np.where(potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.connections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[ np.in1d(cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.connections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.connections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[ np.in1d(cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti(potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.connections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.connections.createSegments(newSegmentCells) self.connections.growSynapsesToSample( newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments def sensoryCompute(self, anchorInput, anchorGrowthCandidates, learn): if learn: self._sensoryComputeLearningMode(anchorGrowthCandidates) else: self._sensoryComputeInferenceMode(anchorInput) @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells def numberOfCells(self): return np.prod(self.cellDimensions)
def test_growSynapsesToSample_multi(self): rng = Random() for (name, cells, growingSegments, initialConnectedInputs, presynapticInputs, activeInputs, initialPermanence, connectedPermanence, sampleSizes, expected) in (("Basic test", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [2, 3], [2, 0, 3]), ("One already connected", [1, 2, 3], [0, 2], [42], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [1, 2], [2, 0, 3]), ("Higher sample size than axon count", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [5, 10], [4, 0, 4]), ("Higher sample size than available axon count", [1, 2, 3], [0, 2], [42, 43], [42, 43, 44, 45], [42, 43, 44, 45], 0.55, 0.5, [3, 3], [4, 0, 4]) ): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses( segments[growingSegments], initialConnectedInputs, initialPermanence) connections.growSynapsesToSample( segments[growingSegments], presynapticInputs, sampleSizes, initialPermanence, rng) overlaps = connections.computeActivity(activeInputs, connectedPermanence) np.testing.assert_equal(overlaps[segments], expected, name) for (name, cells, growingSegments, initialConnectedInputs, presynapticInputs, activeInputs, initialPermanence, connectedPermanence, sampleSizes) in (("Basic randomness test", [1, 2, 3], [0, 2], [], [42, 43, 44, 45], [42, 43], 0.55, 0.5, [2, 3]), ): # Activate a subset of the inputs. The resulting overlaps should # differ on various trials. firstResult = None differingResults = False for _ in xrange(20): connections = SparseMatrixConnections(2048, 2048) segments = connections.createSegments(cells) connections.growSynapses( segments[growingSegments], initialConnectedInputs, initialPermanence) connections.growSynapsesToSample( segments[growingSegments], presynapticInputs, sampleSizes, initialPermanence, rng) overlaps = connections.computeActivity(activeInputs, connectedPermanence) if firstResult is None: firstResult = overlaps[segments] else: differingResults = not np.array_equal(overlaps[segments], firstResult) if differingResults: break self.assertTrue(differingResults, name)
class SensorToSpecificObjectModule(object): """ Represents the sensor location relative to a specific object. Typically these modules are arranged in an array, and the combined population SDR is used to predict a feature-location pair. This class has two sets of connections. Both of them compute the "sensor's location relative to a specific object" in different ways. The "metric connections" compute it from the "body's location relative to a specific object" and the "sensor's location relative to body" These connections are learned once and then never need to be updated. They might be genetically hardcoded. They're initialized externally, e.g. in BodyToSpecificObjectModule2D. The "anchor connections" compute it from the sensory input. Whenever a cortical column learns a feature-location pair, this layer forms reciprocal connections with the feature-location pair layer. These segments receive input at different times. The metric connections receive input first, and they activate a set of cells. This set of cells is used externally to predict a feature-location pair. Then this feature-location pair is the input to the anchor connections. """ def __init__(self, cellDimensions, anchorInputSize, activationThreshold=10, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.0, maxSynapsesPerSegment=-1, seed=42): """ @param cellDimensions (sequence of ints) @param anchorInputSize (int) @param activationThreshold (int) """ self.activationThreshold = activationThreshold self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) self.cellCount = np.prod(cellDimensions) cellCountBySource = { "bodyToSpecificObject": self.cellCount, "sensorToBody": self.cellCount, } self.metricConnections = Multiconnections(self.cellCount, cellCountBySource) self.anchorConnections = SparseMatrixConnections(self.cellCount, anchorInputSize) def reset(self): self.activeCells = np.empty(0, dtype="int") def metricCompute(self, sensorToBody, bodyToSpecificObject): """ Compute the "sensor's location relative to a specific object" from the "body's location relative to a specific object" and the "sensor's location relative to body" @param sensorToBody (numpy array) Active cells of a single module that represents the sensor's location relative to the body @param bodyToSpecificObject (numpy array) Active cells of a single module that represents the body's location relative to a specific object """ overlaps = self.metricConnections.computeActivity({ "bodyToSpecificObject": bodyToSpecificObject, "sensorToBody": sensorToBody, }) self.activeMetricSegments = np.where(overlaps >= 2)[0] self.activeCells = np.unique( self.metricConnections.mapSegmentsToCells( self.activeMetricSegments)) def anchorCompute(self, anchorInput, learn): """ Compute the "sensor's location relative to a specific object" from the feature-location pair. @param anchorInput (numpy array) Active cells in the feature-location pair layer @param learn (bool) If true, maintain current cell activity and learn this input on the currently active cells """ if learn: self._anchorComputeLearningMode(anchorInput) else: overlaps = self.anchorConnections.computeActivity( anchorInput, self.connectedPermanence) self.activeSegments = np.where(overlaps >= self.activationThreshold)[0] self.activeCells = np.unique( self.anchorConnections.mapSegmentsToCells(self.activeSegments)) def _anchorComputeLearningMode(self, anchorInput): """ Associate this location with a sensory input. Subsequently, anchorInput will activate the current location during anchor(). @param anchorInput (numpy array) A sensory input. This will often come from a feature-location pair layer. """ overlaps = self.anchorConnections.computeActivity( anchorInput, self.connectedPermanence) activeSegments = np.where(overlaps >= self.activationThreshold)[0] potentialOverlaps = self.anchorConnections.computeActivity(anchorInput) matchingSegments = np.where(potentialOverlaps >= self.learningThreshold)[0] # Cells with a active segment: reinforce the segment cellsForActiveSegments = self.anchorConnections.mapSegmentsToCells( activeSegments) learningActiveSegments = activeSegments[ np.in1d(cellsForActiveSegments, self.activeCells)] remainingCells = np.setdiff1d(self.activeCells, cellsForActiveSegments) # Remaining cells with a matching segment: reinforce the best # matching segment. candidateSegments = self.anchorConnections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = ( self.anchorConnections.mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[ np.in1d(cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti(potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.anchorConnections, self.rng, learningSegments, anchorInput, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) # Remaining cells without a matching segment: grow one. numNewSynapses = len(anchorInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.anchorConnections.createSegments(newSegmentCells) self.anchorConnections.growSynapsesToSample( newSegments, anchorInput, numNewSynapses, self.initialPermanence, self.rng) self.activeSegments = activeSegments @staticmethod def _learn(connections, rng, learningSegments, activeInput, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(activeInput) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, activeInput, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells
class SingleLayerLocationMemory(object): """ A layer of cells which learns how to take a "delta location" (e.g. a motor command or a proprioceptive delta) and update its active cells to represent the new location. Its active cells might represent a union of locations. As the location changes, the featureLocationInput causes this union to narrow down until the location is inferred. This layer receives absolute proprioceptive info as proximal input. For now, we assume that there's a one-to-one mapping between absolute proprioceptive input and the location SDR. So rather than modeling proximal synapses, we'll just relay the proprioceptive SDR. In the future we might want to consider a many-to-one mapping of proprioceptive inputs to location SDRs. After this layer is trained, it no longer needs the proprioceptive input. The delta location will drive the layer. The current active cells and the other distal connections will work together with this delta location to activate a new set of cells. When no cells are active, activate a large union of possible locations. With subsequent inputs, the union will narrow down to a single location SDR. """ def __init__(self, cellCount, deltaLocationInputSize, featureLocationInputSize, activationThreshold=13, initialPermanence=0.21, connectedPermanence=0.50, learningThreshold=10, sampleSize=20, permanenceIncrement=0.1, permanenceDecrement=0.1, maxSynapsesPerSegment=-1, seed=42): # For transition learning, every segment is split into two parts. # For the segment to be active, both parts must be active. self.internalConnections = SparseMatrixConnections( cellCount, cellCount) self.deltaConnections = SparseMatrixConnections( cellCount, deltaLocationInputSize) # Distal segments that receive input from the layer that represents # feature-locations. self.featureLocationConnections = SparseMatrixConnections( cellCount, featureLocationInputSize) self.activeCells = np.empty(0, dtype="uint32") self.activeDeltaSegments = np.empty(0, dtype="uint32") self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") self.initialPermanence = initialPermanence self.connectedPermanence = connectedPermanence self.learningThreshold = learningThreshold self.sampleSize = sampleSize self.permanenceIncrement = permanenceIncrement self.permanenceDecrement = permanenceDecrement self.activationThreshold = activationThreshold self.maxSynapsesPerSegment = maxSynapsesPerSegment self.rng = Random(seed) def reset(self): """ Deactivate all cells. """ self.activeCells = np.empty(0, dtype="uint32") self.activeDeltaSegments = np.empty(0, dtype="uint32") self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") def compute(self, deltaLocation=(), newLocation=(), featureLocationInput=(), featureLocationGrowthCandidates=(), learn=True): """ Run one time step of the Location Memory algorithm. @param deltaLocation (sorted numpy array) @param newLocation (sorted numpy array) @param featureLocationInput (sorted numpy array) @param featureLocationGrowthCandidates (sorted numpy array) """ prevActiveCells = self.activeCells self.activeDeltaSegments = np.where( (self.internalConnections.computeActivity( prevActiveCells, self.connectedPermanence) >= self.activationThreshold) & (self.deltaConnections.computeActivity( deltaLocation, self.connectedPermanence) >= self.activationThreshold))[0] # When we're moving, the feature-location input has no effect. if len(deltaLocation) == 0: self.activeFeatureLocationSegments = np.where( self.featureLocationConnections.computeActivity( featureLocationInput, self.connectedPermanence) >= self.activationThreshold)[0] else: self.activeFeatureLocationSegments = np.empty(0, dtype="uint32") if len(newLocation) > 0: # Drive activations by relaying this location SDR. self.activeCells = newLocation if learn: # Learn the delta. self._learnTransition(prevActiveCells, deltaLocation, newLocation) # Learn the featureLocationInput. self._learnFeatureLocationPair( newLocation, featureLocationInput, featureLocationGrowthCandidates) elif len(prevActiveCells) > 0: if len(deltaLocation) > 0: # Drive activations by applying the deltaLocation to the current location. # Completely ignore the featureLocationInput. It's outdated, associated # with the previous location. cellsForDeltaSegments = self.internalConnections.mapSegmentsToCells( self.activeDeltaSegments) self.activeCells = np.unique(cellsForDeltaSegments) else: # Keep previous active cells active. # Modulate with the featureLocationInput. if len(self.activeFeatureLocationSegments) > 0: cellsForFeatureLocationSegments = ( self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments)) self.activeCells = np.intersect1d( prevActiveCells, cellsForFeatureLocationSegments) else: self.activeCells = prevActiveCells elif len(featureLocationInput) > 0: # Drive activations with the featureLocationInput. cellsForFeatureLocationSegments = ( self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments)) self.activeCells = np.unique(cellsForFeatureLocationSegments) def _learnTransition(self, prevActiveCells, deltaLocation, newLocation): """ For each cell in the newLocation SDR, learn the transition of prevLocation (i.e. prevActiveCells) + deltaLocation. The transition might be already known. In that case, just reinforce the existing segments. """ prevLocationPotentialOverlaps = self.internalConnections.computeActivity( prevActiveCells) deltaPotentialOverlaps = self.deltaConnections.computeActivity( deltaLocation) matchingDeltaSegments = np.where( (prevLocationPotentialOverlaps >= self.learningThreshold) & (deltaPotentialOverlaps >= self.learningThreshold))[0] # Cells with a active segment pair: reinforce the segment cellsForActiveSegments = self.internalConnections.mapSegmentsToCells( self.activeDeltaSegments) learningActiveDeltaSegments = self.activeDeltaSegments[np.in1d( cellsForActiveSegments, newLocation)] remainingCells = np.setdiff1d(newLocation, cellsForActiveSegments) # Remaining cells with a matching segment pair: reinforce the best matching # segment pair. candidateSegments = self.internalConnections.filterSegmentsByCell( matchingDeltaSegments, remainingCells) cellsForCandidateSegments = self.internalConnections.mapSegmentsToCells( candidateSegments) candidateSegments = matchingDeltaSegments[np.in1d( cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( prevLocationPotentialOverlaps[candidateSegments] + deltaPotentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingDeltaSegments = candidateSegments[onePerCellFilter] newDeltaSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveDeltaSegments, learningMatchingDeltaSegments): self._learn(self.internalConnections, self.rng, learningSegments, prevActiveCells, prevActiveCells, prevLocationPotentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) self._learn(self.deltaConnections, self.rng, learningSegments, deltaLocation, deltaLocation, deltaPotentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) numNewLocationSynapses = len(prevActiveCells) numNewDeltaSynapses = len(deltaLocation) if self.sampleSize != -1: numNewLocationSynapses = min(numNewLocationSynapses, self.sampleSize) numNewDeltaSynapses = min(numNewDeltaSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewLocationSynapses = min(numNewLocationSynapses, self.maxSynapsesPerSegment) numNewDeltaSynapses = min(numNewLocationSynapses, self.maxSynapsesPerSegment) newPrevLocationSegments = self.internalConnections.createSegments( newDeltaSegmentCells) newDeltaSegments = self.deltaConnections.createSegments( newDeltaSegmentCells) assert np.array_equal(newPrevLocationSegments, newDeltaSegments) self.internalConnections.growSynapsesToSample(newPrevLocationSegments, prevActiveCells, numNewLocationSynapses, self.initialPermanence, self.rng) self.deltaConnections.growSynapsesToSample(newDeltaSegments, deltaLocation, numNewDeltaSynapses, self.initialPermanence, self.rng) def _learnFeatureLocationPair(self, newLocation, featureLocationInput, featureLocationGrowthCandidates): """ Grow / reinforce synapses between the location layer's dendrites and the input layer's active cells. """ potentialOverlaps = self.featureLocationConnections.computeActivity( featureLocationInput) matchingSegments = np.where( potentialOverlaps > self.learningThreshold)[0] # Cells with a active segment pair: reinforce the segment cellsForActiveSegments = self.featureLocationConnections.mapSegmentsToCells( self.activeFeatureLocationSegments) learningActiveSegments = self.activeFeatureLocationSegments[np.in1d( cellsForActiveSegments, newLocation)] remainingCells = np.setdiff1d(newLocation, cellsForActiveSegments) # Remaining cells with a matching segment pair: reinforce the best matching # segment pair. candidateSegments = self.featureLocationConnections.filterSegmentsByCell( matchingSegments, remainingCells) cellsForCandidateSegments = (self.featureLocationConnections. mapSegmentsToCells(candidateSegments)) candidateSegments = candidateSegments[np.in1d( cellsForCandidateSegments, remainingCells)] onePerCellFilter = np2.argmaxMulti( potentialOverlaps[candidateSegments], cellsForCandidateSegments) learningMatchingSegments = candidateSegments[onePerCellFilter] newSegmentCells = np.setdiff1d(remainingCells, cellsForCandidateSegments) for learningSegments in (learningActiveSegments, learningMatchingSegments): self._learn(self.featureLocationConnections, self.rng, learningSegments, featureLocationInput, featureLocationGrowthCandidates, potentialOverlaps, self.initialPermanence, self.sampleSize, self.permanenceIncrement, self.permanenceDecrement, self.maxSynapsesPerSegment) numNewSynapses = len(featureLocationInput) if self.sampleSize != -1: numNewSynapses = min(numNewSynapses, self.sampleSize) if self.maxSynapsesPerSegment != -1: numNewSynapses = min(numNewSynapses, self.maxSynapsesPerSegment) newSegments = self.featureLocationConnections.createSegments( newSegmentCells) self.featureLocationConnections.growSynapsesToSample( newSegments, featureLocationGrowthCandidates, numNewSynapses, self.initialPermanence, self.rng) @staticmethod def _learn(connections, rng, learningSegments, activeInput, growthCandidates, potentialOverlaps, initialPermanence, sampleSize, permanenceIncrement, permanenceDecrement, maxSynapsesPerSegment): """ Adjust synapse permanences, grow new synapses, and grow new segments. @param learningActiveSegments (numpy array) @param learningMatchingSegments (numpy array) @param segmentsToPunish (numpy array) @param activeInput (numpy array) @param growthCandidates (numpy array) @param potentialOverlaps (numpy array) """ # Learn on existing segments connections.adjustSynapses(learningSegments, activeInput, permanenceIncrement, -permanenceDecrement) # Grow new synapses. Calculate "maxNew", the maximum number of synapses to # grow per segment. "maxNew" might be a number or it might be a list of # numbers. if sampleSize == -1: maxNew = len(growthCandidates) else: maxNew = sampleSize - potentialOverlaps[learningSegments] if maxSynapsesPerSegment != -1: synapseCounts = connections.mapSegmentsToSynapseCounts( learningSegments) numSynapsesToReachMax = maxSynapsesPerSegment - synapseCounts maxNew = np.where(maxNew <= numSynapsesToReachMax, maxNew, numSynapsesToReachMax) connections.growSynapsesToSample(learningSegments, growthCandidates, maxNew, initialPermanence, rng) def getActiveCells(self): return self.activeCells