Struct ChainedOptimizer 

pub struct ChainedOptimizer<A, D>
where
    A: Float + ScalarOperand + Debug,
    D: Dimension,
{ /* private fields */ }

A chained composition of optimizers

This wraps one optimizer with another, similar to how Lookahead wraps another optimizer. The inner optimizer is applied first, and then the outer optimizer is applied to the result.

Example

use scirs2_core::ndarray::Array1;
use optirs_core::optimizer_composition::ChainedOptimizer;
use optirs_core::optimizers::{SGD, Adam, Optimizer};

// Create optimizers
let inner = SGD::new(0.1);
let outer = Adam::new(0.01);

// Chain them together
let mut chained_optimizer = ChainedOptimizer::new(Box::new(inner), Box::new(outer));

// Use the chained optimizer
let params = Array1::zeros(5);
let gradients = Array1::ones(5);
let updated_params = chained_optimizer.step(&params, &gradients).unwrap();

Implementations

impl<A, D> ChainedOptimizer<A, D>

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

pub fn new( inner: Box<dyn Optimizer<A, D>>, outer: Box<dyn Optimizer<A, D>>, ) -> Self

Create a new chained optimizer

Arguments

• inner - The inner optimizer, applied first
• outer - The outer optimizer, applied to the result of the inner optimizer

pub fn inner(&self) -> &dyn Optimizer<A, D>

Get a reference to the inner optimizer

pub fn inner_mut(&mut self) -> &mut dyn Optimizer<A, D>

Get a mutable reference to the inner optimizer

pub fn outer(&self) -> &dyn Optimizer<A, D>

Get a reference to the outer optimizer

pub fn outer_mut(&mut self) -> &mut dyn Optimizer<A, D>

Get a mutable reference to the outer optimizer

Trait Implementations

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

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, learningrate: 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