Struct EvolutionaryProgramming 

pub struct EvolutionaryProgramming<B: Backend> { /* private fields */ }

Classical Fogel EP.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::ep::{EpConfig, EvolutionaryProgramming};

let strategy = EvolutionaryProgramming::<Flex>::new();
let params = EpConfig::default_for(30, 10);
let _ = (strategy, params);

Implementations

impl<B: Backend> EvolutionaryProgramming<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

impl<B: Clone + Backend> Clone for EvolutionaryProgramming<B>

fn clone(&self) -> EvolutionaryProgramming<B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Copy + Backend> Copy for EvolutionaryProgramming<B>

impl<B: Debug + Backend> Debug for EvolutionaryProgramming<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Default + Backend> Default for EvolutionaryProgramming<B>

fn default() -> EvolutionaryProgramming<B>

Returns the “default value” for a type.

impl<B: Backend> Strategy<B> for EvolutionaryProgramming<B>

where B::Device: Clone,

fn init( &self, params: &EpConfig, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> EpState<B>

Samples the initial parent population uniformly within params.bounds, initializes per-parent σ to params.initial_sigma, and returns an EpState with an empty fitness cache.

Initial sampling goes through seed_stream rather than B::seed + Tensor::random to keep results reproducible across parallel test threads.

fn ask( &self, params: &EpConfig, state: &EpState<B>, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (Tensor<B, 2>, EpState<B>)

Proposes the offspring population for this generation.

First call (fitness cache empty): returns the initial parents unchanged so the caller can evaluate them before any mutation step.

Subsequent calls:

1. Applies the log-normal σ update to each parent: σ'_i = σ_i · exp(τ · N(0, 1)), host-sampled via seed_stream with SeedPurpose::Other.
2. Mutates each parent by its updated σ using gaussian_mutation_per_row, host-sampled via seed_stream with SeedPurpose::Mutation.
3. Clamps offspring to params.bounds.
4. Appends the offspring σ values to state.sigmas, making it length 2μ so Strategy::tell can select over the combined pool without re-deriving them.

Returns the offspring tensor and the updated state.

fn tell( &self, params: &EpConfig, offspring: Tensor<B, 2>, fitness: Tensor<B, 1>, state: EpState<B>, rng: &mut dyn Rng, ) -> (EpState<B>, StrategyMetrics)

Consumes the evaluated offspring and advances the state.

First call (fitness cache empty): stores the initial parent fitness, initializes best_genome/best_fitness, resets σ to params.initial_sigma, and increments the generation counter.

Subsequent calls:

1. Builds the (μ + μ) combined pool of parents and offspring (and their 2μ σ values from Strategy::ask).
2. Runs q-tournament selection: each of the 2μ members plays params.tournament_q random opponents; the member wins a bout if its fitness is strictly higher. The μ members with the most wins survive; ties are broken by fitness (higher wins). Tournament indices are host-sampled via seed_stream with SeedPurpose::Selection.
3. Updates best_genome/best_fitness from the offspring fitness if improved.

Returns the updated EpState and a StrategyMetrics snapshot covering the current offspring generation’s fitness distribution.

fn best(&self, state: &EpState<B>) -> Option<(Tensor<B, 2>, f32)>

Returns the best-so-far genome and its canonical (maximise) fitness.

Returns None before the first Strategy::tell call, when EpState::best_genome is still None.

type Params = EpConfig

Static parameters for a run.

type State = EpState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.