Struct FISTA 

pub struct FISTA { /* private fields */ }

FISTA (Fast Iterative Shrinkage-Thresholding Algorithm).

Accelerated proximal gradient method for minimizing composite objectives:

minimize f(x) + g(x)

where f is smooth and convex, g is convex (possibly non-smooth but “simple”).

FISTA achieves O(1/k²) convergence rate using Nesterov acceleration, compared to O(1/k) for standard proximal gradient (ISTA).

Key Applications

• Lasso regression: f(x) = ½‖Ax - b‖², g(x) = λ‖x‖₁
• Elastic Net: f(x) = ½‖Ax - b‖², g(x) = λ₁‖x‖₁ + λ₂‖x‖₂²
• Total variation: Image denoising with TV regularization
• Non-negative least squares: f(x) = ½‖Ax - b‖², g(x) = indicator(x ≥ 0)

Example

use aprender::optim::{FISTA, Optimizer, prox};
use aprender::primitives::Vector;

// Minimize: ½(x - 5)² + 2|x|  (L1-regularized quadratic)
let smooth = |x: &Vector<f32>| 0.5 * (x[0] - 5.0).powi(2);
let grad_smooth = |x: &Vector<f32>| Vector::from_slice(&[x[0] - 5.0]);
let proximal = |v: &Vector<f32>, _alpha: f32| prox::soft_threshold(v, 2.0);

let mut fista = FISTA::new(1000, 0.1, 1e-5);
let x0 = Vector::from_slice(&[0.0]);
let result = fista.minimize(smooth, grad_smooth, proximal, x0);

// Check that optimization completed successfully
assert!(!result.solution[0].is_nan());

References

• Beck & Teboulle (2009). “A fast iterative shrinkage-thresholding algorithm for linear inverse problems.” SIAM Journal on Imaging Sciences, 2(1), 183-202.

Implementations

impl FISTA

pub fn new(max_iter: usize, step_size: f32, tol: f32) -> Self

Creates a new FISTA optimizer.

Arguments

• max_iter - Maximum number of iterations
• step_size - Step size α (should be ≤ 1/L where L is Lipschitz constant of ∇f)
• tol - Convergence tolerance

Returns

New FISTA optimizer instance

Example

use aprender::optim::FISTA;

let optimizer = FISTA::new(1000, 0.01, 1e-6);

pub fn minimize<F, G, P>( &mut self, smooth: F, grad_smooth: G, prox: P, x0: Vector<f32>, ) -> OptimizationResult

where F: Fn(&Vector<f32>) -> f32, G: Fn(&Vector<f32>) -> Vector<f32>, P: Fn(&Vector<f32>, f32) -> Vector<f32>,

Minimizes a composite objective function using FISTA.

Solves: minimize f(x) + g(x) where f is smooth, g is “simple” (has easy prox).

Type Parameters

• F - Smooth objective function type
• G - Gradient of smooth part type
• P - Proximal operator type

Arguments

• smooth - Smooth part f(x)
• grad_smooth - Gradient ∇f(x)
• prox - Proximal operator prox_g(v, α)
• x0 - Initial point

Returns

OptimizationResult with solution and convergence information

Trait Implementations

impl Clone for FISTA

fn clone(&self) -> FISTA

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FISTA

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

Formats the value using the given formatter.

impl Optimizer for FISTA

fn step(&mut self, _params: &mut Vector<f32>, _gradients: &Vector<f32>)

Stochastic update (mini-batch mode) - for SGD, Adam, RMSprop.

fn reset(&mut self)

Resets the optimizer state (momentum, history, etc.).

fn minimize<F, G>( &mut self, _objective: F, _gradient: G, _x0: Vector<f32>, ) -> OptimizationResult

where F: Fn(&Vector<f32>) -> f32, G: Fn(&Vector<f32>) -> Vector<f32>,

Batch optimization (deterministic mode) - for L-BFGS, CG, Damped Newton.