audit_regressor.cc File Reference

#include "reductions.h"
#include "interactions.h"
#include "parse_args.h"
#include "vw.h"

Go to the source code of this file.

Classes
struct	audit_regressor_data

Functions
void	audit_regressor_interaction (audit_regressor_data &dat, const audit_strings *f)
void	audit_regressor_feature (audit_regressor_data &dat, const float, const uint64_t ft_idx)
void	audit_regressor_lda (audit_regressor_data &rd, LEARNER::single_learner &, example &ec)
void	audit_regressor (audit_regressor_data &rd, LEARNER::single_learner &base, example &ec)
void	end_examples (audit_regressor_data &d)
void	print_ex (vw &all, size_t ex_processed, size_t vals_found, size_t progress)
void	finish_example (vw &all, audit_regressor_data &dd, example &ec)
void	finish (audit_regressor_data &dat)
template<class T >
void	regressor_values (audit_regressor_data &dat, T &w)
void	init_driver (audit_regressor_data &dat)
LEARNER::base_learner *	audit_regressor_setup (options_i &options, vw &all)

Function Documentation

audit_regressor()

void audit_regressor	(	audit_regressor_data &	rd,
		LEARNER::single_learner &	base,
		example &	ec
	)

Definition at line 103 of file audit_regressor.cc.

References audit_regressor_data::all, audit_regressor_feature(), audit_regressor_interaction(), audit_regressor_lda(), v_array< T >::begin(), audit_regressor_data::cur_class, v_array< T >::end(), example_predict::feature_space, example_predict::ft_offset, INTERACTIONS::generate_interactions(), example_predict::indices, features::indicies, vw::interactions, vw::lda, vw::permutations, v_array< T >::size(), features::size(), features::space_names, parameters::sparse, parameters::sparse_weights, audit_regressor_data::total_class_cnt, features::values, and vw::weights.

Referenced by audit_regressor_setup().

{
  vw& all = *rd.all;

  if (all.lda > 0)
    audit_regressor_lda(rd, base, ec);
  else
  {
    rd.cur_class = 0;
    uint64_t old_offset = ec.ft_offset;

    while (rd.cur_class < rd.total_class_cnt)
    {
      for (unsigned char* i = ec.indices.begin(); i != ec.indices.end(); ++i)
      {
        features& fs = ec.feature_space[(size_t)*i];
        if (fs.space_names.size() > 0)
          for (size_t j = 0; j < fs.size(); ++j)
          {
            audit_regressor_interaction(rd, fs.space_names[j].get());
            audit_regressor_feature(rd, fs.values[j], (uint32_t)fs.indicies[j] + ec.ft_offset);
            audit_regressor_interaction(rd, NULL);
          }
        else
          for (size_t j = 0; j < fs.size(); ++j)
            audit_regressor_feature(rd, fs.values[j], (uint32_t)fs.indicies[j] + ec.ft_offset);
      }

      if (rd.all->weights.sparse)
        INTERACTIONS::generate_interactions<audit_regressor_data, const uint64_t, audit_regressor_feature, true,
            audit_regressor_interaction, sparse_parameters>(
            rd.all->interactions, rd.all->permutations, ec, rd, rd.all->weights.sparse_weights);
      else
        INTERACTIONS::generate_interactions<audit_regressor_data, const uint64_t, audit_regressor_feature, true,
            audit_regressor_interaction, dense_parameters>(
            rd.all->interactions, rd.all->permutations, ec, rd, rd.all->weights.dense_weights);

      ec.ft_offset += rd.increment;
      ++rd.cur_class;
    }

    ec.ft_offset = old_offset;  // make sure example is not changed.
  }
}

audit_regressor_feature()

void audit_regressor_feature ( audit_regressor_data &  dat, const float  , const uint64_t  ft_idx  )

inline

Definition at line 51 of file audit_regressor.cc.

References audit_regressor_data::all, io_buf::bin_write_fixed(), audit_regressor_data::cur_class, parameters::mask(), audit_regressor_data::ns_pre, audit_regressor_data::out_file, parameters::stride_shift(), prediction_type::to_string(), audit_regressor_data::total_class_cnt, audit_regressor_data::values_audited, and vw::weights.

Referenced by audit_regressor().

{
  parameters& weights = dat.all->weights;
  if (weights[ft_idx] != 0)
    ++dat.values_audited;
  else
    return;

  std::string ns_pre;
  for (std::vector<std::string>::const_iterator s = dat.ns_pre->begin(); s != dat.ns_pre->end(); ++s) ns_pre += *s;

  std::ostringstream tempstream;
  tempstream << ':' << ((ft_idx & weights.mask()) >> weights.stride_shift()) << ':' << weights[ft_idx];

  std::string temp = ns_pre + tempstream.str() + '\n';
  if (dat.total_class_cnt > 1)  // add class prefix for multiclass problems
    temp = std::to_string(dat.cur_class) + ':' + temp;

  dat.out_file->bin_write_fixed(temp.c_str(), (uint32_t)temp.size());

  weights[ft_idx] = 0.;  // mark value audited
}

audit_regressor_interaction()

