baseline.cc File Reference

#include <float.h>
#include <errno.h>
#include "reductions.h"
#include "vw.h"

Go to the source code of this file.

Classes
struct	baseline

Namespaces
	anonymous_namespace{baseline.cc}
	BASELINE

Functions
void	BASELINE::set_baseline_enabled (example *ec)
void	BASELINE::reset_baseline_disabled (example *ec)
bool	BASELINE::baseline_enabled (example *ec)
void	init_global (baseline &data)
template<bool is_learn>
void	predict_or_learn (baseline &data, single_learner &base, example &ec)
float	sensitivity (baseline &data, base_learner &base, example &ec)
base_learner *	baseline_setup (options_i &options, vw &all)

Variables
const float	anonymous_namespace{baseline.cc}::max_multiplier = 1000.f
const size_t	anonymous_namespace{baseline.cc}::baseline_enabled_idx = 1357

Function Documentation

baseline_setup()

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

Definition at line 193 of file baseline.cc.

References VW::config::option_group_definition::add(), add(), VW::config::options_i::add_and_parse(), VW::alloc_examples(), LEARNER::as_singleline(), loss_function::getType(), LEARNER::init_learner(), vw::interactions, label_parser::label_size, vw::loss, LEARNER::make_base(), VW::config::make_option(), sensitivity(), LEARNER::learner< T, E >::set_sensitivity(), setup_base(), and simple_label.

Referenced by parse_reductions().

{
  auto data = scoped_calloc_or_throw<baseline>();
  bool baseline_option = false;
  std::string loss_function;

  option_group_definition new_options("Baseline options");
  new_options
      .add(make_option("baseline", baseline_option)
               .keep()
               .help("Learn an additive baseline (from constant features) and a residual separately in regression."))
      .add(make_option("lr_multiplier", data->lr_multiplier).help("learning rate multiplier for baseline model"))
      .add(make_option("global_only", data->global_only)
               .keep()
               .help("use separate example with only global constant for baseline predictions"))
      .add(make_option("check_enabled", data->check_enabled)
               .keep()
               .help("only use baseline when the example contains enabled flag"));
  options.add_and_parse(new_options);

  if (!baseline_option)
    return nullptr;

  // initialize baseline example
  data->ec = VW::alloc_examples(simple_label.label_size, 1);
  data->ec->interactions = &all.interactions;

  data->ec->in_use = true;
  data->all = &all;

  auto loss_function_type = all.loss->getType();
  if (loss_function_type != "logistic")
    data->lr_scaling = true;

  auto base = as_singleline(setup_base(options, all));

  learner<baseline, example>& l = init_learner(data, base, predict_or_learn<true>, predict_or_learn<false>);

  l.set_sensitivity(sensitivity);

  return make_base(l);
}

init_global()

void init_global

(

baseline &

data

)

Definition at line 81 of file baseline.cc.

References baseline::all, constant, constant_namespace, baseline::ec, example_predict::feature_space, baseline::global_only, example_predict::indices, example::num_features, v_array< T >::push_back(), parameters::stride_shift(), example::total_sum_feat_sq, vw::weights, and vw::wpp.

Referenced by predict_or_learn().

{
  if (!data.global_only)
    return;
  // use a separate global constant
  data.ec->indices.push_back(constant_namespace);
  // different index from constant to avoid conflicts
  data.ec->feature_space[constant_namespace].push_back(
      1, ((constant - 17) * data.all->wpp) << data.all->weights.stride_shift());
  data.ec->total_sum_feat_sq++;
  data.ec->num_features++;
}

predict_or_learn()

template<bool is_learn>

void predict_or_learn	(	baseline &	data,
		single_learner &	base,
		example &	ec
	)

Definition at line 95 of file baseline.cc.

