Struct CmaEs 

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

Covariance Matrix Adaptation Evolution Strategy.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::cma_es::{CmaEsConfig, CmaEs};

let strategy = CmaEs::<Flex>::new();
let params = CmaEsConfig::default_for(10);
let _ = (strategy, params);

Implementations

impl<B: Backend> CmaEs<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

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

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

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

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

Formats the value using the given formatter.

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

fn default() -> CmaEs<B>

Returns the “default value” for a type.

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

where B::Device: Clone,

fn init( &self, params: &CmaEsConfig, rng: &mut dyn Rng, _device: &<B as BackendTypes>::Device, ) -> CmaEsState<B>

Initializes m⁰ uniformly in params.bounds (host-RNG convention), C = I, σ = initial_sigma, and both evolution paths to zero.

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

Samples λ offspring from N(m, σ²C).

The covariance is eigendecomposed into C = B diag(Λ) Bᵀ; each offspring is xᵢ = m + σ · B diag(√Λ) zᵢ for zᵢ ~ N(0, I), drawn host-side from a deterministic SeedPurpose::CmaSampling stream. The distribution parameters are returned unchanged (the mean/covariance update happens in tell, which recomputes the steps from the population).

The one thing ask does mutate on the returned state is the eigendecomposition memo (CmaEsState::eig): it stores the fresh decomposition of the current C so the paired tell reuses it to build C^{-1/2} instead of decomposing the same unchanged matrix a second time. ask produces the memo and never trusts a prior one.

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

Ranks the offspring, recombines the mean, and runs CSA + the rank-1 / rank-μ covariance updates.

Lost generations

The rank-μ update needs μ usable selection steps. Ranking already sanitizes (NaN → −∞) and sorts with total_cmp, so a non-finite fitness can never rank among the best — but if fewer than μ sanitized values are finite, non-usable individuals would still fill out the selected μ and feed meaningless steps yᵢ = (xᵢ − m)/σ into the mean and covariance updates. When that happens tell takes a deliberate lost generation: the entire adaptive update (mean, C, p_σ, p_c, σ, and the eigendecomposition memo) is skipped and the search distribution is left exactly unchanged. A legitimate −∞ counts as non-usable here — it marks a member evaluation that broke, so it cannot contribute a meaningful recombination step.

A lost generation still advances the generation counter and updates best-so-far tracking. Advancing the counter matters for determinism: the per-generation sampling stream is keyed on seed_stream(_, generation, _), so bumping it ensures the next ask draws a fresh offspring batch rather than replaying the identical draw that just failed. The retained eigendecomposition memo stays coherent because cov is untouched.

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

Returns the best-so-far genome and its fitness, or None before the first tell call.

type Params = CmaEsConfig

Static parameters for a run.

type State = CmaEsState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.