Struct ProgressiveNAS 

pub struct ProgressiveNAS<T: Float + Debug + Send + Sync + 'static> { /* private fields */ }

Engine-side progressive search: a staged complexity schedule that constrains which candidates may be evaluated in each phase of the run.

This complements crate::search_strategies::ProgressiveNAS, which generates progressively more complex architectures: whatever strategy the engine is configured with, this filter enforces the schedule on the candidates that actually reach the evaluator, so NASConfig::progressive_search means something for every strategy.

It used to mean nothing at all. new built an empty stages vector and filter_candidates was Ok(candidates) — the input returned verbatim — while current_stage stayed 0 and stage_history was never written. Enabling progressive_search therefore changed no behaviour whatsoever, even though the engine reports it among the run’s key hyperparameters.

Implementations

impl<T: Float + Debug + Default + Clone + Send + Sync + 'static> ProgressiveNAS<T>

pub fn new(config: &NASConfig<T>) -> Result<Self>

Build the stage schedule from the configuration.

One stage per allowed component count between SearchSpaceConfig::min_components and max_components, each stage holding a narrowed copy of the search space (its own max_components) so the stage configuration describes exactly what that stage may explore. The generation budget is split evenly across the stages, which is TimeBudgetAllocation::Uniform applied to the generation axis.

pub fn stage_for_generation(&self, generation: usize) -> usize

The stage generation falls into, clamped to the last stage once the schedule is exhausted (the search may legitimately run longer than the budget the stages were sized from).

pub fn complexity_limit(&self, generation: usize) -> Option<usize>

Maximum component count allowed in the stage generation falls into.

pub fn stages(&self) -> &[ProgressiveStage<T>]

The stage schedule.

pub fn current_stage(&self) -> usize

The stage the most recent filter_candidates call was in.

pub fn stage_results(&self, stage: usize) -> &[SearchResult<T>]

Results recorded for stage.

pub fn filter_candidates( &mut self, candidates: Vec<OptimizerArchitecture<T>>, generation: usize, ) -> Result<Vec<OptimizerArchitecture<T>>>

Restrict candidates to the complexity the current stage allows.

Candidates over the limit are held back rather than evaluated early — that is the whole point of a progressive schedule. If every candidate exceeds the limit the simplest ones are kept anyway: returning an empty list would stall the search, and a stalled generation is a worse answer than evaluating the closest candidates available.

pub fn record_stage_results( &mut self, generation: usize, results: &[SearchResult<T>], )

Record results against the stage they were produced in, so the stage history describes what each stage actually achieved.

Trait Implementations

impl<T: Debug + Float + Debug + Send + Sync + 'static> Debug for ProgressiveNAS<T>

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

Formats the value using the given formatter.