search.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_SEARCH_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_SEARCH_TCC)
#define      ULTRA_SEARCH_TCC

template<template<class> class ES, Evaluator E>
basic_search<ES, E>::basic_search(problem &prob, E eva)
  : eva_(std::move(eva), prob.params.cache.size), prob_(prob)
{
  Ensures(is_valid());
}

template<template<class> class ES, Evaluator E>
void basic_search<ES, E>::init()
{
  tune_parameters();
 
  if (!load())
    ultraINFO("Init continues without cache");
}
 
template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::messages(bool m) noexcept
{
  emit_messages_ = m;
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::stop_source(std::stop_source ss)
{
  stop_source_ = ss;
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::logger(search_log &sl) noexcept
{
  search_log_ = &sl;
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::tag(const std::string &t)
{
  tag_ = t;
  return *this;
}

template<template<class> class ES, Evaluator E>
void basic_search<ES, E>::after_evolution(
  unsigned run, const std::vector<model_measurements<fitness_t>> &mm)
{
  Expects(mm.size());
 
  static const std::vector<std::string> phase_names {"TRAINING", "VALIDATION"};
 
  const std::string tags(tag_.empty() ? tag_ : "[" + tag_ + "] ");
 
  for (std::size_t i(0); const auto &m : mm)
  {
    std::string accuracy;
    if (m.accuracy)
      accuracy = std::format("{:.6g}%", *m.accuracy * 100.0);
 
    if (emit_messages_)
    {
      const auto phase(mm.size() <= phase_names.size()
                       ? phase_names[i] : "PHASE" + std::to_string(i));
 
      ultraPAROUT("{}Run {} {}. Fitness: {}  Accuracy: {}",
                  tags, run, phase, internal::streamed(*m.fitness), accuracy);
    }
 
    ++i;
  }
}
 
template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::refinement(refinement_callback_t f)
{
  refinement_callback_ = std::move(f);
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::after_generation(
  after_generation_callback_t f)
{
  after_generation_callback_ = std::move(f);
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::on_training_new_best(
  on_training_new_best_callback_t f)
{
  on_training_new_best_callback_ = std::move(f);
  return *this;
}

template<template<class> class ES, Evaluator E>
void basic_search<ES, E>::tune_parameters()
{
  auto &params(prob_.params);
 
  // The `shape` function modifies the default parameters with
  // strategy-specific values.
  const auto dflt(ES<E>::shape(parameters().init()));
  assert(!dflt.needs_init());
 
  // User specified values are constraints.
  const auto constrained(params);
 
  params.fill_undefined_from(dflt);
 
  if (!constrained.evolution.mate_zone)
    params.evolution.mate_zone =
      std::max<std::size_t>(params.population.individuals / 5, 4);
 
  Ensures(params.is_valid(true));
}

template<template<class> class ES, Evaluator E>
search_stats<typename basic_search<ES, E>::individual_t,
             typename basic_search<ES, E>::fitness_t>
basic_search<ES, E>::run(unsigned n,
                         const model_measurements<fitness_t> &threshold)
{
  init();
 
  shake_function_callback_t shake([this](unsigned g) { return vs_->shake(g); });
  search_stats<individual_t, fitness_t> stats;
 
  for (unsigned r(0); r < n && !stop_source_.stop_requested(); ++r)
  {
    if (vs_->training_setup(r) == evaluation_context::changed)
      invalidate_cache_if_supported(eva_);
 
    evolution evo(prob_, eva_);
    if (search_log_)
      evo.logger(*search_log_);
    evo.after_generation(after_generation_callback_)
       .messages(emit_messages_)
       .on_new_best(on_training_new_best_callback_)
       .refinement(refinement_callback_)
       .shake_function(shake)
       .stop_source(stop_source_)
       .tag(tag_);
 
    const auto run_summary(evo.template run<ES>());
 
    if (const auto prg(run_summary.best().ind); !prg.empty())
    {
      std::vector metrics = { calculate_metrics(prg) };  // training metrics
 
      if (vs_->validation_setup(r))
        metrics.push_back(calculate_metrics(prg));  // validation metrics
 
      after_evolution(r, metrics);
 
      // Update the search statistics (possibly using the validation setup).
      stats.update(prg, metrics.back(), run_summary.elapsed);
    }
 
    if (search_log_)
      search_log_->save_summary(stats, threshold);
  }
 
  return stats;
}

template<template<class> class ES, Evaluator E>
model_measurements<typename basic_search<ES, E>::fitness_t>
basic_search<ES, E>::calculate_metrics(const individual_t &prg) const
{
  model_measurements<fitness_t> ret;
 
  // `calculate_metrics` is called after an environment-switch and must not use
  // a cached value (so using `core()`).
  ret.fitness = eva_.core()(prg);
 
  return ret;
}

template<template<class> class ES, Evaluator E>
template<ValidationStrategy V, class... Args>
basic_search<ES, E> &basic_search<ES, E>::validation_strategy(Args && ...args)
{
  vs_ = std::make_unique<V>(std::forward<Args>(args)...);
  return *this;
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E> &basic_search<ES, E>::validation_strategy(
  const ultra::validation_strategy &vs)
{
  vs_ = vs.clone();
  return *this;
}

template<template<class> class ES, Evaluator E>
bool basic_search<ES, E>::load()
{
  const auto &file(prob_.params.cache.serialization_file);
 
  if (file.empty())
    return true;
 
  if (!prob_.params.cache.size)
  {
    ultraINFO("Cache size is 0; skipping cache load from {}", file.string());
    return false;
  }
 
  std::ifstream in(file);
  if (!in)
  {
    ultraWARNING("Cannot open cache file {}", file.string());
    return false;
  }
 
  if (!eva_.load_cache(in))
  {
    ultraWARNING("Cannot load cache from {}", file.string());
    return false;
  }
 
  ultraINFO("Loaded cache from {}", file.string());
  return true;
}

template<template<class> class ES, Evaluator E>
bool basic_search<ES, E>::is_valid() const
{
  return true;
}
 
#endif  // include guard