SequenceSpanTask Namespace Reference

Classes
struct	task_data

Enumerations
enum	EncodingType { BIO, BILOU }

Functions
action	bilou_to_bio (action y)
void	convert_bio_to_bilou (multi_ex &ec)
void	initialize (Search::search &sch, size_t &num_actions, options_i &options)
void	finish (Search::search &sch)
void	setup (Search::search &sch, multi_ex &ec)
void	takedown (Search::search &sch, multi_ex &ec)
void	run (Search::search &sch, multi_ex &ec)

Variables
Search::search_task	task = {"sequencespan", run, initialize, finish, setup, takedown}

Enumeration Type Documentation

EncodingType

enum SequenceSpanTask::EncodingType

Enumerator
BIO
BILOU

Definition at line 62 of file search_sequencetask.cc.

{
  BIO,
  BILOU
};

Function Documentation

bilou_to_bio()

action SequenceSpanTask::bilou_to_bio ( action  y )

inline

Definition at line 92 of file search_sequencetask.cc.

Referenced by convert_bio_to_bilou(), run(), and takedown().

{
  return y / 2 + 1;  // out -> out, {unit,begin} -> begin; {in,last} -> in
}

convert_bio_to_bilou()

void SequenceSpanTask::convert_bio_to_bilou

(

multi_ex &

ec

)

Definition at line 97 of file search_sequencetask.cc.

References bilou_to_bio(), and MULTICLASS::label_t::label.

Referenced by setup().

{
  for (size_t n = 0; n < ec.size(); n++)
  {
    MULTICLASS::label_t& ylab = ec[n]->l.multi;
    action y = ylab.label;
    action nexty = (n == ec.size() - 1) ? 0 : ec[n + 1]->l.multi.label;
    if (y == 1)  // do nothing
      ;
    else if (y % 2 == 0)  // this is a begin-X
    {
      if (nexty != y + 1)                  // should be unit
        ylab.label = (y / 2 - 1) * 4 + 2;  // from 2 to 2, 4 to 6, 6 to 10, etc.
      else                                 // should be begin-X
        ylab.label = (y / 2 - 1) * 4 + 3;  // from 2 to 3, 4 to 7, 6 to 11, etc.
    }
    else if (y % 2 == 1)  // this is an in-X
    {
      if (nexty != y)                  // should be last
        ylab.label = (y - 1) * 2 + 1;  // from 3 to 5, 5 to 9, 7 to 13, etc.
      else                             // should be in-X
        ylab.label = (y - 1) * 2;      // from 3 to 4, 5 to 8, 7 to 12, etc.
    }
    assert(y == bilou_to_bio(ylab.label));
  }
}

finish()

void SequenceSpanTask::finish

(

Search::search &

sch

)

Definition at line 181 of file search_sequencetask.cc.

References SequenceSpanTask::task_data::allowed_actions, v_array< T >::delete_v(), Search::search::get_task_data(), and SequenceSpanTask::task_data::only_two_allowed.

{
  task_data* D = sch.get_task_data<task_data>();
  D->allowed_actions.delete_v();
  D->only_two_allowed.delete_v();
  delete D;
}

initialize()

void SequenceSpanTask::initialize	(	Search::search &	sch,
		size_t &	num_actions,
		options_i &	options
	)

Definition at line 132 of file search_sequencetask.cc.

References VW::config::option_group_definition::add(), VW::config::options_i::add_and_parse(), SequenceSpanTask::task_data::allowed_actions, Search::AUTO_CONDITION_FEATURES, Search::AUTO_HAMMING_LOSS, BILOU, BIO, v_array< T >::clear(), SequenceSpanTask::task_data::encoding, Search::EXAMPLES_DONT_CHANGE, VW::config::make_option(), SequenceSpanTask::task_data::multipass, SequenceSpanTask::task_data::only_two_allowed, v_array< T >::push_back(), Search::search::set_num_learners(), Search::search::set_options(), and Search::search::set_task_data().

{
  task_data* D = new task_data();

  bool search_span_bilou = false;
  option_group_definition new_options("search sequencespan options");
  new_options
      .add(make_option("search_span_bilou", search_span_bilou)
               .help("switch to (internal) BILOU encoding instead of BIO encoding"))
      .add(make_option("search_span_multipass", D->multipass).default_value(1).help("do multiple passes"));
  options.add_and_parse(new_options);

  if (search_span_bilou)
  {
    std::cerr << "switching to BILOU encoding for sequence span labeling" << std::endl;
    D->encoding = BILOU;
    num_actions = num_actions * 2 - 1;
  }
  else
    D->encoding = BIO;

  D->allowed_actions.clear();

  if (D->encoding == BIO)
  {
    D->allowed_actions.push_back(1);
    for (action l = 2; l < num_actions; l += 2) D->allowed_actions.push_back(l);
    D->allowed_actions.push_back(1);  // push back an extra 1 that we can overwrite later if we want
  }
  else if (D->encoding == BILOU)
  {
    D->allowed_actions.push_back(1);
    for (action l = 2; l < num_actions; l += 4)
    {
      D->allowed_actions.push_back(l);
      D->allowed_actions.push_back(l + 1);
    }
    D->only_two_allowed.push_back(0);
    D->only_two_allowed.push_back(0);
  }

  sch.set_task_data<task_data>(D);
  sch.set_options(Search::AUTO_CONDITION_FEATURES |  // automatically add history features to our examples, please
      Search::AUTO_HAMMING_LOSS |     // please just use hamming loss on individual predictions -- we won't declare loss
      Search::EXAMPLES_DONT_CHANGE |  // we don't do any internal example munging
      0);
  sch.set_num_learners(D->multipass);
}

