cb_algs.cc File Reference

#include <float.h>
#include "vw.h"
#include "reductions.h"
#include "cb_algs.h"
#include "vw_exception.h"
#include "gen_cs_example.h"

Go to the source code of this file.

Classes
struct	CB_ALGS::cb

Namespaces
	CB_ALGS

Functions
bool	CB_ALGS::know_all_cost_example (CB::label &ld)
template<bool is_learn>
void	CB_ALGS::predict_or_learn (cb &data, single_learner &base, example &ec)
void	CB_ALGS::predict_eval (cb &, single_learner &, example &)
void	CB_ALGS::learn_eval (cb &data, single_learner &, example &ec)
void	CB_ALGS::output_example (vw &all, cb &data, example &ec, CB::label &ld)
void	CB_ALGS::finish_example (vw &all, cb &c, example &ec)
void	CB_ALGS::eval_finish_example (vw &all, cb &c, example &ec)
base_learner *	cb_algs_setup (options_i &options, vw &all)

Function Documentation

cb_algs_setup()

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

Definition at line 132 of file cb_algs.cc.

References VW::config::option_group_definition::add(), add(), VW::config::options_i::add_and_parse(), LEARNER::as_singleline(), c, label_type::cb, CB_EVAL::cb_eval, label_type::cb_eval, CB::cb_label, GEN_CS::cb_to_cs::cb_type, CB_TYPE_DM, CB_TYPE_DR, CB_TYPE_IPS, CB_ALGS::eval_finish_example(), CB_ALGS::finish_example(), LEARNER::init_learner(), VW::config::options_i::insert(), vw::label_type, CB_ALGS::learn_eval(), parser::lp, LEARNER::make_base(), VW::config::make_option(), prediction_type::multiclass, vw::p, CB_ALGS::predict_eval(), GEN_CS::cb_to_cs::scorer, vw::scorer, LEARNER::learner< T, E >::set_finish_example(), setup_base(), THROW, and VW::config::options_i::was_supplied().

Referenced by parse_reductions().

{
  auto data = scoped_calloc_or_throw<cb>();
  std::string type_string = "dr";
  bool eval = false;

  option_group_definition new_options("Contextual Bandit Options");
  new_options
      .add(make_option("cb", data->cbcs.num_actions).keep().help("Use contextual bandit learning with <k> costs"))
      .add(make_option("cb_type", type_string).keep().help("contextual bandit method to use in {ips,dm,dr}"))
      .add(make_option("eval", eval).help("Evaluate a policy rather than optimizing."));
  options.add_and_parse(new_options);

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

  // Ensure serialization of this option in all cases.
  if (!options.was_supplied("cb_type"))
  {
    options.insert("cb_type", type_string);
    options.add_and_parse(new_options);
  }

  cb_to_cs& c = data->cbcs;

  size_t problem_multiplier = 2;  // default for DR
  if (type_string.compare("dr") == 0)
    c.cb_type = CB_TYPE_DR;
  else if (type_string.compare("dm") == 0)
  {
    if (eval)
      THROW("direct method can not be used for evaluation --- it is biased.");
    c.cb_type = CB_TYPE_DM;
    problem_multiplier = 1;
  }
  else if (type_string.compare("ips") == 0)
  {
    c.cb_type = CB_TYPE_IPS;
    problem_multiplier = 1;
  }
  else
  {
    std::cerr << "warning: cb_type must be in {'ips','dm','dr'}; resetting to dr." << std::endl;
    c.cb_type = CB_TYPE_DR;
  }

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

  auto base = as_singleline(setup_base(options, all));
  if (eval)
  {
    all.p->lp = CB_EVAL::cb_eval;
    all.label_type = label_type::cb_eval;
  }
  else
  {
    all.p->lp = CB::cb_label;
    all.label_type = label_type::cb;
  }

  learner<cb, example>* l;
  if (eval)
  {
    l = &init_learner(data, base, learn_eval, predict_eval, problem_multiplier, prediction_type::multiclass);
    l->set_finish_example(eval_finish_example);
  }
  else
  {
    l = &init_learner(
        data, base, predict_or_learn<true>, predict_or_learn<false>, problem_multiplier, prediction_type::multiclass);
    l->set_finish_example(finish_example);
  }
  c.scorer = all.scorer;

  return make_base(*l);
}