COST_SENSITIVE Namespace Reference

Classes
struct	label
struct	wclass

Functions
void	name_value (substring &s, v_array< substring > &name, float &v)
char *	bufread_label (label *ld, char *c, io_buf &cache)
size_t	read_cached_label (shared_data *, void *v, io_buf &cache)
float	weight (void *)
char *	bufcache_label (label *ld, char *c)
void	cache_label (void *v, io_buf &cache)
void	default_label (void *v)
bool	test_label (void *v)
void	delete_label (void *v)
void	copy_label (void *dst, void *src)
void	parse_label (parser *p, shared_data *sd, void *v, v_array< substring > &words)
void	print_update (vw &all, bool is_test, example &ec, multi_ex *ec_seq, bool action_scores, uint32_t prediction)
void	output_example (vw &all, example &ec)
void	finish_example (vw &all, example &ec)
bool	example_is_test (example &ec)
bool	ec_is_example_header (example const &ec)
template<class T >
void	finish_example (vw &all, T &, example &ec)

Variables
label_parser	cs_label

Function Documentation

bufcache_label()

char* COST_SENSITIVE::bufcache_label	(	label *	ld,
		char *	c
	)

Definition at line 67 of file cost_sensitive.cc.

References c, and COST_SENSITIVE::label::costs.

Referenced by cache_label().

{
  *(size_t*)c = ld->costs.size();
  c += sizeof(size_t);
  for (unsigned int i = 0; i < ld->costs.size(); i++)
  {
    *(wclass*)c = ld->costs[i];
    c += sizeof(wclass);
  }
  return c;
}

bufread_label()

char* COST_SENSITIVE::bufread_label	(	label *	ld,
		char *	c,
		io_buf &	cache
	)

Definition at line 31 of file cost_sensitive.cc.

References io_buf::buf_read(), c, and COST_SENSITIVE::label::costs.

Referenced by read_cached_label().

{
  size_t num = *(size_t*)c;
  ld->costs.clear();
  c += sizeof(size_t);
  size_t total = sizeof(wclass) * num;
  if (cache.buf_read(c, (int)total) < total)
  {
    std::cout << "error in demarshal of cost data" << std::endl;
    return c;
  }
  for (size_t i = 0; i < num; i++)
  {
    wclass temp = *(wclass*)c;
    c += sizeof(wclass);
    ld->costs.push_back(temp);
  }

  return c;
}

cache_label()

void COST_SENSITIVE::cache_label	(	void *	v,
		io_buf &	cache
	)

Definition at line 79 of file cost_sensitive.cc.

References io_buf::buf_write(), bufcache_label(), c, and COST_SENSITIVE::label::costs.

{
  char* c;
  label* ld = (label*)v;
  cache.buf_write(c, sizeof(size_t) + sizeof(wclass) * ld->costs.size());
  bufcache_label(ld, c);
}

copy_label()

void COST_SENSITIVE::copy_label	(	void *	dst,
		void *	src
	)

Definition at line 111 of file cost_sensitive.cc.

References copy_array(), and COST_SENSITIVE::label::costs.

{
  if (dst && src)
  {
    label* ldD = (label*)dst;
    label* ldS = (label*)src;
    copy_array(ldD->costs, ldS->costs);
  }
}

default_label()

void COST_SENSITIVE::default_label

(

void *

v

)

Definition at line 87 of file cost_sensitive.cc.

References COST_SENSITIVE::label::costs.

{
  label* ld = (label*)v;
  ld->costs.clear();
}

delete_label()

void COST_SENSITIVE::delete_label

(

void *

v

)

Definition at line 104 of file cost_sensitive.cc.

References COST_SENSITIVE::label::costs.

{
  label* ld = (label*)v;
  if (ld)
    ld->costs.delete_v();
}

ec_is_example_header()

bool COST_SENSITIVE::ec_is_example_header

(

example const &

ec

)

Definition at line 308 of file cost_sensitive.cc.

References COST_SENSITIVE::label::costs, polylabel::cs, example::l, and v_array< T >::size().