void audit_regressor_interaction ( audit_regressor_data &  dat, const audit_strings *  f  )

inline

Definition at line 26 of file audit_regressor.cc.

References audit_regressor_data::ns_pre.

Referenced by audit_regressor().

{
  // same as audit_interaction in gd.cc
  if (f == nullptr)
  {
    dat.ns_pre->pop_back();
    return;
  }

  std::string ns_pre;
  if (!dat.ns_pre->empty())
    ns_pre += '*';

  if (f->first != "" && ((f->first) != " "))
  {
    ns_pre.append(f->first);
    ns_pre += '^';
  }
  if (f->second != "")
  {
    ns_pre.append(f->second);
    dat.ns_pre->push_back(ns_pre);
  }
}

audit_regressor_lda()

void audit_regressor_lda	(	audit_regressor_data &	rd,
		LEARNER::single_learner &	,
		example &	ec
	)

Definition at line 74 of file audit_regressor.cc.

References audit_regressor_data::all, v_array< T >::begin(), io_buf::bin_write_fixed(), v_array< T >::end(), example_predict::feature_space, example_predict::indices, features::indicies, vw::lda, audit_regressor_data::out_file, vw::parse_mask, features::size(), features::space_names, parameters::stride_shift(), and vw::weights.

Referenced by audit_regressor().

{
  vw& all = *rd.all;

  std::ostringstream tempstream;
  parameters& weights = rd.all->weights;
  for (unsigned char* i = ec.indices.begin(); i != ec.indices.end(); i++)
  {
    features& fs = ec.feature_space[*i];
    for (size_t j = 0; j < fs.size(); ++j)
    {
      tempstream << '\t' << fs.space_names[j].get()->first << '^' << fs.space_names[j].get()->second << ':'
                 << ((fs.indicies[j] >> weights.stride_shift()) & all.parse_mask);
      for (size_t k = 0; k < all.lda; k++)
      {
        weight& w = weights[(fs.indicies[j] + k)];
        tempstream << ':' << w;
        w = 0.;
      }
      tempstream << std::endl;
    }
  }

  rd.out_file->bin_write_fixed(tempstream.str().c_str(), (uint32_t)tempstream.str().size());
}

audit_regressor_setup()

LEARNER::base_learner* audit_regressor_setup	(	options_i &	options,
		vw &	all
	)

Definition at line 246 of file audit_regressor.cc.

References VW::config::option_group_definition::add(), VW::config::options_i::add_and_parse(), LEARNER::as_singleline(), vw::audit, audit_regressor(), end_examples(), VW::finish(), VW::finish_example(), init_driver(), LEARNER::init_learner(), VW::config::make_option(), vw::numpasses, LEARNER::learner< T, E >::set_end_examples(), LEARNER::learner< T, E >::set_finish(), LEARNER::learner< T, E >::set_finish_example(), LEARNER::learner< T, E >::set_init_driver(), setup_base(), vw::stdin_off, THROW, VW::config::options_i::was_supplied(), and io_buf::WRITE.

Referenced by parse_reductions().

{
  std::string out_file;

  option_group_definition new_options("Audit Regressor");
  new_options.add(make_option("audit_regressor", out_file)
                      .keep()
                      .help("stores feature names and their regressor values. Same dataset must be used for both "
                            "regressor training and this mode."));
  options.add_and_parse(new_options);

  if (!options.was_supplied("audit_regressor"))
    return nullptr;

  if (out_file.empty())
    THROW("audit_regressor argument (output filename) is missing.");

  if (all.numpasses > 1)
    THROW("audit_regressor can't be used with --passes > 1.");

  all.audit = true;

  auto dat = scoped_calloc_or_throw<audit_regressor_data>();
  dat->all = &all;
  dat->ns_pre = new std::vector<std::string>();  // explicitly invoking std::vector's constructor
  dat->out_file = new io_buf();
  dat->out_file->open_file(out_file.c_str(), all.stdin_off, io_buf::WRITE);

  LEARNER::learner<audit_regressor_data, example>& ret =
      LEARNER::init_learner(dat, as_singleline(setup_base(options, all)), audit_regressor, audit_regressor, 1);
  ret.set_end_examples(end_examples);
  ret.set_finish_example(finish_example);
  ret.set_finish(finish);
  ret.set_init_driver(init_driver);

  return LEARNER::make_base<audit_regressor_data>(ret);
}

end_examples()

void end_examples

(

audit_regressor_data &

d

)

Definition at line 147 of file audit_regressor.cc.

References io_buf::close_file(), io_buf::flush(), audit_regressor_data::ns_pre, and audit_regressor_data::out_file.

Referenced by audit_regressor_setup().

{
  d.out_file->flush();  // close_file() should do this for me ...
  d.out_file->close_file();
  delete (d.out_file);
  d.out_file = NULL;
  delete d.ns_pre;
  d.ns_pre = NULL;
}

finish()

void finish

(

audit_regressor_data &

dat

)

Definition at line 185 of file audit_regressor.cc.

References audit_regressor_data::all, audit_regressor_data::loaded_regressor_values, vw::trace_message, and audit_regressor_data::values_audited.

