Struct ReptileOptimizer 

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

Reptile meta-learning optimizer

Implements the Reptile algorithm for meta-learning. Reptile performs multiple inner SGD steps on a task, then interpolates between the original parameters and the adapted parameters using an interpolation factor epsilon.

Algorithm

For each step:

1. Save initial parameters theta_0
2. Perform inner_steps SGD updates: theta_k = theta_{k-1} - inner_lr * grad
3. Compute meta-update: theta_new = theta_0 + epsilon * (theta_K - theta_0)

This effectively moves the initialization point toward a region that is beneficial for fast adaptation across tasks.

Examples

use scirs2_core::ndarray::Array1;
use optirs_core::optimizers::{ReptileOptimizer, Optimizer};

let params = Array1::from_vec(vec![1.0, 2.0, 3.0]);
let gradients = Array1::from_vec(vec![0.1, -0.2, 0.3]);

let mut optimizer = ReptileOptimizer::new(0.01);
let new_params = optimizer.step(&params, &gradients).expect("step failed");

Implementations

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

pub fn new(lr: A) -> Self

Creates a new Reptile optimizer with the given outer learning rate

Defaults:

• inner_steps: 5
• epsilon: same as learning_rate
• inner_lr: same as learning_rate

Arguments

• lr - The outer learning rate (also used as default epsilon and inner_lr)

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

Sets the number of inner SGD steps

More inner steps allow better task adaptation but increase computation.

Arguments

• n - Number of inner SGD steps (must be >= 1)

pub fn with_epsilon(self, e: A) -> Self

Sets the interpolation factor epsilon

Controls how much the meta-update moves toward the adapted parameters. Smaller values mean more conservative updates.

Arguments

• e - Interpolation factor (typically in [0, 1])

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

Sets the inner SGD learning rate

This learning rate is used for the inner adaptation steps on each task.

Arguments

• lr - Inner learning rate

pub fn get_inner_steps(&self) -> usize

Returns the number of inner steps configured

pub fn get_epsilon(&self) -> A

Returns the current epsilon (interpolation factor)

pub fn get_inner_lr(&self) -> A

Returns the inner learning rate

pub fn get_step_count(&self) -> usize

Returns the number of outer steps taken so far

Trait Implementations

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

fn clone(&self) -> ReptileOptimizer<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 ReptileOptimizer<A>

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

Formats the value using the given formatter.

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

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

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

Updates parameters using the given gradients

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