Struct MAML 

pub struct MAML<A: Float + ScalarOperand + Debug> { /* private fields */ }

Implementations

impl<A: Float + ScalarOperand + Debug> MAML<A>

pub fn new(meta_lr: A) -> Self

Creates a new MAML optimizer with the given meta-learning rate beta.

Defaults:

• inner_lr (alpha): 0.01
• inner_steps (K): 5
• variant: MAMLVariant::FirstOrder
• weight_decay: 0

Arguments

• meta_lr – outer learning rate beta used for the meta-update.

pub fn with_inner_lr(self, alpha: A) -> Self

Sets the inner-loop learning rate alpha.

pub fn with_inner_steps(self, k: usize) -> Self

Sets the number of inner-loop adaptation steps K.

Zero is interpreted as one step (the inner loop must take at least one step to produce a meta-gradient).

pub fn with_variant(self, v: MAMLVariant) -> Self

Selects the MAML variant (MAMLVariant::SecondOrder, MAMLVariant::FirstOrder or MAMLVariant::Reptile).

pub fn with_weight_decay(self, wd: A) -> Self

Sets the L2 weight-decay coefficient applied during the outer update.

pub fn get_meta_lr(&self) -> A

Returns the meta-learning rate beta.

pub fn get_inner_lr(&self) -> A

Returns the inner-loop learning rate alpha.

pub fn get_inner_steps(&self) -> usize

Returns the number of inner-loop steps K.

pub fn get_variant(&self) -> MAMLVariant

Returns the active MAML variant.

pub fn get_weight_decay(&self) -> A

Returns the configured weight-decay coefficient.

pub fn get_step_count(&self) -> usize

Returns the number of outer meta-steps applied so far.

pub fn meta_params(&self) -> Option<&Array<A, IxDyn>>

Returns a reference to the current meta-parameters, if they have been initialised by a prior call to MAML::meta_step or Optimizer::step.

pub fn reset(&mut self)

Clears the stored meta-parameters and resets the step counter.

pub fn inner_adapt<D: Dimension>( &self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Performs a single inner-loop adaptation step: params' = params - inner_lr * gradients.

pub fn inner_adapt_multi_step<D, F>( &self, params: &Array<A, D>, loss_grad_fn: F, ) -> Result<(Array<A, D>, Vec<Array<A, D>>)>

where D: Dimension, F: FnMut(&Array<A, D>) -> Array<A, D>,

Performs inner_steps adaptation steps starting from params, using loss_grad_fn to compute the gradient at each iterate.

Returns the final adapted parameters together with the trajectory of gradients evaluated at iterates theta^{(0)}, theta^{(1)}, ..., theta^{(K-1)}. The returned vector therefore has length inner_steps, suitable for direct use in a TaskBatch.

pub fn meta_step<D: Dimension>( &mut self, task_batches: &[TaskBatch<A>], ) -> Result<Array<A, IxDyn>>

Performs one outer (meta-) update step over a batch of tasks.

The meta-gradient is averaged over all task batches, optionally augmented with L2 weight decay, and applied as theta <- theta - meta_lr * mean_meta_grad. Returns the updated meta-parameters.

All task batches must share the same parameter shape and, when the optimizer already holds meta-parameters, must also match that shape.

Trait Implementations

impl<A: Clone + Float + ScalarOperand + Debug> Clone for MAML<A>

fn clone(&self) -> MAML<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Float + ScalarOperand + Debug> Debug for MAML<A>

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

Formats the value using the given formatter.

impl<A, D> Optimizer<A, D> for MAML<A>

where A: Float + ScalarOperand + Debug, D: Dimension,

fn step( &mut self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Drop-in plain-SGD step using the meta-learning rate. Useful when embedding MAML inside a standard supervised training loop that has not (yet) been refactored to use MAML::meta_step.

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learning_rate: A)

Sets a new learning rate

fn step_list( &mut self, params_list: &[&Array<A, D>], gradients_list: &[&Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Updates multiple parameter arrays at once