Struct AdvancedAdam 

pub struct AdvancedAdam {
    pub lr: f64,
    pub beta1: f64,
    pub beta2: f64,
    pub eps: f64,
    pub weight_decay: f64,
    pub amsgrad: bool,
    pub param_groups: Vec<ParamGroup>,
    pub state: HashMap<String, AdamState>,
    pub step_count: u64,
    pub adaptive_lr: bool,
    pub gradient_clipping: Option<f64>,
    pub warmup_steps: Option<u64>,
}

Advanced Adam optimizer with SciRS2 enhancements

Fields

lr: f64

beta1: f64

beta2: f64

eps: f64

weight_decay: f64

amsgrad: bool

param_groups: Vec<ParamGroup>

Parameter groups optimised by this instance

state: HashMap<String, AdamState>

step_count: u64

adaptive_lr: bool

gradient_clipping: Option<f64>

warmup_steps: Option<u64>

Implementations

impl AdvancedAdam

pub fn new(lr: f64) -> Self

Create a new advanced Adam optimizer

pub fn with_params(lr: f64, params: Vec<Arc<RwLock<Tensor>>>) -> Self

Create an optimizer that already owns params

pub fn with_amsgrad(self) -> Self

Enable AMSGrad variant

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

Add weight decay (L2 regularization)

pub fn with_adaptive_lr(self) -> Self

Enable the adaptive (inverse square-root) learning rate schedule

With this enabled the learning rate decays as sqrt(t_ref / t) once the step count passes t_ref (the warmup length, or 1 when no warmup is configured) — the “Noam” schedule used for transformer training.

pub fn with_gradient_clipping(self, max_norm: f64) -> Self

Add gradient clipping

pub fn with_warmup(self, warmup_steps: u64) -> Self

Add learning rate warmup

Trait Implementations

impl Optimizer for AdvancedAdam

fn step(&mut self) -> OptimizerResult<()>

Perform a single optimization step

fn zero_grad(&mut self)

Zero all gradients

fn get_lr(&self) -> Vec<f32>

Get the current learning rate

fn set_lr(&mut self, lr: f32)

Set one learning rate for every parameter group (broadcast).

fn set_lrs(&mut self, lrs: &[f32])

Set the learning rate of each parameter group individually.

fn add_param_group( &mut self, params: Vec<Arc<RwLock<Tensor>>>, options: HashMap<String, f32>, )

Add a parameter group

fn parameters(&self) -> Vec<Arc<RwLock<Tensor>>>

Get the parameter tensors managed by this optimizer.

fn state_dict(&self) -> OptimizerResult<OptimizerState>

Get state dict for serialization

fn load_state_dict(&mut self, state: OptimizerState) -> OptimizerResult<()>

Load state dict