cb_explore.cc File Reference

#include "reductions.h"
#include "cb_algs.h"
#include "rand48.h"
#include "bs.h"
#include "gen_cs_example.h"
#include "explore.h"
#include <memory>

Go to the source code of this file.

Classes
struct	CB_EXPLORE::cb_explore

Namespaces
	CB_EXPLORE

Functions
template<bool is_learn>
void	CB_EXPLORE::predict_or_learn_first (cb_explore &data, single_learner &base, example &ec)
template<bool is_learn>
void	CB_EXPLORE::predict_or_learn_greedy (cb_explore &data, single_learner &base, example &ec)
template<bool is_learn>
void	CB_EXPLORE::predict_or_learn_bag (cb_explore &data, single_learner &base, example &ec)
void	CB_EXPLORE::get_cover_probabilities (cb_explore &data, single_learner &, example &ec, v_array< action_score > &probs)
template<bool is_learn>
void	CB_EXPLORE::predict_or_learn_cover (cb_explore &data, single_learner &base, example &ec)
void	CB_EXPLORE::print_update_cb_explore (vw &all, bool is_test, example &ec, std::stringstream &pred_string)
void	CB_EXPLORE::output_example (vw &all, cb_explore &data, example &ec, CB::label &ld)
void	CB_EXPLORE::finish_example (vw &all, cb_explore &c, example &ec)
base_learner *	cb_explore_setup (options_i &options, vw &all)

Function Documentation

cb_explore_setup()

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

Definition at line 274 of file cb_explore.cc.

References prediction_type::action_probs, add(), VW::config::options_i::add_and_parse(), LEARNER::as_singleline(), CB_TYPE_DR, vw::cost_sensitive, ACTION_SCORE::delete_action_scores(), vw::delete_prediction, f, CB_EXPLORE::finish_example(), vw::get_random_state(), LEARNER::init_learner(), VW::config::options_i::insert(), LEARNER::make_base(), VW::config::make_option(), vw::scorer, LEARNER::learner< T, E >::set_finish_example(), setup_base(), and VW::config::options_i::was_supplied().

Referenced by parse_reductions().

{
  auto data = scoped_calloc_or_throw<cb_explore>();
  option_group_definition new_options("Contextual Bandit Exploration");
  new_options
      .add(make_option("cb_explore", data->cbcs.num_actions)
               .keep()
               .help("Online explore-exploit for a <k> action contextual bandit problem"))
      .add(make_option("first", data->tau).keep().help("tau-first exploration"))
      .add(make_option("epsilon", data->epsilon).keep().default_value(0.05f).help("epsilon-greedy exploration"))
      .add(make_option("bag", data->bag_size).keep().help("bagging-based exploration"))
      .add(make_option("cover", data->cover_size).keep().help("Online cover based exploration"))
      .add(make_option("psi", data->psi).keep().default_value(1.0f).help("disagreement parameter for cover"));
  options.add_and_parse(new_options);

  if (!options.was_supplied("cb_explore"))
    return nullptr;

  data->_random_state = all.get_random_state();
  uint32_t num_actions = data->cbcs.num_actions;

  if (!options.was_supplied("cb"))
  {
    std::stringstream ss;
    ss << data->cbcs.num_actions;
    options.insert("cb", ss.str());
  }

  all.delete_prediction = delete_action_scores;
  data->cbcs.cb_type = CB_TYPE_DR;

  single_learner* base = as_singleline(setup_base(options, all));
  data->cbcs.scorer = all.scorer;

  learner<cb_explore, example>* l;
  if (options.was_supplied("cover"))
  {
    data->cs = (learner<cb_explore, example>*)(as_singleline(all.cost_sensitive));
    data->second_cs_label.costs.resize(num_actions);
    data->second_cs_label.costs.end() = data->second_cs_label.costs.begin() + num_actions;
    data->cover_probs = v_init<float>();
    data->cover_probs.resize(num_actions);
    data->preds = v_init<uint32_t>();
    data->preds.resize(data->cover_size);
    l = &init_learner(data, base, predict_or_learn_cover<true>, predict_or_learn_cover<false>, data->cover_size + 1,
        prediction_type::action_probs);
  }
  else if (options.was_supplied("bag"))
    l = &init_learner(data, base, predict_or_learn_bag<true>, predict_or_learn_bag<false>, data->bag_size,
        prediction_type::action_probs);
  else if (options.was_supplied("first"))
    l = &init_learner(
        data, base, predict_or_learn_first<true>, predict_or_learn_first<false>, 1, prediction_type::action_probs);
  else  // greedy
    l = &init_learner(
        data, base, predict_or_learn_greedy<true>, predict_or_learn_greedy<false>, 1, prediction_type::action_probs);

  l->set_finish_example(finish_example);
  return make_base(*l);
}