Predictor: remove numRecord arg, fixes

as numRecord is no longer needed for inference. API changes to
bidings and tests to reflect the change.

Several fixes from earlier commits in this PR, this fixes the segfaults.

Author: breznak

bindings/py/cpp_src/bindings/algorithms/py_SDRClassifier.cpp

@@ -138,11 +138,11 @@ Example Usage:
     # Give the predictor partial information, and make predictions
     # about the future.
     pred.reset()
-    A = pred.infer( 0, sequence[0] )
+    A = pred.infer( sequence[0] )
     numpy.argmax( A[1] )  ->  labels[1]
     numpy.argmax( A[2] )  ->  labels[2]
 
-    B = pred.infer( 1, sequence[1] )
+    B = pred.infer( sequence[1] )
     numpy.argmax( B[1] )  ->  labels[2]
     numpy.argmax( B[2] )  ->  labels[3]
 )");
@@ -162,14 +162,10 @@ R"(For use with time series datasets.)");
         py_Predictor.def("infer", &Predictor::infer,
 R"(Compute the likelihoods.
 
-Argument recordNum is an incrementing integer for each record.
-Gaps in numbers correspond to missing records.
-
 Argument pattern is the SDR containing the active input bits.
 
 Returns a dictionary whos keys are prediction steps, and values are PDFs.
 See help(Classifier.infer) for details about PDFs.)",
-            py::arg("recordNum"),
             py::arg("pattern"));
 
         py_Predictor.def("learn", &Predictor::learn,

bindings/py/tests/algorithms/sdr_classifier_test.py

@@ -69,11 +69,11 @@ def testExampleUsage(self):
     # Give the predictor partial information, and make predictions
     # about the future.
     pred.reset()
-    A = pred.infer( 0, sequence[0] )
+    A = pred.infer( sequence[0] )
     assert( numpy.argmax( A[1] )  ==  labels[1] )
     assert( numpy.argmax( A[2] )  ==  labels[2] )
 
-    B = pred.infer( 1, sequence[1] )
+    B = pred.infer( sequence[1] )
     assert( numpy.argmax( B[1] )  ==  labels[2] )
     assert( numpy.argmax( B[2] )  ==  labels[3] )
 
@@ -121,7 +121,7 @@ def testSingleValue0Steps(self):
     for recordNum in range(10):
       pred.learn(recordNum, inp, 2)
 
-    retval = pred.infer( 10, inp )
+    retval = pred.infer( inp )
     self.assertGreater(retval[0][2], 0.9)
 
 
@@ -131,15 +131,18 @@ def testComputeInferOrLearnOnly(self):
     inp.randomize( .3 )
 
     # learn only
-    c.infer(recordNum=0, pattern=inp) # Don't crash with not enough training data.
+    with self.assertRaises(RuntimeError):
+      c.infer(pattern=inp) # crash with not enough training data.
     c.learn(recordNum=0, pattern=inp, classification=4)
-    c.infer(recordNum=1, pattern=inp) # Don't crash with not enough training data.
+    with self.assertRaises(RuntimeError):
+      c.infer(pattern=inp) # crash with not enough training data.
     c.learn(recordNum=2, pattern=inp, classification=4)
     c.learn(recordNum=3, pattern=inp, classification=4)
+    c.infer(pattern=inp) # Don't crash with not enough training data.
 
     # infer only
-    retval1 = c.infer(recordNum=5, pattern=inp)
-    retval2 = c.infer(recordNum=6, pattern=inp)
+    retval1 = c.infer(pattern=inp)
+    retval2 = c.infer(pattern=inp)
     self.assertSequenceEqual(list(retval1[1]), list(retval2[1]))
 
 
@@ -164,7 +167,7 @@ def testComputeComplex(self):
               classification=4,)
 
     inp.sparse = [1, 5, 9]
-    result = c.infer(recordNum=4, pattern=inp)
+    result = c.infer(pattern=inp)
 
     self.assertSetEqual(set(result.keys()), set([1]))
     self.assertEqual(len(result[1]), 6)
@@ -206,7 +209,7 @@ def testMultistepSingleValue(self):
     for recordNum in range(10):
       classifier.learn(recordNum, inp, 0)
 
-    retval = classifier.infer(10, inp)
+    retval = classifier.infer(inp)
 
     # Should have a probability of 100% for that bucket.
     self.assertEqual(retval[1], [1.])
@@ -221,7 +224,7 @@ def testMultistepSimple(self):
       inp.sparse = [i % 10]
       classifier.learn(recordNum=i, pattern=inp, classification=(i % 10))
 
-    retval = classifier.infer(99, inp)
+    retval = classifier.infer(inp)
 
     self.assertGreater(retval[1][0], 0.99)
     for i in range(1, 10):
