midas-edge 0.1.0

data/vendor/MIDAS/edgehash.cpp

@@ -0,0 +1,63 @@
+#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
+
+#include <iostream>
+#include "edgehash.hpp"
+
+Edgehash::Edgehash(int r, int b, int m0)
+{
+    num_rows = r;
+    num_buckets = b;
+    m = m0;
+    hash_a.resize(num_rows);
+    hash_b.resize(num_rows);
+    for (int i = 0; i < r; i++) {
+        // a is in [1, p-1]; b is in [0, p-1]
+        hash_a[i] = rand() % (num_buckets - 1) + 1;
+        hash_b[i] = rand() % num_buckets;
+    }
+    this->clear();
+}
+
+Edgehash::~Edgehash()
+{
+}
+
+int Edgehash::hash(int a, int b, int i)
+{
+    int resid = ((a + m * b) * hash_a[i] + hash_b[i]) % num_buckets;
+    return resid + (resid < 0 ? num_buckets : 0);
+}
+
+void Edgehash::insert(int a, int b, double weight)
+{
+    for (int i = 0; i < num_rows; i++) {
+        int bucket = hash(a, b, i);
+        count[i][bucket] += weight;
+    }
+}
+
+double Edgehash::get_count(int a, int b)
+{
+    double min_count = numeric_limits<double>::max();
+    int bucket;
+    for (int i = 0; i < num_rows; i++) {
+        bucket = hash(a, b, i);
+        min_count = MIN(min_count, count[i][bucket]);
+    }
+    return min_count;
+}
+
+void Edgehash::clear()
+{
+    count = vector<vector<double> >(num_rows, vector<double>(num_buckets, 0.0));
+}
+
+void Edgehash::lower(double factor)
+{
+    for (int i = 0; i < num_rows; i++) {
+        for (int j = 0; j < num_buckets; j++) {
+            count[i][j] = count[i][j] * factor;
+        }
+    }
+}

data/vendor/MIDAS/edgehash.hpp

@@ -0,0 +1,25 @@
+#ifndef edgehash_hpp
+#define edgehash_hpp
+
+#include <vector>
+using namespace std;
+
+class Edgehash {
+public:
+    Edgehash(int r, int b, int m0);
+    ~Edgehash();
+    void insert(int a, int b, double weight);
+    double get_count(int a, int b);
+    void clear();
+    void lower(double factor);
+    int num_rows;
+    int num_buckets;
+    int m;
+
+private:
+    vector<int> hash_a, hash_b;
+    vector<std::vector<double> > count;
+    int hash(int a, int b, int i);
+};
+
+#endif /* edgehash_hpp */

data/vendor/MIDAS/main.cpp

@@ -0,0 +1,127 @@
+#include <iostream>
+#include <vector>
+#include "anom.hpp"
+#include "argparse.hpp"
+using namespace std;
+
+void load_data(vector<int>& src, vector<int>& dst, vector<int>& times, string input_file, bool undirected)
+{
+    FILE* infile = fopen(input_file.c_str(), "r");
+    if (infile == NULL) {
+        cerr << "Could not read file " << input_file << "\n";
+        exit(0);
+    }
+
+    int s, d, t;
+
+    if (undirected == false) {
+        while (fscanf(infile, "%d,%d,%d", &s, &d, &t) == 3) {
+            src.push_back(s);
+            dst.push_back(d);
+            times.push_back(t);
+        }
+        return;
+    }
+    else {
+        while (fscanf(infile, "%d:%d:%d", &s, &d, &t) == 3) {
+            src.push_back(s);
+            dst.push_back(d);
+            times.push_back(t);
+            src.push_back(d);
+            dst.push_back(s);
+            times.push_back(t);
+        }
+        return;
+    }
+}
+
+int main(int argc, const char* argv[])
+{
+    argparse::ArgumentParser program("midas");
+    program.add_argument("-i", "--input")
+        .required()
+        .help("Input File ");
+    program.add_argument("-o", "--output")
+        .default_value(string("scores.txt"))
+        .help("Output File. Default is scores.txt");
+    program.add_argument("-r", "--rows")
+        .default_value(2)
+        .action([](const std::string& value) { return std::stoi(value); })
+        .help("Number of rows/hash functions. Default is 2");
+    program.add_argument("-b", "--buckets")
+        .default_value(769)
+        .action([](const std::string& value) { return std::stoi(value); })
+        .help("Number of buckets. Default is 769");
+    program.add_argument("-a", "--alpha")
+        .default_value(0.6)
+        .action([](const std::string& value) { return std::stod(value); })
+        .help("Alpha: Temporal Decay Factor. Default is 0.6");
+    program.add_argument("--norelations")
+        .default_value(false)
+        .implicit_value(true)
+        .help("To run Midas instead of Midas-R.");
+    program.add_argument("--undirected")
+        .default_value(false)
+        .implicit_value(true)
+        .help("If graph is undirected.");
+    try {
+        program.parse_args(argc, argv);
+    }
+    catch (const std::runtime_error& err) {
+        std::cout << err.what() << std::endl;
+        program.print_help();
+        exit(0);
+    }
+
+    string input_file = program.get<string>("-i");
+    string output_file = program.get<string>("-o");
+    int rows = program.get<int>("-r");
+    int buckets = program.get<int>("-b");
+    double alpha = program.get<double>("-a");
+
+    if (rows < 1) {
+        cerr << "Number of hash functions should be positive." << endl;
+        exit(0);
+    }
+
+    if (buckets < 2) {
+        cerr << "Number of buckets should be atleast 2" << endl;
+        exit(0);
+    }
+
+    if (alpha <= 0 || alpha >= 1) {
+        cerr << "Alpha: Temporal Decay Factor must be between 0 and 1." << endl;
+        exit(0);
+    }
+
+    vector<int> src, dst, times;
+    if (program["--undirected"] == true)
+        load_data(src, dst, times, input_file, true);
+    else
+        load_data(src, dst, times, input_file, false);
+    cout << "Finished Loading Data from " << input_file << endl;
+
+    if (program["--norelations"] == true) {
+        clock_t start_time1 = clock();
+        vector<double>* scores = midas(src, dst, times, rows, buckets);
+        cout << "Time taken: " << ((double)(clock() - start_time1)) / CLOCKS_PER_SEC << " s" << endl;
+
+        cout << "Writing Anomaly Scores to " << output_file << endl;
+        FILE* outfile = fopen(output_file.c_str(), "w");
+        for (int i = 0; i < scores->size(); i++) {
+            fprintf(outfile, "%f\n", scores->at(i));
+        }
+    }
+    else {
+        clock_t start_time2 = clock();
+        vector<double>* scores2 = midasR(src, dst, times, rows, buckets, alpha);
+        cout << "Time taken: " << ((double)(clock() - start_time2)) / CLOCKS_PER_SEC << " s" << endl;
+        cout << "Writing Anomaly Scores to " << output_file << endl;
+        FILE* outfile2 = fopen(output_file.c_str(), "w");
+        for (int i = 0; i < scores2->size(); i++) {
+            fprintf(outfile2, "%f\n", scores2->at(i));
+        }
+    }
+
+    return 0;
+}

