isotree 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa5516ad971c1fc1def4766fdf39ec74121a20f6c95d9b7bda705707324a5571
-  data.tar.gz: c7aed404ad88d2e0365f7698cbad0a2d198a85860b9863d6322b10e53852f8a3
+  metadata.gz: a5974c65c4adc4fd79ee7770f324c906a2788534f3fe6f381d61711e7cdce78c
+  data.tar.gz: d401e7c5aaabcd5dcffd5e4f54d93ea4d0966698854e70d3475fd79a92e1e241
 SHA512:
-  metadata.gz: 92a74815ea52c38c0a4d0f27cb78524413cc32f966732c520590937f9523c253344e04673be280ff04659c7ed4a8db96560fba54fc425221b8542244e275ed33
-  data.tar.gz: a5824999e81a4732742646e66cdbae55812340667122b262c799bf3a5b243e9185445855ef64c31c877941d6427cd4fdfb7d77b4f87c2160b489ebe90aa18af6
+  metadata.gz: d00de0c3902b4f7fd3e13e08f0738ec4daf8be173f60cf46f49318e76f5be3c4ef3edd925f83074e03b4fe181aa6384d43c749f5f72247cf08d44f6811a6fe80
+  data.tar.gz: 70195ae442c2e4762b2f900a82a891d8f991ace1e521d625f910a1b5e3482334a299674c255e1aebf855728ee169ab5886428baf6df9a5e436bc73f3aff6dda6

data/CHANGELOG.md

@@ -1,3 +1,27 @@
-## 0.1.0 (unreleased)
+## 0.1.5 (2021-03-14)
+
+- Updated Isotree to 0.1.25
+- Added support for exporting and importing models
+
+## 0.1.4 (2020-08-22)
+
+- Added `missing_action`, `new_categ_action`, `categ_split_type`, `coefs`, `depth_imp`, and `weigh_imp_rows` options
+- Fixed signal handling
+
+## 0.1.3 (2020-08-13)
+
+- Added support for categorical data
+- Added support for Rover data frames
+- Added `output` option to `predict` method
+
+## 0.1.2 (2020-08-11)
+
+- Fixed outlier scores
+
+## 0.1.1 (2020-08-10)
+
+- Fixed installation error when cereal not installed
+
+## 0.1.0 (2020-08-10)
 
 - First release

data/LICENSE.txt

@@ -1,6 +1,7 @@
 BSD 2-Clause License
 
-Copyright (c) 2020, Andrew Kane
+Copyright (c) 2020, David Cortes
+Copyright (c) 2020-2021, Andrew Kane
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -1,9 +1,13 @@
 # IsoTree
 