run()

void SequenceSpanTask::run	(	Search::search &	sch,
		multi_ex &	ec
	)

Definition at line 208 of file search_sequencetask.cc.

References Search::predictor::add_allowed(), Search::predictor::add_condition_range(), SequenceSpanTask::task_data::allowed_actions, BILOU, bilou_to_bio(), BIO, SequenceSpanTask::task_data::encoding, Search::search::get_history_length(), Search::search::get_task_data(), SequenceSpanTask::task_data::multipass, Search::search::output(), Search::predictor::predict(), Search::predictor::set_allowed(), Search::predictor::set_condition_range(), Search::predictor::set_input(), Search::predictor::set_learner_id(), Search::predictor::set_oracle(), and Search::predictor::set_tag().

{
  task_data& D = *sch.get_task_data<task_data>();
  v_array<action>* y_allowed = &(D.allowed_actions);
  Search::predictor P(sch, (ptag)0);
  for (size_t pass = 1; pass <= D.multipass; pass++)
  {
    action last_prediction = 1;
    for (size_t i = 0; i < ec.size(); i++)
    {
      action oracle = ec[i]->l.multi.label;
      size_t len = y_allowed->size();
      P.set_tag((ptag)i + 1);
      P.set_learner_id(pass - 1);
      if (D.encoding == BIO)
      {
        if (last_prediction == 1)
          P.set_allowed(y_allowed->begin(), len - 1);
        else if (last_prediction % 2 == 0)
        {
          (*y_allowed)[len - 1] = last_prediction + 1;
          P.set_allowed(*y_allowed);
        }
        else
        {
          (*y_allowed)[len - 1] = last_prediction;
          P.set_allowed(*y_allowed);
        }
        if ((oracle > 1) && (oracle % 2 == 1) && (last_prediction != oracle) && (last_prediction != oracle - 1))
          oracle = 1;  // if we are supposed to I-X, but last wasn't B-X or I-X, then say O
      }
      else if (D.encoding == BILOU)
      {
        if ((last_prediction == 1) || ((last_prediction - 2) % 4 == 0) ||
            ((last_prediction - 2) % 4 == 3))  // O or unit-X or last-X
        {
          P.set_allowed(D.allowed_actions);
          // we cannot allow in-X or last-X next
          if ((oracle > 1) && (((oracle - 2) % 4 == 2) || ((oracle - 2) % 4 == 3)))
            oracle = 1;
        }
        else  // begin-X or in-X
        {
          action other = ((last_prediction - 2) % 4 == 1) ? (last_prediction + 2) : last_prediction;
          P.set_allowed(last_prediction + 1);
          P.add_allowed(other);
          if ((oracle != last_prediction + 1) && (oracle != other))
            oracle = other;
        }
      }
      P.set_input(*ec[i]);
      P.set_condition_range((ptag)i, sch.get_history_length(), 'p');
      if (pass > 1)
        P.add_condition_range((ptag)(i + 1 + sch.get_history_length()), sch.get_history_length() + 1, 'a');
      P.set_oracle(oracle);
      last_prediction = P.predict();

      if ((pass == D.multipass) && sch.output().good())
        sch.output() << ((D.encoding == BIO) ? last_prediction : bilou_to_bio(last_prediction)) << ' ';
    }
  }
}

setup()

void SequenceSpanTask::setup	(	Search::search &	sch,
		multi_ex &	ec
	)

Definition at line 189 of file search_sequencetask.cc.

References BILOU, convert_bio_to_bilou(), SequenceSpanTask::task_data::encoding, and Search::search::get_task_data().

{
  task_data& D = *sch.get_task_data<task_data>();
  if (D.encoding == BILOU)
    convert_bio_to_bilou(ec);
}

takedown()

void SequenceSpanTask::takedown	(	Search::search &	sch,
		multi_ex &	ec
	)

Definition at line 196 of file search_sequencetask.cc.

References BILOU, bilou_to_bio(), SequenceSpanTask::task_data::encoding, Search::search::get_task_data(), and MULTICLASS::label_t::label.

{
  task_data& D = *sch.get_task_data<task_data>();

  if (D.encoding == BILOU)
    for (size_t n = 0; n < ec.size(); n++)
    {
      MULTICLASS::label_t ylab = ec[n]->l.multi;
      ylab.label = bilou_to_bio(ylab.label);
    }
}

Variable Documentation

task

Search::search_task SequenceSpanTask::task = {"sequencespan", run, initialize, finish, setup, takedown}

Definition at line 17 of file search_sequencetask.cc.