isotree 0.2.2 → 0.3.0

data/vendor/isotree/src/sql.cpp

@@ -18,11 +18,29 @@
 *     [5] https://sourceforge.net/projects/iforest/
 *     [6] https://math.stackexchange.com/questions/3388518/expected-number-of-paths-required-to-separate-elements-in-a-binary-tree
 *     [7] Quinlan, J. Ross. C4. 5: programs for machine learning. Elsevier, 2014.
-*     [8] Cortes, David. "Distance approximation using Isolation Forests." arXiv preprint arXiv:1910.12362 (2019).
-*     [9] Cortes, David. "Imputing missing values with unsupervised random trees." arXiv preprint arXiv:1911.06646 (2019).
+*     [8] Cortes, David.
+*         "Distance approximation using Isolation Forests."
+*         arXiv preprint arXiv:1910.12362 (2019).
+*     [9] Cortes, David.
+*         "Imputing missing values with unsupervised random trees."
+*         arXiv preprint arXiv:1911.06646 (2019).
+*     [10] https://math.stackexchange.com/questions/3333220/expected-average-depth-in-random-binary-tree-constructed-top-to-bottom
+*     [11] Cortes, David.
+*          "Revisiting randomized choices in isolation forests."
+*          arXiv preprint arXiv:2110.13402 (2021).
+*     [12] Guha, Sudipto, et al.
+*          "Robust random cut forest based anomaly detection on streams."
+*          International conference on machine learning. PMLR, 2016.
+*     [13] Cortes, David.
+*          "Isolation forests: looking beyond tree depth."
+*          arXiv preprint arXiv:2111.11639 (2021).
+*     [14] Ting, Kai Ming, Yue Zhu, and Zhi-Hua Zhou.
+*          "Isolation kernel and its effect on SVM"
+*          Proceedings of the 24th ACM SIGKDD
+*          International Conference on Knowledge Discovery & Data Mining. 2018.
 * 
 *     BSD 2-Clause License
-*     Copyright (c) 2020, David Cortes
+*     Copyright (c) 2019-2022, David Cortes
 *     All rights reserved.
 *     Redistribution and use in source and binary forms, with or without
 *     modification, are permitted provided that the following conditions are met:
@@ -93,7 +111,26 @@ std::string generate_sql_with_select_from(IsoForest *model_outputs, ExtIsoForest
                                                        categ_levels,
                                                        false, index1, false, 0,
                                                        nthreads);
