Struct OneCycle 

pub struct OneCycle<A: Float> { /* private fields */ }

One-cycle learning rate policy

The one-cycle policy combines triangular learning rate policy with momentum cycling. It consists of two phases:

1. A warm-up phase where learning rate increases and momentum decreases
2. A cool-down phase where learning rate decreases and momentum increases

The schedule is saturating: once total_steps have been taken the learning rate stays at its final value instead of continuing past the end of the cycle (which used to produce negative learning rates).

Example

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

let mut scheduler = OneCycle::new(
    0.0001,  // initial learning rate
    0.001,   // max learning rate
    1000,    // total steps
    0.25,    // warm-up percentage
);

// The learning rate will increase from 0.0001 to 0.001 in first 250 steps,
// then decrease to a value lower than initial in remaining 750 steps
for _ in 0..1000 {
    let lr = scheduler.get_learning_rate();
    // Use lr for optimization
    scheduler.step();
}

Implementations

impl<A: Float + ScalarOperand + Debug + Send + Sync> OneCycle<A>

pub fn new( initial_lr: A, max_lr: A, total_steps: usize, warmup_frac: f64, ) -> Self

Create a new one-cycle scheduler

Arguments

• initial_lr - Starting learning rate
• max_lr - Maximum learning rate reached after warm-up
• total_steps - Total number of training steps. 0 is invalid and is clamped to 1; use OneCycle::try_new to reject it instead.
• warmup_frac - Fraction of total steps used for warm-up (typically 0.2-0.3). Values outside (0, 1) (and non-finite values) are clamped so the resulting schedule always has at least one cool-down step.

pub fn try_new( initial_lr: A, max_lr: A, total_steps: usize, warmup_frac: f64, ) -> Result<Self>

Create a new one-cycle scheduler, validating the configuration

Errors

Returns OptimError::InvalidConfig when

• total_steps == 0,
• warmup_frac is not finite or is outside the open interval (0, 1),
• initial_lr or max_lr is not finite, or
• initial_lr <= 0 or max_lr < initial_lr.

pub fn with_final_lr(self, final_lr: A) -> Self

Create with specific final learning rate

pub fn with_momentum( self, min_momentum: A, max_momentum: A, base_momentum: A, ) -> Self

Set momentum cycling parameters

pub fn with_anneal_strategy(self, strategy: AnnealStrategy) -> Self

Set annealing strategy for cool-down phase

pub fn total_steps(&self) -> usize

Total number of steps in the cycle (always >= 1)

pub fn warmup_steps(&self) -> usize

Number of warm-up steps (always < total_steps)

pub fn get_momentum(&self) -> Option<A>

Get current momentum value

pub fn get_percentage_complete(&self) -> A

Get fraction of the cycle that has been completed, clamped to [0, 1]

Trait Implementations

impl<A: Float + Debug + Send + Sync> Debug for OneCycle<A>

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

Formats the value using the given formatter.

impl<A: Float + ScalarOperand + Debug + Send + Sync> LearningRateScheduler<A> for OneCycle<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