Struct GeneticAlgorithm 

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

Real-valued canonical Genetic Algorithm.

Example

use burn::backend::Flex;
use rlevo_core::bounds::Bounds;
use rlevo_core::rate::NonNegativeRate;
use rlevo_evolution::algorithms::ga::{
    GaConfig, GaCrossover, GaReplacement, GaSelection, GeneticAlgorithm,
};

let strategy = GeneticAlgorithm::<Flex>::new();
let params = GaConfig {
    pop_size: 64,
    genome_dim: 10,
    bounds: Bounds::new(-5.12, 5.12),
    mutation_sigma: NonNegativeRate::new(0.3),
    selection: GaSelection::Tournament { size: 2 },
    crossover: GaCrossover::BlxAlpha { alpha: NonNegativeRate::new(0.5) },
    replacement: GaReplacement::Elitist { elitism_k: 2 },
};
let _ = (strategy, params);

Implementations

impl<B: Backend> GeneticAlgorithm<B>

pub fn new() -> Self

Build a new (stateless) strategy object.

Trait Implementations

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

fn clone(&self) -> GeneticAlgorithm<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 GeneticAlgorithm<B>

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

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

Formats the value using the given formatter.

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

fn default() -> GeneticAlgorithm<B>

Returns the “default value” for a type.

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

where B::Device: Clone,

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

Build the initial state.

Samples an (pop_size, genome_dim) real-valued population uniformly within params.bounds using a host RNG derived from rng. Sets fitness to empty and best_fitness to f32::NEG_INFINITY (the worst value under the maximise convention); the first tell call populates both.

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

Propose the next offspring population.

On the very first call (before any tell), state.fitness is empty — the harness has not evaluated the seed population yet. In that case the unchanged seed population is returned so the harness can evaluate and pass it back to tell.

On subsequent calls the method runs selection → crossover → mutation, deriving three independent host sub-streams from rng via crate::rng::seed_stream:

• SeedPurpose::Selection — two independent tournament draws (parents A and parents B);
• SeedPurpose::Crossover — BLX-α or uniform crossover;
• SeedPurpose::Mutation — isotropic Gaussian perturbation.

After mutation, offspring are clamped to params.bounds.

fn tell( &self, params: &GaConfig, population: Tensor<B, 2>, fitness: Tensor<B, 1>, state: GaState<B>, _rng: &mut dyn Rng, ) -> (GaState<B>, StrategyMetrics)

Consume offspring fitness and produce the next generation’s state.

The first call (when state.fitness is empty) caches the seed population’s fitness and increments the generation counter; no replacement is performed.

On subsequent calls the replacement policy is applied:

• GaReplacement::Generational — offspring completely replace parents.
• GaReplacement::Elitist — the elitism_k highest-fitness parents survive; the remainder come from offspring.

fitness must have shape (pop_size,) in the canonical maximise convention — higher is better.

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

Return the best-so-far genome and its fitness.

Returns None before the first tell call. The fitness value uses the canonical maximise convention (higher is better).

type Params = GaConfig

Static parameters for a run.

type State = GaState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.