References baseline::all, BASELINE::baseline_enabled(), baseline::check_enabled, constant_namespace, VW::copy_example_metadata(), baseline::ec, vw::eta, f, baseline::global_initialized, baseline::global_only, init_global(), label_data::initial, example::l, LEARNER::learner< T, E >::learn(), baseline::lr_multiplier, baseline::lr_scaling, shared_data::max_label, anonymous_namespace{baseline.cc}::max_multiplier, shared_data::min_label, VW::move_feature_namespace(), example::pred, LEARNER::learner< T, E >::predict(), polyprediction::scalar, vw::sd, and polylabel::simple.

{
  // no baseline if check_enabled is true and example contains flag
  if (data.check_enabled && !BASELINE::baseline_enabled(&ec))
  {
    if (is_learn)
      base.learn(ec);
    else
      base.predict(ec);
    return;
  }

  // always do a full prediction, for safety in accurate predictive validation
  if (data.global_only)
  {
    if (!data.global_initialized)
    {
      init_global(data);
      data.global_initialized = true;
    }
    VW::copy_example_metadata(/*audit=*/false, data.ec, &ec);
    base.predict(*data.ec);
    ec.l.simple.initial = data.ec->pred.scalar;
    base.predict(ec);
  }
  else
    base.predict(ec);

  if (is_learn)
  {
    const float pred = ec.pred.scalar;  // save 'safe' prediction

    // now learn
    data.ec->l.simple = ec.l.simple;
    if (!data.global_only)
    {
      // move label & constant features data over to baseline example
      VW::copy_example_metadata(/*audit=*/false, data.ec, &ec);
      VW::move_feature_namespace(data.ec, &ec, constant_namespace);
    }

    // regress baseline on label
    if (data.lr_scaling)
    {
      float multiplier = data.lr_multiplier;
      if (multiplier == 0)
      {
        multiplier = std::max(0.0001f, std::max(std::abs(data.all->sd->min_label), std::abs(data.all->sd->max_label)));
        if (multiplier > max_multiplier)
          multiplier = max_multiplier;
      }
      data.all->eta *= multiplier;
      base.learn(*data.ec);
      data.all->eta /= multiplier;
    }
    else
      base.learn(*data.ec);

    // regress residual
    ec.l.simple.initial = data.ec->pred.scalar;
    base.learn(ec);

    if (!data.global_only)
    {
      // move feature data back to the original example
      VW::move_feature_namespace(&ec, data.ec, constant_namespace);
    }

    // return the safe prediction
    ec.pred.scalar = pred;
  }
}

sensitivity()

float sensitivity	(	baseline &	data,
		base_learner &	base,
		example &	ec
	)

Definition at line 168 of file baseline.cc.

References LEARNER::as_singleline(), BASELINE::baseline_enabled(), baseline::check_enabled, VW::copy_example_metadata(), baseline::ec, baseline::global_only, label_data::initial, example::l, label_data::label, example::pred, LEARNER::learner< T, E >::predict(), polyprediction::scalar, LEARNER::learner< T, E >::sensitivity(), polylabel::simple, and THROW.

Referenced by baseline_setup(), and predict_or_learn_with_confidence().

{
  // no baseline if check_enabled is true and example contains flag
  if (data.check_enabled && !BASELINE::baseline_enabled(&ec))
    return base.sensitivity(ec);

  if (!data.global_only)
    THROW("sensitivity for baseline without --global_only not implemented");

  // sensitivity of baseline term
  VW::copy_example_metadata(/*audit=*/false, data.ec, &ec);
  data.ec->l.simple.label = ec.l.simple.label;
  data.ec->pred.scalar = ec.pred.scalar;
  // std::cout << "before base" << std::endl;
  const float baseline_sens = base.sensitivity(*data.ec);
  // std::cout << "base sens: " << baseline_sens << std::endl;

  // sensitivity of residual
  as_singleline(&base)->predict(*data.ec);
  ec.l.simple.initial = data.ec->pred.scalar;
  const float sens = base.sensitivity(ec);
  // std::cout << " residual sens: " << sens << std::endl;
  return baseline_sens + sens;
}