Struct FastAdaptationEngine 

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

Fast adaptation engine

Implementations

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

pub fn new(config: FastAdaptationConfig) -> Result<Self>

Create a new fast adaptation engine

pub fn register_algorithm( &mut self, algorithm: Box<dyn FastAdaptationAlgorithm<T>>, )

Register a concrete adaptation algorithm, dispatched to by Self::adapt_fast when its FastAdaptationAlgorithm::name matches the requested AdaptationStrategyType’s {:?} label.

pub fn algorithm_count(&self) -> usize

Number of algorithms currently registered.

pub fn from_params(inner_lr: T, adaptation_steps: usize) -> Result<Self>

Create from inner learning rate and adaptation steps (convenience)

pub fn config(&self) -> &FastAdaptationConfig

Get the configuration

pub fn adapt_fast( &mut self, optimizer: &mut dyn FewShotOptimizer<T>, task_data: &TaskData<T>, strategy: AdaptationStrategyType, config: &AdaptationConfig, ) -> Result<AdaptationResult<T>>

Perform fast adaptation.

Dispatches to a registered FastAdaptationAlgorithm whose FastAdaptationAlgorithm::name matches strategy’s {:?} label (registered via Self::register_algorithm); when none matches – the common case, since the crate ships no built-in algorithms – falls back to optimizer’s own FewShotOptimizer::adapt_few_shot, which every FewShotOptimizer implementation must provide. Either way the returned AdaptationResult reflects what actually happened, not a fixed placeholder.

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

pub fn adapt( &self, params: &Array1<T>, gradients: &[Array1<T>], inner_lr: T, ) -> Result<Array1<T>>

Perform multi-step gradient adaptation on parameters.

For each gradient in gradients, applies one step: params = params - inner_lr * gradient returning the final adapted parameters.

pub fn select_algorithm(&self, task_complexity: T) -> AdaptationStrategyType

Select an adaptation algorithm based on task complexity.

Low complexity -> FOMAML (fast, first-order) Medium -> MAML (second-order) High -> MemoryAugmented (richer capacity)

pub fn evaluate_adaptation( &self, before: &Array1<T>, after: &Array1<T>, ) -> Result<T>

Evaluate the quality of an adaptation step.

Returns the relative improvement: ||before|| - ||after|| normalised by ||before|| (higher is better; negative means regression).