cb_adf.cc File Reference

#include <cfloat>
#include <cerrno>
#include <algorithm>
#include "reductions.h"
#include "v_hashmap.h"
#include "label_dictionary.h"
#include "vw.h"
#include "cb_algs.h"
#include "vw_exception.h"
#include "gen_cs_example.h"
#include "vw_versions.h"
#include "explore.h"

Go to the source code of this file.

Classes
struct	CB_ADF::cb_adf

Namespaces
	CB_ADF

Functions
CB::cb_class	CB_ADF::get_observed_cost (multi_ex &examples)
example *	CB_ADF::test_adf_sequence (multi_ex &ec_seq)
void	CB_ADF::global_print_newline (const v_array< int > &final_prediction_sink)
void	CB_ADF::output_example (vw &all, cb_adf &c, example &ec, multi_ex *ec_seq)
void	CB_ADF::output_rank_example (vw &all, cb_adf &c, example &ec, multi_ex *ec_seq)
void	CB_ADF::output_example_seq (vw &all, cb_adf &data, multi_ex &ec_seq)
void	CB_ADF::finish_multiline_example (vw &all, cb_adf &data, multi_ex &ec_seq)
void	CB_ADF::save_load (cb_adf &c, io_buf &model_file, bool read, bool text)
void	CB_ADF::learn (cb_adf &c, multi_learner &base, multi_ex &ec_seq)
void	CB_ADF::predict (cb_adf &c, multi_learner &base, multi_ex &ec_seq)
base_learner *	cb_adf_setup (options_i &options, vw &all)

Function Documentation

cb_adf_setup()

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

Definition at line 481 of file cb_adf.cc.

References prediction_type::action_scores, VW::config::option_group_definition::add(), VW::config::options_i::add_and_parse(), LEARNER::as_multiline(), label_type::cb, CB::cb_label, CB_TYPE_DM, CB_TYPE_DR, CB_TYPE_IPS, CB_TYPE_MTR, CB_TYPE_SM, ACTION_SCORE::delete_action_scores(), vw::delete_prediction, f, CB_ADF::finish_multiline_example(), LEARNER::init_learner(), VW::config::options_i::insert(), vw::label_type, CB_ADF::learn(), parser::lp, LEARNER::make_base(), VW::config::make_option(), vw::model_file_ver, vw::p, CB_ADF::predict(), CB_ADF::save_load(), vw::scorer, vw::sd, LEARNER::learner< T, E >::set_finish_example(), LEARNER::learner< T, E >::set_save_load(), CB_ADF::cb_adf::set_scorer(), setup_base(), vw::trace_message, and VW::config::options_i::was_supplied().

Referenced by parse_reductions().

{
  bool cb_adf_option = false;
  std::string type_string = "mtr";

  size_t cb_type;
  bool rank_all;
  float clip_p;
  bool no_predict;

  option_group_definition new_options("Contextual Bandit with Action Dependent Features");
  new_options
      .add(make_option("cb_adf", cb_adf_option)
               .keep()
               .help("Do Contextual Bandit learning with multiline action dependent features."))
      .add(make_option("rank_all", rank_all).keep().help("Return actions sorted by score order"))
      .add(make_option("no_predict", no_predict).help("Do not do a prediction when training"))
      .add(make_option("clip_p", clip_p)
               .keep()
               .default_value(0.f)
               .help("Clipping probability in importance weight. Default: 0.f (no clipping)."))
      .add(make_option("cb_type", type_string)
               .keep()
               .help("contextual bandit method to use in {ips, dm, dr, mtr, sm}. Default: mtr"));
  options.add_and_parse(new_options);

  if (!cb_adf_option)
    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);
  }

  // number of weight vectors needed
  size_t problem_multiplier = 1;  // default for IPS
  bool check_baseline_enabled = false;

  if (type_string == "dr")
  {
    cb_type = CB_TYPE_DR;
    problem_multiplier = 2;
    // only use baseline when manually enabled for loss estimation
    check_baseline_enabled = true;
  }
  else if (type_string == "ips")
    cb_type = CB_TYPE_IPS;
  else if (type_string == "mtr")
    cb_type = CB_TYPE_MTR;
  else if (type_string == "dm")
    cb_type = CB_TYPE_DM;
  else if (type_string == "sm")
    cb_type = CB_TYPE_SM;
  else
  {
    all.trace_message << "warning: cb_type must be in {'ips','dr','mtr','dm','sm'}; resetting to mtr." << std::endl;
    cb_type = CB_TYPE_MTR;
  }

  if (clip_p > 0.f && cb_type == CB_TYPE_SM)
    all.trace_message << "warning: clipping probability not yet implemented for cb_type sm; p will not be clipped."
                      << std::endl;

  all.delete_prediction = ACTION_SCORE::delete_action_scores;

  // Push necessary flags.
  if ((!options.was_supplied("csoaa_ldf") && !options.was_supplied("wap_ldf")) || rank_all ||
      !options.was_supplied("csoaa_rank"))
  {
    if (!options.was_supplied("csoaa_ldf"))
    {
      options.insert("csoaa_ldf", "multiline");
    }

    if (!options.was_supplied("csoaa_rank"))
    {
      options.insert("csoaa_rank", "");
    }
  }

  if (options.was_supplied("baseline") && check_baseline_enabled)
  {
    options.insert("check_enabled", "");
  }

  auto ld = scoped_calloc_or_throw<cb_adf>(all.sd, cb_type, &all.model_file_ver, rank_all, clip_p, no_predict);

  auto base = as_multiline(setup_base(options, all));
  all.p->lp = CB::cb_label;
  all.label_type = label_type::cb;

  cb_adf* bare = ld.get();
  learner<cb_adf, multi_ex>& l =
      init_learner(ld, base, learn, predict, problem_multiplier, prediction_type::action_scores);
  l.set_finish_example(CB_ADF::finish_multiline_example);

  bare->set_scorer(all.scorer);

  l.set_save_load(CB_ADF::save_load);
  return make_base(l);
}