Bagged.hpp

Go to the documentation of this file.

#pragma once
 
#include "utils/Types.hpp"
 
#include <Eigen/Dense>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
namespace ppforest2 {
  template<typename M> struct Bagged {
    using Ptr = std::unique_ptr<Bagged<M>>;

    std::unique_ptr<M> model;
    std::vector<int> sample_indices;
 
    Bagged(std::unique_ptr<M> model, std::vector<int> sample_indices)
        : model(std::move(model))
        , sample_indices(std::move(sample_indices)) {}

    template<typename Derived = M> static Ptr make(std::unique_ptr<Derived> model, std::vector<int> sample_indices) {
      return std::make_unique<Bagged<M>>(std::move(model), std::move(sample_indices));
    }

    types::Outcome predict(types::FeatureVector const& x) const { return this->model->predict(x); }

    types::OutcomeVector predict(types::FeatureMatrix const& x) const { return this->model->predict(x); }

    std::vector<int> oob_indices(int n_total) const {
      if (n_total <= 0) {
        return {};
      }
 
      std::vector<std::uint8_t> in_bag(static_cast<std::size_t>(n_total), 0);
 
      for (int const i : sample_indices) {
        if (i >= 0 && i < n_total) {
          in_bag[static_cast<std::size_t>(i)] = 1;
        }
      }
 
      std::vector<int> oob;
      oob.reserve(static_cast<std::size_t>(n_total));
      for (int i = 0; i < n_total; ++i) {
        if (in_bag[static_cast<std::size_t>(i)] == 0) {
          oob.push_back(i);
        }
      }
      return oob;
    }

    types::OutcomeVector predict_oob(types::FeatureMatrix const& x, std::vector<int> const& row_idx) const {
      if (row_idx.empty()) {
        return types::OutcomeVector(0);
      }
      return model->predict(static_cast<types::FeatureMatrix>(x(row_idx, Eigen::all)));
    }

    bool degenerate() const { return model->degenerate; }

    bool operator==(Bagged const& other) const { return *model == *other.model; }
    bool operator!=(Bagged const& other) const { return !(*this == other); }
  };

  template<typename M, typename F>
  void for_each_bag_with_oob(std::vector<std::unique_ptr<Bagged<M>>> const& bags, int n_total, F fn) {
    int const n = static_cast<int>(bags.size());
    for (int k = 0; k < n; ++k) {
      Bagged<M> const& bag     = *bags[static_cast<std::size_t>(k)];
      std::vector<int> oob_idx = bag.oob_indices(n_total);
      if (oob_idx.empty()) {
        continue;
      }
      fn(bag, oob_idx, k);
    }
  }
}