memory_tree.cc File Reference

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <float.h>
#include <time.h>
#include <sstream>
#include <ctime>
#include <memory>
#include "reductions.h"
#include "rand48.h"
#include "vw.h"
#include "v_array.h"

Go to the source code of this file.

Classes
struct	memory_tree_ns::node
struct	memory_tree_ns::memory_tree

Namespaces
	memory_tree_ns

Functions
template<typename T >
void	memory_tree_ns::remove_at_index (v_array< T > &array, uint32_t index)
void	memory_tree_ns::copy_example_data (example *dst, example *src, bool oas=false)
void	memory_tree_ns::free_example (example *ec)
void	memory_tree_ns::diag_kronecker_prod_fs_test (features &f1, features &f2, features &prod_f, float &total_sum_feat_sq, float norm_sq1, float norm_sq2)
int	memory_tree_ns::cmpfunc (const void *a, const void *b)
void	memory_tree_ns::diag_kronecker_product_test (example &ec1, example &ec2, example &ec, bool oas=false)
float	memory_tree_ns::linear_kernel (const flat_example *fec1, const flat_example *fec2)
float	memory_tree_ns::normalized_linear_prod (memory_tree &b, example *ec1, example *ec2)
void	memory_tree_ns::init_tree (memory_tree &b)
uint64_t	memory_tree_ns::insert_descent (node &n, const float prediction)
int	memory_tree_ns::random_sample_example_pop (memory_tree &b, uint64_t &cn)
float	memory_tree_ns::train_node (memory_tree &b, single_learner &base, example &ec, const uint64_t cn)
void	memory_tree_ns::split_leaf (memory_tree &b, single_learner &base, const uint64_t cn)
int	memory_tree_ns::compare_label (const void *a, const void *b)
uint32_t	memory_tree_ns::over_lap (v_array< uint32_t > &array_1, v_array< uint32_t > &array_2)
uint32_t	memory_tree_ns::hamming_loss (v_array< uint32_t > &array_1, v_array< uint32_t > &array_2)
void	memory_tree_ns::collect_labels_from_leaf (memory_tree &b, const uint64_t cn, v_array< uint32_t > &leaf_labs)
void	memory_tree_ns::train_one_against_some_at_leaf (memory_tree &b, single_learner &base, const uint64_t cn, example &ec)
uint32_t	memory_tree_ns::compute_hamming_loss_via_oas (memory_tree &b, single_learner &base, const uint64_t cn, example &ec, v_array< uint32_t > &selected_labs)
int64_t	memory_tree_ns::pick_nearest (memory_tree &b, single_learner &base, const uint64_t cn, example &ec)
float	memory_tree_ns::get_overlap_from_two_examples (example &ec1, example &ec2)
float	memory_tree_ns::F1_score_for_two_examples (example &ec1, example &ec2)
void	memory_tree_ns::predict (memory_tree &b, single_learner &base, example &ec)
float	memory_tree_ns::return_reward_from_node (memory_tree &b, single_learner &base, uint64_t cn, example &ec, float weight=1.f)
void	memory_tree_ns::learn_at_leaf_random (memory_tree &b, single_learner &base, const uint64_t &leaf_id, example &ec, const float &weight)
void	memory_tree_ns::route_to_leaf (memory_tree &b, single_learner &base, const uint32_t &ec_array_index, uint64_t cn, v_array< uint64_t > &path, bool insertion)
void	memory_tree_ns::single_query_and_learn (memory_tree &b, single_learner &base, const uint32_t &ec_array_index, example &ec)
void	memory_tree_ns::update_rew (memory_tree &b, single_learner &base, const uint32_t &ec_array_index, example &ec)
void	memory_tree_ns::insert_example (memory_tree &b, single_learner &base, const uint32_t &ec_array_index, bool fake_insert=false)
void	memory_tree_ns::experience_replay (memory_tree &b, single_learner &base)
void	memory_tree_ns::learn (memory_tree &b, single_learner &base, example &ec)
void	memory_tree_ns::end_pass (memory_tree &b)
void	memory_tree_ns::save_load_example (example *ec, io_buf &model_file, bool &read, bool &text, std::stringstream &msg, bool &oas)
void	memory_tree_ns::save_load_node (node &cn, io_buf &model_file, bool &read, bool &text, std::stringstream &msg)
void	memory_tree_ns::save_load_memory_tree (memory_tree &b, io_buf &model_file, bool read, bool text)
base_learner *	memory_tree_setup (options_i &options, vw &all)

