Struct Prodigy 

pub struct Prodigy { /* private fields */ }

Prodigy optimizer (Adaptive Learning Rate Method)

Prodigy automatically tunes the learning rate without manual tuning. Just use lr=1.0 for almost any problem!

Implementations

impl Prodigy

pub fn new( params: Vec<Arc<RwLock<Tensor>>>, lr: f32, beta1: f32, beta2: f32, weight_decay: f32, ) -> Self

Create a new Prodigy optimizer

Arguments

• params - Parameters to optimize
• lr - Learning rate (use 1.0 for most problems!)
• beta1 - Momentum coefficient (default: 0.9)
• beta2 - Variance coefficient (default: 0.999)
• weight_decay - Weight decay coefficient (default: 0.0)

Example

use torsh_optim::prelude::Prodigy;
use parking_lot::RwLock;
use std::sync::Arc;

let param = Arc::new(RwLock::new(randn::<f32>(&[100, 100])?));
let params = vec![param];

// Use lr=1.0 - it adapts automatically!
let optimizer = Prodigy::new(params, 1.0, 0.9, 0.999, 0.0);

pub fn from_config( params: Vec<Arc<RwLock<Tensor>>>, config: ProdigyConfig, ) -> Self

Create from configuration

pub fn builder() -> ProdigyBuilder

Builder for Prodigy optimizer

pub fn get_d(&self) -> f32

Get current learning rate scale (d)

pub fn get_effective_lr(&self) -> f32

Get effective learning rate

Trait Implementations

impl Optimizer for Prodigy

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 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

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

Set the learning rate of each parameter group individually.