{
  if (dat.values_audited < dat.loaded_regressor_values)
    dat.all->trace_message << "Note: for some reason audit couldn't find all regressor values in dataset ("
                           << dat.values_audited << " of " << dat.loaded_regressor_values << " found)." << std::endl;
}

finish_example()

void finish_example	(	vw &	all,
		audit_regressor_data &	dd,
		example &	ec
	)

Definition at line 163 of file audit_regressor.cc.

References shared_data::dump_interval, example::example_counter, VW::finish_example(), audit_regressor_data::loaded_regressor_values, print_ex(), vw::progress_add, vw::progress_arg, vw::quiet, vw::sd, set_done(), shared_data::update_dump_interval(), audit_regressor_data::values_audited, and shared_data::weighted_unlabeled_examples.

{
  bool printed = false;
  if (ec.example_counter + 1 >= all.sd->dump_interval && !all.quiet)
  {
    print_ex(all, ec.example_counter + 1, dd.values_audited, dd.values_audited * 100 / dd.loaded_regressor_values);
    all.sd->weighted_unlabeled_examples = (double)(ec.example_counter + 1);  // used in update_dump_interval
    all.sd->update_dump_interval(all.progress_add, all.progress_arg);
    printed = true;
  }

  if (dd.values_audited == dd.loaded_regressor_values)
  {
    // all regressor values were audited
    if (!printed)
      print_ex(all, ec.example_counter + 1, dd.values_audited, 100);
    set_done(all);
  }

  VW::finish_example(all, ec);
}

init_driver()

void init_driver

(

audit_regressor_data &

dat

)

Definition at line 200 of file audit_regressor.cc.

References audit_regressor_data::all, shared_data::col_current_label, shared_data::col_example_counter, shared_data::col_example_weight, parameters::dense_weights, shared_data::dump_interval, shared_data::example_number, VW::config::options_i::get_typed_option(), audit_regressor_data::increment, LEARNER::learner< T, E >::increment, vw::l, audit_regressor_data::loaded_regressor_values, vw::options, vw::quiet, regressor_values(), vw::sd, parameters::sparse, parameters::sparse_weights, THROW, audit_regressor_data::total_class_cnt, vw::trace_message, VW::config::options_i::was_supplied(), LEARNER::learner< T, E >::weights, and vw::weights.

Referenced by audit_regressor_setup().

{
  // checks a few settings that might be applied after audit_regressor_setup() is called
  if ((dat.all->options->was_supplied("cache_file") || dat.all->options->was_supplied("cache")) &&
      !dat.all->options->was_supplied("kill_cache"))
  {
    THROW("audit_regressor is incompatible with a cache file.  Use it in single pass mode only.");
  }

  dat.all->sd->dump_interval = 1.;  // regressor could initialize these if saved with --save_resume
  dat.all->sd->example_number = 0;

  dat.increment = dat.all->l->increment / dat.all->l->weights;
  dat.total_class_cnt = dat.all->l->weights;

  if (dat.all->options->was_supplied("csoaa"))
  {
    size_t n = dat.all->options->get_typed_option<uint32_t>("csoaa").value();
    if (n != dat.total_class_cnt)
    {
      dat.total_class_cnt = n;
      dat.increment = dat.all->l->increment / n;
    }
  }

  // count non-null feature values in regressor
  if (dat.all->weights.sparse)
    regressor_values(dat, dat.all->weights.sparse_weights);
  else
    regressor_values(dat, dat.all->weights.dense_weights);

  if (dat.loaded_regressor_values == 0)
    THROW("regressor has no non-zero weights. Nothing to audit.");

  if (!dat.all->quiet)
  {
    dat.all->trace_message << "Regressor contains " << dat.loaded_regressor_values << " values\n";
    dat.all->trace_message << std::left << std::setw(shared_data::col_example_counter) << "example"
                           << " " << std::setw(shared_data::col_example_weight) << "values"
                           << " " << std::setw(shared_data::col_current_label) << "total" << std::endl;
    dat.all->trace_message << std::left << std::setw(shared_data::col_example_counter) << "counter"
                           << " " << std::setw(shared_data::col_example_weight) << "audited"
                           << " " << std::setw(shared_data::col_current_label) << "progress" << std::endl;
  }
}

print_ex()

void print_ex ( vw &  all, size_t  ex_processed, size_t  vals_found, size_t  progress  )

inline

Definition at line 157 of file audit_regressor.cc.

References shared_data::col_example_counter, and vw::trace_message.

Referenced by finish_example().

{
  all.trace_message << std::left << std::setw(shared_data::col_example_counter) << ex_processed << " " << std::right
                    << std::setw(9) << vals_found << " " << std::right << std::setw(12) << progress << '%' << std::endl;
}

regressor_values()

template<class T >

void regressor_values	(	audit_regressor_data &	dat,
		T &	w
	)

Definition at line 193 of file audit_regressor.cc.

References audit_regressor_data::loaded_regressor_values.

Referenced by init_driver().

{
  for (typename T::iterator iter = w.begin(); iter != w.end(); ++iter)
    if (*iter != 0)
      dat.loaded_regressor_values++;
}