search.h

Go to the documentation of this file.

 
#if !defined(ULTRA_SEARCH_H)
#define      ULTRA_SEARCH_H
 
#include "kernel/evaluator_proxy.h"
#include "kernel/evolution.h"
#include "kernel/model_measurements.h"
#include "kernel/problem.h"
#include "kernel/search_log.h"
#include "kernel/search_stats.h"
#include "kernel/validation_strategy.h"
 
#include <algorithm>
#include <fstream>
#include <format>
#include <memory>
#include <string>
#include <stop_token>
#include <utility>
#include <vector>
 
namespace ultra
{

template<template<class> class ES, Evaluator E>
class basic_search
{
public:
  // ---- Member types ----
  using individual_t = evaluator_individual_t<E>;
  using fitness_t = evaluator_fitness_t<E>;
  using after_generation_callback_t =
    ultra::after_generation_callback_t<individual_t, fitness_t>;
  using refinement_callback_t =
    ultra::refinement_callback_t<evaluator_proxy<E>>;
  using on_training_new_best_callback_t =
    ultra::on_new_best_callback_t<individual_t, fitness_t>;
 
  // ---- Constructor ----
  basic_search(problem &, E);
 
  // basic_search is directly instantiable. The virtual destructor only
  // protects against accidental base-pointer deletion; polymorphic
  // ownership is discouraged.
  virtual ~basic_search() = default;
 
  // ---- Run ----
  search_stats<individual_t, fitness_t> run(
    unsigned = 1, const model_measurements<fitness_t> & = {});
 
  // ---- Hooks ----
  basic_search &after_generation(after_generation_callback_t);
  basic_search &logger(search_log &) noexcept;
  basic_search &refinement(refinement_callback_t);
  basic_search &on_training_new_best(on_training_new_best_callback_t);
 
  basic_search &messages(bool) noexcept;
  basic_search &tag(const std::string &);
  basic_search &stop_source(std::stop_source);
 
  template<ValidationStrategy, class... Args>
  basic_search &validation_strategy(Args && ...);
  basic_search &validation_strategy(const ultra::validation_strategy &);
 
  // ---- Misc ----
  [[nodiscard]] virtual bool is_valid() const;
 
protected:
  // ---- Template methods ----
  virtual void after_evolution(
    unsigned, const std::vector<model_measurements<fitness_t>> &);
 
  [[nodiscard]] virtual model_measurements<fitness_t> calculate_metrics(
    const individual_t &) const;
 
  virtual void tune_parameters();
 
  // ---- Data members ----
  evaluator_proxy<E> eva_;
 
  std::unique_ptr<ultra::validation_strategy> vs_
    {std::make_unique<as_is_validation>()};
 
  problem &prob_;  // problem we're working on
 
  // Callback functions.
  after_generation_callback_t after_generation_callback_ {};
  refinement_callback_t refinement_callback_ {};
  on_training_new_best_callback_t on_training_new_best_callback_ {};
 
private:
  // Template method of the `basic_search::run` member function.
  virtual void init();
 
  bool load();
 
  mutable search_log *search_log_ {nullptr};
  std::stop_source stop_source_ {std::nostopstate};
  std::string tag_ {};
  bool emit_messages_ {true};
};  // class basic_search
 
 
template<Evaluator E>
class search : public basic_search<alps_es, E>
{
public:
  search(problem &prob, E eva)
    : basic_search<alps_es, E>(prob, std::move(eva))
  {
  }
};
 
template<Evaluator E> search(problem &, E) -> search<E>;
 
#include "kernel/search.tcc"
}  // namespace ultra
 
#endif  // include guard