Model.hpp

Go to the documentation of this file.

#pragma once
 
#include "models/TrainingSpec.hpp"
#include "utils/Types.hpp"
 
#include <memory>
 
namespace ppforest2 {
  class Tree;
  class Forest;
  class ClassificationTree;
  class ClassificationForest;
  class RegressionTree;
  class RegressionForest;

  struct Proportions {};
 

  class Model {
  public:
    using Ptr = std::shared_ptr<Model>;

     * @brief Visitor interface for model dispatch.
     *
     * Two layers of dispatch:
     *   - `visit(Tree)` / `visit(Forest)` — bimodal (classification or
     *     regression). Default to no-op so visitors can override only
     *     the cases they care about.
     *   - `visit(ClassificationTree)` / `visit(RegressionTree)` /
     *     `visit(ClassificationForest)` / `visit(RegressionForest)` —
     *     mode-specific. Default implementations delegate to the
     *     bimodal overload, so a visitor that overrides only `visit(Tree)`
     *     still receives both classification and regression trees.
     *
     * Visitors that don't care about mode override only the bimodal
     * pair. Visitors that need to call mode-specific API (e.g., the
     * classification-only `predict(data, Proportions{})`) override the
     * relevant mode-specific overload(s).
     */
    class Visitor {
    public:
      virtual ~Visitor() = default;
 
      virtual void visit(Tree const&) {}
      virtual void visit(Forest const&) {}
 
      virtual void visit(ClassificationTree const& tree);
      virtual void visit(ClassificationForest const& forest);
      virtual void visit(RegressionTree const& tree);
      virtual void visit(RegressionForest const& forest);
    };
 
    virtual ~Model() = default;

    bool degenerate = false;

    TrainingSpec::Ptr training_spec;

    virtual void accept(Visitor& visitor) const = 0;

    virtual types::Outcome predict(types::FeatureVector const& x) const = 0;

    virtual types::OutcomeVector predict(types::FeatureMatrix const& x) const {
      types::OutcomeVector result(x.rows());
 
      for (Eigen::Index i = 0; i < x.rows(); ++i) {
        result(i) = predict(static_cast<types::FeatureVector>(x.row(i)));
      }
 
      return result;
    }

    static Ptr train(TrainingSpec const& spec, types::FeatureMatrix& x, types::OutcomeVector& y);

    static void check_train_inputs(types::FeatureMatrix const& x, types::OutcomeVector const& y);
  };

  types::FeatureMatrix predict_proportions(Model const& model, types::FeatureMatrix const& x);

  types::FeatureVector predict_proportions(Model const& model, types::FeatureVector const& x);

  inline bool is_classification(Model const& model) {
    return is_classification(model.training_spec);
  }

  inline bool is_regression(Model const& model) {
    return is_regression(model.training_spec);
  }

  inline bool is_classification(Model const* model) {
    return model != nullptr && is_classification(*model);
  }

  inline bool is_regression(Model const* model) {
    return model != nullptr && is_regression(*model);
  }
}