Imagination

src/carver/htm/__init__.py

@@ -23,8 +23,15 @@
 EXTENSION_NEXT_STEP_PENALTY = config.getboolean('extensions', 'next_step_penalty')
 
 class HTM(object):
+
+    dimensions = 2 #hard-coded for now
+
     def __init__(self, cellsPerColumn=None):
         self.inhibitionRadius = config.getint('init', 'inhibitionRadius')
+
+        impliedSparsity = float(config.getint('constants','desiredLocalActivity'))/(self.inhibitionRadius**self.dimensions)
+        self.impliedSparsity = min(impliedSparsity, 1.0)
+
         if cellsPerColumn:
             self.cellsPerColumn = cellsPerColumn
         else:
@@ -97,36 +104,35 @@ def inputLength(self):
         return len(self._inputCells[0])
 
     def imagineNext(self):
-        'project down estimates for next time step to the input cells'
+        'project down estimates for next time step to the input cells, and step through'
         self._imagineStimulate(self.columns)
-        return self._imagineOverride(self._inputCells)
-
+        self._imagineOverride(self._inputCells)
+        self.__executeOne(False)
+
     @classmethod
-    def _imagineStimulate(cls, columns):
-        'testable step one of imagineNext'
+    def stimulateFromColumns(cls, columns, columnFilter):
         for col in columns:
-            if col.predicting:
-                down_scale = len(col.synapsesConnected)
-                activityPerSynapse = float(1) / down_scale
+            if columnFilter(col):
+                permanences = map(lambda syn: syn.permanence, col.synapsesConnected)
+                down_scale = float(sum(permanences))
 
                 for synapse in col.synapsesConnected:
-                    synapse.input.stimulate(activityPerSynapse)
+                    synapse.input.stimulate(synapse.permanence / down_scale)
+
+    @classmethod
+    def _imagineStimulate(cls, columns):
+        'testable step one of imagineNext'
+        cls.stimulateFromColumns(columns, lambda col: col.predictingNext)
 
     @classmethod
     def _imagineOverride(cls, inputCells):
         'testable step two of imagineNext'
 
-        #flatten cell matrix
-        allInputs = []
+        cls.normalize_input_stimulation(inputCells)
+
         for row in inputCells:
             for cell in row:
-                allInputs.append(cell)
-
-        maxStim = max(map(lambda inCell: inCell.stimulation, allInputs))
-        if maxStim:
-            for inCell in allInputs:
-                inCell.stimulation /= maxStim
-                inCell.override()
+                cell.override()
 
     def executeOnce(self, data, learning=True, postTick=None):
         '''
@@ -248,8 +254,22 @@ def average_receptive_field_size(self):
         radii = []
         for c in self.columns:
             for syn in c.synapsesConnected:
-                radii.append(((c.x-syn.input.x)**2 + (c.y-syn.input.y)**2)**0.5)
+                radius = ((c.x-syn.input.x)**2 + (c.y-syn.input.y)**2)**0.5
+                if radius!=0:
+                    radii.append(radius)
         return sum(radii)/len(radii)
+
+    @classmethod
+    def _max_input_stimulation(cls, inputCells):
+        return max(cell.stimulation for row in inputCells for cell in row)
+
+    @classmethod
+    def normalize_input_stimulation(cls, inputCells):
+        maxStim = cls._max_input_stimulation(inputCells)
+        if maxStim:
+            for row in inputCells:
+                for cell in row:
+                    cell.stimulation /= maxStim
 
 class UpdateSegments(DictDefault):
 

src/carver/htm/cell.py

@@ -144,15 +144,25 @@ def __ne__(self, other):
         return not (self == other)
 
     def findSegmentWasActive(self, nextStep=True):
-        'prefer distal, return hits from segments connected to other cells that were active'
+        '''
+        prefer distal (comes for free, all cells have only distal segments)
+        prefer segments where learning cell triggered
+        return hits from segments connected to other cells that were active
+        '''
         if nextStep:
             segments = self.segmentsNear
         else:
             segments = self.segments
 
+        activeSeg = None
+
         for seg in segments:
             if seg.wasActive:
-                return seg
+                activeSeg = seg
+                if seg.wasActiveFromLearningCells:
+                    return seg
+
+        return activeSeg
 
     def bestMatchingSegment(self, nextStep):
         '''
