Struct ParallelOptimizer 

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

A parallel composition of optimizers

This applies different optimizers to different parameter groups. Each group of parameters is updated using its assigned optimizer.

Example

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

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

// Create parameter groups
let params1 = Array1::zeros(3);
let params2 = Array1::zeros(5);

let group1 = ParameterGroup::new(params1, 0); // Use SGD
let group2 = ParameterGroup::new(params2, 1); // Use Adam

// Combine them in parallel
let mut parallel_optimizer = ParallelOptimizer::new(
    vec![Box::new(sgd), Box::new(adam)],
    vec![group1, group2],
);

// The step method will update all parameter groups using their assigned optimizers
// (In a real use case, you'd provide the corresponding gradients)

Implementations

impl<A, D> ParallelOptimizer<A, D>

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

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

Create a new parallel optimizer

Arguments

• optimizers - List of optimizers to use
• parameter_groups - Groups of parameters with their assigned optimizer indices

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

Add an optimizer

Arguments

• optimizer - The optimizer to add

Returns

The index of the added optimizer

pub fn add_parameter_group( &mut self, params: Array<A, D>, optimizerindex: usize, ) -> Result<usize>

Add a parameter group

Arguments

• params - The parameters in this group
• optimizerindex - The index of the optimizer to use for this group

Returns

Result with the index of the added parameter group, or an error if the optimizer index is invalid

pub fn num_optimizers(&self) -> usize

Get the number of optimizers

pub fn num_parameter_groups(&self) -> usize

Get the number of parameter groups

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

pub fn get_parameter_group(&self, index: usize) -> Option<&ParameterGroup<A, D>>

Get a reference to a parameter group by index

Arguments

• index - The index of the parameter group

Returns

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

pub fn get_parameter_group_mut( &mut self, index: usize, ) -> Option<&mut ParameterGroup<A, D>>

Get a mutable reference to a parameter group by index

Arguments

• index - The index of the parameter group

Returns

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

pub fn get_all_parameters(&self) -> Result<Vec<Array<A, D>>>

Get all current parameter values as a single array

Returns

A result containing all parameter values concatenated into a single array

pub fn update_all_parameters( &mut self, gradients: &[Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Update all parameter groups using their assigned optimizers

Arguments

• gradients - List of gradient arrays corresponding to parameter groups

Returns

Result with the updated parameter values, or an error

Trait Implementations

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

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learningrate: A)

Sets a new learning rate