data/vendor/MIDAS/nodehash.cpp

@@ -0,0 +1,63 @@
+#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
+#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
+
+#include <iostream>
+#include "nodehash.hpp"
+
+Nodehash::Nodehash(int r, int b)
+{
+    num_rows = r;
+    num_buckets = b;
+    hash_a.resize(num_rows);
+    hash_b.resize(num_rows);
+    for (int i = 0; i < r; i++) {
+        // a is in [1, p-1]; b is in [0, p-1]
+        hash_a[i] = rand() % (num_buckets - 1) + 1;
+        hash_b[i] = rand() % num_buckets;
+    }
+    this->clear();
+}
+
+Nodehash::~Nodehash()
+{
+}
+
+int Nodehash::hash(int a, int i)
+{
+    int resid = (a * hash_a[i] + hash_b[i]) % num_buckets;
+    return resid + (resid < 0 ? num_buckets : 0);
+}
+
+void Nodehash::insert(int a, double weight)
+{
+    int bucket;
+    for (int i = 0; i < num_rows; i++) {
+        bucket = hash(a, i);
+        count[i][bucket] += weight;
+    }
+}
+
+double Nodehash::get_count(int a)
+{
+    double min_count = numeric_limits<double>::max();
+    int bucket;
+    for (int i = 0; i < num_rows; i++) {
+        bucket = hash(a, i);
+        min_count = MIN(min_count, count[i][bucket]);
+    }
+    return min_count;
+}
+
+void Nodehash::clear()
+{
+    count = vector<vector<double> >(num_rows, vector<double>(num_buckets, 0.0));
+}
+
+void Nodehash::lower(double factor)
+{
+    for (int i = 0; i < num_rows; i++) {
+        for (int j = 0; j < num_buckets; j++) {
+            count[i][j] = count[i][j] * factor;
+        }
+    }
+}

data/vendor/MIDAS/nodehash.hpp

@@ -0,0 +1,25 @@
+#ifndef nodehash_hpp
+#define nodehash_hpp
+
+#include <vector>
+using namespace std;
+
+class Nodehash {
+public:
+    Nodehash(int r, int b);
+    ~Nodehash();
+    void insert(int a, double weight);
+    double get_count(int a);
+    void clear();
+    void lower(double factor);
+    int num_rows;
+    int num_buckets;
+    int m;
+
+private:
+    vector<int> hash_a, hash_b;
+    vector<vector<double> > count;
+    int hash(int a, int i);
+};
+
+#endif /* nodehash_hpp */

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: midas-edge
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions:
+- ext/midas/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- NOTICE.txt
+- README.md
+- ext/midas/ext.cpp
+- ext/midas/extconf.rb
+- lib/midas-edge.rb
+- lib/midas/detector.rb
+- lib/midas/ext.bundle
+- lib/midas/version.rb
+- vendor/MIDAS/LICENSE
+- vendor/MIDAS/README.md
+- vendor/MIDAS/anom.cpp
+- vendor/MIDAS/anom.hpp
+- vendor/MIDAS/argparse.hpp
+- vendor/MIDAS/edgehash.cpp
+- vendor/MIDAS/edgehash.hpp
+- vendor/MIDAS/main.cpp
+- vendor/MIDAS/nodehash.cpp
+- vendor/MIDAS/nodehash.hpp
+homepage: https://github.com/ankane/midas
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Edge stream anomaly detection for Ruby
+test_files: []