@@ -167,7 +177,12 @@ def bestMatchingSegment(self, nextStep):
         '''
         bestSegment = None
         bestSegmentSynapseCount = MIN_THRESHOLD-1
-        for seg in filter(lambda seg: seg.nextStep == nextStep, self.segments):
+
+        segments = self.segments
+        if nextStep:
+            segments = self.segmentsNear
+
+        for seg in segments:
             synapseCount = len(seg.old_firing_synapses(requireConnection=False))
             if synapseCount > bestSegmentSynapseCount:
                 bestSegmentSynapseCount = synapseCount

src/carver/htm/column.py

@@ -127,16 +127,20 @@ def neighbor_duty_cycle_max(self):
         '''
         return max((c.dutyCycleActive for c in self.neighbors))
 
+    def __adjustKthNeighborForSparsity(self, numNeighbors):
+        return max(int(self.htm.impliedSparsity*numNeighbors), 1)
+
     def kth_neighbor(self, k):
         '''
 
         Numenta docs: Given the list of columns, return the kth highest overlap value
         '''
         allNeighbors = sorted(self.neighbors, reverse=True, key=lambda col: col.overlap)
-        index = min(k-1,len(allNeighbors)-1)
+        sparserK = self.__adjustKthNeighborForSparsity(len(allNeighbors))
+        index = min(k-1, sparserK-1)
         return allNeighbors[index]
 
-    @property
+    @property
     def predicting(self):
         for cell in self.cells:
             if cell.predicting:
@@ -151,6 +155,18 @@ def predictedNext(self):
                 return True
         return False
 
+    @property
+    def predictingNext(self):
+        '''
+        is this column expected to get excited next?
+        @requires: cells' active state is already set
+        '''
+        for cell in self.cells:
+            for seg in cell.segmentsNear:
+                if seg.active:
+                    return True
+        return False
+
     def __hash__(self):
         return self.x * self.y * hash(self.htm)
 

src/carver/htm/input.py

@@ -3,6 +3,8 @@
 
 @author: Jason Carver
 '''
+from carver.htm.synapse import SYNAPSES_PER_SEGMENT
+from carver.htm.segment import FRACTION_SEGMENT_ACTIVATION_THRESHOLD
 
 class InputCell(object):
     '''
@@ -49,8 +51,12 @@ def stimulate(self, amount):
 
     def override(self):
         self.overrideInput = True
-        #TODO move magic number 0.8 into .properties file, or make htm understand float
-        self.stimulationPast = 1 if self.stimulation > 0.8 else 0
-        self.resetStimulation()
+
+        if self.stimulation >= FRACTION_SEGMENT_ACTIVATION_THRESHOLD:
+            self.stimulationPast = 1
+        else:
+            self.stimulationPast = 0
+
+        self.resetStimulation()
 
 

src/carver/htm/io/image_builder.py

@@ -5,6 +5,10 @@
 '''
 
 from PIL import Image
+from carver.htm import HTM
+from carver.htm.synapse import SYNAPSES_PER_SEGMENT
+from carver.htm.segment import FRACTION_SEGMENT_ACTIVATION_THRESHOLD
+from carver.htm.ui.excite_history import ExciteHistory
 
 class ImageBuilder(object):
     '''
@@ -35,37 +39,101 @@ def setData(self, data):
     def show(self):
         return self.img.show()
 
-class ColumnDisplay(object):
-    def __init__(self, htm):
-        width = len(htm._column_grid)
-        length = len(htm._column_grid[0])
-        self.imageBuilder = ImageBuilder((width, length), self.colStateColor)
-        self.imageBuilder.setData(htm.columns)
+class HTMDisplayBase(object):
 
     def show(self):
         return self.imageBuilder.show()
-
+        
     @classmethod
     def showNow(cls, htm):
         cls(htm).show()
+
+class ActivityOverTimeDisplay(HTMDisplayBase):
+    def __init__(self, columnStates):
+        img = ImageBuilder([len(columnStates[0]), len(columnStates)], self.stateToRGB)
+        img.setData2D(columnStates)
+        img.rotate90()
+        self.imageBuilder = img
+
+    def show(self):
+        print """*************** Graph History **************
+Y-Axis: All cells in the network, with the 4 cells per column grouped together
+X-Axis: Time
+Colors:
+\tblack: no activity
+\tgray: predicting
+\twhite: active  
+"""
+        HTMDisplayBase.show(self)
+
+    @classmethod
+    def stateToRGB(cls, state):
+        if state == ExciteHistory.ACTIVE:
+            return (255, 255, 255)
+        elif state == ExciteHistory.PREDICTING:
+            return (127, 127, 127)
+        elif state == ExciteHistory.INACTIVE:
+            return (0, 0, 0)
+        else:
+            return (255, 0, 0) #unknown cell/column state
+
+class ColumnDisplay(HTMDisplayBase):
+    def __init__(self, htm):
+        width = len(htm._column_grid)
+        length = len(htm._column_grid[0])
+        self.imageBuilder = ImageBuilder((width, length), self.colStateColor)
+        self.imageBuilder.setData(htm.columns)
 
     @classmethod
     def colStateColor(cls, column):
