Struct ArchNasStrategy 

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

Custom NAS harness. Does not implement Strategy — see the module docs.

The strategy is stateless; all evolving state lives in NasState. Drive it with the same ask/tell loop as a Strategy:

let strat = ArchNasStrategy::<B>::new();
let mut state = strat.init(&params, &mut rng, &device);
for _ in 0..generations {
    let (genome, next) = strat.ask(&params, &state, &mut rng, &device);
    let fitness = fitness_fn.evaluate(&genome, &device);
    state = strat.tell(&params, genome, fitness, next, &mut rng);
}
let (arch_id, weights, fitness) = strat.best(&state).unwrap();

Implementations

impl<B: Backend> ArchNasStrategy<B>

pub fn new() -> Self

Build a new (stateless) NAS strategy.

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

Build the initial state: uniform random architecture ids and Gaussian-initialized active weights (padding zeroed).

fitness is left empty and best_fitness is −∞; the first tell populates both.

Panics

Panics if weight_init_std is non-finite (+∞ or NaN).

pub fn ask( &self, params: &NasParams, state: &NasState<B>, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (NasGenome<B>, NasState<B>)

Propose the next population.

Before the first tell (resident fitness still empty) the unchanged resident population is returned for evaluation. Afterwards the method produces offspring: elite_count best residents carried over unmutated, then tournament selection, same-architecture blend crossover (single-parent copy when parents’ architectures differ), and either a per-child architecture mutation (re-initializing the child’s active weights) at arch_mutation_rate or an isotropic Gaussian weight perturbation. Five independent host substreams are derived from rng: selection, crossover, mutation, architecture (re)assignment, and weight re-initialization.

The returned NasGenome is freshly allocated (no struct-level clone).

Panics

Panics if weight_init_std or weight_mutation_std is non-finite (+∞ or NaN), or if the resident weight tensor cannot be read back to the host as f32.

pub fn tell( &self, params: &NasParams, population: NasGenome<B>, fitness: Tensor<B, 1>, state: NasState<B>, _rng: &mut dyn Rng, ) -> NasState<B>

Consume a population’s fitness and produce the next state.

Records the told population as the new residents, updates the best-ever (arch_id, weights, fitness) triple, and increments the generation. fitness follows the canonical maximise convention (higher is better).

Fitness hygiene

This is the ArchNasStrategy driver chokepoint (ADR 0034): the strategy is its own driver and does not run through EvolutionaryHarness, so there is no harness above it. tell applies sanitize_fitness to the host fitness vector (NaN → −∞, +∞ → f32::MAX, −∞ and finite pass through) before update_best and before it is stored as state.fitness, so a non-finite fitness can never become an immortal champion nor win the next ask’s elite carry or tournament.

Panics

Panics if the fitness tensor cannot be read back to the host as f32.

pub fn best(&self, state: &NasState<B>) -> Option<(usize, Tensor<B, 1>, f32)>

Best-ever individual: (arch_id, padded weights, fitness).

The weight tensor has length max_param_count (trailing padding retained). Returns None before the first tell.

Trait Implementations

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

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

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

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

Formats the value using the given formatter.

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

fn default() -> ArchNasStrategy<B>

Returns the “default value” for a type.