simple_label.cc File Reference

#include <cstring>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include "cache.h"
#include "accumulate.h"
#include "best_constant.h"

Go to the source code of this file.

Functions
char *	bufread_simple_label (shared_data *sd, label_data *ld, char *c)
size_t	read_cached_simple_label (shared_data *sd, void *v, io_buf &cache)
float	get_weight (void *v)
char *	bufcache_simple_label (label_data *ld, char *c)
void	cache_simple_label (void *v, io_buf &cache)
void	default_simple_label (void *v)
bool	test_label (void *v)
void	delete_simple_label (void *)
void	parse_simple_label (parser *, shared_data *sd, void *v, v_array< substring > &words)
void	print_update (vw &all, example &ec)
void	output_and_account_example (vw &all, example &ec)
void	return_simple_example (vw &all, void *, example &ec)
bool	summarize_holdout_set (vw &all, size_t &no_win_counter)

Variables
label_parser	simple_label

Function Documentation

bufcache_simple_label()

char* bufcache_simple_label	(	label_data *	ld,
		char *	c
	)

Definition at line 43 of file simple_label.cc.

References c, label_data::initial, label_data::label, and label_data::weight.

Referenced by cache_simple_label().

{
  memcpy(c, &ld->label, sizeof(ld->label));
  c += sizeof(ld->label);
  memcpy(c, &ld->weight, sizeof(ld->weight));
  c += sizeof(ld->weight);
  memcpy(c, &ld->initial, sizeof(ld->initial));
  c += sizeof(ld->initial);
  return c;
}

bufread_simple_label()

char* bufread_simple_label	(	shared_data *	sd,
		label_data *	ld,
		char *	c
	)

Definition at line 10 of file simple_label.cc.

References c, count_label(), label_data::initial, label_data::label, and label_data::weight.

Referenced by read_cached_simple_label().

{
  memcpy(&ld->label, c, sizeof(ld->label));
  //  std::cout << ld->label << " " << sd->is_more_than_two_labels_observed << " " << sd->first_observed_label <<
  //  std::endl;
  c += sizeof(ld->label);
  memcpy(&ld->weight, c, sizeof(ld->weight));
  c += sizeof(ld->weight);
  memcpy(&ld->initial, c, sizeof(ld->initial));
  c += sizeof(ld->initial);

  count_label(sd, ld->label);
  return c;
}

cache_simple_label()

void cache_simple_label	(	void *	v,
		io_buf &	cache
	)

Definition at line 54 of file simple_label.cc.

References io_buf::buf_write(), bufcache_simple_label(), c, label_data::initial, label_data::label, and label_data::weight.

{
  char* c;
  label_data* ld = (label_data*)v;
  cache.buf_write(c, sizeof(ld->label) + sizeof(ld->weight) + sizeof(ld->initial));
  bufcache_simple_label(ld, c);
}

default_simple_label()

void default_simple_label

(

void *

v

)

Definition at line 62 of file simple_label.cc.

References label_data::initial, label_data::label, and label_data::weight.

{
  label_data* ld = (label_data*)v;
  ld->label = FLT_MAX;
  ld->weight = 1.;
  ld->initial = 0.;
}

delete_simple_label()

void delete_simple_label

(

void *

)

Definition at line 76 of file simple_label.cc.

{}

get_weight()

float get_weight

(

void *

v

)

Definition at line 37 of file simple_label.cc.

References label_data::weight.

{
  label_data* ld = (label_data*)v;
  return ld->weight;
}

output_and_account_example()

void output_and_account_example	(	vw &	all,
		example &	ec
	)

Definition at line 119 of file simple_label.cc.

References f, vw::final_prediction_sink, example::l, label_data::label, example::loss, example::num_features, example::partial_prediction, example::pred, vw::print, 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, and shared_data::weighted_labels.

Referenced by return_simple_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 += ((double)ld.label) * ec.weight;

  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];
    all.print(f, ec.pred.scalar, 0, ec.tag);
  }

  print_update(all, ec);
}

parse_simple_label()

void parse_simple_label	(	parser *	,
		shared_data *	sd,
		void *	v,
		v_array< substring > &	words
	)

Definition at line 78 of file simple_label.cc.

References count_label(), float_of_substring(), label_data::initial, label_data::label, print_substring(), v_array< T >::size(), and label_data::weight.

