desk.h

Go to the documentation of this file.

/* Author: Christoph Lassner. */
#pragma once
#ifndef FORPY_UTIL_DESK_H_
#define FORPY_UTIL_DESK_H_

#include "../global.h"
#include "../types.h"

namespace forpy {

struct TreeDesk {
  std::vector<TodoMark> marks;
  std::atomic<size_t> *stored_in_leafs;
  std::atomic<id_t> *next_id_p;
  std::vector<std::pair<id_t, id_t>> *tree_p;

  inline void setup(std::atomic<size_t> *silp, std::atomic<id_t> *np,
                    std::vector<std::pair<id_t, id_t>> *tsp) {
    stored_in_leafs = silp;
    next_id_p = np;
    tree_p = tsp;
  }
  inline void reset() {
    marks.clear();
    stored_in_leafs = nullptr;
    next_id_p = nullptr;
    tree_p = nullptr;
  }
};

struct DeciderDesk {
  size_t n_samples, input_dim, annot_dim;
  uint min_samples_at_leaf;
  id_t *elem_id_p;
  id_t start_id, end_id, node_id;

  OptSplitV best_res_v, opt_res_v;
  id_t best_feat_idx;
  bool presorted, need_sort;
  std::vector<id_t> feature_indices;

  std::vector<float> full_sum;
  float *full_sum_p;
  float fullentropy, maxproxy;
  const float *annot_p;
  const uint *class_annot_p;
  size_t annot_os;
  const float *weights_p;
  float full_w;
  std::vector<id_t> sort_perm;
  id_t *sort_perm_p;
  std::vector<id_t> elem_ids_sorted;
  id_t *elem_ids_sorted_p;
  std::vector<float> feat_values;
  float *feat_p;
  DataV class_feat_values;
  std::vector<float> left_sum_vec;
  float *left_sum_p;

  mu::variant<const float *, const double *, const uint *, const uint8_t *>
      full_feat_p_v;

  bool make_to_leaf;
  // These only contain valid values if `make_to_leaf` is false.
  interv_t left_int, right_int;
  id_t left_id, right_id;

  std::vector<size_t> invalid_counts;

  std::vector<size_t> *node_to_featsel_p;
  mu::variant<std::vector<float>, std::vector<double>, std::vector<uint32_t>,
              std::vector<uint8_t>> *node_to_thresh_v_p;

  inline void setup(
      std::vector<size_t> *ntfp,
      mu::variant<std::vector<float>, std::vector<double>,
                  std::vector<uint32_t>, std::vector<uint8_t>> *nttp) {
    node_to_featsel_p = ntfp;
    node_to_thresh_v_p = nttp;
    if (ntfp != nullptr) invalid_counts.resize(ntfp->size());
  }
  inline void reset() {
    n_samples = input_dim = annot_dim = 0;
    min_samples_at_leaf = 0;
    elem_id_p = nullptr;
    weights_p = nullptr;
    full_w = 0.f;
    start_id = end_id = node_id = 0;
    node_to_featsel_p = nullptr;
    node_to_thresh_v_p = nullptr;
    invalid_counts.clear();
  }
};

struct LeafDesk {
  std::vector<Mat<float>> *leaf_regression_map_p;
  inline void setup(std::vector<Mat<float>> *lrmp) {
    leaf_regression_map_p = lrmp;
  };
  inline void reset() { leaf_regression_map_p = nullptr; }
};

struct RandomDesk {
  std::mt19937 random_engine;
  uint seed;
  inline void setup(const uint &seed) {
    this->seed = seed;
    random_engine.seed(seed);
  };
  inline void reset() {
    this->seed = 0;
    random_engine.seed(1);
  };
};

struct Desk {
  inline Desk(int i) : thread_id(i){};
  TreeDesk t;
  DeciderDesk d;
  LeafDesk l;
  RandomDesk r;

  const int thread_id;
  inline void setup(
      std::atomic<size_t> *stored_in_leaf_p, std::atomic<id_t> *next_id_p,
      std::vector<std::pair<id_t, id_t>> *tree_p,
      std::vector<size_t> *ntfp = nullptr,
      mu::variant<std::vector<float>, std::vector<double>,
                  std::vector<uint32_t>, std::vector<uint8_t>> *nttp = nullptr,
      std::vector<Mat<float>> *lrmp = nullptr, const uint &random_seed = 0) {
    t.setup(stored_in_leaf_p, next_id_p, tree_p);
    d.setup(ntfp, nttp);
    l.setup(lrmp);
    r.setup(random_seed);
  };
  inline void reset() {
    t.reset();
    d.reset();
    l.reset();
    r.reset();
  }
};

};      // namespace forpy
#endif  // FORPY_UTIL_DESK_H_