Struct GroupedAdam 

pub struct GroupedAdam<A: Float + Send + Sync, D: Dimension> { /* private fields */ }

Adam optimizer with parameter group support

This optimizer allows different parameter groups to have different hyperparameters (learning rate, weight decay, betas).

Example

use scirs2_core::ndarray::Array1;
use optirs_core::optimizers::{GroupedAdam, Optimizer};
use optirs_core::parameter_groups::{GroupedOptimizer, ParameterGroupConfig};

// Create grouped optimizer
let mut optimizer = GroupedAdam::new(0.001);

// Add parameter groups with different learning rates
let params_fast = vec![Array1::zeros(5)];
let config_fast = ParameterGroupConfig::new().with_learning_rate(0.01);
let group_fast = optimizer.add_group(params_fast, config_fast).unwrap();

let params_slow = vec![Array1::zeros(3)];
let config_slow = ParameterGroupConfig::new().with_learning_rate(0.0001);
let group_slow = optimizer.add_group(params_slow, config_slow).unwrap();

// Optimize each group separately
let grads_fast = vec![Array1::ones(5)];
let updated_fast = optimizer.step_group(group_fast, &grads_fast).unwrap();

let grads_slow = vec![Array1::ones(3)];
let updated_slow = optimizer.step_group(group_slow, &grads_slow).unwrap();

Implementations

impl<A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension + Send + Sync> GroupedAdam<A, D>

pub fn new(defaultlr: A) -> Self

Create a new grouped Adam optimizer

pub fn with_beta1(self, beta1: A) -> Self

Set default beta1

pub fn with_beta2(self, beta2: A) -> Self

Set default beta2

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

Set default weight decay

pub fn with_amsgrad(self) -> Self

Enable AMSGrad

Trait Implementations

impl<A: Debug + Float + Send + Sync, D: Debug + Dimension> Debug for GroupedAdam<A, D>

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

Formats the value using the given formatter.

impl<A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension + Send + Sync> GroupedOptimizer<A, D> for GroupedAdam<A, D>

fn add_group( &mut self, params: Vec<Array<A, D>>, config: ParameterGroupConfig<A>, ) -> Result<usize>

Add a parameter group

fn get_group(&self, groupid: usize) -> Result<&ParameterGroup<A, D>>

Get parameter group by ID

fn get_group_mut(&mut self, groupid: usize) -> Result<&mut ParameterGroup<A, D>>

Get mutable parameter group by ID

fn groups(&self) -> &[ParameterGroup<A, D>]

Get all parameter groups

fn groups_mut(&mut self) -> &mut [ParameterGroup<A, D>]

Get all parameter groups mutably

fn step_group( &mut self, groupid: usize, gradients: &[Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Step for a specific group

fn set_group_learning_rate(&mut self, groupid: usize, lr: A) -> Result<()>

Set learning rate for a specific group

fn set_group_weight_decay(&mut self, groupid: usize, wd: A) -> Result<()>

Set weight decay for a specific group

impl<A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension + Send + Sync> Optimizer<A, D> for GroupedAdam<A, D>

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