parse_args.h File Reference

#include "global_data.h"
#include "options.h"

Go to the source code of this file.

Classes
struct	input_options

Functions
vw &	parse_args (VW::config::options_i &options, trace_message_t trace_listener=nullptr, void *trace_context=nullptr)
void	parse_modules (VW::config::options_i &options, vw &all)
void	parse_sources (VW::config::options_i &options, vw &all, io_buf &model, bool skipModelLoad=false)
LEARNER::base_learner *	setup_base (VW::config::options_i &options, vw &all)
std::string	spoof_hex_encoded_namespaces (const std::string &arg)

Function Documentation

parse_args()

vw& parse_args	(	VW::config::options_i &	options,
		trace_message_t	trace_listener = nullptr,
		void *	trace_context = nullptr
	)

Definition at line 1308 of file parse_args.cc.

References VW::config::option_group_definition::add(), add(), VW::config::options_i::add_and_parse(), vw::all_reduce, vw::all_reduce_type, vw::eta, vw::eta_decay_rate, vw::feature_mask, VW::finish(), vw::init_time, vw::initial_regressors, vw::initial_t, vw::initial_weight, VW::config::make_option(), vw::normal_weights, vw::options, vw::p, parse_diagnostics(), vw::per_feature_regularizer_input, vw::power_t, vw::quiet, vw::random_weights, vw::sd, Socket, parameters::sparse, shared_data::t, THROW, vw::tnormal_weights, vw_ostream::trace_context, vw_ostream::trace_listener, vw::trace_message, VW::config::options_i::was_supplied(), and vw::weights.

Referenced by VW::initialize().

{
  vw& all = *(new vw());
  all.options = &options;

  if (trace_listener)
  {
    all.trace_message.trace_listener = trace_listener;
    all.trace_message.trace_context = trace_context;
  }

  try
  {
    time(&all.init_time);

    bool strict_parse = false;
    size_t ring_size;
    option_group_definition vw_args("VW options");
    vw_args.add(make_option("ring_size", ring_size).default_value(256).help("size of example ring"))
        .add(make_option("strict_parse", strict_parse).help("throw on malformed examples"));
    options.add_and_parse(vw_args);

    all.p = new parser{ring_size, strict_parse};

    option_group_definition update_args("Update options");
    update_args.add(make_option("learning_rate", all.eta).help("Set learning rate").short_name("l"))
        .add(make_option("power_t", all.power_t).help("t power value"))
        .add(make_option("decay_learning_rate", all.eta_decay_rate)
                 .help("Set Decay factor for learning_rate between passes"))
        .add(make_option("initial_t", all.sd->t).help("initial t value"))
        .add(make_option("feature_mask", all.feature_mask)
                 .help("Use existing regressor to determine which parameters may be updated.  If no initial_regressor "
                       "given, also used for initial weights."));
    options.add_and_parse(update_args);

    option_group_definition weight_args("Weight options");
    weight_args
        .add(make_option("initial_regressor", all.initial_regressors).help("Initial regressor(s)").short_name("i"))
        .add(make_option("initial_weight", all.initial_weight).help("Set all weights to an initial value of arg."))
        .add(make_option("random_weights", all.random_weights).help("make initial weights random"))
        .add(make_option("normal_weights", all.normal_weights).help("make initial weights normal"))
        .add(make_option("truncated_normal_weights", all.tnormal_weights).help("make initial weights truncated normal"))
        .add(make_option("sparse_weights", all.weights.sparse).help("Use a sparse datastructure for weights"))
        .add(make_option("input_feature_regularizer", all.per_feature_regularizer_input)
                 .help("Per feature regularization input file"));
    options.add_and_parse(weight_args);

    std::string span_server_arg;
    int span_server_port_arg;
    // bool threads_arg;
    size_t unique_id_arg;
    size_t total_arg;
    size_t node_arg;
    option_group_definition parallelization_args("Parallelization options");
    parallelization_args
        .add(make_option("span_server", span_server_arg).help("Location of server for setting up spanning tree"))
        //(make_option("threads", threads_arg).help("Enable multi-threading")) Unused option?
        .add(make_option("unique_id", unique_id_arg).default_value(0).help("unique id used for cluster parallel jobs"))
        .add(
            make_option("total", total_arg).default_value(1).help("total number of nodes used in cluster parallel job"))
        .add(make_option("node", node_arg).default_value(0).help("node number in cluster parallel job"))
        .add(make_option("span_server_port", span_server_port_arg)
                 .default_value(26543)
                 .help("Port of the server for setting up spanning tree"));
    options.add_and_parse(parallelization_args);

    // total, unique_id and node must be specified together.
    if ((options.was_supplied("total") || options.was_supplied("node") || options.was_supplied("unique_id")) &&
        !(options.was_supplied("total") && options.was_supplied("node") && options.was_supplied("unique_id")))
    {
      THROW("you must specificy unique_id, total, and node if you specify any");
    }

    if (options.was_supplied("span_server"))
    {
      all.all_reduce_type = AllReduceType::Socket;
      all.all_reduce =
          new AllReduceSockets(span_server_arg, span_server_port_arg, unique_id_arg, total_arg, node_arg, all.quiet);
    }

    parse_diagnostics(options, all);

    all.initial_t = (float)all.sd->t;
    return all;
  }
  catch (...)
  {
    VW::finish(all);
    throw;
  }
}