Referenced by finish_example(), Search::generate_training_example(), output_example(), Search::search::predictLDF(), Search::search_predict(), and Search::single_prediction_LDF().

{
  v_array<COST_SENSITIVE::wclass> costs = ec.l.cs.costs;
  if (costs.size() != 1)
    return false;
  if (costs[0].class_index != 0)
    return false;
  if (costs[0].x != -FLT_MAX)
    return false;
  return true;
}

example_is_test()

bool COST_SENSITIVE::example_is_test

(

example &

ec

)

Definition at line 297 of file cost_sensitive.cc.

References COST_SENSITIVE::label::costs, polylabel::cs, example::l, and v_array< T >::size().

{
  v_array<COST_SENSITIVE::wclass> costs = ec.l.cs.costs;
  if (costs.size() == 0)
    return true;
  for (size_t j = 0; j < costs.size(); j++)
    if (costs[j].x != FLT_MAX)
      return false;
  return true;
}

finish_example() [1/2]

template<class T >

void COST_SENSITIVE::finish_example	(	vw &	all,
		T &	,
		example &	ec
	)

Definition at line 37 of file cost_sensitive.h.

References cs_label, ec_is_example_header(), finish_example(), MULTILABEL::multilabel, and print_update().

{
  finish_example(all, ec);
}

finish_example() [2/2]

void COST_SENSITIVE::finish_example	(	vw &	all,
		example &	ec
	)

Definition at line 291 of file cost_sensitive.cc.

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

Referenced by finish_example(), CSOAA::finish_example(), and LEARNER::init_cost_sensitive_learner().

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

name_value()

void COST_SENSITIVE::name_value	(	substring &	s,
		v_array< substring > &	name,
		float &	v
	)

Definition at line 9 of file cost_sensitive.cc.

References substring::begin, substring::end, float_of_substring(), v_array< T >::size(), THROW, and tokenize().

Referenced by parse_label().

{
  tokenize(':', s, name);

  switch (name.size())
  {
    case 0:
    case 1:
      v = 1.;
      break;
    case 2:
      v = float_of_substring(name[1]);
      if (std::isnan(v))
        THROW("error NaN value for: " << name[0]);
      break;
    default:
      std::cerr << "example with a wierd name.  What is '";
      std::cerr.write(s.begin, s.end - s.begin);
      std::cerr << "'?\n";
  }
}

output_example()

void COST_SENSITIVE::output_example	(	vw &	all,
		example &	ec
	)

Definition at line 236 of file cost_sensitive.cc.

References substring::begin, COST_SENSITIVE::wclass::class_index, COST_SENSITIVE::label::costs, polylabel::cs, substring::end, vw::final_prediction_sink, namedlabels::get(), example::l, shared_data::ldict, loss(), polyprediction::multiclass, example::num_features, COST_SENSITIVE::wclass::partial_prediction, example::pred, vw::print, vw::print_text, print_update(), vw::raw_prediction, vw::sd, example::tag, test_label(), example::test_only, shared_data::update(), and example::weight.

Referenced by finish_example().

{
  label& ld = ec.l.cs;

  float loss = 0.;
  if (!test_label(&ld))
  {
    // need to compute exact loss
    size_t pred = (size_t)ec.pred.multiclass;

    float chosen_loss = FLT_MAX;
    float min = FLT_MAX;
    for (auto& cl : ld.costs)
    {
      if (cl.class_index == pred)
        chosen_loss = cl.x;
      if (cl.x < min)
        min = cl.x;
    }
    if (chosen_loss == FLT_MAX)
      std::cerr << "warning: csoaa predicted an invalid class. Are all multi-class labels in the {1..k} range?"
                << std::endl;

    loss = (chosen_loss - min) * ec.weight;
    // TODO(alberto): add option somewhere to allow using absolute loss instead?
    // loss = chosen_loss;
  }

  all.sd->update(ec.test_only, !test_label(&ld), loss, ec.weight, ec.num_features);

  for (int sink : all.final_prediction_sink)
    if (!all.sd->ldict)
      all.print(sink, (float)ec.pred.multiclass, 0, ec.tag);
    else
    {
      substring ss_pred = all.sd->ldict->get(ec.pred.multiclass);
      all.print_text(sink, std::string(ss_pred.begin, ss_pred.end - ss_pred.begin), ec.tag);
    }

  if (all.raw_prediction > 0)
  {
    std::stringstream outputStringStream;
    for (unsigned int i = 0; i < ld.costs.size(); i++)
    {
      wclass cl = ld.costs[i];
      if (i > 0)
        outputStringStream << ' ';
      outputStringStream << cl.class_index << ':' << cl.partial_prediction;
    }
    all.print_text(all.raw_prediction, outputStringStream.str(), ec.tag);
  }

  print_update(all, test_label(&ec.l.cs), ec, nullptr, false, ec.pred.multiclass);
}

