Struct GroupLasso 

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

Group Lasso regularizer for structured sparsity

The Group Lasso penalty encourages entire groups of parameters to be zero, rather than individual parameters (as in standard L1/Lasso). This is useful when parameters have a natural grouping structure (e.g., features belonging to the same category, filters in a convolutional layer).

Penalty: lambda * sum_g(w_g * ||params[group_g]||_2)

where w_g is the weight for group g and ||.||_2 is the L2 norm.

Examples

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

// Create a Group Lasso regularizer with two groups
let regularizer = GroupLasso::new(0.1_f64)
    .with_groups(vec![vec![0, 1, 2], vec![3, 4, 5]]);

let params = Array1::from_vec(vec![1.0, 2.0, 3.0, 0.0, 0.0, 0.0]);
let penalty = regularizer.penalty(&params).expect("penalty computation failed");

Implementations

impl<A: Float + ScalarOperand + Debug> GroupLasso<A>

pub fn new(lambda: A) -> Self

Create a new Group Lasso regularizer

Arguments

• lambda - Regularization strength (must be non-negative)

pub fn with_groups(self, groups: Vec<Vec<usize>>) -> Self

Set the groups for the regularizer (builder pattern)

Arguments

• groups - A vector of index sets, where each inner vector contains the parameter indices belonging to that group

pub fn with_group_weights(self, weights: Vec<A>) -> Self

Set per-group weights (builder pattern)

Arguments

• weights - A vector of weights, one per group. Must have the same length as the number of groups.

pub fn auto_groups(self, param_size: usize, group_size: usize) -> Self

Automatically create equal-sized groups (builder pattern)

Partitions parameter indices [0, param_size) into groups of group_size. The last group may be smaller if param_size is not evenly divisible.

Arguments

• param_size - Total number of parameters
• group_size - Number of parameters per group

pub fn lambda(&self) -> A

Get the regularization strength

pub fn groups(&self) -> &[Vec<usize>]

Get the groups

pub fn num_groups(&self) -> usize

Get the number of groups

Trait Implementations

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

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

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

Formats the value using the given formatter.

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