{
  label_data* ld = (label_data*)v;

  switch (words.size())
  {
    case 0:
      break;
    case 1:
      ld->label = float_of_substring(words[0]);
      break;
    case 2:
      ld->label = float_of_substring(words[0]);
      ld->weight = float_of_substring(words[1]);
      break;
    case 3:
      ld->label = float_of_substring(words[0]);
      ld->weight = float_of_substring(words[1]);
      ld->initial = float_of_substring(words[2]);
      break;
    default:
      std::cout << "Error: " << words.size() << " is too many tokens for a simple label: ";
      for (unsigned int i = 0; i < words.size(); ++i) print_substring(words[i]);
      std::cout << std::endl;
  }
  count_label(sd, ld->label);
}

print_update()

void print_update	(	vw &	all,
		example &	ec
	)

Definition at line 109 of file simple_label.cc.

References vw::bfgs, vw::current_pass, shared_data::dump_interval, vw::holdout_set_off, example::l, label_data::label, example::num_features, example::pred, shared_data::print_update(), vw::progress_add, vw::progress_arg, vw::quiet, polyprediction::scalar, vw::sd, polylabel::simple, shared_data::weighted_labeled_examples, and shared_data::weighted_unlabeled_examples.

Referenced by output_and_account_example().

{
  if (all.sd->weighted_labeled_examples + all.sd->weighted_unlabeled_examples >= all.sd->dump_interval && !all.quiet &&
      !all.bfgs)
  {
    all.sd->print_update(all.holdout_set_off, all.current_pass, ec.l.simple.label, ec.pred.scalar, ec.num_features,
        all.progress_add, all.progress_arg);
  }
}

read_cached_simple_label()

size_t read_cached_simple_label	(	shared_data *	sd,
		void *	v,
		io_buf &	cache
	)

Definition at line 25 of file simple_label.cc.

References io_buf::buf_read(), bufread_simple_label(), c, label_data::initial, label_data::label, and label_data::weight.

{
  label_data* ld = (label_data*)v;
  char* c;
  size_t total = sizeof(ld->label) + sizeof(ld->weight) + sizeof(ld->initial);
  if (cache.buf_read(c, total) < total)
    return 0;
  bufread_simple_label(sd, ld, c);

  return total;
}

return_simple_example()

void return_simple_example	(	vw &	all,
		void *	,
		example &	ec
	)

Definition at line 137 of file simple_label.cc.

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

Referenced by finish_example(), LEARNER::learner< CB_EXPLORE::cb_explore, example >::init_learner(), and receive_result().

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

summarize_holdout_set()

bool summarize_holdout_set	(	vw &	all,
		size_t &	no_win_counter
	)

Definition at line 143 of file simple_label.cc.

References accumulate_scalar(), vw::all_reduce, vw::current_pass, f, shared_data::holdout_best_loss, shared_data::holdout_best_pass, shared_data::holdout_sum_loss_since_last_pass, vw::sd, and shared_data::weighted_holdout_examples_since_last_pass.

Referenced by GD::end_pass(), and end_pass().

{
  float thisLoss = (all.sd->weighted_holdout_examples_since_last_pass > 0)
      ? (float)(all.sd->holdout_sum_loss_since_last_pass / all.sd->weighted_holdout_examples_since_last_pass)
      : FLT_MAX * 0.5f;
  if (all.all_reduce != nullptr)
    thisLoss = accumulate_scalar(all, thisLoss);

  all.sd->weighted_holdout_examples_since_last_pass = 0;
  all.sd->holdout_sum_loss_since_last_pass = 0;

  if (thisLoss < all.sd->holdout_best_loss)
  {
    all.sd->holdout_best_loss = thisLoss;
    all.sd->holdout_best_pass = all.current_pass;
    no_win_counter = 0;
    return true;
  }

  if ((thisLoss != FLT_MAX) ||
      (std::isfinite(
          all.sd->holdout_best_loss)))  // it's only a loss if we're not infinite when the previous one wasn't infinite
    no_win_counter++;
  return false;
}

test_label()

bool test_label

(

void *

v

)

Definition at line 70 of file simple_label.cc.

References label_data::label.

Referenced by CB_ALGS::output_example(), CB_EXPLORE::output_example(), output_example(), CSOAA::output_example(), CSOAA::output_rank_example(), and CSOAA::test_ldf_sequence().

{
  label_data* ld = (label_data*)v;
  return ld->label == FLT_MAX;
}

Variable Documentation

simple_label

label_parser simple_label

Initial value:

= {default_simple_label, parse_simple_label, cache_simple_label, read_cached_simple_label,
    delete_simple_label, get_weight, nullptr, test_label, sizeof(label_data)}

Definition at line 106 of file simple_label.cc.

Referenced by baseline_setup(), CSOAA::do_actual_learning_oaa(), CSOAA::do_actual_learning_wap(), CSOAA::make_single_prediction(), parser::parser(), and baseline::~baseline().