parse_label()

void COST_SENSITIVE::parse_label	(	parser *	p,
		shared_data *	sd,
		void *	v,
		v_array< substring > &	words
	)

Definition at line 121 of file cost_sensitive.cc.

References v_array< T >::begin(), COST_SENSITIVE::wclass::class_index, COST_SENSITIVE::label::costs, f, float_of_substring(), namedlabels::get(), hashstring(), shared_data::ldict, name_value(), parser::parse_name, v_array< T >::size(), substring_equal(), THROW, and COST_SENSITIVE::wclass::x.

{
  label* ld = (label*)v;
  ld->costs.clear();

  // handle shared and label first
  if (words.size() == 1)
  {
    float fx;
    name_value(words[0], p->parse_name, fx);
    bool eq_shared = substring_equal(p->parse_name[0], "***shared***");
    bool eq_label = substring_equal(p->parse_name[0], "***label***");
    if (!sd->ldict)
    {
      eq_shared |= substring_equal(p->parse_name[0], "shared");
      eq_label |= substring_equal(p->parse_name[0], "label");
    }
    if (eq_shared || eq_label)
    {
      if (eq_shared)
      {
        if (p->parse_name.size() != 1)
          std::cerr << "shared feature vectors should not have costs on: " << words[0] << std::endl;
        else
        {
          wclass f = {-FLT_MAX, 0, 0., 0.};
          ld->costs.push_back(f);
        }
      }
      if (eq_label)
      {
        if (p->parse_name.size() != 2)
          std::cerr << "label feature vectors should have exactly one cost on: " << words[0] << std::endl;
        else
        {
          wclass f = {float_of_substring(p->parse_name[1]), 0, 0., 0.};
          ld->costs.push_back(f);
        }
      }
      return;
    }
  }

  // otherwise this is a "real" example
  for (unsigned int i = 0; i < words.size(); i++)
  {
    wclass f = {0., 0, 0., 0.};
    name_value(words[i], p->parse_name, f.x);

    if (p->parse_name.size() == 0)
      THROW(" invalid cost: specification -- no names on: " << words[i]);

    if (p->parse_name.size() == 1 || p->parse_name.size() == 2 || p->parse_name.size() == 3)
    {
      f.class_index =
          sd->ldict ? (uint32_t)sd->ldict->get(p->parse_name[0]) : (uint32_t)hashstring(p->parse_name[0], 0);
      if (p->parse_name.size() == 1 && f.x >= 0)  // test examples are specified just by un-valued class #s
        f.x = FLT_MAX;
    }
    else
      THROW("malformed cost specification on '" << (p->parse_name[0].begin) << "'");

    ld->costs.push_back(f);
  }
}

print_update()

void COST_SENSITIVE::print_update	(	vw &	all,
		bool	is_test,
		example &	ec,
		multi_ex *	ec_seq,
		bool	action_scores,
		uint32_t	prediction
	)

Definition at line 190 of file cost_sensitive.cc.

References polyprediction::a_s, vw::bfgs, shared_data::col_current_predict, vw::current_pass, shared_data::dump_interval, namedlabels::get(), vw::holdout_set_off, shared_data::ldict, example::num_features, example::pred, shared_data::print_update(), vw::progress_add, vw::progress_arg, vw::quiet, vw::sd, and shared_data::weighted_examples().