-    std::string out = std::accumulate(tree_conds.begin(), tree_conds.end(), std::string("SELECT\nPOWER(2.0, -(0.0"),
+    bool is_density = (model_outputs != NULL && model_outputs->scoring_metric == Density) ||
+                      (model_outputs_ext != NULL && model_outputs_ext->scoring_metric == Density);
+    bool is_bdens   = (model_outputs != NULL && model_outputs->scoring_metric == BoxedDensity) ||
+                      (model_outputs_ext != NULL && model_outputs_ext->scoring_metric == BoxedDensity);
+    bool is_bdens2  = (model_outputs != NULL && model_outputs->scoring_metric == BoxedDensity) ||
+                      (model_outputs_ext != NULL && model_outputs_ext->scoring_metric == BoxedDensity);
+    bool is_bratio  = (model_outputs != NULL && model_outputs->scoring_metric == BoxedRatio) ||
+                      (model_outputs_ext != NULL && model_outputs_ext->scoring_metric == BoxedRatio);
+    is_density = is_density || is_bdens2;
+    std::string out = std::accumulate(tree_conds.begin(), tree_conds.end(),
+                                      is_density?
+                                          std::string("SELECT\n(-(0.0")
+                                          :
+                                          (is_bdens?
+                                               std::string("SELECT\n((0.0")
+                                               :
+                                               (is_bratio?
+                                                    std::string("SELECT\n((0.0")
+                                                    :
+                                                    std::string("SELECT\nPOWER(2.0, -(0.0"))),
                                       [&tree_conds, &index1](std::string &a, std::string &b)
                                       {return a
                                                 + std::string(" + \n---BEGIN TREE ")
@@ -104,11 +141,11 @@ std::string generate_sql_with_select_from(IsoForest *model_outputs, ExtIsoForest
                                                 + std::to_string((size_t)std::distance(tree_conds.data(), &b) + (size_t)index1)
                                                 + std::string("---\n");});
     size_t ntrees = (model_outputs != NULL)? (model_outputs->trees.size()) : (model_outputs_ext->hplanes.size());
-   return
+    return
        out
         + std::string(") / ")
-        + std::to_string((long double)ntrees * ((model_outputs != NULL)?
-                                                (model_outputs->exp_avg_depth) : (model_outputs_ext->exp_avg_depth)))
+        + std::to_string((double)ntrees * ((model_outputs != NULL)?
+                                           (model_outputs->exp_avg_depth) : (model_outputs_ext->exp_avg_depth)))
         + std::string(") AS ")
         + select_as
         + std::string("\nFROM ")
@@ -174,13 +211,13 @@ std::vector<std::string> generate_sql(IsoForest *model_outputs, ExtIsoForest *mo
     size_t_for loop_end = ntrees_use;
     if (single_tree)
     {
-        loop_st = tree_num;
+        loop_st = tree_num - index1;
         loop_end = loop_st + 1;
     }
 
     /* determine maximum number of nodes in a tree */
     size_t max_nodes = 0;
-    for (size_t tree = loop_st; tree < loop_end; tree++)
+    for (size_t tree = loop_st; tree < (size_t)loop_end; tree++)
         max_nodes = std::max(max_nodes,
                              (model_outputs != NULL)?
                                 (model_outputs->trees[tree].size()) : (model_outputs_ext->hplanes[tree].size()));
@@ -192,80 +229,111 @@ std::vector<std::string> generate_sql(IsoForest *model_outputs, ExtIsoForest *mo
 
     size_t tree_use;
 
+    bool threw_exception = false;
+    std::exception_ptr ex = NULL;
+
     #pragma omp parallel for schedule(dynamic) num_threads(nthreads) \
             shared(model_outputs, model_outputs_ext, numeric_colnames, categ_colnames, categ_levels, \
-                   loop_st, loop_end, index1, single_tree, all_node_rules, out) \
+                   loop_st, loop_end, index1, single_tree, all_node_rules, out, ex, threw_exception) \
             firstprivate(conditions_left, conditions_right) private(tree_use)
     for (size_t_for tree = loop_st; tree < loop_end; tree++)
     {
-        if (model_outputs != NULL)
-        {
-            for (size_t node = 0; node < model_outputs->trees[tree].size(); node++)
-                extract_cond_isotree(*model_outputs, model_outputs->trees[tree][node],
-                                     conditions_left[node], conditions_right[node],
-                                     numeric_colnames, categ_colnames,
-                                     categ_levels);
-        }
-
-        else
+        if (threw_exception) continue;
+        
+        try
         {
-            for (size_t node = 0; node < model_outputs_ext->hplanes[tree].size(); node++)
-                extract_cond_ext_isotree(*model_outputs_ext, model_outputs_ext->hplanes[tree][node],
+            if (model_outputs != NULL)
+            {
+                for (size_t node = 0; node < model_outputs->trees[tree].size(); node++)
+                    extract_cond_isotree(*model_outputs, model_outputs->trees[tree][node],
                                          conditions_left[node], conditions_right[node],
                                          numeric_colnames, categ_colnames,
                                          categ_levels);
-        }
+            }
 
-        generate_tree_rules(
-            (model_outputs == NULL)? (NULL) : &(model_outputs->trees[tree]),
-            (model_outputs_ext == NULL)? (NULL) : &(model_outputs_ext->hplanes[tree]),
-            output_score,
-            0, index1, initial_str, all_node_rules[single_tree? 0 : tree],
-            conditions_left, conditions_right
-        );
+            else
+            {
+                for (size_t node = 0; node < model_outputs_ext->hplanes[tree].size(); node++)
+                    extract_cond_ext_isotree(*model_outputs_ext, model_outputs_ext->hplanes[tree][node],
+                                             conditions_left[node], conditions_right[node],
+                                             numeric_colnames, categ_colnames,
+                                             categ_levels);
+            }
 
-        /* Code below doesn't compile with MSVC (stuck with an OMP standard that's >20 years old) */
-        // if (single_tree)
-        //     tree = 0;
-        tree_use = single_tree? (size_t)0 : tree;
+            generate_tree_rules(
+                (model_outputs == NULL)? (NULL) : &(model_outputs->trees[tree]),
+                (model_outputs_ext == NULL)? (NULL) : &(model_outputs_ext->hplanes[tree]),
+                output_score,
+                0, index1, initial_str, all_node_rules[single_tree? 0 : tree],
+                conditions_left, conditions_right,
+                model_outputs, model_outputs_ext
+            );
 
-        if (all_node_rules[tree_use].size() <= 1)
-        {
-            for (std::string &rule : all_node_rules[tree_use])
-                rule = std::string("WHEN TRUE THEN ")
-                        + std::to_string((model_outputs != NULL)?
-                                            (model_outputs->exp_avg_depth) : (model_outputs_ext->exp_avg_depth))
-                        + std::string(" ");
+            /* Code below doesn't compile with MSVC (stuck with an OMP standard that's >20 years old) */
+            // if (single_tree)
+            //     tree = 0;
+            tree_use = single_tree? (size_t)0 : tree;
+
+            if (all_node_rules[tree_use].size() <= 1)
+            {
+                for (std::string &rule : all_node_rules[tree_use])
+                    rule = std::string("WHEN TRUE THEN ")
+                            + std::to_string((model_outputs != NULL)?
+                                                (model_outputs->exp_avg_depth) : (model_outputs_ext->exp_avg_depth))
+                            + std::string(" ");
+            }
+
+            out[tree_use] = std::accumulate(all_node_rules[tree_use].begin(), all_node_rules[tree_use].end(),
+                                            std::string("CASE\n"),
+                                            [&all_node_rules, &tree_use, &index1](std::string &a, std::string &b)
+                                            {return a
+                                                        + std::string("---begin terminal node ")
+                                                        + std::to_string((size_t)std::distance(&(all_node_rules[tree_use][0]), &b) + (size_t)index1)
+                                                        + std::string("---\n")
+                                                    + b;})
+                            + std::string("END\n");
+            all_node_rules[tree_use].clear();
         }
 
-        out[tree_use] = std::accumulate(all_node_rules[tree_use].begin(), all_node_rules[tree_use].end(),
-                                        std::string("CASE\n"),
-                                        [&all_node_rules, &tree_use, &index1](std::string &a, std::string &b)
-                                        {return a
-                                                    + std::string("---begin terminal node ")
-                                                    + std::to_string((size_t)std::distance(&(all_node_rules[tree_use][0]), &b) + (size_t)index1)
-                                                    + std::string("---\n")
-                                                + b;})
-                        + std::string("END\n");
-        all_node_rules[tree_use].clear();
+        catch (...)
+        {
+            #pragma omp critical
+            {
+                if (!threw_exception)
+                {
+                    threw_exception = true;
+                    ex = std::current_exception();
+                }
+            }
+        }
     }
 
+    if (threw_exception)
+        std::rethrow_exception(ex);
+
     return out;
 } 
 
 
 void generate_tree_rules(std::vector<IsoTree> *trees, std::vector<IsoHPlane> *hplanes, bool output_score,
                          size_t curr_ix, bool index1, std::string &prev_cond, std::vector<std::string> &node_rules,
-                         std::vector<std::string> &conditions_left, std::vector<std::string> &conditions_right)
+                         std::vector<std::string> &conditions_left, std::vector<std::string> &conditions_right,
+                         const IsoForest *model_outputs, const ExtIsoForest *model_outputs_ext)
 {
-    if ((trees != NULL && (*trees)[curr_ix].score >= 0) ||
-        (hplanes != NULL && (*hplanes)[curr_ix].score >= 0))
+    // if ((trees != NULL && (*trees)[curr_ix].score >= 0) ||
+    //     (hplanes != NULL && (*hplanes)[curr_ix].score >= 0))
+    if ((trees != NULL && (*trees)[curr_ix].tree_left == 0) ||
+        (hplanes != NULL && (*hplanes)[curr_ix].hplane_left == 0))
     {
         node_rules.push_back(prev_cond
                                 + std::string("\tTHEN ")
                                 + (output_score?
                                     (std::to_string((trees != NULL)?
-                                        ((*trees)[curr_ix].score) : ((*hplanes)[curr_ix].score)))
+                                        ((model_outputs->scoring_metric != Density && model_outputs->scoring_metric != BoxedRatio)?
+                                            (*trees)[curr_ix].score : (-(*trees)[curr_ix].score))
+                                            :
+                                        ((model_outputs_ext->scoring_metric != Density && model_outputs_ext->scoring_metric != BoxedRatio)?
+                                            (*hplanes)[curr_ix].score : (-(*hplanes)[curr_ix].score))))
                                         :
                                     (std::to_string(node_rules.size() + (size_t)index1)))
                                 + std::string("\n---end of terminal node ")
@@ -283,7 +351,7 @@ void generate_tree_rules(std::vector<IsoTree> *trees, std::vector<IsoHPlane> *hp
                         (trees != NULL)?
                             ((*trees)[curr_ix].tree_left) : ((*hplanes)[curr_ix].hplane_left),
                         index1, cond_left, node_rules,
-                        conditions_left, conditions_right);
+                        conditions_left, conditions_right, model_outputs, model_outputs_ext);
     cond_left.clear();
     std::string cond_right = prev_cond
                                 + ((curr_ix > 0)? std::string("\t\tAND (") : std::string("\t\t    ("))
@@ -293,7 +361,7 @@ void generate_tree_rules(std::vector<IsoTree> *trees, std::vector<IsoHPlane> *hp
                         (trees != NULL)?
                             ((*trees)[curr_ix].tree_right) : ((*hplanes)[curr_ix].hplane_right),
                         index1, cond_right, node_rules,
-                        conditions_left, conditions_right);
+                        conditions_left, conditions_right, model_outputs, model_outputs_ext);
 }
 
 
