gp/src/search.tcc

Go to the documentation of this file.

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

struct no_predictor
{
};
 
namespace internal
{
 
template<class P>
[[nodiscard]] std::unique_ptr<basic_oracle> make_basic_oracle(P &&p)
{
  using predictor_t = std::remove_cvref_t<P>;
 
  if constexpr (std::derived_from<predictor_t, basic_oracle>)
    return std::make_unique<predictor_t>(std::forward<P>(p));
  // Check classification predictor before since it's the richer contract.
  else if constexpr (ClassificationPredictor<predictor_t>)
    return std::make_unique<class_oracle_adaptor<predictor_t>>(std::forward<P>(p));
  else if constexpr (RegressionPredictor<predictor_t>)
    return std::make_unique<reg_oracle_adaptor<predictor_t>>(std::forward<P>(p));
 
  return nullptr;
}
 
}  // namespace internal
 
[[nodiscard]] constexpr std::underlying_type_t<metric_flags> operator&(
  metric_flags f1, metric_flags f2)
{
  return std::to_underlying(f1) & std::to_underlying(f2);
}

template<template<class> class ES, Evaluator E>
basic_search<ES, E>::basic_search(problem &p, metric_flags m)
  : ultra::basic_search<ES, E>(p, E(p.data)), metrics_(m)
{
  Ensures(this->is_valid());
}

/// compile time via the `no_predictor` fallback rather than via runtime errors.
///
template<template<class> class ES, Evaluator E>
auto basic_search<ES, E>::predictor(const individual_t &ind) const
{
  const auto &eva_core(this->eva_.core());
 
  if constexpr (requires { eva_core.predictor(ind); })
    return eva_core.predictor(ind);
  else
    return no_predictor();
}

template<template<class> class ES, Evaluator E>
problem &basic_search<ES, E>::prob() const noexcept
{
  return static_cast<problem &>(this->prob_);
}

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
{
  auto ret(ultra::basic_search<ES, E>::calculate_metrics(prg));
  const auto prg_predictor(predictor(prg));
 
  if constexpr (ClassificationPredictor<decltype(prg_predictor)>)
    if ((metrics_ & metric_flags::accuracy) && prob().classification())
    {
      ret.accuracy = metrics::accuracy(prg_predictor, prob().data.selected());
    }
 
  return ret;
}

template<template<class> class ES, Evaluator E>
void basic_search<ES, E>::tune_parameters()
{
  // The `shape` function modifies the default parameters with
  // strategy-specific values.
  const auto dflt(ES<E>::shape(parameters().init()));
 
  auto &params(prob().params);
 
  // Contains user-specified parameters that will be partly changed by this
  // function.
  const auto constrained(params);
 
  ultra::basic_search<ES, E>::tune_parameters();
 
  const auto d_size(prob().data.selected().size());
  Expects(d_size);
 
  if (!constrained.population.init_subgroups)
  {
    if (dflt.population.init_subgroups > 1 && d_size > 8)
      params.population.init_subgroups =
        static_cast<std::size_t>(std::log(d_size));
    else
      params.population.init_subgroups = dflt.population.init_subgroups;
 
    ultraINFO("Number of layers set to {}", params.population.init_subgroups);
  }
 
  // A larger number of training cases requires an increase in the population
  // size (e.g. https://github.com/morinim/ultra/wiki/bibliography#11 suggests
  // 10 - 1000 individuals for smaller problems; between 1000 and 10000
  // individuals for complex problem (more than 200 fitness cases).
  //
  // We chose a strictly increasing function to link training set size and
  // population size.
  if (!constrained.population.individuals)
  {
    if (d_size > 8)
    {
      params.population.individuals =
        2 * static_cast<std::size_t>(std::pow(std::log2(d_size), 3))
        / params.population.init_subgroups;
    }
    else
      params.population.individuals = dflt.population.individuals;
 
    if (params.population.individuals < 4)
      params.population.individuals = 4;
 
    ultraINFO("Population size set to {}", params.population.individuals);
  }
 
  Ensures(params.is_valid(true));
}

