evolution_strategy.tcc

Go to the documentation of this file.

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

template<Evaluator E>
evolution_strategy<E>::evolution_strategy(const problem &prob, E &eva)
  : eva_(eva), prob_(prob)
{
}
 
template<Evaluator E>
template<LayeredPopulation P>
bool evolution_strategy<E>::valid_layer(P &pop, typename P::layer_iter iter)
{
  return pop.layers() && iterator_of(iter, pop.range_of_layers());
}

template<Evaluator E>
template<Population P>
P *evolution_strategy<E>::refinement_subgroup(P &pop) const noexcept
{
  return &pop;
}

template<Evaluator E>
template<Population P>
std::size_t evolution_strategy<E>::max_parallelism(const P &pop) const noexcept
{
  if constexpr (LayeredPopulation<P>)
    return pop.layers();
 
  return 1;
}

template<Evaluator E>
template<Population P>
void evolution_strategy<E>::after_generation(
  P &pop, const summary<individual_t, fitness_t> &sum)
{
  pop.inc_age();
 
  if constexpr (LayeredPopulation<P>)
  {
    assert(&pop.problem() == &this->get_problem());
    const auto &params(pop.problem().params);
    assert(params.evolution.max_stuck_gen);
 
    for (const auto layers(pop.range_of_layers()); auto &layer : layers)
      if (sum.stagnation() > params.evolution.max_stuck_gen
          && issmall(sum.az.fit_dist(layer).variance()))
      {
        layer.reset(pop.problem());
        ultraINFO("Resetting layer {}", layer.uid());
      }
  }
}

template<Evaluator E>
alps_es<E>::alps_es(const problem &prob, E &eva)
  : evolution_strategy<E>(prob, eva),
    select_(this->eva_, prob.params),
    recombine_(this->eva_, prob),
    replace_(this->eva_, prob.params)
{
}

template<Evaluator E>
template<LayeredPopulation P>
auto alps_es<E>::operations(
  P &pop, typename P::layer_iter iter,
  const evolution_status<individual_t, fitness_t> &starting_status) const
{
  Expects(this->valid_layer(pop, iter));
 
  return
    [this,
     sel_pop = alps::selection_layers(pop, iter),
     rep_pop = alps::replacement_layers(pop, iter),
     status = starting_status] mutable
    {
      Ensures(sel_pop.size());
      Ensures(rep_pop.size());
      Ensures(&sel_pop.primary() == &rep_pop.primary());
 
      const auto parents(this->select_(sel_pop));
      const auto offspring(this->recombine_(parents));
      this->replace_(rep_pop, offspring, status);
    };
}

template<Evaluator E>
template<LayeredPopulation P>
void alps_es<E>::init(P &pop) const
{
  alps::set_age(pop);
}

template<Evaluator E>
template<LayeredPopulation P>
auto *alps_es<E>::refinement_subgroup(P &pop) const noexcept
{
  return pop.layers() < 3 ? nullptr : &pop.back();
}

template<Evaluator E>
template<LayeredPopulation P>
std::size_t alps_es<E>::max_parallelism(const P &) const noexcept
{
  return hardware_threads();
}