-:evergreen_tree: [IsoTree](https://github.com/david-cortes/isotree) - outlier/anomaly detection for using Isolation Forest - for Ruby
+:evergreen_tree: [IsoTree](https://github.com/david-cortes/isotree) - outlier/anomaly detection using Isolation Forest - for Ruby
 
 Learn how [Isolation Forest](https://www.youtube.com/watch?v=RyFQXQf4w4w) works
 
+:deciduous_tree: Check out [OutlierTree](https://github.com/ankane/outliertree) for human-readable explanations of outliers
+
+[![Build Status](https://github.com/ankane/isotree/workflows/build/badge.svg?branch=master)](https://github.com/ankane/isotree/actions)
+
 ## Installation
 
 Add this line to your application’s Gemfile:
@@ -17,24 +21,40 @@ gem 'isotree'
 Prep your data
 
 ```ruby
-x = [[1, 2], [3, 4], [5, 6], [7, 8]]
+data = [
+  {department: "Books",  sale: false, price: 2.50},
+  {department: "Books",  sale: true,  price: 3.00},
+  {department: "Movies", sale: false, price: 5.00}
+]
 ```
 
 Train a model
 
 ```ruby
 model = IsoTree::IsolationForest.new
-model.fit(x)
+model.fit(data)
 ```
 
 Get outlier scores
 
 ```ruby
-model.predict(x)
+model.predict(data)
 ```
 
 Scores are between 0 and 1, with higher scores indicating outliers
 
+Export the model
+
+```ruby
+model.export_model("model.bin")
+```
+
+Import a model
+
+```ruby
+model = IsoTree::IsolationForest.import_model("model.bin")
+```
+
 ## Parameters
 
 Pass parameters - default values below
@@ -50,12 +70,18 @@ IsoTree::IsolationForest.new(
   prob_split_avg_gain: 0,
   prob_split_pooled_gain: 0,
   min_gain: 0,
+  missing_action: "impute",
+  new_categ_action: "smallest",
+  categ_split_type: "subset",
   all_perm: false,
   coef_by_prop: false,
   sample_with_replacement: false,
   penalize_range: true,
   weigh_by_kurtosis: false,
+  coefs: "normal",
   min_imp_obs: 3,
+  depth_imp: "higher",
+  weigh_imp_rows: "inverse",
   random_seed: 1,
   nthreads: -1
 )
@@ -65,10 +91,20 @@ See a [detailed explanation](https://isotree.readthedocs.io/en/latest/#isotree.I
 
 ## Data
 
-Data can be an array of arrays
+Data can be an array of hashes
+
+```ruby
+[
+  {department: "Books",  sale: false, price: 2.50},
+  {department: "Books",  sale: true,  price: 3.00},
+  {department: "Movies", sale: false, price: 5.00}
+]
+```
+
+Or a Rover data frame
 
 ```ruby
-[[1, 2, 3], [4, 5, 6]]
+Rover.read_csv("data.csv")
 ```
 
 Or a Numo array
@@ -87,6 +123,28 @@ brew install libomp
 
 Then reinstall the gem.
 
+```sh
+gem uninstall isotree --force
+bundle install
+```
+
+## Deployment
+
+Check out [Trove](https://github.com/ankane/trove) for deploying models.
+
+```sh
+trove push model.bin
+trove push model.bin.metadata
+```
+
+## Reference
+
+Get the average isolation depth
+
+```ruby
+model.predict(data, output: "avg_depth")
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/isotree/blob/master/CHANGELOG.md)

data/ext/isotree/ext.cpp

@@ -5,17 +5,77 @@
 #include <rice/Array.hpp>
 #include <rice/Hash.hpp>
 #include <rice/Module.hpp>
+#include <rice/Object.hpp>
 #include <rice/String.hpp>
 #include <rice/Symbol.hpp>
 
 using Rice::Array;
 using Rice::Hash;
 using Rice::Module;
+using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 using Rice::define_class_under;
 using Rice::define_module;
 
+template<>
+NewCategAction from_ruby<NewCategAction>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "weighted") return Weighted;
+  if (value == "smallest") return Smallest;
+  if (value == "random") return Random;
+  throw std::runtime_error("Unknown new categ action: " + value);
+}
+
+template<>
+MissingAction from_ruby<MissingAction>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "divide") return Divide;
+  if (value == "impute") return Impute;
+  if (value == "fail") return Fail;
+  throw std::runtime_error("Unknown missing action: " + value);
+}
+
+template<>
+CategSplit from_ruby<CategSplit>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "subset") return SubSet;
+  if (value == "single_categ") return SingleCateg;
+  throw std::runtime_error("Unknown categ split: " + value);
+}
+
+template<>
+CoefType from_ruby<CoefType>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "uniform") return Uniform;
+  if (value == "normal") return Normal;
+  throw std::runtime_error("Unknown coef type: " + value);
+}
+
+template<>
+UseDepthImp from_ruby<UseDepthImp>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "lower") return Lower;
+  if (value == "higher") return Higher;
+  if (value == "same") return Same;
+  throw std::runtime_error("Unknown depth imp: " + value);
+}
+
+template<>
+WeighImpRows from_ruby<WeighImpRows>(Object x)
+{
+  auto value = x.to_s().str();
+  if (value == "inverse") return Inverse;
+  if (value == "prop") return Prop;
+  if (value == "flat") return Flat;
+  throw std::runtime_error("Unknown weight imp rows: " + value);
+}
+
 extern "C"
 void Init_ext()
 {
@@ -33,36 +93,28 @@ void Init_ext()
 
         // 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;
+        size_t ncols_numeric = options.get<size_t, Symbol>("ncols_numeric");
+        size_t ncols_categ = options.get<size_t, Symbol>("ncols_categ");
+
+        double *restrict numeric_data = NULL;
+        if (ncols_numeric > 0) {
+          numeric_data = (double*) options.get<String, Symbol>("numeric_data").c_str();
+        }
+
+        int *restrict categorical_data = NULL;
+        int *restrict ncat = NULL;
+        if (ncols_categ > 0) {
+          categorical_data = (int*) options.get<String, Symbol>("categorical_data").c_str();
+          ncat = (int*) options.get<String, Symbol>("ncat").c_str();
+        }
+
+        // not used (sparse matrices)
         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
+        // Rice has limit of 14 arguments, so use hash
         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");
@@ -72,21 +124,41 @@ void Init_ext()
         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");
+        MissingAction missing_action = options.get<MissingAction, Symbol>("missing_action");
+        CategSplit cat_split_type = options.get<CategSplit, Symbol>("categ_split_type");
+        NewCategAction new_cat_action = options.get<NewCategAction, Symbol>("new_categ_action");
         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");
+        CoefType coef_type = options.get<CoefType, Symbol>("coefs");
         size_t min_imp_obs = options.get<size_t, Symbol>("min_imp_obs");
+        UseDepthImp depth_imp = options.get<UseDepthImp, Symbol>("depth_imp");
+        WeighImpRows weigh_imp_rows = options.get<WeighImpRows, Symbol>("weigh_imp_rows");
         uint64_t random_seed = options.get<uint64_t, Symbol>("random_seed");
         int nthreads = options.get<int, Symbol>("nthreads");
 
+        // TODO options
+        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;
+        Imputer *imputer = NULL;
+        bool impute_at_fit = false;
+        bool handle_interrupt = false;
+
         fit_iforest(
           NULL,
           &iso,
           numeric_data,
           ncols_numeric,
-          categ_data,
+          categorical_data,
           ncols_categ,
           ncat,
           Xc,
@@ -126,6 +198,7 @@ void Init_ext()
           weigh_imp_rows,
           impute_at_fit,
           random_seed,
+          handle_interrupt,
           nthreads
         );
 
@@ -136,8 +209,20 @@ void Init_ext()
       *[](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;
+        size_t ncols_numeric = options.get<size_t, Symbol>("ncols_numeric");
+        size_t ncols_categ = options.get<size_t, Symbol>("ncols_categ");
+
+        double *restrict numeric_data = NULL;
+        if (ncols_numeric > 0) {
+          numeric_data = (double*) options.get<String, Symbol>("numeric_data").c_str();
+        }
+
+        int *restrict categorical_data = NULL;
+        if (ncols_categ > 0) {
+          categorical_data = (int*) options.get<String, Symbol>("categorical_data").c_str();
+        }
+
+        // not used (sparse matrices)
         double* Xc = NULL;
         sparse_ix* Xc_ind = NULL;
         sparse_ix* Xc_indptr = NULL;
@@ -147,13 +232,13 @@ void Init_ext()
 
         // options
         int nthreads = options.get<int, Symbol>("nthreads");
-        bool standardize = true;
+        bool standardize = options.get<bool, Symbol>("standardize");
         std::vector<double> outlier_scores(nrows);
         sparse_ix* tree_num = NULL;
 
         predict_iforest(
           numeric_data,
-          categ_data,
+          categorical_data,
           Xc,
           Xc_ind,
           Xc_indptr,
@@ -174,5 +259,29 @@ void Init_ext()
           ret.push(outlier_scores[i]);
         }
         return ret;
+      })
+    .define_singleton_method(
+      "serialize_ext_isoforest",
+      *[](ExtIsoForest& iso, String path) {
+        #ifdef _MSC_VER
+        // TODO convert to wchar_t
+        throw std::runtime_error("Not supported on Windows yet");
+        #else
+        serialize_ext_isoforest(iso, path.c_str());
+        #endif
+      })
+    .define_singleton_method(
+      "deserialize_ext_isoforest",
+      *[](String path) {
+        ExtIsoForest iso;
+
+        #ifdef _MSC_VER
+        // TODO convert to wchar_t
+        throw std::runtime_error("Not supported on Windows yet");
+        #else
+        deserialize_ext_isoforest(iso, path.c_str());
+        #endif
+
+        return iso;
       });
 }

data/ext/isotree/extconf.rb

@@ -12,10 +12,11 @@ end
 
 ext = File.expand_path(".", __dir__)
 isotree = File.expand_path("../../vendor/isotree/src", __dir__)
+cereal = File.expand_path("../../vendor/cereal/include", __dir__)
 
 exclude = %w(Rwrapper.cpp RcppExports.cpp)
 $srcs = Dir["{#{ext},#{isotree}}/*.{cc,cpp}"].reject { |f| exclude.include?(File.basename(f)) }
-$INCFLAGS << " -I#{isotree}"
+$INCFLAGS << " -I#{isotree} -I#{cereal}"
 $VPATH << isotree
 
 create_makefile("isotree/ext")

data/lib/isotree.rb

@@ -3,7 +3,9 @@ require "isotree/ext"
 
 # stdlib
 require "etc"
+require "json"
 
 # modules
+require "isotree/dataset"
 require "isotree/isolation_forest"
 require "isotree/version"