gd_mf.h File Reference

Go to the source code of this file.

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

Function Documentation

gd_mf_setup()

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

Definition at line 327 of file gd_mf.cc.

References VW::config::option_group_definition::add(), VW::config::options_i::add_and_parse(), LEARNER::end_pass(), vw::eta, f, VW::config::options_i::get_typed_option(), shared_data::holdout_best_loss, vw::holdout_set_off, LEARNER::init_learner(), vw::initial_t, learn(), LEARNER::make_base(), VW::config::make_option(), vw::power_t, ldamath::powf(), predict(), vw::random_weights, save_load(), vw::sd, LEARNER::learner< T, E >::set_end_pass(), LEARNER::learner< T, E >::set_save_load(), parameters::stride_shift(), shared_data::t, THROW, UINT64_ONE, VW::config::options_i::was_supplied(), and vw::weights.

Referenced by parse_reductions().

{
  auto data = scoped_calloc_or_throw<gdmf>();

  bool bfgs = false;
  bool conjugate_gradient = false;
  option_group_definition gf_md_options("Gradient Descent Matrix Factorization");
  gf_md_options.add(make_option("rank", data->rank).keep().help("rank for matrix factorization."));

  // Not supported, need to be checked to be false.
  gf_md_options.add(make_option("bfgs", bfgs).help("Option not supported by this reduction"));
  gf_md_options.add(
      make_option("conjugate_gradient", conjugate_gradient).help("Option not supported by this reduction"));
  options.add_and_parse(gf_md_options);

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

  if (options.was_supplied("adaptive"))
    THROW("adaptive is not implemented for matrix factorization");
  if (options.was_supplied("normalized"))
    THROW("normalized is not implemented for matrix factorization");
  if (options.was_supplied("exact_adaptive_norm"))
    THROW("normalized adaptive updates is not implemented for matrix factorization");

  if (bfgs || conjugate_gradient)
    THROW("bfgs is not implemented for matrix factorization");

  data->all = &all;
  data->no_win_counter = 0;

  // store linear + 2*rank weights per index, round up to power of two
  float temp = ceilf(logf((float)(data->rank * 2 + 1)) / logf(2.f));
  all.weights.stride_shift((size_t)temp);
  all.random_weights = true;

  if (!all.holdout_set_off)
  {
    all.sd->holdout_best_loss = FLT_MAX;
    data->early_stop_thres = options.get_typed_option<size_t>("early_terminate").value();
  }

  if (!options.was_supplied("learning_rate") && !options.was_supplied("l"))
    all.eta = 10;  // default learning rate to 10 for non default update rule

  // default initial_t to 1 instead of 0
  if (!options.was_supplied("initial_t"))
  {
    all.sd->t = 1.f;
    all.initial_t = 1.f;
  }
  all.eta *= powf((float)(all.sd->t), all.power_t);

  learner<gdmf, example>& l = init_learner(data, learn, predict, (UINT64_ONE << all.weights.stride_shift()));
  l.set_save_load(save_load);
  l.set_end_pass(end_pass);

  return make_base(l);
}