anomaly_detection 0.1.3 → 0.2.0

data/licenses/NOTICE-AnomalyDetection-cpp.txt

@@ -0,0 +1,15 @@
+Copyright (C) 2015 Twitter, Inc and other contributors
+Copyright (C) 2022 Andrew Kane
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anomaly_detection
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2023-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -35,7 +35,6 @@ files:
 - LICENSE.txt
 - NOTICE.txt
 - README.md
-- ext/anomaly_detection/anomaly_detection.cpp
 - ext/anomaly_detection/anomaly_detection.hpp
 - ext/anomaly_detection/dist.h
 - ext/anomaly_detection/ext.cpp
@@ -43,8 +42,10 @@ files:
 - ext/anomaly_detection/stl.hpp
 - lib/anomaly_detection.rb
 - lib/anomaly_detection/version.rb
+- licenses/LICENSE-AnomalyDetection-cpp.txt
 - licenses/LICENSE-MIT-dist-h.txt
 - licenses/LICENSE-MIT-stl-cpp.txt
+- licenses/NOTICE-AnomalyDetection-cpp.txt
 - licenses/UNLICENSE-dist-h.txt
 - licenses/UNLICENSE-stl-cpp.txt
 homepage: https://github.com/ankane/AnomalyDetection.rb
@@ -59,14 +60,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Time series anomaly detection for Ruby

data/ext/anomaly_detection/anomaly_detection.cpp

@@ -1,139 +0,0 @@
-#include <functional>
-#include <iostream>
-#include <iterator>
-#include <numeric>
-#include <string>
-#include <vector>
-
-#include "anomaly_detection.hpp"
-#include "dist.h"
-#include "stl.hpp"
-
-namespace anomaly_detection {
-
-float median(const std::vector<float>& sorted) {
-    return (sorted[(sorted.size() - 1) / 2] + sorted[sorted.size() / 2]) / 2.0;
-}
-
-float mad(const std::vector<float>& data, float med) {
-    std::vector<float> res;
-    res.reserve(data.size());
-    for (auto v : data) {
-        res.push_back(fabs(v - med));
-    }
-    std::sort(res.begin(), res.end());
-    return 1.4826 * median(res);
-}
-
-std::vector<size_t> detect_anoms(const std::vector<float>& data, int num_obs_per_period, float k, float alpha, bool one_tail, bool upper_tail, bool verbose, std::function<void()> check_for_interrupts) {
-    auto n = data.size();
-
-    // Check to make sure we have at least two periods worth of data for anomaly context
-    if (n < num_obs_per_period * 2) {
-        throw std::invalid_argument("series must contain at least 2 periods");
-    }
-
-    // Handle NANs
-    auto nan = std::count_if(data.begin(), data.end(), [](const auto& value) { return std::isnan(value); });
-    if (nan > 0) {
-        throw std::invalid_argument("series contains NANs");
-    }
-
-    // Decompose data. This returns a univarite remainder which will be used for anomaly detection. Optionally, we might NOT decompose.
-    auto seasonal_length = n * 10 + 1;
-    auto data_decomp = stl::params().robust(true).seasonal_length(seasonal_length).fit(data, num_obs_per_period);
-
-    auto seasonal = data_decomp.seasonal;
-    auto med = median(data);
-    std::vector<float> data2;
-    data2.reserve(n);
-    for (auto i = 0; i < n; i++) {
-        data2.push_back(data[i] - seasonal[i] - med);
-    }
-
-    std::vector<size_t> r_idx;
-    auto num_anoms = 0;
-    auto max_outliers = (size_t) n * k;
-
-    // Sort data for fast median
-    // Use stable sort for indexes for deterministic results
-    std::vector<size_t> indexes(n);
-    std::iota(indexes.begin(), indexes.end(), 0);
-    std::stable_sort(indexes.begin(), indexes.end(), [&data2](size_t a, size_t b) { return data2[a] < data2[b]; });
-    std::sort(data2.begin(), data2.end());
-
-    // Compute test statistic until r=max_outliers values have been removed from the sample
-    for (auto i = 1; i <= max_outliers; i++) {
-        check_for_interrupts();
-
-        if (verbose) {
-            std::cout << i << " / " << max_outliers << " completed" << std::endl;
-        }
-
-        // TODO Improve performance between loop iterations
-        auto ma = median(data2);
-        std::vector<float> ares;
-        ares.reserve(data2.size());
-        if (one_tail) {
-            if (upper_tail) {
-                for (auto v : data2) {
-                    ares.push_back(v - ma);
-                }
-            } else {
-                for (auto v : data2) {
-                    ares.push_back(ma - v);
-                }
-            }
-        } else {
-            for (auto v : data2) {
-                ares.push_back(fabs(v - ma));
-            }
-        }
-
-        // Protect against constant time series
-        auto data_sigma = mad(data2, ma);
-        if (data_sigma == 0.0) {
-            break;
-        }
-
-        auto iter = std::max_element(ares.begin(), ares.end());
-        auto r_idx_i = std::distance(ares.begin(), iter);
-
-        // Only need to take sigma of r for performance
-        auto r = ares[r_idx_i] / data_sigma;
-
-        r_idx.push_back(indexes[r_idx_i]);
-        data2.erase(data2.begin() + r_idx_i);
-        indexes.erase(indexes.begin() + r_idx_i);
-
-        // Compute critical value
-        float p;
-        if (one_tail) {
-            p = 1.0 - alpha / (n - i + 1);
-        } else {
-            p = 1.0 - alpha / (2.0 * (n - i + 1));
-        }
-
-        auto t = students_t_ppf(p, n - i - 1);
-        auto lam = t * (n - i) / sqrt(((n - i - 1) + powf(t, 2.0)) * (n - i + 1));
-
-        if (r > lam) {
-            num_anoms = i;
-        }
-    }
-
-    std::vector<size_t> anomalies(r_idx.begin(), r_idx.begin() + num_anoms);
-
-    // Sort like R version
-    std::sort(anomalies.begin(), anomalies.end());
-
-    return anomalies;
-}
-
-std::vector<size_t> anomalies(const std::vector<float>& x, int period, float k, float alpha, Direction direction, bool verbose, std::function<void()> check_for_interrupts) {
-    bool one_tail = direction != Direction::Both;
-    bool upper_tail = direction == Direction::Positive;
-    return detect_anoms(x, period, k, alpha, one_tail, upper_tail, verbose, check_for_interrupts);
-}
-
-}