Anomaly likelihood

src/CMakeLists.txt

@@ -256,6 +256,7 @@ set(src_lib_static_nupiccore_solo nupic_core_solo)
 
 set(src_nupiccore_srcs
     nupic/algorithms/Anomaly.cpp
+    nupic/algorithms/AnomalyLikelihood.cpp
     nupic/algorithms/BacktrackingTMCpp.cpp
     nupic/algorithms/BitHistory.cpp
     nupic/algorithms/Cell.cpp

src/nupic/algorithms/Anomaly.cpp

@@ -33,13 +33,13 @@
 using namespace std;
 
 namespace nupic {
-
 namespace algorithms {
-
 namespace anomaly {
 
-Real32 computeRawAnomalyScore(const vector<UInt> &active,
-                              const vector<UInt> &predicted) {
+
+Real computeRawAnomalyScore(const vector<UInt>& active,
+                              const vector<UInt>& predicted)
+{
   // Return 0 if no active columns are present
   if (active.size() == 0) {
     return 0.0f;
@@ -53,39 +53,38 @@ Real32 computeRawAnomalyScore(const vector<UInt> &active,
   set_intersection(active_.begin(), active_.end(), predicted_.begin(),
                    predicted_.end(), back_inserter(predictedActiveCols));
 
-  return (active.size() - predictedActiveCols.size()) / Real32(active.size());
+  return (active.size() - predictedActiveCols.size()) / Real(active.size());
 }
 
-Anomaly::Anomaly(UInt slidingWindowSize, AnomalyMode mode,
-                 Real32 binaryAnomalyThreshold)
-    : binaryThreshold_(binaryAnomalyThreshold) {
-  NTA_ASSERT(binaryAnomalyThreshold >= 0 && binaryAnomalyThreshold <= 1)
-      << "binaryAnomalyThreshold must be within [0.0,1.0]";
+Anomaly::Anomaly(UInt slidingWindowSize, AnomalyMode mode, Real binaryAnomalyThreshold)
+    : binaryThreshold_(binaryAnomalyThreshold)
+{
+  NTA_CHECK(binaryAnomalyThreshold >= 0 && binaryAnomalyThreshold <= 1) << "binaryAnomalyThreshold must be within [0.0,1.0]";
   mode_ = mode;
   if (slidingWindowSize > 0) {
     movingAverage_.reset(new nupic::util::MovingAverage(slidingWindowSize));
   }
-
-  // Not implemented. Fail.
-  NTA_ASSERT(mode_ == AnomalyMode::PURE)
-      << "C++ Anomaly implemented only for PURE mode!";
 }
 
-Real32 Anomaly::compute(const vector<UInt> &active,
-                        const vector<UInt> &predicted, Real64 inputValue,
-                        UInt timestamp) {
-  Real32 anomalyScore = computeRawAnomalyScore(active, predicted);
-  Real32 score = anomalyScore;
-  switch (mode_) {
-  case AnomalyMode::PURE:
-    score = anomalyScore;
-    break;
-  case AnomalyMode::LIKELIHOOD:
-  case AnomalyMode::WEIGHTED:
-    // Not implemented. Fail
-    NTA_ASSERT(mode_ == AnomalyMode::PURE)
-        << "C++ Anomaly implemented only for PURE mode!";
-    break;
+
+Real Anomaly::compute(const vector<UInt>& active, const vector<UInt>& predicted, int timestamp)
+{
+  Real anomalyScore = computeRawAnomalyScore(active, predicted);
+  Real likelihood = 0.5;
+  Real score = anomalyScore;
+  switch(mode_)
+  {
+    case AnomalyMode::PURE:
+      score = anomalyScore;
+      break;
+    case AnomalyMode::LIKELIHOOD:
+      likelihood = likelihood_.anomalyProbability(anomalyScore, timestamp);
+      score = 1 - likelihood;
+      break;
+    case AnomalyMode::WEIGHTED:
+      likelihood = likelihood_.anomalyProbability(anomalyScore, timestamp);
+      score = anomalyScore * (1 - likelihood);
+      break;
   }
 
   if (movingAverage_) {
@@ -100,7 +99,5 @@ Real32 Anomaly::compute(const vector<UInt> &active,
 }
 
 } // namespace anomaly
-
 } // namespace algorithms
-
 } // namespace nupic

src/nupic/algorithms/Anomaly.hpp

@@ -24,20 +24,16 @@
 #define NUPIC_ALGORITHMS_ANOMALY_HPP
 
 #include <memory> // Needed for smart pointer templates
+#include <nupic/algorithms/AnomalyLikelihood.hpp>
 #include <nupic/types/Types.hpp>
 #include <nupic/utils/MovingAverage.hpp> // Needed for for smart pointer templates
 #include <vector>
 
 namespace nupic {
-
-namespace util {
-class MovingAverage; // Forward declaration
-}
-
 namespace algorithms {
-
 namespace anomaly {
 
+
 /**
  * Computes the raw anomaly score.
  *
@@ -93,24 +89,20 @@ class Anomaly {
    * @param active: array of active column indices
    * @param predicted: array of columns indices predicted in this step
    *        (used for anomaly in step T+1)
-   * @param inputValue: (optional) value of current input to encoders
-   *                    (eg "cat" for category encoder)
-   *                    (used in anomaly-likelihood)
    * @param timestamp: (optional) date timestamp when the sample occured
    *                   (used in anomaly-likelihood)
    * @return the computed anomaly score; Real32 0..1
    */
-  Real32 compute(const std::vector<UInt> &active,
-                 const std::vector<UInt> &predicted, Real64 inputValue = 0,
-                 UInt timestamp = 0);
+  Real compute(const std::vector<UInt> &active,
+                 const std::vector<UInt> &predicted, 
+                 int timestamp = 0);
 
 private:
   AnomalyMode mode_;
   Real32 binaryThreshold_;
   std::unique_ptr<nupic::util::MovingAverage> movingAverage_;
+  AnomalyLikelihood likelihood_; //TODO which params/how pass them to constructor?
 };
-} // namespace anomaly
-} // namespace algorithms
-} // namespace nupic
+}}} //end-ns
 
 #endif // NUPIC_ALGORITHMS_ANOMALY_HPP