isotree 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa5516ad971c1fc1def4766fdf39ec74121a20f6c95d9b7bda705707324a5571
+  data.tar.gz: c7aed404ad88d2e0365f7698cbad0a2d198a85860b9863d6322b10e53852f8a3
+SHA512:
+  metadata.gz: 92a74815ea52c38c0a4d0f27cb78524413cc32f966732c520590937f9523c253344e04673be280ff04659c7ed4a8db96560fba54fc425221b8542244e275ed33
+  data.tar.gz: a5824999e81a4732742646e66cdbae55812340667122b262c799bf3a5b243e9185445855ef64c31c877941d6427cd4fdfb7d77b4f87c2160b489ebe90aa18af6

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (unreleased)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2020, Andrew Kane
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,111 @@
+# IsoTree
+
+:evergreen_tree: [IsoTree](https://github.com/david-cortes/isotree) - outlier/anomaly detection for using Isolation Forest - for Ruby
+
+Learn how [Isolation Forest](https://www.youtube.com/watch?v=RyFQXQf4w4w) works
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'isotree'
+```
+
+## Getting Started
+
+Prep your data
+
+```ruby
+x = [[1, 2], [3, 4], [5, 6], [7, 8]]
+```
+
+Train a model
+
+```ruby
+model = IsoTree::IsolationForest.new
+model.fit(x)
+```
+
+Get outlier scores
+
+```ruby
+model.predict(x)
+```
+
+Scores are between 0 and 1, with higher scores indicating outliers
+
+## Parameters
+
+Pass parameters - default values below
+
+```ruby
+IsoTree::IsolationForest.new(
+  sample_size: nil,
+  ntrees: 500,
+  ndim: 3,
+  ntry: 3,
+  prob_pick_avg_gain: 0,
+  prob_pick_pooled_gain: 0,
+  prob_split_avg_gain: 0,
+  prob_split_pooled_gain: 0,
+  min_gain: 0,
+  all_perm: false,
+  coef_by_prop: false,
+  sample_with_replacement: false,
+  penalize_range: true,
+  weigh_by_kurtosis: false,
+  min_imp_obs: 3,
+  random_seed: 1,
+  nthreads: -1
+)
+```
+
+See a [detailed explanation](https://isotree.readthedocs.io/en/latest/#isotree.IsolationForest)
+
+## Data
+
+Data can be an array of arrays
+
+```ruby
+[[1, 2, 3], [4, 5, 6]]
+```
+
+Or a Numo array
+
+```ruby
+Numo::NArray.cast([[1, 2, 3], [4, 5, 6]])
+```
+
+## Performance
+
+IsoTree uses OpenMP when possible for best performance. To enable OpenMP on Mac, run:
+
+```sh
+brew install libomp
+```
+
+Then reinstall the gem.
+
+## History
+
+View the [changelog](https://github.com/ankane/isotree/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/isotree/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/isotree/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone --recursive https://github.com/ankane/isotree.git
+cd isotree
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/isotree/ext.cpp

@@ -0,0 +1,178 @@
+// isotree
+#include <isotree.hpp>
+
+// rice
+#include <rice/Array.hpp>
+#include <rice/Hash.hpp>
+#include <rice/Module.hpp>
+#include <rice/String.hpp>
+#include <rice/Symbol.hpp>
+
+using Rice::Array;
+using Rice::Hash;
+using Rice::Module;
+using Rice::String;
+using Rice::Symbol;
+using Rice::define_class_under;
+using Rice::define_module;
+
+extern "C"
+void Init_ext()
+{
+  Module rb_mIsoTree = define_module("IsoTree");
+
+  Module rb_mExt = define_module_under(rb_mIsoTree, "Ext");
+  define_class_under<ExtIsoForest>(rb_mExt, "ExtIsoForest");
+
+  rb_mExt
+    .define_singleton_method(
+      "fit_iforest",
+      *[](Hash options) {
+        // model
+        ExtIsoForest iso;
+
+        // data
+        size_t nrows = options.get<size_t, Symbol>("nrows");
+        size_t ncols = options.get<size_t, Symbol>("ncols");
+        double* numeric_data = (double*) options.get<String, Symbol>("numeric_data").c_str();
+        size_t ncols_numeric = ncols;
+        int* categ_data = NULL;
+        size_t ncols_categ = 0;
+        int* ncat = NULL;
+        double* Xc = NULL;
+        sparse_ix* Xc_ind = NULL;
+        sparse_ix* Xc_indptr = NULL;
+
+        // options
+        CoefType coef_type = Normal;
+        double* sample_weights = NULL;
+        bool weight_as_sample = false;
+        size_t max_depth = 0;
+        bool limit_depth = true;
+        bool standardize_dist = false;
+        double* tmat = NULL;
+        double* output_depths = NULL;
+        bool standardize_depth = false;
+        double* col_weights = NULL;
+        MissingAction missing_action = Impute;
+        CategSplit cat_split_type = SubSet;
+        NewCategAction new_cat_action = Smallest;
+        Imputer *imputer = NULL;
+        UseDepthImp depth_imp = Higher;
+        WeighImpRows weigh_imp_rows = Inverse;
+        bool impute_at_fit = false;
+
+        // Rice has limit of 14 arguments, so use hash for options
+        size_t sample_size = options.get<size_t, Symbol>("sample_size");
+        size_t ndim = options.get<size_t, Symbol>("ndim");
+        size_t ntrees = options.get<size_t, Symbol>("ntrees");
+        size_t ntry = options.get<size_t, Symbol>("ntry");
+        double prob_pick_by_gain_avg = options.get<double, Symbol>("prob_pick_avg_gain");
+        double prob_split_by_gain_avg = options.get<double, Symbol>("prob_split_avg_gain");
+        double prob_pick_by_gain_pl = options.get<double, Symbol>("prob_pick_pooled_gain");
+        double prob_split_by_gain_pl = options.get<double, Symbol>("prob_split_pooled_gain");
+        double min_gain = options.get<double, Symbol>("min_gain");
+        bool all_perm = options.get<bool, Symbol>("all_perm");
+        bool coef_by_prop = options.get<bool, Symbol>("coef_by_prop");
+        bool with_replacement = options.get<bool, Symbol>("sample_with_replacement");
+        bool penalize_range = options.get<bool, Symbol>("penalize_range");
+        bool weigh_by_kurt = options.get<bool, Symbol>("weigh_by_kurtosis");
+        size_t min_imp_obs = options.get<size_t, Symbol>("min_imp_obs");
+        uint64_t random_seed = options.get<uint64_t, Symbol>("random_seed");
+        int nthreads = options.get<int, Symbol>("nthreads");
+
+        fit_iforest(
+          NULL,
+          &iso,
+          numeric_data,
+          ncols_numeric,
+          categ_data,
+          ncols_categ,
+          ncat,
+          Xc,
+          Xc_ind,
+          Xc_indptr,
+          ndim,
+          ntry,
+          coef_type,
+          coef_by_prop,
+          sample_weights,
+          with_replacement,
+          weight_as_sample,
+          nrows,
+          sample_size,
+          ntrees,
+          max_depth,
+          limit_depth,
+          penalize_range,
+          standardize_dist,
+          tmat,
+          output_depths,
+          standardize_depth,
+          col_weights,
+          weigh_by_kurt,
+          prob_pick_by_gain_avg,
+          prob_split_by_gain_avg,
+          prob_pick_by_gain_pl,
+          prob_split_by_gain_pl,
+          min_gain,
+          missing_action,
+          cat_split_type,
+          new_cat_action,
+          all_perm,
+          imputer,
+          min_imp_obs,
+          depth_imp,
+          weigh_imp_rows,
+          impute_at_fit,
+          random_seed,
+          nthreads
+        );
+
+        return iso;
+      })
+    .define_singleton_method(
+      "predict_iforest",
+      *[](ExtIsoForest& iso, Hash options) {
+        // data
+        size_t nrows = options.get<size_t, Symbol>("nrows");
+        double* numeric_data = (double*) options.get<String, Symbol>("numeric_data").c_str();
+        int* categ_data = NULL;
+        double* Xc = NULL;
+        sparse_ix* Xc_ind = NULL;
+        sparse_ix* Xc_indptr = NULL;
+        double* Xr = NULL;
+        sparse_ix* Xr_ind = NULL;
+        sparse_ix* Xr_indptr = NULL;
+
+        // options
+        int nthreads = options.get<int, Symbol>("nthreads");
+        bool standardize = true;
+        std::vector<double> outlier_scores(nrows);
+        sparse_ix* tree_num = NULL;
+
+        predict_iforest(
+          numeric_data,
+          categ_data,
+          Xc,
+          Xc_ind,
+          Xc_indptr,
+          Xr,
+          Xr_ind,
+          Xr_indptr,
+          nrows,
+          nthreads,
+          standardize,
+          NULL,
+          &iso,
+          outlier_scores.data(),
+          tree_num
+        );
+
+        Array ret;
+        for (size_t i = 0; i < outlier_scores.size(); i++) {
+          ret.push(outlier_scores[i]);
+        }
+        return ret;
+      });
+}

data/ext/isotree/extconf.rb

@@ -0,0 +1,21 @@
+require "mkmf-rice"
+
+$CXXFLAGS += " -std=c++11 -D_USE_MERSENNE_TWISTER -D_ENABLE_CEREAL"
+
+apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
+
+# check omp first
+if have_library("omp") || have_library("gomp")
+  $CXXFLAGS += " -Xclang" if apple_clang
+  $CXXFLAGS += " -fopenmp"
+end
+
+ext = File.expand_path(".", __dir__)
+isotree = File.expand_path("../../vendor/isotree/src", __dir__)
+
+exclude = %w(Rwrapper.cpp RcppExports.cpp)
+$srcs = Dir["{#{ext},#{isotree}}/*.{cc,cpp}"].reject { |f| exclude.include?(File.basename(f)) }
+$INCFLAGS << " -I#{isotree}"
+$VPATH << isotree
+
+create_makefile("isotree/ext")

data/lib/isotree.rb

@@ -0,0 +1,9 @@
+# ext
+require "isotree/ext"
+
+# stdlib
+require "etc"
+
+# modules
+require "isotree/isolation_forest"
+require "isotree/version"

data/lib/isotree/isolation_forest.rb

@@ -0,0 +1,94 @@
+module IsoTree
+  class IsolationForest
+    def initialize(
+      sample_size: nil, ntrees: 500, ndim: 3, ntry: 3,
+      prob_pick_avg_gain: 0, prob_pick_pooled_gain: 0,
+      prob_split_avg_gain: 0, prob_split_pooled_gain: 0,
+      min_gain: 0, all_perm: false, coef_by_prop: false,
+      sample_with_replacement: false, penalize_range: true,
+      weigh_by_kurtosis: false, min_imp_obs: 3, random_seed: 1, nthreads: -1
+    )
+
+      @sample_size = sample_size
+      @ntrees = ntrees
+      @ndim = ndim
+      @ntry = ntry
+      @prob_pick_avg_gain = prob_pick_avg_gain
+      @prob_pick_pooled_gain = prob_pick_pooled_gain
+      @prob_split_avg_gain = prob_split_avg_gain
+      @prob_split_pooled_gain = prob_split_pooled_gain
+      @min_gain = min_gain
+      @all_perm = all_perm
+      @coef_by_prop = coef_by_prop
+      @sample_with_replacement = sample_with_replacement
+      @penalize_range = penalize_range
+      @weigh_by_kurtosis = weigh_by_kurtosis
+      @min_imp_obs = min_imp_obs
+      @random_seed = random_seed
+
+      # etc module returns virtual cores
+      nthreads = Etc.nprocessors if nthreads < 0
+      @nthreads = nthreads
+    end
+
+    def fit(x)
+      options = data_options(x).merge(fit_options)
+      options[:sample_size] ||= options[:nrows]
+      @ncols = options[:ncols]
+      @ext_iso_forest = Ext.fit_iforest(options)
+    end
+
+    def predict(x)
+      raise "Not fit" unless @ext_iso_forest
+      options = data_options(x).merge(nthreads: @nthreads)
+      if options[:ncols] != @ncols
+        raise ArgumentError, "Input must have #{@ncols} columns for this model"
+      end
+      Ext.predict_iforest(@ext_iso_forest, options)
+    end
+
+    private
+
+    # TODO support categorical data
+    def data_options(x)
+      if defined?(Numo::NArray) && x.is_a?(Numo::NArray)
+        raise ArgumentError, "Input must have 2 dimensions" if x.ndim != 2
+        x = x.cast_to(Numo::DFloat)
+        numeric_data = x.to_binary
+        nrows, ncols = x.shape
+      else
+        x = x.to_a
+        nrows = x.size
+        ncols = x.first ? x.first.size : 0
+        if x.any? { |r| r.size != ncols }
+          raise ArgumentError, "All rows must have the same number of columns"
+        end
+        numeric_data = x.flatten(1).pack("d*")
+      end
+      raise ArgumentError, "No data" if nrows == 0
+
+      {
+        nrows: nrows,
+        ncols: ncols,
+        numeric_data: numeric_data
+      }
+    end
+
+    def fit_options
+      keys = %i(
+        sample_size ntrees ndim ntry
+        prob_pick_avg_gain prob_pick_pooled_gain
+        prob_split_avg_gain prob_split_pooled_gain
+        min_gain all_perm coef_by_prop
+        sample_with_replacement penalize_range
+        weigh_by_kurtosis min_imp_obs
+        random_seed nthreads
+      )
+      options = {}
+      keys.each do |k|
+        options[k] = instance_variable_get("@#{k}")
+      end
+      options
+    end
+  end
+end