Struct TensorRegularizer 

pub struct TensorRegularizer { /* private fields */ }

L1/L2/ElasticNet regularization for tensor weight vectors.

Examples

use ipfrs_tensorlogic::regularizer::{TensorRegularizer, RegularizerConfig, RegularizerType};

let config = RegularizerConfig {
    reg_type: RegularizerType::L1,
    lambda: 0.1,
    elastic_alpha: 0.5,
};
let mut reg = TensorRegularizer::new(config);

let weights = vec![1.0, -2.0, 3.0];
let penalty = reg.penalty(&weights);
assert!((penalty - 0.6).abs() < 1e-12); // 0.1 * (1 + 2 + 3)

Implementations

impl TensorRegularizer

pub fn new(config: RegularizerConfig) -> Self

Create a new regularizer from the given configuration.

pub fn penalty(&mut self, weights: &[f64]) -> f64

Compute the regularization penalty for the given weight vector.

pub fn gradient(&mut self, weights: &[f64]) -> Vec<f64>

Compute the regularization gradient for the given weight vector.

pub fn l1_penalty(&self, weights: &[f64]) -> f64

L1 penalty: lambda * sum(|w_i|).

pub fn l1_gradient(&self, weights: &[f64]) -> Vec<f64>

L1 gradient: lambda * sign(w_i).

The sub-gradient at zero is defined as 0.0.

pub fn l2_penalty(&self, weights: &[f64]) -> f64

L2 penalty: lambda * sum(w_i^2).

pub fn l2_gradient(&self, weights: &[f64]) -> Vec<f64>

L2 gradient: 2 * lambda * w_i.

pub fn elastic_penalty(&self, weights: &[f64]) -> f64

ElasticNet penalty: alpha * L1(w) + (1 - alpha) * L2(w).

pub fn elastic_gradient(&self, weights: &[f64]) -> Vec<f64>

ElasticNet gradient: alpha * L1_grad(w) + (1 - alpha) * L2_grad(w).

pub fn stats(&self) -> RegularizerStats

Return runtime statistics.