cache segment activation states. implement hashCode,equals on Cell to ensure proper reproducibility

Author: binarybarry

src/HTM/java/htm/Cell.java

@@ -13,6 +13,7 @@ public class Cell extends AbstractCell {
 
   private final Column _column;
   private final int _index;
+  private final int _id;
   private boolean _isActive;
   private boolean _wasActive;
   private boolean _isPredicting;
@@ -40,6 +41,24 @@ public class Cell extends AbstractCell {
     _wasPredicted = false;
     _isLearning = false;
     _wasLearning = false;
+    int cpc = _column.getRegion().getCellsPerCol();
+    _id = (_column.cx()*cpc + _index) + 
+          (_column.cy()*cpc*_column.getRegion().getWidth());
+  }
+  
+  @Override
+  public int hashCode() {
+    return _id;
+  }
+  
+  @Override
+  public boolean equals(Object obj) {
+    if(obj instanceof Cell) {
+      Cell cell = (Cell)obj;
+      if(cell.getRegion()==getRegion())
+        return cell._id==_id;
+    }
+    return false;
   }
 
   public Region getRegion() {
@@ -76,6 +95,10 @@ public int gridIndex() {
     return _column.gridIndex();
   }
 
+  public int getId() {
+    return _id;
+  }
+  
   /** Return the Cell's index position within its Column. */
   public int getIndex() { return _index; }
   @Override
@@ -159,6 +182,8 @@ void nextTimeStep() {
     _isActive = false;
     _isPredicting = false;
     _isLearning = false;
+    for(Segment seg : _segments)
+      seg.nextTimeStep();
   }
 
   /**
@@ -255,10 +280,8 @@ SegmentUpdateInfo updateSegmentActiveSynapses(boolean previous,
       Segment segment, boolean newSynapses) {
     Set<Synapse> activeSyns = new HashSet<Synapse>();
     if(segment!=null) {
-      if(previous)
-        segment.getPrevActiveSynapses(activeSyns);
-      else
-        segment.getActiveSynapses(activeSyns);
+      activeSyns = previous ? segment.getPrevActiveSynapses() : 
+        segment.getActiveSynapses();
     }
 
     SegmentUpdateInfo segmentUpdate =

src/HTM/java/htm/Column.java

@@ -62,6 +62,11 @@ public CellAndSegment(Cell cell, Segment segment) {
    */
   Column(Region region, int srcPosX, int srcPosY, int posX, int posY) {
     _region = region;
+    _ix = srcPosX; //'input' row and col
+    _iy = srcPosY;
+    _cx = posX; //'column grid' row and col
+    _cy = posY;
+    
     int numCells = region.getCellsPerCol();
     _cells = new Cell[numCells];
     for(int i=0; i<numCells; ++i)
@@ -85,10 +90,6 @@ public CellAndSegment(Cell cell, Segment segment) {
     _overlapDutyCycle = 1.0f;
 
     _overlap = 0; //the last computed input overlap for the Column.
-    _ix = srcPosX; //'input' row and col
-    _iy = srcPosY;
-    _cx = posX; //'column grid' row and col
-    _cy = posY;
   }
 
   public int ix() { return _ix; }

src/HTM/java/htm/Region.java

@@ -149,7 +149,7 @@ public Region(int inputSizeX, int inputSizeY, int localityRadius,
     _columns = new Column[_width*_height];
     for(int cx=0; cx<_width; ++cx) {
       for(int cy=0; cy<_height; ++cy) {
-        _columns[(cy*_height)+cx] = new Column(this, cx, cy, cx, cy);
+        _columns[(cy*_width)+cx] = new Column(this, cx, cy, cx, cy);
       }
     }
 
@@ -1020,6 +1020,11 @@ private void performTemporalPooling() {
     for(Column col : _columns) {
       for(int c=0; c<col.numCells(); ++c) {
         Cell cell = col.getCell(c);
+        
+        //process all segments on the cell to cache the activity for later
+        for(int s=0; s<cell.numSegments(); ++s)
+          cell.getSegment(s).processSegment();
+        
         for(int s=0; s<cell.numSegments(); ++s) {
           Segment seg = cell.getSegment(s);
           if(seg.isActive()) {
@@ -1218,6 +1223,11 @@ protected void compute() {
           Column col = _region._columns[i];
           for(int c=0; c<col.numCells(); ++c) {
             Cell cell = col.getCell(c);
+            
+            //process all segments on the cell to cache the activity for later
+            for(int s=0; s<cell.numSegments(); ++s)
+              cell.getSegment(s).processSegment();
+            
             for(int s=0; s<cell.numSegments(); ++s) {
               Segment seg = cell.getSegment(s);
               if(seg.isActive()) {

src/HTM/java/htm/Segment.java

@@ -1,6 +1,8 @@
 package htm;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -23,13 +25,54 @@ public class Segment {
   private int _predictionSteps;
   private final float _segActiveThreshold;
 
+  private boolean _isActive;
+  private boolean _wasActive;
+  private Set<Synapse> _activeSynapses;
+  private Set<Synapse> _prevSynapses;
+  
   /**
    * Initialize a new Segment with the specified segment activation threshold.
    */
   Segment(int segActiveThreshold) {
     _synapses = new ArrayList<Synapse>();
     _isSequence = false;
     _segActiveThreshold = segActiveThreshold;
+    _isActive = false;
+    _wasActive = false;
+    _activeSynapses = new HashSet<Synapse>();
+    _prevSynapses = new HashSet<Synapse>();
+  }
+  
+  /**
+   * Advance this segment to the next time step.  The current state of this
+   * segment (active, number of synapes) will be set as the previous state and
+   * the current state will be reset to no cell activity by default until it
+   * can be determined.
+   */
+  void nextTimeStep() {
+    _wasActive = _isActive;
+    _isActive = false;
+    _prevSynapses.clear();
+    _prevSynapses.addAll(_activeSynapses);
+    _activeSynapses.clear();
+  }
+  
+  /**
+   * Process this segment for the current time step.  Processing will determine
+   * the set of active synapses on this segment for this time step.  From there
+   * we will determine if this segment is active if enough active synapses
+   * are present.  This information is then cached for the remainder of the
+   * Region's processing for the time step.  When a new time step occurs, the
+   * Region will call nextTimeStep() on all cells/segments to cache the 
+   * information as what was previously active.
+   */
+  public void processSegment() {
+    _activeSynapses.clear();
+    for(Synapse syn : _synapses) {
+      if(syn.isActive())
+        _activeSynapses.add(syn);
+    }
+    _isActive = _activeSynapses.size() >= _segActiveThreshold;
   }
 
   /**
@@ -40,7 +83,7 @@ public class Segment {
    * (something that will eventually happen).
    * @param sequence true to make the segment a sequence segment, false not.
    */
-  public void setSequence(boolean sequence) { 
+  private void setSequence(boolean sequence) { 
     _isSequence = sequence;
   }
 
@@ -140,15 +183,11 @@ public void getSynapseCells(Set<Cell> cells) {
   }
 
   /**
-   *  Populate the set with all the currently active (firing) synapses on
-   *  this segment.
-   *  @param connectedOnly: only consider if active if a synapse is connected.
+   *  Return the set of all the currently active (connected and firing) 
+   *  synapses on this segment.
    */
-  public void getActiveSynapses(Set<Synapse> syns) {
-    for(Synapse syn : _synapses) {
-      if(syn.isActive())
-        syns.add(syn);
-    }
+  public Set<Synapse> getActiveSynapses() {
+    return Collections.unmodifiableSet(_activeSynapses);
   }
 
   /**
@@ -166,6 +205,9 @@ public int getActiveSynapseCount() {
    * synapses which are currently connected.
    */
   public int getActiveSynapseCount(boolean connectedOnly) {
+    if(connectedOnly)
+      return _activeSynapses.size();
+    
     int c=0;
     for(Synapse syn : _synapses) {
       if(syn.isActive(connectedOnly))
@@ -175,15 +217,11 @@ public int getActiveSynapseCount(boolean connectedOnly) {
   }
 
   /**
-   *  Populate the set with all the previously active (firing) synapses on
+   *  Return the set of all the previously active (firing) synapses on
    *  this segment.
-   *  @param connectedOnly: only consider if active if a synapse is connected.
    */
-  public void getPrevActiveSynapses(Set<Synapse> syns) {
-    for(Synapse syn : _synapses) {
-      if(syn.wasActive())
-        syns.add(syn);
-    }
+  public Set<Synapse> getPrevActiveSynapses() {
+    return Collections.unmodifiableSet(_prevSynapses);
   }
 
   /**
@@ -201,6 +239,9 @@ public int getPrevActiveSynapseCount() {
    * synapses which are currently connected.
    */
   public int getPrevActiveSynapseCount(boolean connectedOnly) {
+    if(connectedOnly)
+      return _prevSynapses.size();
+    
     int c=0;
     for(Synapse syn : _synapses) {
       if(syn.wasActive(connectedOnly))
@@ -264,20 +305,15 @@ public void decreasePermanences(Set<Synapse> activeSynapses) {
    *  that are active due to active states at time t is greater than activationThreshold.
    */
   public boolean isActive() {
-    int c=0;
-    for(Synapse syn : _synapses) {
-      if(syn.isActive())
-        ++c;
-    }
-    return c >= _segActiveThreshold;
+    return _isActive;
   }
 
   /**
    *  This routine returns true if the number of connected synapses on this segment
    *  that were active due to active states at time t-1 is greater than activationThreshold.
    */
   public boolean wasActive() {
-    return getPrevActiveSynapseCount() >= _segActiveThreshold;
+    return _wasActive;
   }
 
   /**