Function Documentation

memory_tree_setup()

base_learner* memory_tree_setup	(	options_i &	options,
		vw &	all
	)

Definition at line 1223 of file memory_tree.cc.

References add(), VW::config::options_i::add_and_parse(), LEARNER::as_singleline(), label_parser::delete_label, vw::delete_prediction, LEARNER::end_pass(), f, vw::get_random_state(), LEARNER::init_learner(), LEARNER::init_multiclass_learner(), init_tree(), vw::label_type, memory_tree_ns::learn(), parser::lp, LEARNER::make_base(), VW::config::make_option(), label_type::multi, MULTILABEL::multilabel, prediction_type::multilabels, vw::numpasses, vw::p, memory_tree_ns::predict(), vw::quiet, memory_tree_ns::save_load_memory_tree(), LEARNER::learner< T, E >::set_end_pass(), LEARNER::learner< T, E >::set_save_load(), setup_base(), and vw::trace_message.

Referenced by parse_reductions().

{
  using namespace memory_tree_ns;
  auto tree = scoped_calloc_or_throw<memory_tree>();
  option_group_definition new_options("Memory Tree");

  new_options
      .add(make_option("memory_tree", tree->max_nodes)
               .keep()
               .default_value(0)
               .help("Make a memory tree with at most <n> nodes"))
      .add(make_option("max_number_of_labels", tree->max_num_labels)
               .default_value(10)
               .help("max number of unique label"))
      .add(make_option("leaf_example_multiplier", tree->leaf_example_multiplier)
               .default_value(1)
               .help("multiplier on examples per leaf (default = log nodes)"))
      .add(make_option("alpha", tree->alpha).default_value(0.1f).help("Alpha"))
      .add(make_option("dream_repeats", tree->dream_repeats)
               .default_value(1)
               .help("number of dream operations per example (default = 1)"))
      .add(make_option("top_K", tree->top_K).default_value(1).help("top K prediction error (default 1)"))
      .add(make_option("learn_at_leaf", tree->learn_at_leaf).help("whether or not learn at leaf (defualt = True)"))
      .add(make_option("oas", tree->oas).help("use oas at the leaf"))
      .add(make_option("dream_at_update", tree->dream_at_update)
               .default_value(0)
               .help("turn on dream operations at reward based update as well"))
      .add(make_option("online", tree->online).help("turn on dream operations at reward based update as well"));
  options.add_and_parse(new_options);
  if (!tree->max_nodes)
  {
    return nullptr;
  }

  tree->all = &all;
  tree->_random_state = all.get_random_state();
  tree->current_pass = 0;
  tree->final_pass = all.numpasses;

  tree->max_leaf_examples = (size_t)(tree->leaf_example_multiplier * (log(tree->max_nodes) / log(2)));

  init_tree(*tree);

  if (!all.quiet)
    all.trace_message << "memory_tree:"
                      << " "
                      << "max_nodes = " << tree->max_nodes << " "
                      << "max_leaf_examples = " << tree->max_leaf_examples << " "
                      << "alpha = " << tree->alpha << " "
                      << "oas = " << tree->oas << " "
                      << "online =" << tree->online << " " << std::endl;

  size_t num_learners = 0;

  // multi-class classification
  if (tree->oas == false)
  {
    num_learners = tree->max_nodes + 1;
    learner<memory_tree, example>& l =
        init_multiclass_learner(tree, as_singleline(setup_base(options, all)), learn, predict, all.p, num_learners);
    // srand(time(0));
    l.set_save_load(save_load_memory_tree);
    l.set_end_pass(end_pass);

    return make_base(l);
  }  // multi-label classification
  else
  {
    num_learners = tree->max_nodes + 1 + tree->max_num_labels;
    learner<memory_tree, example>& l = init_learner(
        tree, as_singleline(setup_base(options, all)), learn, predict, num_learners, prediction_type::multilabels);

    // all.p->lp = MULTILABEL::multilabel;
    // all.label_type = label_type::multi;
    // all.delete_prediction = MULTILABEL::multilabel.delete_label;
    // srand(time(0));
    l.set_end_pass(end_pass);
    l.set_save_load(save_load_memory_tree);
    // l.set_end_pass(end_pass);

    all.p->lp = MULTILABEL::multilabel;
    all.label_type = label_type::multi;
    all.delete_prediction = MULTILABEL::multilabel.delete_label;

    return make_base(l);
  }
}