Struct ElasticNet 

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

ElasticNet regularization

Combines L1 and L2 regularization to get the benefits of both:

• L1 encourages sparsity (many parameters are exactly 0)
• L2 discourages large weights for more stable solutions

Penalty: l1_ratio * L1_penalty + (1 - l1_ratio) * L2_penalty

Examples

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

// Create an ElasticNet regularizer with strength 0.01 and l1_ratio 0.5
// (equal weight to L1 and L2)
let regularizer = ElasticNet::new(0.01, 0.5);

// 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 both L1 and L2 penalty gradients

Implementations

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

pub fn new(alpha: A, l1ratio: A) -> Self

Create a new ElasticNet regularizer

Arguments

• alpha - Total regularization strength
• l1_ratio - Mixing parameter (0 <= l1_ratio <= 1)
  • l1_ratio = 1: only L1 penalty
  • l1_ratio = 0: only L2 penalty

pub fn alpha(&self) -> A

Get the total regularization strength

pub fn l1_ratio(&self) -> A

Get the L1 ratio

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

Set the regularization parameters

Arguments

• alpha - Total regularization strength
• l1_ratio - Mixing parameter (0 <= l1_ratio <= 1)

Trait Implementations

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

fn clone(&self) -> ElasticNet<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 ElasticNet<A>

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

Formats the value using the given formatter.

impl<A, D> Regularizer<A, D> for ElasticNet<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 ElasticNet<A>