napi_sine now is the same as HelloSPTP

dkeeney · dkeeney · commit 76e0abb66a64 · 2019-11-25T14:32:22.000-08:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -417,6 +417,7 @@ install(TARGETS
         
 install(TARGETS
         ${src_executable_hotgym}
+        ${src_executable_napi_sine}
         ${src_executable_mnistsp}
         RUNTIME DESTINATION bin
         LIBRARY DESTINATION lib
diff --git a/src/examples/hotgym/HelloSPTP.cpp b/src/examples/hotgym/HelloSPTP.cpp
@@ -121,7 +121,7 @@ EPOCHS = 2; // make test faster in Debug
     input.addNoise(0.01f, rnd); //change 1% of the SDR for each iteration, this makes a random sequence, but seemingly stable
     tRng.stop();
 
-    //SP (global x local)
+    //SP (global and local)
     if(useSPlocal) {
     tSPloc.start();
     spLocal.compute(input, true, outSPlocal);
@@ -154,7 +154,7 @@ EPOCHS = 2; // make test faster in Debug
       avgAnomOld_ = avgAnom10.getCurrentAvg(); //update
     }
     tAnLikelihood.start();
-    anLikelihood.anomalyProbability(an); //FIXME AnLikelihood is 0.0, probably not working correctly
+    anLikely = anLikelihood.anomalyProbability(an); //FIXME AnLikelihood is 0.0, probably not working correctly
     tAnLikelihood.stop();
 
 
@@ -173,13 +173,14 @@ EPOCHS = 2; // make test faster in Debug
 	   << "\n";
 
       // output values
-      cout << "Epoch = " << e << endl;
+      cout << "Epoch = " << e+1 << endl;
       cout << "Anomaly = " << an << endl;
       cout << "Anomaly (avg) = " << avgAnom10.getCurrentAvg() << endl;
       cout << "Anomaly (Likelihood) = " << anLikely << endl;
-      cout << "SP (g)= " << outSP << endl;
-      cout << "SP (l)= " << outSPlocal <<endl;
-      cout << "TM= " << outTM << endl;
+      cout << "input = " << input << endl;
+      if(useSPlocal) cout << "SP (g)= " << outSP << endl;
+      if(useSPlocal) cout << "SP (l)= " << outSPlocal <<endl;
+      if(useTM) cout << "TM= " << outTM << endl;
 
       //timers
       cout << "==============TIMERS============" << endl;
@@ -220,7 +221,7 @@ EPOCHS = 2; // make test faster in Debug
       const float goldAnAvg = 0.411894f; // ...the averaged value, on the other hand, should improve/decrease. 
 
 #ifdef _ARCH_DETERMINISTIC
-      if(EPOCHS == 5000) {
+      if(e+1 == 5000) {
         //these hand-written values are only valid for EPOCHS = 5000 (default), but not for debug and custom runs.
         NTA_CHECK(input == goldEnc) << "Deterministic output of Encoder failed!\n" << input << "should be:\n" << goldEnc;
         if(useSPglobal) { NTA_CHECK(outSPglobal == goldSP) << "Deterministic output of SP (g) failed!\n" << outSP << "should be:\n" << goldSP; }
@@ -230,6 +231,7 @@ EPOCHS = 2; // make test faster in Debug
                   << "Deterministic output of Anomaly failed! " << an << "should be: " << goldAn;
         NTA_CHECK(static_cast<UInt>(avgAnom10.getCurrentAvg() * 10000.0f) == static_cast<UInt>(goldAnAvg * 10000.0f))
                   << "Deterministic average anom score failed:" << avgAnom10.getCurrentAvg() << " should be: " << goldAnAvg;
+        std::cout << "outputs match\n";
       }
 #endif
 
diff --git a/src/examples/hotgym/HelloSPTP.hpp b/src/examples/hotgym/HelloSPTP.hpp
@@ -16,7 +16,7 @@ class BenchmarkHotgym {
 public:	
   Real64 run(
     UInt EPOCHS = 5000,
-    bool useSPlocal=true, //can toggle which (long running) components are tested, default all
+    bool useSPlocal=false, //can toggle which (long running) components are tested, default all
     bool useSPglobal=true,
     bool useTM=true,
     const UInt COLS = 2048, // number of columns in SP, TP
diff --git a/src/examples/napi_sine/napi_sine.cpp b/src/examples/napi_sine/napi_sine.cpp
@@ -19,27 +19,33 @@
 #include <htm/utils/Random.hpp>
 #include <htm/utils/Log.hpp>
 #include <htm/ntypes/Value.hpp>
+#include "htm/utils/MovingAverage.hpp"
+#include "htm/algorithms/AnomalyLikelihood.hpp"
 #include <fstream>
 
 using namespace htm;
 
-static bool verbose = false;
+static bool verbose = true;
 #define VERBOSE if (verbose)  std::cout << "    "
 
 
 //this runs as an executable
 
 int main(int argc, char* argv[]) {
   htm::UInt EPOCHS = 5000;      // number of iterations (calls to encoder/SP/TP compute() )
+#ifndef NDEBUG
+  EPOCHS = 2; // make test faster in Debug
+#endif
+
   const UInt DIM_INPUT = 1000;  // Width of encoder output
   const UInt COLS = 2048;       // number of columns in SP, TP
   const UInt CELLS = 8;         // cells per column in TP
   Random rnd(42);               // uses fixed seed for deterministic output
   std::ofstream ofs;
 
-  std::string encoder_params   = "{size: " + std::to_string(DIM_INPUT) + ", activeBits: 4, radius: 0.5, seed: 2019 }";
+  std::string encoder_params   = "{size: " + std::to_string(DIM_INPUT) + ", sparsity: 0.2, radius: 0.03, seed: 2019, noise: 0.01}";
   std::string sp_global_params = "{columnCount: " + std::to_string(COLS) + ", globalInhibition: true}";
-  std::string tm_params        = "{activationThreshold: 9, cellsPerColumn: " + std::to_string(CELLS) + "}";
+  std::string tm_params        = "{cellsPerColumn: " + std::to_string(CELLS) + ", orColumnOutputs: true}";
 
   //  Runtime arguments:  napi_sine [epochs [filename]]
   if(argc >= 2) {
@@ -51,7 +57,7 @@ int main(int argc, char* argv[]) {
 
   try {
 
-    std::cout << "initializing\n";
+    std::cout << "initializing. DIM_INPUT=" << DIM_INPUT << ", COLS=" << COLS << ", CELLS=" << CELLS << "\n";
 
     Network net;
 
@@ -66,6 +72,7 @@ int main(int argc, char* argv[]) {
 
     net.initialize();
 
+
     ///////////////////////////////////////////////////////////////
     //
     //                          .----------------.
@@ -92,39 +99,60 @@ int main(int argc, char* argv[]) {
     // enable this to see a trace as it executes
     //net.setLogLevel(LogLevel::LogLevel_Verbose);
 
-    std::cout << "Running: \n";
+    std::cout << "Running: " << EPOCHS << " Iterations.\n ";
+
+    float anLikely = 0.0f;
+    MovingAverage avgAnomaly(1000); 
+    AnomalyLikelihood anLikelihood;
+
     // RUN
-    for (size_t i = 0; i < EPOCHS; i++) {
+    float x = 0.00f; 
+    for (size_t e = 0; e < EPOCHS; e++) {
       // genarate some data to send to the encoder
-      //  -- A sin wave, one degree rotation per iteration, 1% noise added
-      double data = std::sin(i * (3.1415 / 180)) + (double)rnd.realRange(-0.01f, +0.1f);
+      
+      //  -- A sine wave, one degree rotation per iteration (an alternate function)
+      //double data = std::sin(i * (3.1415 / 180));
+      
+      // -- sine wave, 0.01 radians per iteration   (Note: first iteration is for x=0.01, not 0)
+      x += 0.01f; // step size for fn(x)
+      double data = std::sin(x);
       encoder->setParameterReal64("sensedValue", data); // feed data into RDSE encoder for this iteration.
 
       // Execute an iteration.
       net.run(1);
 
-      // output values
       float an = ((float *)tm->getOutputData("anomaly").getBuffer())[0];
-      VERBOSE << "Epoch = " << i << std::endl;
-      VERBOSE << "  Data        = " << data << std::endl;
-      VERBOSE << "  Encoder out = " << encoder->getOutputData("encoded").getSDR();
-      VERBOSE << "  SP (global) = " << sp_global->getOutputData("bottomUpOut").getSDR();
-      VERBOSE << "  TM output   = " << tm->getOutputData("bottomUpOut").getSDR();
-      VERBOSE << "  ActiveCells = " << tm->getOutputData("activeCells").getSDR();
-      VERBOSE << "  winners     = " << tm->getOutputData("predictedActiveCells").getSDR();
-      VERBOSE << "  Anomaly     = " << an << std::endl;
-
-      // Save the data for plotting.   <iteration>, <sin data>, <anomaly>\n
-      if (ofs.is_open())
-        ofs << i << "," << data << "," << an << std::endl;
+      avgAnomaly.compute(an);
+      anLikely = anLikelihood.anomalyProbability(an); 
+
+
+      // Save the data for plotting.   <iteration>, <sin data>, <anomaly>, <likelyhood>\n
+      if (ofs.is_open()) {
+        ofs << e << "," << data << "," << an << "," << anLikely << std::endl;
+      }
+
+      if (e == EPOCHS - 1) 
+      {
+
+        // output values
+        float final_an = ((float *)tm->getOutputData("anomaly").getBuffer())[0];
+        VERBOSE << "Result after " << e + 1 << " iterations.\n";
+        VERBOSE << "  Anomaly(avg)        = " << avgAnomaly.getCurrentAvg() << std::endl;
+        VERBOSE << "  Anomaly(Likelihood) = " << anLikely << endl;
+        VERBOSE << "  Encoder out         = " << encoder->getOutputData("encoded").getSDR();
+        VERBOSE << "  SP (global)         = " << sp_global->getOutputData("bottomUpOut").getSDR();
+        VERBOSE << "  TM predictive       = " << tm->getOutputData("predictiveCells").getSDR();
+      }
     }
     if (ofs.is_open())
       ofs.close();
+
+
     std::cout << "finished\n";
 
 
-  } catch (Exception &e) {
-    std::cerr << e.what();
+  } catch (Exception &ex) {
+    std::cerr << ex.what();
     if (ofs.is_open())
       ofs.close();
     return 1;
diff --git a/src/htm/algorithms/SpatialPooler.hpp b/src/htm/algorithms/SpatialPooler.hpp
@@ -66,17 +66,18 @@ class SpatialPooler : public Serializable
 
   SpatialPooler();
   SpatialPooler(const vector<UInt> inputDimensions, const vector<UInt> columnDimensions,
-                UInt potentialRadius = 16u, Real potentialPct = 0.5f,
-                bool globalInhibition = true, 
+    UInt potentialRadius = 16u, 
+    Real potentialPct = 0.5f,
+    bool globalInhibition = false, 
 		Real localAreaDensity = 0.05f, //5%
-                UInt stimulusThreshold = 0u, 
+    UInt stimulusThreshold = 0u, 
 		Real synPermInactiveDec = 0.008f,
-                Real synPermActiveInc = 0.05f, 
+    Real synPermActiveInc = 0.05f, 
 		Real synPermConnected = 0.1f,
-                Real minPctOverlapDutyCycles = 0.001f,
-                UInt dutyCyclePeriod = 1000u, 
+    Real minPctOverlapDutyCycles = 0.001f,
+    UInt dutyCyclePeriod = 1000u, 
 		Real boostStrength = 0.0f,
-                Int seed = 1, 
+    Int seed = 1, 
 		UInt spVerbosity = 0u, 
 		bool wrapAround = true);
 
diff --git a/src/htm/regions/RDSERegion.cpp b/src/htm/regions/RDSERegion.cpp
@@ -28,6 +28,7 @@
 #include <htm/engine/Region.hpp>
 #include <htm/engine/Spec.hpp>
 #include <htm/ntypes/Array.hpp>
+#include "htm/utils/Random.hpp"
 #include <htm/utils/Log.hpp>
 
 #include <memory>
@@ -47,18 +48,23 @@ namespace htm {
           resolution:  {type: Real32, default: "0.0"},
           category:    {type: Bool,   default: "false"},
           seed:        {type: UInt32, default: "0"},
-          sensedValue: {type: Real64, default: "0.0", access: ReadWrite }},
+          noise:       {description: "amount of noise to add to the output SDR. 0.01 is 1%",
+                        type: Real32, default: "0.0"},
+          sensedValue: {description: "The value to encode. Overriden by input 'values'.",
+                        type: Real64, default: "0.0", access: ReadWrite }},
       inputs: {
-          values:      {type: Real64, count: 1, isDefaultInput: yes, isRegionLevel: yes}}, 
+          values:      {description: "Values to encode. Overrides sensedValue.",
+                        type: Real64, count: 1, isDefaultInput: yes, isRegionLevel: yes}}, 
       outputs: {
-          encoded:     {type: SDR,    count: 0, isDefaultOutput: yes, isRegionLevel: yes }}} )");
+          encoded:     {description: "Encoded bits. Not a true Sparse Data Representation.",
+                        type: SDR,    count: 0, isDefaultOutput: yes, isRegionLevel: yes }}} )");
 
   return ns;
 }
 
 
 RDSERegion::RDSERegion(const ValueMap &par, Region *region) : RegionImpl(region) {
-
+  rnd_ = Random(42);
   spec_.reset(createSpec());
   ValueMap params = ValidateParameters(par, spec_.get());
     
@@ -73,7 +79,7 @@ RDSERegion::RDSERegion(const ValueMap &par, Region *region) : RegionImpl(region)
 
   encoder_ = std::make_shared<RandomDistributedScalarEncoder>(args);
   sensedValue_ = params.getScalarT<Real64>("sensedValue");
-
+  noise_ = params.getScalarT<Real32>("noise");
 }
 
 RDSERegion::RDSERegion(ArWrapper &wrapper, Region *region)
@@ -99,6 +105,11 @@ void RDSERegion::compute() {
   }
   SDR &output = getOutput("encoded")->getData().getSDR();
   encoder_->encode((Real64)sensedValue_, output);
+
+  // Add some noise.
+  // noise_ = 0.01 means change 1% of the SDR for each iteration, this makes a random sequence, but seemingly stable
+  if (noise_ != 0.0f)
+    output.addNoise(noise_, rnd_);
 }
 
 
diff --git a/src/htm/regions/RDSERegion.hpp b/src/htm/regions/RDSERegion.hpp
@@ -67,6 +67,8 @@ class RDSERegion : public RegionImpl, Serializable {
   template<class Archive>
   void save_ar(Archive& ar) const {
     ar(CEREAL_NVP(sensedValue_));
+    ar(CEREAL_NVP(noise_));
+    ar(CEREAL_NVP(rnd_));
     ar(cereal::make_nvp("encoder", encoder_));
   }
   // FOR Cereal Deserialization
@@ -77,6 +79,8 @@ class RDSERegion : public RegionImpl, Serializable {
   template<class Archive>
   void load_ar(Archive& ar) {
     ar(CEREAL_NVP(sensedValue_));
+    ar(CEREAL_NVP(noise_));
+    ar(CEREAL_NVP(rnd_));
     ar(cereal::make_nvp("encoder", encoder_));
     setDimensions(encoder_->dimensions); 
   }
@@ -89,6 +93,8 @@ class RDSERegion : public RegionImpl, Serializable {
 
 private:
   Real64 sensedValue_;
+  Real32 noise_;
+  Random rnd_;
   std::shared_ptr<RandomDistributedScalarEncoder> encoder_;
 };
 } // namespace htm
diff --git a/src/htm/regions/SPRegion.cpp b/src/htm/regions/SPRegion.cpp
@@ -43,7 +43,7 @@ SPRegion::SPRegion(const ValueMap &values, Region *region)
   // parameters out of the map and set aside so we can pass them to the SpatialPooler
   // algorithm when we create it during initialization().
   args_.columnCount = values.getScalarT<UInt32>("columnCount", 0);
-  args_.potentialRadius = values.getScalarT<UInt32>("potentialRadius", 0);
+  args_.potentialRadius = values.getScalarT<UInt32>("potentialRadius", 16u);
   args_.potentialPct = values.getScalarT<Real32>("potentialPct", 0.5);
   args_.globalInhibition = values.getScalarT<bool>("globalInhibition", false);
   args_.localAreaDensity = values.getScalarT<Real32>("localAreaDensity", 0.05f);
@@ -54,7 +54,7 @@ SPRegion::SPRegion(const ValueMap &values, Region *region)
   args_.minPctOverlapDutyCycles = values.getScalarT<Real32>("minPctOverlapDutyCycles", 0.001f);
   args_.dutyCyclePeriod = values.getScalarT<UInt32>("dutyCyclePeriod", 1000);
   args_.boostStrength = values.getScalarT<Real32>("boostStrength", 0.0f);
-  args_.seed = values.getScalarT<Int32>("seed", -1);
+  args_.seed = values.getScalarT<Int32>("seed", 1);
   args_.spVerbosity = values.getScalarT<UInt32>("spVerbosity", 0);
   args_.wrapAround = values.getScalarT<bool>("wrapAround", true);
   spatialImp_ = values.getString("spatialImp", "");
@@ -235,7 +235,7 @@ Spec *SPRegion::createSpec() {
                     NTA_BasicType_UInt32,             // type
                     1,                                // elementCount
                     "",                               // constraints
-                    "0",                              // defaultValue
+                    "16",                              // defaultValue
                     ParameterSpec::ReadWriteAccess)); // access
 
   ns->parameters.add(
diff --git a/src/htm/regions/TMRegion.cpp b/src/htm/regions/TMRegion.cpp