template<Evaluator E>
template<LayeredPopulation P>
void alps_es<E>::after_generation(P &pop,
                                  const summary<individual_t, fitness_t> &sum)
{
  Expects(&pop.problem() == &this->get_problem());
 
  const auto &params(pop.problem().params);
  Expects(params.alps.max_layers > 1);
 
  pop.inc_age();
 
  const auto layers(pop.range_of_layers());
  bool layer_structure_changed(false);
 
  if (pop.layers() > 1)
  {
    auto layer(std::next(layers.begin()));
 
    while (layer != layers.end())
    {
      if (almost_equal(sum.az.fit_dist(*std::prev(layer)).mean(),
                       sum.az.fit_dist(*layer).mean()))
      {
        ultraDEBUG("ALPS: erasing layer UID={}", layer->uid());
        layer = pop.erase(layer);
        layer_structure_changed = true;
      }
      else
      {
        const auto sd(sum.az.fit_dist(*layer).standard_deviation());
        const bool converged(issmall(sd));
 
        if (converged)
        {
          const auto prev_allowed(layer->allowed());
          const auto new_allowed(std::max(params.population.min_individuals,
                                          layer->size() / 2));
 
          if (new_allowed < prev_allowed)
          {
            ultraDEBUG("ALPS: decreasing allowed individuals of layer "
                         "UID={} to {}", layer->uid(), new_allowed);
 
            layer->allowed(new_allowed);
          }
        }
        else if (layer->allowed() < params.population.individuals)
        {
          ultraDEBUG("ALPS: restoring allowed individuals of layer UID={} "
                       "to {}", layer->uid(), params.population.individuals);
 
          layer->allowed(params.population.individuals);
        }
 
        ++layer;
      }
    }
  }
 
  // Code executed every `age_gap` interval.
  if (sum.generation && sum.generation % params.alps.age_gap == 0)
  {
    if (pop.layers() < params.alps.max_layers)
    {
      ultraDEBUG("ALPS: adding layer");
      pop.add_layer();
      layer_structure_changed = true;
    }
    else
    {
      ultraDEBUG("ALPS: try moving up first layer");
      this->replace_.try_promote_individuals(pop.front(), pop.layer(1));
      pop.init(pop.front());
    }
  }
 
  if (layer_structure_changed)
    alps::set_age(pop);
}

template<Evaluator E>
parameters alps_es<E>::shape(parameters params)
{
  params.alps.age_gap = 20;
  params.alps.max_layers =
    std::max<unsigned>(2, std::thread::hardware_concurrency());
  params.alps.p_main_layer = 0.75;
 
  return params;
}
 
template<Evaluator E>
std_es<E>::std_es(const problem &prob, E &eva)
  : evolution_strategy<E>(prob, eva),
    select_(this->eva_, prob.params),
    recombine_(this->eva_, prob),
    replace_(this->eva_, prob.params)
{
}

template<Evaluator E>
template<SizedRandomAccessPopulation P>
auto std_es<E>::operations(
  P &pop,
  const evolution_status<individual_t, fitness_t> &starting_status) const
{
  return
    [this, &p = pop, status = starting_status]() mutable
    {
      Ensures(!p.empty());
 
      const auto parents(this->select_(p));
      const auto offspring(this->recombine_(parents));
      this->replace_(p, offspring, status);
    };
}

template<Evaluator E>
template<LayeredPopulation P>
auto std_es<E>::operations(
  [[maybe_unused]] P &pop, typename P::layer_iter iter,
  const evolution_status<individual_t, fitness_t> &starting_status) const
{
  Expects(this->valid_layer(pop, iter));
 
  return operations(*iter, starting_status);
}
 
template<Evaluator E>
de_es<E>::de_es(const problem &prob, E &eva)
  : evolution_strategy<E>(prob, eva),
    recombine_(prob),
    replace_(this->eva_, prob.params)
{
}

template<Evaluator E>
template<SizedRandomAccessPopulation P>
auto de_es<E>::operations(
  [[maybe_unused]] P &pop,
  const evolution_status<individual_t, fitness_t> &starting_status) const
{
  return
    [this, &p = pop, status = starting_status]() mutable
    {
      Ensures(!p.empty());
 
      const auto selected(this->select_(p));
      const auto offspring(this->recombine_(selected));
      this->replace_(selected.target, offspring, status);
    };
}

template<Evaluator E>
template<LayeredPopulation P>
auto de_es<E>::operations(
  [[maybe_unused]] P &pop, typename P::layer_iter iter,
  const evolution_status<individual_t, fitness_t> &starting_status) const
{
  Expects(this->valid_layer(pop, iter));
 
  return operations(*iter, starting_status);
}
 
#endif  // include guard