template<template<class> class ES, Evaluator E>
bool basic_search<ES, E>::is_valid() const
{
  return ultra::basic_search<ES, E>::is_valid();
}
 
template<Individual P>
search<P>::search(problem &p, metric_flags m)
  : engine_(make_engine(p, m)), prob_(p), classification_(p.classification())
{
}
 
template<Individual P>
typename search<P>::engine_t search<P>::make_engine(problem &p, metric_flags m)
{
  if (p.classification())
    return engine_t(std::in_place_type<class_search_t>, p, m);
 
  return engine_t(std::in_place_type<reg_search_t>, p, m);
}
 
template<Individual P>
bool search<P>::problem_type_unchanged() const noexcept
{
  return classification_ == prob_.classification();
}

template<Individual P>
search<P> &search<P>::stop_source(std::stop_source ss)
{
  std::visit([&](auto &s) { s.stop_source(ss); }, engine_);
  return *this;
}

template<Individual P>
search<P> &search<P>::logger(search_log &sl)
{
  Expects(sl.is_valid());
 
  std::visit([&](auto &s) { s.logger(sl); }, engine_);
  return *this;
}
 
template<Individual P>
search<P> &search<P>::messages(bool m) noexcept
{
  std::visit([&](auto &s) { s.messages(m); }, engine_);
  return *this;
}

template<Individual P>
search<P> &search<P>::tag(const std::string &t)
{
  std::visit([&](auto &s) { s.tag(t); }, engine_);
  return *this;
}
 
template<Individual P>
search_stats<P, typename search<P>::fitness_t> search<P>::run(
  unsigned n, const model_measurements<fitness_t> &threshold)
{
  Expects(problem_type_unchanged());
 
  return std::visit([&](auto &s) { return s.run(n, threshold); }, engine_);
}

template<Individual P>
template<class F>
search<P> &search<P>::refinement(F &&f)
{
  using callback_t = std::remove_cvref_t<F>;
 
  constexpr bool class_ok = std::is_invocable_r_v<
    std::optional<fitness_t>, callback_t &, P &,
    const evaluator_proxy<class_evaluator_t> &,
    const parameters::refinement_parameters &>;
 
  constexpr bool reg_ok = std::is_invocable_r_v<
    std::optional<fitness_t>, callback_t &, P &,
    const evaluator_proxy<reg_evaluator_t> &,
    const parameters::refinement_parameters &>;
 
  static_assert(class_ok || reg_ok,
                "Refinement callback is not compatible with available "
                "evaluator signatures");
 
  auto callback(std::forward<F>(f));
 
  std::visit(
    [&](auto &s)
    {
      s.refinement({});
 
      using search_t = std::remove_cvref_t<decltype(s)>;
 
      constexpr bool compatible =
        (std::same_as<search_t, class_search_t> && class_ok)
        || (std::same_as<search_t, reg_search_t> && reg_ok);
 
      if constexpr (compatible)
        s.refinement(callback);
    },
    engine_);
 
  return *this;
}

template<Individual P>
std::unique_ptr<basic_oracle> search<P>::predictor(const P &prg) const
{
  Expects(problem_type_unchanged());
 
  return std::visit(
    [&](const auto &s) { return internal::make_basic_oracle(s.predictor(prg)); },
    engine_);
}

template<Individual P>
search<P> &search<P>::after_generation(after_generation_callback_t f)
{
  std::visit([&](auto &s) { s.after_generation(std::move(f)); }, engine_);
  return *this;
}

template<Individual P>
search<P> &search<P>::on_training_new_best(on_training_new_best_callback_t f)
{
  std::visit([&](auto &s) { s.on_training_new_best(std::move(f)); }, engine_);
  return *this;
}

template<Individual P>
template<ValidationStrategy V, class... Args>
search<P> &search<P>::validation_strategy(Args && ...args)
{
  std::visit(
    [&](auto &s)
    { s.template validation_strategy<V>(std::forward<Args>(args)...); },
    engine_);
  return *this;
}
 
#endif  // include guard