Evaluation.hpp

Go to the documentation of this file.

#pragma once
 
#include "stats/Metrics.hpp"
#include "utils/Types.hpp"
 
#include <memory>
#include <optional>

namespace ppforest2 {
  class Model;
  class Tree;
  class Forest;
  class ClassificationForest;
  class RegressionForest;

  struct VariableImportance {
    types::FeatureVector permuted;
    types::FeatureVector projections;
    types::FeatureVector weighted_projections;
    types::FeatureVector scale;
  };
 
  // ---------------------------------------------------------------------------
  // Variable importance
  // ---------------------------------------------------------------------------

  types::FeatureVector vi_projections(Tree const& tree, int n_vars, types::FeatureVector const* scale = nullptr);

  types::FeatureVector vi_projections(Forest const& forest, int n_vars, types::FeatureVector const* scale = nullptr);

  types::FeatureVector
  vi_permuted(Forest const& forest, types::FeatureMatrix const& x, types::OutcomeVector const& y, int seed);

  types::FeatureVector vi_weighted_projections(
      Forest const& forest,
      types::FeatureMatrix const& x,
      types::OutcomeVector const& y,
      types::FeatureVector const* scale = nullptr
  );

  VariableImportance variable_importance(Tree const& tree, types::FeatureMatrix const& x);

  VariableImportance
  variable_importance(Forest const& forest, types::FeatureMatrix const& x, types::OutcomeVector const& y, int seed);
 
  // ---------------------------------------------------------------------------
  // Out-of-bag diagnostics
  // ---------------------------------------------------------------------------

  types::OutcomeVector oob_predict(Forest const& forest, types::FeatureMatrix const& x);

  stats::ClassificationMetrics::Maybe
  oob_metrics(ClassificationForest const& forest, types::FeatureMatrix const& x, types::OutcomeVector const& y);
 
  stats::RegressionMetrics::Maybe
  oob_metrics(RegressionForest const& forest, types::FeatureMatrix const& x, types::OutcomeVector const& y);

  std::optional<double> oob_error(Forest const& forest, types::FeatureMatrix const& x, types::OutcomeVector const& y);

  std::optional<double> oob_error(Forest const& forest, types::FeatureMatrix const& x, types::GroupIdVector const& y);
 
  // ---------------------------------------------------------------------------
  // Prediction error
  // ---------------------------------------------------------------------------

  double error(Model const& model, types::FeatureMatrix const& x, types::OutcomeVector const& y);
 
  // ---------------------------------------------------------------------------
  // Pointer-friendly overloads
  //
  // Each forwards to the reference overload via `*ptr`, so callers holding
  // a `Tree::Ptr` / `Forest::Ptr` (or any concrete subclass smart pointer
  // like `ClassificationForest::Ptr`) skip the dereference at the call site.
  //
  // Templated on `std::unique_ptr<T>` rather than overloaded per concrete
  // type so they cover unique_ptr<Tree>, unique_ptr<Forest>,
  // unique_ptr<ClassificationForest>, etc., uniformly. The `*` dereference
  // gives a `T const&` that resolves the right reference overload above.
  // ---------------------------------------------------------------------------
 
  template<typename T>
  types::FeatureVector
  vi_projections(std::unique_ptr<T> const& m, int n_vars, types::FeatureVector const* scale = nullptr) {
    return vi_projections(*m, n_vars, scale);
  }
 
  template<typename T>
  types::FeatureVector
  vi_permuted(std::unique_ptr<T> const& m, types::FeatureMatrix const& x, types::OutcomeVector const& y, int seed) {
    return vi_permuted(*m, x, y, seed);
  }
 
  template<typename T>
  types::FeatureVector vi_weighted_projections(
      std::unique_ptr<T> const& m,
      types::FeatureMatrix const& x,
      types::OutcomeVector const& y,
      types::FeatureVector const* scale = nullptr
  ) {
    return vi_weighted_projections(*m, x, y, scale);
  }
 
  template<typename T>
  VariableImportance variable_importance(std::unique_ptr<T> const& m, types::FeatureMatrix const& x) {
    return variable_importance(*m, x);
  }
 
  template<typename T>
  VariableImportance variable_importance(
      std::unique_ptr<T> const& m, types::FeatureMatrix const& x, types::OutcomeVector const& y, int seed
  ) {
    return variable_importance(*m, x, y, seed);
  }
 
  template<typename T> types::OutcomeVector oob_predict(std::unique_ptr<T> const& m, types::FeatureMatrix const& x) {
    return oob_predict(*m, x);
  }
 
  template<typename T>
  std::optional<double>
  oob_error(std::unique_ptr<T> const& m, types::FeatureMatrix const& x, types::OutcomeVector const& y) {
    return oob_error(*m, x, y);
  }
 
  template<typename T>
  std::optional<double>
  oob_error(std::unique_ptr<T> const& m, types::FeatureMatrix const& x, types::GroupIdVector const& y) {
    return oob_error(*m, x, y);
  }
 
  template<typename T>
  double error(std::unique_ptr<T> const& m, types::FeatureMatrix const& x, types::OutcomeVector const& y) {
    return error(*m, x, y);
  }
}