Struct ProgressiveNAS 

pub struct ProgressiveNAS<T: Float + Debug + Send + Sync + 'static> {
    pub current_phase: SearchPhase,
    pub progression_strategy: ProgressionStrategy,
    pub complexity_scheduler: ComplexityScheduler<T>,
    pub architecture_progression: ArchitectureProgression<T>,
    /* private fields */
}

Progressive NAS configuration

Fields

current_phase: SearchPhase

Current search phase

progression_strategy: ProgressionStrategy

Phase progression strategy

complexity_scheduler: ComplexityScheduler<T>

Complexity scheduler

architecture_progression: ArchitectureProgression<T>

Architecture progression tracker

Implementations

impl<T: Float + Debug + Send + Sync + Sum> ProgressiveNAS<T>

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

Create new progressive NAS.

The budget-derived phase length is floored at one: search_budget / 4 is 0 for any budget under four, and the previous code then divided by it on the first ProgressiveNAS::update_search_phase call.

pub fn is_search_complete(&self) -> bool

Whether the schedule has been exhausted.

Set once the search is in SearchPhase::Final and a further advance is requested. Recording and phase updates keep working afterwards, so a caller that ignores this still gets valid bookkeeping.

pub fn update_search_phase(&mut self, generation: usize) -> Result<()>

Update search phase based on progress.

Phases never move backwards: the budget- and time-based rules compute the phase the elapsed budget/time implies and take the later of that and the current phase. Recomputing unconditionally, as this used to, let a caller passing a smaller generation — or a clock that had not yet crossed the next boundary after an adaptive advance — walk the search back into an earlier phase and re-lower the complexity budget.

pub fn get_current_search_config(&self) -> SearchPhaseConfig<T>

Get current search configuration based on phase

pub fn record_architecture_evaluation( &mut self, architecture_id: String, performance: T, complexity: T, ) -> Result<()>

Record an architecture evaluation, crediting it to the phase the search is in and to the architecture that produced it.

An empty architecture_id is rejected: an unidentified result cannot be credited to anything, and the previous code stored it anyway, so get_best_for_phase handed back an empty string as a “best architecture”.

Trait Implementations

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

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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.