@@ -267,15 +270,15 @@ def testMissingRecords(self):
     # At this point, we should have learned [1,3,5] => bucket 1
     #                                       [2,4,6] => bucket 2
     inp.sparse = [1, 3, 5]
-    result = c.infer(recordNum=recordNum, pattern=inp)
+    result = c.infer(pattern=inp)
     c.learn(recordNum=recordNum, pattern=inp, classification=2)
     recordNum += 1
     self.assertLess(result[1][0], 0.1)
     self.assertGreater(result[1][1], 0.9)
     self.assertLess(result[1][2], 0.1)
 
     inp.sparse = [2, 4, 6]
-    result = c.infer(recordNum=recordNum, pattern=inp)
+    result = c.infer(pattern=inp)
     c.learn(recordNum=recordNum, pattern=inp, classification=1)
     recordNum += 1
     self.assertLess(result[1][0], 0.1)
@@ -289,7 +292,7 @@ def testMissingRecords(self):
     #  the previous learn associates with bucket 0
     recordNum += 1
     inp.sparse = [1, 3, 5]
-    result = c.infer(recordNum=recordNum, pattern=inp)
+    result = c.infer(pattern=inp)
     c.learn(recordNum=recordNum, pattern=inp, classification=0)
     recordNum += 1
     self.assertLess(result[1][0], 0.1)
@@ -300,7 +303,7 @@ def testMissingRecords(self):
     #  the previous learn associates with bucket 0
     recordNum += 1
     inp.sparse = [2, 4, 6]
-    result = c.infer(recordNum=recordNum, pattern=inp)
+    result = c.infer(pattern=inp)
     c.learn(recordNum=recordNum, pattern=inp, classification=0)
     recordNum += 1
     self.assertLess(result[1][0], 0.1)
@@ -311,7 +314,7 @@ def testMissingRecords(self):
     #  the previous learn associates with bucket 0
     recordNum += 1
     inp.sparse = [1, 3, 5]
-    result = c.infer(recordNum=recordNum, pattern=inp)
+    result = c.infer(pattern=inp)
     c.learn(recordNum=recordNum, pattern=inp, classification=0)
     recordNum += 1
     self.assertLess(result[1][0], 0.1)
@@ -548,8 +551,8 @@ def testMultiStepPredictions(self):
       c.learn(recordNum, pattern=SDR2, classification=1)
       recordNum += 1
 
-    result1 = c.infer(recordNum, SDR1)
-    result2 = c.infer(recordNum, SDR2)
+    result1 = c.infer(SDR1)
+    result2 = c.infer(SDR2)
 
     self.assertAlmostEqual(result1[0][0], 1.0, places=1)
     self.assertAlmostEqual(result1[0][1], 0.0, places=1)

src/htm/algorithms/SDRClassifier.cpp

@@ -161,28 +161,27 @@ void Predictor::reset() {
 }
 
 
