Struct ExponentialDecay 

pub struct ExponentialDecay<A: Float + Debug> { /* private fields */ }

Exponential decay learning rate scheduler

Applies exponential decay to the learning rate over time: lr = initial_lr * decay_rate^(step / decay_steps)

Examples

use optirs_core::schedulers::{ExponentialDecay, LearningRateScheduler};

// Create a scheduler with initial learning rate 0.1, decay rate 0.95
// and decay steps 1000
let mut scheduler = ExponentialDecay::new(0.1f64, 0.95, 1000);

// Initial learning rate
let initial_lr = scheduler.get_learning_rate();

// Run for a few steps (reduced for test)
for _ in 0..3 {
    // Update learning rate
    let lr = scheduler.step();
    // Verify learning rate is decaying
    assert!(lr < initial_lr);
}

// Verify scheduler is working
let final_lr = scheduler.get_learning_rate();
assert!(final_lr < 0.1);

Implementations

impl<A: Float + Debug + Send + Sync> ExponentialDecay<A>

pub fn new(initial_lr: A, decay_rate: A, decay_steps: usize) -> Self

Create a new exponential decay scheduler

Arguments

• initial_lr - Initial learning rate
• decay_rate - Rate at which learning rate decays (e.g., 0.95)
• decay_steps - Number of steps after which learning rate is decayed by decay_rate

Trait Implementations

impl<A: Clone + Float + Debug> Clone for ExponentialDecay<A>

fn clone(&self) -> ExponentialDecay<A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug + Float + Debug> Debug for ExponentialDecay<A>

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

Formats the value using the given formatter.

impl<A: Float + Debug + ScalarOperand + Send + Sync> LearningRateScheduler<A> for ExponentialDecay<A>

fn get_learning_rate(&self) -> A

Get the learning rate at the current step

fn step(&mut self) -> A

Update the scheduler state and return the new learning rate

fn reset(&mut self)

Reset the scheduler state

fn step_with_metric(&mut self, metric: A) -> A

Update the scheduler state using an observed metric and return the new learning rate

fn apply_to<D: Dimension, O: Optimizer<A, D>>(&self, optimizer: &mut O)

where Self: Sized,

Apply the scheduler to an optimizer