Struct NoiseInjectionScheduler 

pub struct NoiseInjectionScheduler<A, S>
where
    A: Float + Debug + ScalarOperand,
    S: LearningRateScheduler<A>,
{ /* private fields */ }

A learning rate scheduler that injects noise into the base learning rate

The noise sample is drawn once per LearningRateScheduler::step and cached, so LearningRateScheduler::get_learning_rate is idempotent between steps: reading the learning rate twice without stepping returns the same value.

The scheduler owns a seeded, reproducible RNG. Use NoiseInjectionScheduler::with_seed (or NoiseInjectionScheduler::new_seeded) to pin the seed; two schedulers built with the same seed produce byte-identical learning rate sequences.

Implementations

impl<A, S> NoiseInjectionScheduler<A, S>

where A: Float + Debug + ScalarOperand, S: LearningRateScheduler<A>,

pub fn new( base_scheduler: S, noise_dist: NoiseDistribution<A>, min_lr: A, ) -> NoiseInjectionScheduler<A, S>

Create a new noise injection scheduler with a randomly chosen seed

Arguments

• base_scheduler - The base scheduler to add noise to
• noise_dist - The noise distribution to use
• min_lr - The minimum learning rate allowed (to ensure stability)

Example

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

// Create a base scheduler
let base_scheduler = ExponentialDecay::new(0.1, 0.9, 10);

// Create a noise injection scheduler with uniform noise
let mut scheduler = NoiseInjectionScheduler::new(
    base_scheduler,
    NoiseDistribution::Uniform { min: -0.01, max: 0.01 },
    0.001, // Minimum learning rate
);

// Get the learning rate (will be 0.1 plus some noise)
let lr = scheduler.get_learning_rate();
assert!(lr >= 0.001); // Learning rate should be at least min_lr

// Reading again without stepping yields exactly the same value
assert_eq!(lr, scheduler.get_learning_rate());
assert!(scheduler.step() >= 0.001);

pub fn new_seeded( base_scheduler: S, noise_dist: NoiseDistribution<A>, min_lr: A, seed: u64, ) -> NoiseInjectionScheduler<A, S>

Create a new noise injection scheduler with an explicit seed

Two schedulers created with the same seed, the same distribution and the same base scheduler produce identical learning rate sequences.

Example

use optirs_core::schedulers::{
    ConstantScheduler, NoiseDistribution, NoiseInjectionScheduler, LearningRateScheduler
};

let dist = NoiseDistribution::Uniform { min: -0.01f64, max: 0.01 };
let mut a = NoiseInjectionScheduler::new_seeded(ConstantScheduler::new(0.1), dist, 0.001, 7);
let mut b = NoiseInjectionScheduler::new_seeded(ConstantScheduler::new(0.1), dist, 0.001, 7);
for _ in 0..16 {
    assert_eq!(a.step(), b.step());
}

pub fn with_seed(self, seed: u64) -> NoiseInjectionScheduler<A, S>

Re-seed the scheduler’s RNG

The cached noise sample is re-derived from the new seed so the very first LearningRateScheduler::get_learning_rate is already deterministic.

pub fn seed(&self) -> u64

Seed the scheduler’s RNG was built from

pub fn current_noise(&self) -> A

Noise sample currently applied to the base learning rate

Trait Implementations

impl<A, S> Clone for NoiseInjectionScheduler<A, S>

where A: Float + Debug + ScalarOperand, S: LearningRateScheduler<A> + Clone,

fn clone(&self) -> NoiseInjectionScheduler<A, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, S> Debug for NoiseInjectionScheduler<A, S>

where A: Float + Debug + ScalarOperand, S: LearningRateScheduler<A> + Debug,

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

Formats the value using the given formatter.

impl<A, S> LearningRateScheduler<A> for NoiseInjectionScheduler<A, S>

where A: Float + Debug + ScalarOperand, S: LearningRateScheduler<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, O>(&self, optimizer: &mut O)

where D: Dimension, O: Optimizer<A, D>, Self: Sized,

Apply the scheduler to an optimizer