Struct AdaptiveLearningRateController 

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

Adaptive learning-rate controller.

O1: this used to be a stub whose every method ignored its arguments — the rate never moved, compute_adaptation echoed the base rate back and last_change was hard-coded to None, so the whole AdaptationType:: LearningRate pipeline was a no-op that “applied” the same value forever.

The real controller combines two established online signals, both computed from data the caller already supplies:

• Gradient-norm normalisation (an AdaGrad-style trust region): the rate is scaled by 1 / (1 + sqrt(accumulated squared gradient norm)), so a burst of large gradients shrinks the step and a quiet stretch restores it.
• Performance feedback: the sign of the recent loss trend, estimated by ordinary least squares over the supplied metric window, nudges the rate up while the loss is falling and down while it is rising.

Every update is clamped to [min_rate, max_rate] from the configuration and recorded, so last_change reports the real delta that was applied.

Implementations

impl<A: Float> AdaptiveLearningRateController<A>

pub fn new(config: &StreamingConfig) -> Result<Self, OptimError>

Builds a controller from the streaming learning-rate configuration.

pub fn update_learning_rate(&mut self, gradient: &Array1<A>) -> A

Folds a real gradient into the controller and returns the resulting rate.

The gradient’s squared L2 norm feeds an AdaGrad accumulator, so the effective rate is initial / (1 + sqrt(sum of squared norms)) — large or repeated gradients genuinely shrink the step.

pub fn is_cyclical(&self) -> bool

Whether a cyclical schedule is driving this controller.

pub fn current_rate(&self) -> A

Current learning rate.

pub fn accumulated_squared_gradient_norm(&self) -> A

Accumulated squared gradient norm (the AdaGrad state).

pub fn update_count(&self) -> usize

Number of updates the controller has applied.

pub fn compute_adaptation(&self, performance_metrics: &[A]) -> A

Proposes the next learning rate from a window of recent performance metrics, most-recent-last.

The trend is the ordinary-least-squares slope of the metric against its index. A falling metric (negative slope) means the current rate is working, so the rate is grown by 1 + performance_sensitivity; a rising metric shrinks it by 1 - performance_sensitivity. With fewer than two samples there is no trend to read and the current rate is returned unchanged.

pub fn apply_adaptation(&mut self, adaptation: A)

Applies a proposed rate, recording the real delta.

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

Delta applied by the most recent rate change, or None if the rate has never moved.

pub fn reset(&mut self)

Resets the controller to its configured initial rate.

Trait Implementations

impl<A: Clone + Float> Clone for AdaptiveLearningRateController<A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.