Struct L2 

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

L2 (Ridge) regularization

Adds a penalty equal to the sum of the squared values of the parameters, which encourages smaller weights and penalizes large weights.

Penalty: 0.5 * alpha * sum(params^2)

Examples

use scirs2_core::ndarray::Array1;
use optirs_core::regularizers::{L2, Regularizer};

// Create an L2 regularizer with strength 0.01
let regularizer = L2::new(0.01);

// Parameters and gradients
let params = Array1::from_vec(vec![0.5, -0.3, 0.0, 0.2]);
let mut gradients = Array1::from_vec(vec![0.1, 0.2, -0.3, 0.0]);

// Apply regularization
let penalty = regularizer.apply(&params, &mut gradients).unwrap();

// Gradients will be modified to include the L2 penalty gradient
// Penalty will be: 0.5 * 0.01 * (0.5^2 + (-0.3)^2 + 0.0^2 + 0.2^2) = 0.005 * 0.38 = 0.0019

Implementations

impl<A: Float + Debug + Send + Sync> L2<A>

pub fn new(alpha: A) -> Self

Create a new L2 regularizer

Arguments

• alpha - Regularization strength

pub fn alpha(&self) -> A

Get the regularization strength

pub fn set_alpha(&mut self, alpha: A) -> &mut Self

Set the regularization strength

Trait Implementations

impl<A: Clone + Float + Debug> Clone for L2<A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<A, D> Regularizer<A, D> for L2<A>

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

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

Apply regularization to parameters and gradients

fn penalty(&self, params: &Array<A, D>) -> Result<A>

Compute the regularization penalty value

impl<A: Copy + Float + Debug> Copy for L2<A>