TM: activateDendrites now uses SDR

removes old alternative with vectors

Author: breznak

src/nupic/algorithms/TemporalMemory.cpp

@@ -522,6 +522,7 @@ void TemporalMemory::activateCells(const SDR &activeColumns, const bool learn) {
   segmentsValid_ = false;
 }
 
+
 void TemporalMemory::activateDendrites(const bool learn,
                                        const SDR &extraActive,
                                        const SDR &extraWinners)
@@ -536,48 +537,24 @@ void TemporalMemory::activateDendrites(const bool learn,
   both.intersection(extraActive, extraWinners);
   NTA_ASSERT(both == extraWinners) << "ExtraWinners must be a subset of ExtraActive";
 #endif
-        activateDendrites( learn, extraActive.getSparse(),
-                                  extraWinners.getSparse());
     }
     else
     {
         NTA_CHECK( extraActive.getSum() == 0u && extraWinners.getSum() == 0u )
             << "External predictive inputs must be declared to TM constructor!";
-        activateDendrites(learn);
     }
-}
 
-void TemporalMemory::activateDendrites(const bool learn,
-                                       const vector<UInt> &extraActive,
-                                       const vector<UInt> &extraWinners)
-{
+
   if( segmentsValid_ )
     return;
 
-  // Handle external predictive inputs.  extraActive & extraWinners default
-  // values are `vector({ SENTINEL })`
-  const auto SENTINEL = std::numeric_limits<UInt>::max();
-  if( extra_ )
-  {
-    NTA_CHECK( extraActive.size()  != 1 || extraActive[0]  != SENTINEL )
-        << "TM.ActivateDendrites() missing argument extraActive!";
-    NTA_CHECK( extraWinners.size() != 1 || extraWinners[0] != SENTINEL )
-        << "TM.ActivateDendrites() missing argument extraWinners!";
-
-    for(const auto &active : extraActive) {
+  for(const auto &active : extraActive.getSparse()) {
       NTA_ASSERT( active < extra_ );
       activeCells_.push_back( static_cast<CellIdx>(active + numberOfCells()) ); 
-    }
-    for(const auto &winner : extraWinners) {
+  }
+  for(const auto &winner : extraWinners.getSparse()) {
       NTA_ASSERT( winner < extra_ );
       winnerCells_.push_back( static_cast<CellIdx>(winner + numberOfCells()) );
-    }
-  }
-  else {
-    NTA_CHECK( extraActive.size()  == 1 && extraActive[0]  == SENTINEL )
-        << "External predictive inputs must be declared to TM constructor!";
-    NTA_CHECK( extraWinners.size() == 1 && extraWinners[0] == SENTINEL )
-        << "External predictive inputs must be declared to TM constructor!";
   }
 
   const size_t length = connections.segmentFlatListLength();
@@ -590,16 +567,13 @@ void TemporalMemory::activateDendrites(const bool learn,
 
   // Active segments, connected synapses.
   activeSegments_.clear();
-  for (Segment segment = 0;
-       segment < numActiveConnectedSynapsesForSegment_.size(); segment++) {
-    if (numActiveConnectedSynapsesForSegment_[segment] >=
-        activationThreshold_) {
+  for (Segment segment = 0; segment < numActiveConnectedSynapsesForSegment_.size(); segment++) {
+    if (numActiveConnectedSynapsesForSegment_[segment] >= activationThreshold_) {
       activeSegments_.push_back(segment);
     }
   }
-  std::sort(
-      activeSegments_.begin(), activeSegments_.end(),
-      [&](Segment a, Segment b) { return connections.compareSegments(a, b); });
+  const auto compareSegments = [&](const Segment a, const Segment b) { return connections.compareSegments(a, b); };
+  std::sort( activeSegments_.begin(), activeSegments_.end(), compareSegments);
   // Update segment bookkeeping.
   if (learn) {
     for (const auto &segment : activeSegments_) {
@@ -610,19 +584,17 @@ void TemporalMemory::activateDendrites(const bool learn,
 
   // Matching segments, potential synapses.
   matchingSegments_.clear();
-  for (Segment segment = 0;
-       segment < numActivePotentialSynapsesForSegment_.size(); segment++) {
+  for (Segment segment = 0; segment < numActivePotentialSynapsesForSegment_.size(); segment++) {
     if (numActivePotentialSynapsesForSegment_[segment] >= minThreshold_) {
       matchingSegments_.push_back(segment);
     }
   }
-  std::sort(
-      matchingSegments_.begin(), matchingSegments_.end(),
-      [&](Segment a, Segment b) { return connections.compareSegments(a, b); });
+  std::sort( matchingSegments_.begin(), matchingSegments_.end(), compareSegments);
 
   segmentsValid_ = true;
 }
 
+
 void TemporalMemory::compute(const SDR &activeColumns, 
                              const bool learn,
                              const SDR &extraActive,

src/nupic/algorithms/TemporalMemory.hpp

@@ -215,26 +215,28 @@ using namespace nupic::algorithms::connections;
    * used during segment cleanup.
    *
    * @param extraActive
-   * (optional) Vector of active external predictive inputs.  External inputs must be cell
+   * (optional) SDR of active external predictive inputs.  External inputs must be cell
    * indexes in the range [0, extra).
    *
    * @param extraWinners
-   * (optional) Vector of winning external predictive inputs.  When learning, only these
+   * (optional) SDR of winning external predictive inputs.  When learning, only these
    * inputs are considered active.  
    * ExtraWinners must be a subset of extraActive.  
    * External inputs must be cell indices in the range [0, extra).
    *
    * See TM::compute() for details of the parameters. 
    *
    */
-  void activateDendrites(const bool learn = true,
-                         const vector<UInt> &extraActive  = {std::numeric_limits<UInt>::max()},
-                         const vector<UInt> &extraWinners = {std::numeric_limits<UInt>::max()});
-
-  void activateDendrites(const bool learn, //TODO provide convenience overload activateDendrites(bool), and remove the vector version
+  void activateDendrites(const bool learn,
                          const sdr::SDR &extraActive, 
 			 const sdr::SDR &extraWinners);
 
+  inline void activateDendrites(const bool learn = true) {
+    const sdr::SDR extraActive(std::vector<UInt>{ extra });
+    const sdr::SDR extraWinners(std::vector<UInt>{extra });
+    activateDendrites(learn, extraActive, extraWinners);
+  }
+
   /**
    * Perform one time step of the Temporal Memory algorithm.
    *

src/test/unit/algorithms/TemporalMemoryTest.cpp

@@ -1665,9 +1665,11 @@ TEST(TemporalMemoryTest, testExtraActive) {
   // Test the test:  Verify that when the external inputs are missing this test
   // fails.
   tm.reset();
+  extraActive.zero(); //zero out the external inputs
+  extraWinners.zero();
   for(const auto &x : pattern) {
     // Predict whats going to happen.
-    tm.activateDendrites(true, vector<UInt>({}), vector<UInt>({}));
+    tm.activateDendrites(true, extraActive, extraWinners);
     auto predictedCells = tm.getPredictiveCells();
     ASSERT_TRUE( predictedCells.getSum() == 0 ); // No predictions, numActive < threshold
     // Calculate TM output
@@ -1692,7 +1694,7 @@ TEST(TemporalMemoryTest, testEquals) {
 
 TEST(TemporalMemoryTest, testIncorrectDefaultConstructor) {
   TemporalMemory tmFail; //default empty constructor is only used for deserialization
-  SDR data1({tmFail.getColumnDimensions()});
+  SDR data1({0});
   EXPECT_ANY_THROW(tmFail.compute(data1, true));
 
   TemporalMemory tmOk({32} /*column dims must always be specified*/);