@@ -304,7 +372,8 @@ void extract_cond_isotree(IsoForest &model, IsoTree &tree,
 {
     cond_left = std::string("");
     cond_right = std::string("");
-    if (tree.score >= 0.)
+    // if (tree.score >= 0.)
+    if (tree.tree_left == 0)
         return;
 
     switch(tree.col_type)
@@ -457,6 +526,12 @@ void extract_cond_isotree(IsoForest &model, IsoTree &tree,
             }
             break;
         }
+
+        default:
+        {
+            unexpected_error();
+            break;
+        }
     }
 }
 
@@ -467,7 +542,8 @@ void extract_cond_ext_isotree(ExtIsoForest &model, IsoHPlane &hplane,
 {
     cond_left = std::string("");
     cond_right = std::string("");
-    if (hplane.score >= 0.)
+    // if (hplane.score >= 0.)
+    if (hplane.hplane_left == 0)
         return;
 
     std::string hplane_conds = std::string("");
@@ -535,6 +611,12 @@ void extract_cond_ext_isotree(ExtIsoForest &model, IsoHPlane &hplane,
                 n_visited_categ++;
                 break;
             }
+
+            default:
+            {
+                unexpected_error();
+                break;
+            }
         }
         hplane_conds += ((model.missing_action == Impute)?
                             (std::string(", ") + std::to_string(hplane.fill_val[ix]) + std::string(")")) : (std::string("")));

data/vendor/isotree/src/subset_models.cpp

@@ -0,0 +1,174 @@
+/*    Isolation forests and variations thereof, with adjustments for incorporation
+*     of categorical variables and missing values.
+*     Writen for C++11 standard and aimed at being used in R and Python.
+*     
+*     This library is based on the following works:
+*     [1] Liu, Fei Tony, Kai Ming Ting, and Zhi-Hua Zhou.
+*         "Isolation forest."
+*         2008 Eighth IEEE International Conference on Data Mining. IEEE, 2008.
+*     [2] Liu, Fei Tony, Kai Ming Ting, and Zhi-Hua Zhou.
+*         "Isolation-based anomaly detection."
+*         ACM Transactions on Knowledge Discovery from Data (TKDD) 6.1 (2012): 3.
+*     [3] Hariri, Sahand, Matias Carrasco Kind, and Robert J. Brunner.
+*         "Extended Isolation Forest."
+*         arXiv preprint arXiv:1811.02141 (2018).
+*     [4] Liu, Fei Tony, Kai Ming Ting, and Zhi-Hua Zhou.
+*         "On detecting clustered anomalies using SCiForest."
+*         Joint European Conference on Machine Learning and Knowledge Discovery in Databases. Springer, Berlin, Heidelberg, 2010.
+*     [5] https://sourceforge.net/projects/iforest/
+*     [6] https://math.stackexchange.com/questions/3388518/expected-number-of-paths-required-to-separate-elements-in-a-binary-tree
+*     [7] Quinlan, J. Ross. C4. 5: programs for machine learning. Elsevier, 2014.
+*     [8] Cortes, David.
+*         "Distance approximation using Isolation Forests."
+*         arXiv preprint arXiv:1910.12362 (2019).
+*     [9] Cortes, David.
+*         "Imputing missing values with unsupervised random trees."
+*         arXiv preprint arXiv:1911.06646 (2019).
+*     [10] https://math.stackexchange.com/questions/3333220/expected-average-depth-in-random-binary-tree-constructed-top-to-bottom
+*     [11] Cortes, David.
+*          "Revisiting randomized choices in isolation forests."
+*          arXiv preprint arXiv:2110.13402 (2021).
+*     [12] Guha, Sudipto, et al.
+*          "Robust random cut forest based anomaly detection on streams."
+*          International conference on machine learning. PMLR, 2016.
+*     [13] Cortes, David.
+*          "Isolation forests: looking beyond tree depth."
+*          arXiv preprint arXiv:2111.11639 (2021).
+*     [14] Ting, Kai Ming, Yue Zhu, and Zhi-Hua Zhou.
+*          "Isolation kernel and its effect on SVM"
+*          Proceedings of the 24th ACM SIGKDD
+*          International Conference on Knowledge Discovery & Data Mining. 2018.
+* 
+*     BSD 2-Clause License
+*     Copyright (c) 2019-2022, David Cortes
+*     All rights reserved.
+*     Redistribution and use in source and binary forms, with or without
+*     modification, are permitted provided that the following conditions are met:
+*     * Redistributions of source code must retain the above copyright notice, this
+*       list of conditions and the following disclaimer.
+*     * 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.
+*/
+#include "isotree.hpp" 
+
+/* Create a model containing a sub-set of the trees from another model
+* 
+* Parameters
+* ==========
+* - model (in)
+*       Pointer to isolation forest model wich has already been fit through 'fit_iforest',
+*       from which the desired trees will be copied into a new model object.
+*       Pass NULL if using the extended model.
+* - ext_model (in)
+*       Pointer to extended isolation forest model which has already been fit through 'fit_iforest',
+*       from which the desired trees will be copied into a new model object.
+*       Pass NULL if using the single-variable model.
+* - imputer (in)
+*       Pointer to imputation object which has already been fit through 'fit_iforest' along with
+*       either 'model' or 'ext_model' in the same call to 'fit_iforest'.
+*       Pass NULL if the model was built without an imputer.
+* - indexer (in)
+*       Pointer to indexer object which has already been fit through 'fit_iforest' along with
+*       either 'model' or 'ext_model' in the same call to 'fit_iforest' or through another specialized funcction.
+*       Pass NULL if the model was built without an indexer.
+* - model_new (out)
+*       Pointer to already-allocated isolation forest model, which will be reset and to
+*       which the selected trees from 'model' will be copied.
+*       Pass NULL if using the extended model.
+* - ext_model_new (out)
+*       Pointer to already-allocated extended isolation forest model, which will be reset and to
+*       which the selected hyperplanes from 'ext_model' will be copied.
+*       Pass NULL if using the single-variable model.
+* - imputer_new (out)
+*       Pointer to already-allocated imputation object, which will be reset and to
+*       which the selected nodes from 'imputer' (matching to those of either 'model'
+*       or 'ext_model') will be copied.
+*       Pass NULL if the model was built without an imputer.
+* - indexer_new (out)
+*       Pointer to already-allocated indexer object, which will be reset and to
+*       which the selected nodes from 'indexer' (matching to those of either 'model'
+*       or 'ext_model') will be copied.
+*       Pass NULL if the model was built without an indexer.
+*/
+void subset_model(IsoForest*     model,      IsoForest*     model_new,
+                  ExtIsoForest*  ext_model,  ExtIsoForest*  ext_model_new,
+                  Imputer*       imputer,    Imputer*       imputer_new,
+                  TreesIndexer*  indexer,    TreesIndexer*  indexer_new,
+                  size_t *trees_take, size_t ntrees_take)
+{
+    if (model != NULL)
+    {
+        if (model_new == NULL)
+            throw std::runtime_error("Must pass an already-allocated 'model_new'.\n");
+        if (imputer != NULL && model->trees.size() != imputer->imputer_tree.size())
+            throw std::runtime_error("Number of trees in imputer does not match with model.\n");
+        if (ext_model != NULL)
+            throw std::runtime_error("Should pass only one of 'model' or 'ext_model'.\n");
+        model_new->new_cat_action = model->new_cat_action;
+        model_new->cat_split_type = model->cat_split_type;
+        model_new->missing_action = model->missing_action;
+        model_new->exp_avg_depth = model->exp_avg_depth;
+        model_new->exp_avg_sep = model->exp_avg_sep;
+        model_new->orig_sample_size = model->orig_sample_size;
+
+        model_new->trees.resize(ntrees_take);
+        for (size_t ix = 0; ix < ntrees_take; ix++)
+            model_new->trees[ix] = model->trees[trees_take[ix]];
+    }
+
+    else if (ext_model != NULL)
+    {
+        if (ext_model_new == NULL)
+            throw std::runtime_error("Must pass an already-allocated 'ext_model_new'.");
+        if (imputer != NULL && ext_model->hplanes.size() != imputer->imputer_tree.size())
+            throw std::runtime_error("Number of trees in imputer does not match with model.\n");
+        if (model != NULL)
+            throw std::runtime_error("Should pass only one of 'model' or 'ext_model'.\n");
+        ext_model_new->new_cat_action = ext_model->new_cat_action;
+        ext_model_new->cat_split_type = ext_model->cat_split_type;
+        ext_model_new->missing_action = ext_model->missing_action;
+        ext_model_new->exp_avg_depth = ext_model->exp_avg_depth;
+        ext_model_new->exp_avg_sep = ext_model->exp_avg_sep;
+        ext_model_new->orig_sample_size = ext_model->orig_sample_size;
+
+        ext_model_new->hplanes.resize(ntrees_take);
+        for (size_t ix = 0; ix < ntrees_take; ix++)
+            ext_model_new->hplanes[ix] = ext_model->hplanes[trees_take[ix]];
+    }
+
+    if (imputer != NULL)
+    {
+        if (imputer_new == NULL)
+            throw std::runtime_error("Must pass an already-allocated 'imputer_new'.");
+        imputer_new->ncols_numeric = imputer->ncols_numeric;
+        imputer_new->ncols_categ = imputer->ncols_categ;
+        imputer_new->ncat = imputer->ncat;
+        imputer_new->col_means = imputer->col_means;
+        imputer_new->col_modes = imputer->col_modes;
+
+        imputer_new->imputer_tree.resize(ntrees_take);
+        for (size_t ix = 0; ix < ntrees_take; ix++)
+            imputer_new->imputer_tree[ix] = imputer->imputer_tree[trees_take[ix]];
+    }
+
+    if (indexer != NULL)
+    {
+        if (indexer_new == NULL)
+            throw std::runtime_error("Must pass an already-allocated 'indexer_new'.");
+
+        indexer_new->indices.resize(ntrees_take);
+        for (size_t ix = 0; ix < ntrees_take; ix++)
+            indexer_new->indices[ix] = indexer->indices[trees_take[ix]];
+    }
+}