isotree 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b15de55d1a752d14cc97e2b5372308b2d4cb6a1e6fcfce0a05da6f769708b189
-  data.tar.gz: af21414cea40a26b2e291230e5d48bf4f804e1c77837a3132921b896bc617961
+  metadata.gz: ffdc3a4283698bfc43c5563bd1c8cb4dd41881ec0a9920bfbe91f01fcbe0e822
+  data.tar.gz: 83cc4a38f6640fd5a37c2a6aabe0cba12e198bdbd7b010cabb34f8d36073a74b
 SHA512:
-  metadata.gz: 8127b5402c9c9f03bd2bd475b01a5cc8fbd3900ac1517d401ff4647d634e1f1049c8de51086095b132f30217f3571f8aa9e84c5fd18a0d3ac420a84203da85b7
-  data.tar.gz: 63b26ee19d8c49ce33d61891110db56597221a776830eb2aaad84c6d46038cb30822431a6f30b1051289f6becab0b652d968fbd4cf065c0925d50d5ef769c89a
+  metadata.gz: b6642570d6330fc2d72b210a040985dfa025d5d0deed622d04533fe9bf830c6cd3dda1ace94ace3d034c8302aa360e5ef6eeda576b48340db4d6c95016b8979c
+  data.tar.gz: df0716c317e01bd174157e5c1b09e4f4e566f07512ea3861324b8fa9659a416c6ef1319580d2ee8a7231c74f74b9a9e5bdc9770a5adf0d208b82a22db1a9b29d

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.2.1 (2021-05-23)
+
+- Improved performance
+
+## 0.2.0 (2021-05-17)
+
+- Updated to Rice 4
+- Dropped support for Ruby < 2.6
+
+## 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

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

@@ -4,7 +4,9 @@
 
 Learn how [Isolation Forest](https://www.youtube.com/watch?v=RyFQXQf4w4w) works
 
-[![Build Status](https://travis-ci.org/ankane/isotree.svg?branch=master)](https://travis-ci.org/ankane/isotree)
+: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
 
@@ -19,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
@@ -52,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
 )
@@ -67,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
-[[1, 2, 3], [4, 5, 6]]
+[
+  {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
+Rover.read_csv("data.csv")
 ```
 
 Or a Numo array
@@ -94,6 +128,23 @@ 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

@@ -2,20 +2,102 @@
 #include <isotree.hpp>
 
 // rice
-#include <rice/Array.hpp>
-#include <rice/Hash.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
-#include <rice/Symbol.hpp>
+#include <rice/rice.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;
 
+namespace Rice::detail
+{
+  template<>
+  class From_Ruby<NewCategAction>
+  {
+  public:
+    NewCategAction convert(VALUE x)
+    {
+      auto value = Object(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<>
+  class From_Ruby<MissingAction>
+  {
+  public:
+    MissingAction convert(VALUE x)
+    {
+      auto value = Object(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<>
+  class From_Ruby<CategSplit>
+  {
+  public:
+    CategSplit convert(VALUE x)
+    {
+      auto value = Object(x).to_s().str();
+      if (value == "subset") return SubSet;
+      if (value == "single_categ") return SingleCateg;
+      throw std::runtime_error("Unknown categ split: " + value);
+    }
+  };
+
+  template<>
+  class From_Ruby<CoefType>
+  {
+  public:
+    CoefType convert(VALUE x)
+    {
+      auto value = Object(x).to_s().str();
+      if (value == "uniform") return Uniform;
+      if (value == "normal") return Normal;
+      throw std::runtime_error("Unknown coef type: " + value);
+    }
+  };
+
+  template<>
+  class From_Ruby<UseDepthImp>
+  {
+  public:
+    UseDepthImp convert(VALUE x)
+    {
+      auto value = Object(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<>
+  class From_Ruby<WeighImpRows>
+  {
+  public:
+    WeighImpRows convert(VALUE x)
+    {
+      auto value = Object(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()
 {
@@ -25,44 +107,36 @@ void Init_ext()
   define_class_under<ExtIsoForest>(rb_mExt, "ExtIsoForest");
 
   rb_mExt
-    .define_singleton_method(
+    .define_singleton_function(
       "fit_iforest",
-      *[](Hash options) {
+      [](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;
+        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 +146,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,18 +220,31 @@ void Init_ext()
           weigh_imp_rows,
           impute_at_fit,
           random_seed,
+          handle_interrupt,
           nthreads
         );
 
         return iso;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "predict_iforest",
-      *[](ExtIsoForest& iso, Hash options) {
+      [](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 +254,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 +281,29 @@ void Init_ext()
           ret.push(outlier_scores[i]);
         }
         return ret;
+      })
+    .define_singleton_function(
+      "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_function(
+      "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;
       });
 }