confidence.cc File Reference

#include "reductions.h"
#include "vw.h"
#include "math.h"

Go to the source code of this file.

Classes
struct	confidence

Functions
template<bool is_learn, bool is_confidence_after_training>
void	predict_or_learn_with_confidence (confidence &, single_learner &base, example &ec)
void	confidence_print_result (int f, float res, float confidence, v_array< char > tag)
void	output_and_account_confidence_example (vw &all, example &ec)
void	return_confidence_example (vw &all, confidence &, example &ec)
base_learner *	confidence_setup (options_i &options, vw &all)

Function Documentation

confidence_print_result()

void confidence_print_result	(	int	f,
		float	res,
		float	confidence,
		v_array< char >	tag
	)

Definition at line 45 of file confidence.cc.

References print_tag(), and io_buf::write_file_or_socket().

Referenced by output_and_account_confidence_example().

{
  if (f >= 0)
  {
    std::stringstream ss;
    ss << std::fixed << res << " " << confidence;
    if (!print_tag(ss, tag))
      ss << ' ';
    ss << '\n';
    ssize_t len = ss.str().size();
    ssize_t t = io_buf::write_file_or_socket(f, ss.str().c_str(), (unsigned int)len);
    if (t != len)
      std::cerr << "write error: " << strerror(errno) << std::endl;
  }
}

confidence_setup()

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

Definition at line 86 of file confidence.cc.

References VW::config::option_group_definition::add(), VW::config::options_i::add_and_parse(), LEARNER::as_singleline(), LEARNER::init_learner(), LEARNER::make_base(), VW::config::make_option(), return_confidence_example(), LEARNER::learner< T, E >::set_finish_example(), setup_base(), and vw::training.

Referenced by parse_reductions().

{
  bool confidence_arg = false;
  bool confidence_after_training = false;
  option_group_definition new_options("Confidence");
  new_options.add(make_option("confidence", confidence_arg).keep().help("Get confidence for binary predictions"))
      .add(make_option("confidence_after_training", confidence_after_training).help("Confidence after training"));
  options.add_and_parse(new_options);

  if (!confidence_arg)
    return nullptr;

  if (!all.training)
  {
    std::cout
        << "Confidence does not work in test mode because learning algorithm state is needed.  Use --save_resume when "
           "saving the model and avoid --test_only"
        << std::endl;
    return nullptr;
  }

  auto data = scoped_calloc_or_throw<confidence>();
  data->all = &all;

  void (*learn_with_confidence_ptr)(confidence&, single_learner&, example&) = nullptr;
  void (*predict_with_confidence_ptr)(confidence&, single_learner&, example&) = nullptr;

  if (confidence_after_training)
  {
    learn_with_confidence_ptr = predict_or_learn_with_confidence<true, true>;
    predict_with_confidence_ptr = predict_or_learn_with_confidence<false, true>;
  }
  else
  {
    learn_with_confidence_ptr = predict_or_learn_with_confidence<true, false>;
    predict_with_confidence_ptr = predict_or_learn_with_confidence<false, false>;
  }

  // Create new learner
  learner<confidence, example>& l = init_learner(
      data, as_singleline(setup_base(options, all)), learn_with_confidence_ptr, predict_with_confidence_ptr);

  l.set_finish_example(return_confidence_example);

  return make_base(l);
}

output_and_account_confidence_example()

void output_and_account_confidence_example	(	vw &	all,
		example &	ec
	)

Definition at line 61 of file confidence.cc.

References example::confidence, confidence_print_result(), f, vw::final_prediction_sink, example::l, label_data::label, example::loss, example::num_features, example::partial_prediction, example::pred, vw::print, CB::print_update(), vw::raw_prediction, polyprediction::scalar, vw::sd, polylabel::simple, v_array< T >::size(), example::tag, example::test_only, shared_data::update(), example::weight, shared_data::weighted_labels, and shared_data::weighted_unlabeled_examples.

Referenced by return_confidence_example().

{
  label_data& ld = ec.l.simple;

  all.sd->update(ec.test_only, ld.label != FLT_MAX, ec.loss, ec.weight, ec.num_features);
  if (ld.label != FLT_MAX && !ec.test_only)
    all.sd->weighted_labels += ld.label * ec.weight;
  all.sd->weighted_unlabeled_examples += ld.label == FLT_MAX ? ec.weight : 0;

  all.print(all.raw_prediction, ec.partial_prediction, -1, ec.tag);
  for (size_t i = 0; i < all.final_prediction_sink.size(); i++)
  {
    int f = (int)all.final_prediction_sink[i];
    confidence_print_result(f, ec.pred.scalar, ec.confidence, ec.tag);
  }

  print_update(all, ec);
}

predict_or_learn_with_confidence()

template<bool is_learn, bool is_confidence_after_training>

void predict_or_learn_with_confidence	(	confidence &	,
		single_learner &	base,
		example &	ec
	)

Definition at line 15 of file confidence.cc.

References example::confidence, example::l, label_data::label, LEARNER::learner< T, E >::learn(), example::pred, LEARNER::learner< T, E >::predict(), polyprediction::scalar, sensitivity(), LEARNER::learner< T, E >::sensitivity(), and polylabel::simple.

{
  float threshold = 0.f;
  float sensitivity = 0.f;

  float existing_label = ec.l.simple.label;
  if (existing_label == FLT_MAX)
  {
    base.predict(ec);
    float opposite_label = 1.f;
    if (ec.pred.scalar > 0)
      opposite_label = -1.f;
    ec.l.simple.label = opposite_label;
  }

  if (!is_confidence_after_training)
    sensitivity = base.sensitivity(ec);

  ec.l.simple.label = existing_label;
  if (is_learn)
    base.learn(ec);
  else
    base.predict(ec);

  if (is_confidence_after_training)
    sensitivity = base.sensitivity(ec);

  ec.confidence = fabsf(ec.pred.scalar - threshold) / sensitivity;
}

return_confidence_example()

void return_confidence_example	(	vw &	all,
		confidence &	,
		example &	ec
	)

Definition at line 80 of file confidence.cc.

References VW::finish_example(), and output_and_account_confidence_example().

Referenced by confidence_setup().

{
  output_and_account_confidence_example(all, ec);
  VW::finish_example(all, ec);
}