Struct WeightOnly 

pub struct WeightOnly<B, S, M>
where
    B: Backend,
    S: Strategy<B, Genome = Tensor<B, 2>>,
    M: Module<B>,
{ /* private fields */ }

Composes a flat-genome Strategy with a fixed-topology Burn Module.

Type Parameters

• B: Burn backend (non-autodiff — see module docs).
• S: inner strategy with Genome = Tensor<B, 2> (GA, ES, DE, …).
• M: the network whose weights are evolved.

Example

let template = MyMlp::<B>::new(&device);
let strategy = WeightOnly::new(GeneticAlgorithm::<B>::new(), template.clone());
let params = GaConfig::default_for(64, strategy.num_params());
// pair with a ModuleEvalFn over the same template in the harness

Implementations

impl<B, S, M> WeightOnly<B, S, M>

where B: Backend, S: Strategy<B, Genome = Tensor<B, 2>>, M: Module<B>,

pub fn new(inner: S, template: M) -> Self

Build a wrapper from an inner strategy and a template module.

The template is cloned into a ModuleReshaper; its float-leaf count becomes num_params, which must equal the inner strategy’s configured genome width.

pub fn num_params(&self) -> usize

Genome width — the number of float parameters in the template module.

pub fn reshaper(&self) -> &ModuleReshaper<B, M>

Borrow the owned reshaper (e.g. to build a matching fitness adapter).

pub fn inner(&self) -> &S

Borrow the inner strategy.

Trait Implementations

impl<B, S, M> Debug for WeightOnly<B, S, M>

where B: Backend, S: Strategy<B, Genome = Tensor<B, 2>>, M: Module<B>,

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

Formats the value using the given formatter.

impl<B, S, M> Strategy<B> for WeightOnly<B, S, M>

where B: Backend, S: Strategy<B, Genome = Tensor<B, 2>>, M: Module<B> + Sync,

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

Pure delegation to the inner strategy’s init.

fn ask( &self, params: &Self::Params, state: &Self::State, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (Self::Genome, Self::State)

Pure delegation to the inner strategy’s ask. No reshaping here — the genome stays a flat (pop_size, num_params) tensor.

fn tell( &self, params: &Self::Params, population: Self::Genome, fitness: Tensor<B, 1>, state: Self::State, rng: &mut dyn Rng, ) -> (Self::State, StrategyMetrics)

Pure delegation to the inner strategy’s tell. Reshaping to a module already happened in the fitness adapter that produced fitness.

fn best(&self, state: &Self::State) -> Option<(Self::Genome, f32)>

Pure delegation to the inner strategy’s best.

type Params = <S as Strategy<B>>::Params

Static parameters for a run.

type State = <S as Strategy<B>>::State

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.