Struct LBFGS 

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

L-BFGS optimizer

Implements the Limited-memory Broyden-Fletcher-Goldfarb-Shanno (L-BFGS) algorithm. This is a quasi-Newton method that approximates the Hessian inverse using a limited amount of memory by storing only a few vectors from previous iterations.

Examples

use scirs2_core::ndarray::Array1;
use optirs_core::optimizers::{LBFGS, Optimizer};

// Initialize parameters and gradients
let params = Array1::zeros(5);
let gradients = Array1::from_vec(vec![0.1, 0.2, -0.3, 0.0, 0.5]);

// Create an L-BFGS optimizer
let mut optimizer = LBFGS::new(1.0);

// Update parameters
let new_params = optimizer.step(&params, &gradients).unwrap();

Implementations

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

pub fn new(learning_rate: A) -> Self

Creates a new L-BFGS optimizer with the given learning rate

Arguments

• learning_rate - The learning rate for parameter updates

pub fn new_with_config( learning_rate: A, history_size: usize, tolerance_grad: A, c1: A, c2: A, max_ls: usize, ) -> Self

Creates a new L-BFGS optimizer with full configuration

Arguments

• learning_rate - The learning rate for parameter updates
• history_size - Number of past gradients/steps to store (default: 100)
• tolerance_grad - Gradient norm tolerance for convergence (default: 1e-7)
• c1 - Wolfe line search parameter for Armijo condition (default: 1e-4)
• c2 - Wolfe line search parameter for curvature condition (default: 0.9)
• max_ls - Maximum line search iterations (default: 25)

pub fn learning_rate(&self) -> A

Gets the current learning rate

pub fn set_lr(&mut self, lr: A)

Sets the learning rate

pub fn reset(&mut self)

Resets the internal state of the optimizer

Trait Implementations

impl<A: Clone + Float + ScalarOperand + Debug> Clone for LBFGS<A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Float + ScalarOperand + Debug> Debug for LBFGS<A>

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

Formats the value using the given formatter.

impl<A, D> Optimizer<A, D> for LBFGS<A>

where A: Float + ScalarOperand + Debug + Send + Sync, D: Dimension,

fn step( &mut self, params: &Array<A, D>, gradients: &Array<A, D>, ) -> Result<Array<A, D>>

Updates parameters using the given gradients

fn get_learning_rate(&self) -> A

Gets the current learning rate

fn set_learning_rate(&mut self, learning_rate: A)

Sets a new learning rate

fn step_list( &mut self, params_list: &[&Array<A, D>], gradients_list: &[&Array<A, D>], ) -> Result<Vec<Array<A, D>>>

Updates multiple parameter arrays at once