Referenced by finish_example(), output_example(), output_example(), CSOAA::output_example(), and CSOAA::output_rank_example().

{
  if (all.sd->weighted_examples() >= all.sd->dump_interval && !all.quiet && !all.bfgs)
  {
    size_t num_current_features = ec.num_features;
    // for csoaa_ldf we want features from the whole (multiline example),
    // not only from one line (the first one) represented by ec
    if (ec_seq != nullptr)
    {
      num_current_features = 0;
      // TODO: including quadratic and cubic.
      for (auto& ecc : *ec_seq) num_current_features += ecc->num_features;
    }

    std::string label_buf;
    if (is_test)
      label_buf = " unknown";
    else
      label_buf = " known";

    if (action_scores || all.sd->ldict)
    {
      std::ostringstream pred_buf;

      pred_buf << std::setw(all.sd->col_current_predict) << std::right << std::setfill(' ');
      if (all.sd->ldict)
      {
        if (action_scores)
          pred_buf << all.sd->ldict->get(ec.pred.a_s[0].action);
        else
          pred_buf << all.sd->ldict->get(prediction);
      }
      else
        pred_buf << ec.pred.a_s[0].action;
      if (action_scores)
        pred_buf << ".....";
      all.sd->print_update(all.holdout_set_off, all.current_pass, label_buf, pred_buf.str(), num_current_features,
          all.progress_add, all.progress_arg);
      ;
    }
    else
      all.sd->print_update(all.holdout_set_off, all.current_pass, label_buf, prediction, num_current_features,
          all.progress_add, all.progress_arg);
  }
}

read_cached_label()

size_t COST_SENSITIVE::read_cached_label	(	shared_data *	,
		void *	v,
		io_buf &	cache
	)

Definition at line 52 of file cost_sensitive.cc.

References io_buf::buf_read(), bufread_label(), c, and COST_SENSITIVE::label::costs.

{
  label* ld = (label*)v;
  ld->costs.clear();
  char* c;
  size_t total = sizeof(size_t);
  if (cache.buf_read(c, (int)total) < total)
    return 0;
  bufread_label(ld, c, cache);

  return total;
}

test_label()

bool COST_SENSITIVE::test_label

(

void *

v

)

Definition at line 93 of file cost_sensitive.cc.

References COST_SENSITIVE::label::costs.

Referenced by output_example().

{
  label* ld = (label*)v;
  if (ld->costs.size() == 0)
    return true;
  for (unsigned int i = 0; i < ld->costs.size(); i++)
    if (FLT_MAX != ld->costs[i].x)
      return false;
  return true;
}

weight()

float COST_SENSITIVE::weight

(

void *

)

Definition at line 65 of file cost_sensitive.cc.

{ return 1.; }

Variable Documentation

cs_label

label_parser COST_SENSITIVE::cs_label

Initial value:

= {default_label, parse_label, cache_label, read_cached_label, delete_label, weight, copy_label,
    test_label, sizeof(label)}

Definition at line 187 of file cost_sensitive.cc.

Referenced by add_to_vali(), cbifyldf_setup(), cs_active_setup(), CSOAA::csldf_setup(), CSOAA::csoaa_setup(), EntityRelationTask::finish(), DepParserTask::finish(), SequenceTask_DemoLDF::finish(), finish_example(), Search::predictor::free_ec(), init_adf_data(), LEARNER::init_cost_sensitive_learner(), DepParserTask::initialize(), GraphTask::initialize(), SequenceTask_DemoLDF::initialize(), output_example(), CSOAA::output_example(), CSOAA::output_rank_example(), Search::search_initialize(), Search::search_predict(), Search::predictor::set_input_at(), Search::setup(), Search::single_prediction_LDF(), CSOAA::test_ldf_sequence(), Search::train_single_example(), CB_ALGS::cb::~cb(), CB_EXPLORE::cb_explore::~cb_explore(), Search::search::~search(), and warm_cb::~warm_cb().