Struct SequentialOptimizer 

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

A sequential composition of optimizers

This applies multiple optimizers in sequence to the same parameters. Each optimizer’s output becomes the input to the next optimizer.

Example

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

// Create optimizers
let sgd = SGD::new(0.1);
let adam = Adam::new(0.01);

// Combine them sequentially
let mut seq_optimizer = SequentialOptimizer::new(vec![
    Box::new(sgd),
    Box::new(adam),
]);

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

Implementations

impl<A, D> SequentialOptimizer<A, D>

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

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

Create a new sequential optimizer

Arguments

• optimizers - List of optimizers to apply in sequence

pub fn add_optimizer(&mut self, optimizer: Box<dyn Optimizer<A, D>>)

Add an optimizer to the sequence

Arguments

• optimizer - The optimizer to add

pub fn num_optimizers(&self) -> usize

Get the number of optimizers in the sequence

pub fn get_optimizer(&self, index: usize) -> Option<&dyn Optimizer<A, D>>

Get a reference to an optimizer by index

Arguments

• index - The index of the optimizer

Returns

A reference to the optimizer at the given index, or None if out of bounds

pub fn get_optimizer_mut( &mut self, index: usize, ) -> Option<&mut dyn Optimizer<A, D>>

Get a mutable reference to an optimizer by index

Arguments

• index - The index of the optimizer

Returns

A mutable reference to the optimizer at the given index, or None if out of bounds

Trait Implementations

impl<A, D> Optimizer<A, D> for SequentialOptimizer<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