parse_modules()

void parse_modules	(	VW::config::options_i &	options,
		vw &	all
	)

parse_sources()

void parse_sources	(	VW::config::options_i &	options,
		vw &	all,
		io_buf &	model,
		bool	skipModelLoad = false
	)

Definition at line 1551 of file parse_args.cc.

References io_buf::close_file(), enable_sources(), LEARNER::learner< T, E >::increment, vw::l, load_input_model(), vw::numpasses, parse_source(), vw::quiet, parameters::stride_shift(), vw::weights, and vw::wpp.

Referenced by VW::initialize().

{
  if (!skipModelLoad)
    load_input_model(all, model);
  else
    model.close_file();

  auto parsed_source_options = parse_source(all, options);
  enable_sources(all, all.quiet, all.numpasses, parsed_source_options);

  // force wpp to be a power of 2 to avoid 32-bit overflow
  uint32_t i = 0;
  size_t params_per_problem = all.l->increment;
  while (params_per_problem > ((uint64_t)1 << i)) i++;
  all.wpp = (1 << i) >> all.weights.stride_shift();
}

setup_base()

LEARNER::base_learner* setup_base	(	VW::config::options_i &	options,
		vw &	all
	)

Definition at line 1222 of file parse_args.cc.

References vw::reduction_stack, and setup_base().

Referenced by active_cover_setup(), active_setup(), audit_regressor_setup(), autolink_setup(), baseline_setup(), binary_setup(), boosting_setup(), bs_setup(), cb_adf_setup(), cb_algs_setup(), cb_explore_setup(), cb_sample_setup(), cbify_setup(), cbifyldf_setup(), CCB::ccb_explore_adf_setup(), classweight_setup(), confidence_setup(), cs_active_setup(), CSOAA::csldf_setup(), CSOAA::csoaa_setup(), ect_setup(), explore_eval_setup(), ExpReplay::expreplay_setup(), interact_setup(), log_multi_setup(), lrq_setup(), lrqfa_setup(), marginal_setup(), memory_tree_setup(), mf_setup(), multilabel_oaa_setup(), mwt_setup(), nn_setup(), oaa_setup(), parse_reductions(), recall_tree_setup(), scorer_setup(), VW::cb_explore_adf::softmax::setup(), VW::cb_explore_adf::greedy::setup(), VW::cb_explore_adf::first::setup(), VW::cb_explore_adf::bag::setup(), VW::cb_explore_adf::cover::setup(), VW::cb_explore_adf::regcb::setup(), Search::setup(), setup_base(), VW::shared_feature_merger::shared_feature_merger_setup(), stagewise_poly_setup(), topk_setup(), and warm_cb_setup().

{
  auto setup_func = all.reduction_stack.top();
  all.reduction_stack.pop();
  auto base = setup_func(options, all);

  if (base == nullptr)
    return setup_base(options, all);
  else
    return base;
}

spoof_hex_encoded_namespaces()

std::string spoof_hex_encoded_namespaces

(

const std::string &

arg

)

Definition at line 568 of file parse_args.cc.

References c.

Referenced by lrq_setup(), lrqfa_setup(), and parse_feature_tweaks().

{
  std::string res;
  int pos = 0;
  while (pos < (int)arg.size() - 3)
  {
    if (arg[pos] == '\\' && arg[pos + 1] == 'x')
    {
      std::string substr = arg.substr(pos + 2, 2);
      char* p;
      unsigned char c = (unsigned char)strtoul(substr.c_str(), &p, 16);
      if (*p == '\0')
      {
        res.push_back(c);
        pos += 4;
      }
      else
      {
        cerr << "Possibly malformed hex representation of a namespace: '\\x" << substr << "'\n";
        res.push_back(arg[pos++]);
      }
    }
    else
      res.push_back(arg[pos++]);
  }

  while (pos < (int)arg.size())  // copy last 2 characters
    res.push_back(arg[pos++]);

  return res;
}