-Predictions Predictor::infer(const UInt recordNum, const SDR &pattern) const {
-  checkMonotonic_(recordNum);
-
+Predictions Predictor::infer(const SDR &pattern) const {
   Predictions result;
   for( const auto step : steps_ ) {
-    result[step] = classifiers_.at(step).infer( pattern );
+    result.insert({step, classifiers_.at(step).infer( pattern )});
   }
   return result;
 }
 
 
-void Predictor::learn(const UInt recordNum, const SDR &pattern,
+void Predictor::learn(const UInt recordNum, //TODO make recordNum optional, autoincrement as steps 
+		      const SDR &pattern,
                       const std::vector<UInt> &bucketIdxList)
 {
   checkMonotonic_(recordNum);
 
   // Update pattern history if this is a new record.
-  const UInt lastRecordNum = recordNumHistory_.empty() ? -1 : recordNumHistory_.back();
+  const UInt lastRecordNum = recordNumHistory_.empty() ? 0 : recordNumHistory_.back();
   if (recordNumHistory_.size() == 0u || recordNum > lastRecordNum) {
     patternHistory_.emplace_back( pattern );
     recordNumHistory_.push_back(recordNum);
-    if (patternHistory_.size() > steps_.back() + 1u) {
+    if (patternHistory_.size() > steps_.back() + 1u) { //steps_ are sorted, so steps_.back() is the "oldest/deepest" N-th step (ie 10 of [1,2,10])
       patternHistory_.pop_front();
       recordNumHistory_.pop_front();
     }
@@ -191,22 +190,20 @@ void Predictor::learn(const UInt recordNum, const SDR &pattern,
   // Iterate through all recently given inputs, starting from the furthest in the past.
   auto pastPattern   = patternHistory_.begin();
   auto pastRecordNum = recordNumHistory_.begin();
-  for( ; pastRecordNum != recordNumHistory_.end(); pastPattern++, pastRecordNum++ )
+  for( ; pastRecordNum != recordNumHistory_.cend(); pastPattern++, pastRecordNum++ )
   {
     const UInt nSteps = recordNum - *pastRecordNum;
 
     // Update weights.
     if( binary_search( steps_.begin(), steps_.end(), nSteps )) {
-      classifiers_[nSteps].learn( *pastPattern, bucketIdxList );
+      classifiers_.at(nSteps).learn( *pastPattern, bucketIdxList );
     }
   }
 }
 
 
 void Predictor::checkMonotonic_(const UInt recordNum) const {
   // Ensure that recordNum increases monotonically.
-  const UInt lastRecordNum = recordNumHistory_.empty() ? -1 : recordNumHistory_.back();
-  if( not recordNumHistory_.empty() ) {
-    NTA_CHECK(recordNum >= lastRecordNum) << "The record number must increase monotonically.";
-  }
+  const UInt lastRecordNum = recordNumHistory_.empty() ? 0 : recordNumHistory_.back();
+  NTA_CHECK(recordNum >= lastRecordNum) << "The record number must increase monotonically.";
 }

src/htm/algorithms/SDRClassifier.hpp

@@ -218,11 +218,11 @@ using Predictions = std::unordered_map<UInt, PDF>;
  *    // Give the predictor partial information, and make predictions
  *    // about the future.
  *    pred.reset();
- *    Predictions A = pred.infer( 0, sequence[0] );
+ *    Predictions A = pred.infer( sequence[0] );
  *    argmax( A[1] )  ->  labels[1]
  *    argmax( A[2] )  ->  labels[2]
  *
- *    Predictions B = pred.infer( 1, sequence[1] );
+ *    Predictions B = pred.infer( sequence[1] );
  *    argmax( B[1] )  ->  labels[2]
  *    argmax( B[2] )  ->  labels[3]
  *    ```
@@ -254,14 +254,11 @@ class Predictor : public Serializable
   /**
    * Compute the likelihoods.
    *
-   * @param recordNum: An incrementing integer for each record. Gaps in
-   *                   numbers correspond to missing records.
-   *
    * @param pattern: The active input SDR.
    *
    * @returns: A mapping from prediction step to PDF.
    */
-  Predictions infer(const UInt recordNum, const SDR &pattern) const;
+  Predictions infer(const SDR &pattern) const;
 
   /**
    * Learn from example data.

src/test/unit/algorithms/SDRClassifierTest.cpp

@@ -81,11 +81,11 @@ TEST(SDRClassifierTest, ExampleUsagePredictor)
   // Give the predictor partial information, and make predictions
   // about the future.
   pred.reset();
-  Predictions A = pred.infer( 0, sequence[0] );
+  Predictions A = pred.infer( sequence[0] );
   ASSERT_EQ( argmax( A[1] ),  labels[1] );
   ASSERT_EQ( argmax( A[2] ),  labels[2] );
 
-  Predictions B = pred.infer( 1, sequence[1] );
+  Predictions B = pred.infer( sequence[1] );
   ASSERT_EQ( argmax( B[1] ),  labels[2] );
   ASSERT_EQ( argmax( B[2] ),  labels[3] );
 }
@@ -103,7 +103,7 @@ TEST(SDRClassifierTest, SingleValue) {
   for (UInt i = 0u; i < 10u; ++i) {
     c.learn( i, input1, bucketIdxList );
   }
-  Predictions result1 = c.infer( 10u, input1 );
+  Predictions result1 = c.infer( input1 );
 
   ASSERT_EQ( argmax( result1[1u] ), 4u )
       << "Incorrect prediction for bucket 4";
@@ -138,7 +138,7 @@ TEST(SDRClassifierTest, ComputeComplex) {
   c.learn(1, input2, bucketIdxList2);
   c.learn(2, input3, bucketIdxList3);
   c.learn(3, input1, bucketIdxList4);
-  auto result = c.infer(4, input1);
+  auto result = c.infer(input1);
 
   // Check the one-step prediction
   ASSERT_EQ(result.size(), 1u)
@@ -211,7 +211,7 @@ TEST(SDRClassifierTest, SaveLoad) {
   // Measure and save some output.
   A.addNoise( 0.20f ); // Change two bits.
   c1.reset();
-  const auto c1_out = c1.infer( 0u, A );
+  const auto c1_out = c1.infer( A );
 
   // Save and load.
   stringstream ss;
@@ -220,7 +220,7 @@ TEST(SDRClassifierTest, SaveLoad) {
   EXPECT_NO_THROW(c2.load(ss));
 
   // Expect identical results.
-  const auto c2_out = c2.infer( 0u, A );
+  const auto c2_out = c2.infer( A );
   ASSERT_EQ(c1_out, c2_out);
 }