-        if column.active:
+        if column.active and column.predictedNext: #correct
             return (0,255,0)
+        elif column.active: #false negative
+            return (255,0,0)
+        elif column.predictedNext: #false positive
+            return (180,0,180) #purple
         else:
             return (0,0,0)
 
+class InputReflectionOverlayDisplay(HTMDisplayBase):
+    'show the input cells, and the column activation pushed back onto the input space'
+    def __init__(self, htm):
+        self.imageBuilder = ImageBuilder((htm.inputWidth, htm.inputLength), self.inputOverlay)
+
+        HTM.stimulateFromColumns(htm.columns, lambda col: col.active)
+        HTM.normalize_input_stimulation(htm._inputCells)
+
+        data = [(cell, cell.stimulation) for row in htm._inputCells for cell in row]
+
+        for row in htm._inputCells:
+            for cell in row:
+                cell.resetStimulation()
+
+        self.imageBuilder.setData(data)
+
+    @classmethod
+    def inputOverlay(cls, cellInfo):
+        (cell, percentStimulated) = cellInfo
+
+        triggered = percentStimulated >= FRACTION_SEGMENT_ACTIVATION_THRESHOLD
+
+        if cell.wasActive and triggered: #correct
+            return (0,int(percentStimulated*255),0)
+        elif cell.wasActive: #false negative
+            return (255-int(percentStimulated*255),0,0)
+        elif triggered: #false positive
+            return (int(percentStimulated*180),0,int(percentStimulated*180)) #purple
+        else:
+            gray = int(percentStimulated*255)
+            return (gray,gray,gray)
+
 
-class InputCellsDisplay(object):
+class InputCellsDisplay(HTMDisplayBase):
     def __init__(self, htm):
-        self.imageBuilder = ImageBuilder((htm.width, htm.length), self.cellActiveBW)
+        self.imageBuilder = ImageBuilder((htm.inputWidth, htm.inputLength), self.cellActiveBW)
         data = [cell for row in htm._inputCells for cell in row]
         self.imageBuilder.setData(data)
 
-    def show(self):
-        return self.imageBuilder.show()
-
     @classmethod
     def cellActiveBW(cls, cell):
         'A black and white representation of whether a cell is active'

src/carver/htm/segment.py

@@ -46,6 +46,18 @@ def old_firing_synapses(self, requireConnection=True):
         '''
         return filter(lambda synapse: synapse.was_firing(requireConnection=requireConnection), 
             self.synapses)
+
+    @classmethod
+    def _is_firing_filter(cls, requireConnection=True):
+        return lambda synapse: synapse.is_firing(requireConnection=requireConnection)
+
+    def synapses_firing(self, requireConnection=True):
+        '''
+        @param requireConnection: only include synapse if the synapse is connected
+        @return an iterable of firing synapses
+        '''
+        return filter(self._is_firing_filter(requireConnection),
+            self.synapses)
 
     def increase_permanences(self, byAmount):
         'increase permanence on all synapses'
@@ -72,7 +84,7 @@ def active(self):
         Timing note: a synapse is considered active if the cell it came from
         was active in the previous step
         '''
-        filterFunc = lambda synapse: synapse.is_firing(requireConnection=True)
+        filterFunc = self._is_firing_filter(requireConnection=True)
         return self._areSynapsesAboveThreshold(filterFunc)
 
     @property
@@ -121,6 +133,7 @@ def round_out_synapses(self, htm):
         missingSynapses = MAX_NEW_SYNAPSES - len(synapses)
         if missingSynapses > 0:
             lastLearningCells = filter(lambda cell: cell.wasLearning, htm.cells)
-            for _ in xrange(missingSynapses):
-                cell = random.choice(lastLearningCells)
-                self.create_synapse(cell)
+            if len(lastLearningCells):
+                for _ in xrange(missingSynapses):
+                    cell = random.choice(lastLearningCells)
+                    self.create_synapse(cell)

src/carver/htm/synapse.py

@@ -37,7 +37,7 @@ def was_firing(self, requireConnection=True):
             if False: return True even if synapse is not connected
         '''
         return self.input.wasActive and (self.connected or not requireConnection)
-    
+
     def is_firing(self, requireConnection=True):
         '''
         Is the input firing?
@@ -54,7 +54,7 @@ def firing_at(self, timeDelta, requireConnection=True):
         else:
             raise NotImplementedError
 
-    def wasInputLearning(self):
+    def wasInputLearning(self):
         if not hasattr(input, 'learning'):
             return False
         else: