TrainingSpec.hpp

Go to the documentation of this file.

#pragma once
 
#include "models/strategies/pp/ProjectionPursuit.hpp"
#include "models/strategies/vars/VariableSelection.hpp"
#include "models/strategies/cutpoint/Cutpoint.hpp"
#include "models/strategies/stop/StopRule.hpp"
#include "models/strategies/binarize/Binarization.hpp"
#include "models/strategies/grouping/Grouping.hpp"
#include "models/strategies/leaf/LeafStrategy.hpp"
 
#include <algorithm>
#include <memory>
#include <thread>
#include <nlohmann/json.hpp>
 
namespace ppforest2 {
  class TrainingSpec {
  public:
    using Ptr = std::shared_ptr<TrainingSpec>;

    pp::ProjectionPursuit::Ptr const pp;
    vars::VariableSelection::Ptr const vars;
    cutpoint::Cutpoint::Ptr const cutpoint;
    stop::StopRule::Ptr const stop;
    binarize::Binarization::Ptr const binarization;
    grouping::Grouping::Ptr const grouping;
    leaf::LeafStrategy::Ptr const leaf;

    types::Mode const mode;

    int const size;
    int const seed;
    int const threads;
    int const max_retries;

    class Builder {
    public:
      struct Config {
        pp::ProjectionPursuit::Ptr pp            = nullptr;
        vars::VariableSelection::Ptr vars        = nullptr;
        cutpoint::Cutpoint::Ptr cutpoint         = nullptr;
        stop::StopRule::Ptr stop                 = nullptr;
        binarize::Binarization::Ptr binarization = nullptr;
        grouping::Grouping::Ptr grouping         = nullptr;
        leaf::LeafStrategy::Ptr leaf             = nullptr;
 
        int size        = 0;
        int seed        = 0;
        int threads     = 0;
        int max_retries = 3;
      };
 
      Config config;
      types::Mode const mode;
 
      explicit Builder(types::Mode mode)
          : mode(mode) {}
 
      Builder& pp(pp::ProjectionPursuit::Ptr v) {
        config.pp = std::move(v);
        return *this;
      }
      Builder& vars(vars::VariableSelection::Ptr v) {
        config.vars = std::move(v);
        return *this;
      }
      Builder& cutpoint(cutpoint::Cutpoint::Ptr v) {
        config.cutpoint = std::move(v);
        return *this;
      }
      Builder& stop(stop::StopRule::Ptr v) {
        config.stop = std::move(v);
        return *this;
      }
      Builder& binarization(binarize::Binarization::Ptr v) {
        config.binarization = std::move(v);
        return *this;
      }
      Builder& grouping(grouping::Grouping::Ptr v) {
        config.grouping = std::move(v);
        return *this;
      }
      Builder& leaf(leaf::LeafStrategy::Ptr v) {
        config.leaf = std::move(v);
        return *this;
      }
 
      Builder& size(int v) {
        config.size = v;
        return *this;
      }
      Builder& seed(int v) {
        config.seed = v;
        return *this;
      }
      Builder& threads(int v) {
        config.threads = v;
        return *this;
      }
      Builder& max_retries(int v) {
        config.max_retries = v;
        return *this;
      }

      Builder& apply_defaults();

      TrainingSpec build();

      Ptr make();
    };

    static Builder builder(types::Mode mode) { return Builder{mode}; }

    TrainingSpec(
        pp::ProjectionPursuit::Ptr pp,
        vars::VariableSelection::Ptr vars,
        cutpoint::Cutpoint::Ptr cutpoint,
        stop::StopRule::Ptr stop,
        binarize::Binarization::Ptr binarization,
        grouping::Grouping::Ptr grouping,
        leaf::LeafStrategy::Ptr leaf,
        types::Mode mode,
        int size,
        int seed,
        int threads,
        int max_retries
    );
 
    // -- Forwarding methods (delegate to the underlying strategy) -----------

    void find_projection(NodeContext& ctx, stats::RNG& rng) const;

    void select_vars(NodeContext& ctx, stats::RNG& rng) const;

    void find_cutpoint(NodeContext& ctx, stats::RNG& rng) const;

    bool should_stop(NodeContext const& ctx, stats::RNG& rng) const;

    void regroup(NodeContext& ctx, stats::RNG& rng) const;

    void group(NodeContext& ctx, stats::RNG& rng) const;

    stats::GroupPartition init_groups(types::OutcomeVector const& y) const { return grouping->init(y); }

    TreeNode::Ptr create_leaf(NodeContext const& ctx, stats::RNG& rng) const { return leaf->create_leaf(ctx, rng); }

    bool is_forest() const { return size > 0; }

    nlohmann::json to_json() const;

    static Ptr from_json(nlohmann::json const& j);

    template<typename... Args> static Ptr make(Args&&... args) {
      return std::make_shared<TrainingSpec>(std::forward<Args>(args)...);
    }

    int resolve_threads() const {
      // hardware_concurrency() may return 0 when it cannot be determined;
      // passing a non-positive count to omp_set_num_threads is undefined.
      return threads > 0 ? threads : std::max(1, static_cast<int>(std::thread::hardware_concurrency()));
    }
  };

  inline bool is_classification(TrainingSpec const& spec) {
    return types::is_classification(spec.mode);
  }

  inline bool is_regression(TrainingSpec const& spec) {
    return types::is_regression(spec.mode);
  }

  inline bool is_classification(TrainingSpec::Ptr const& spec) {
    return spec != nullptr && is_classification(*spec);
  }

  inline bool is_regression(TrainingSpec::Ptr const& spec) {
    return spec != nullptr && is_regression(*spec);
  }
}