Struct L1ActivityRegularization

pub struct L1ActivityRegularization<F: Float + Debug + Send + Sync> { /* private fields */ }

L1 Activity Regularization layer

A convenience layer that applies only L1 regularization to activations.

Examples

use scirs2_neural::layers::{L1ActivityRegularization, Layer};
use ndarray::{Array, Array2};

// Create an L1 activity regularization layer with factor 0.01
let regularizer = L1ActivityRegularization::new(0.01, Some("l1_reg")).unwrap();

// Forward pass with a batch of 2 samples, 10 features
let batch_size = 2;
let features = 10;
let input = Array2::<f64>::from_elem((batch_size, features), 1.0).into_dyn();

// Forward pass
let output = regularizer.forward(&input).unwrap();

// Output shape should match input shape
assert_eq!(output.shape(), input.shape());

Implementations

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> L1ActivityRegularization<F>

pub fn new(factor: f64, name: Option<&str>) -> Result<Self>

Create a new L1 activity regularization layer

Arguments

• factor - L1 regularization factor
• name - Optional name for the layer

Returns

• A new L1 activity regularization layer

Examples found in repository

examples/new_features_showcase.rs (line 86)

fn demonstrate_activity_regularization() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎯 Activity Regularization Demonstration");
    println!("=======================================\n");

    // Create some activations to regularize
    let activations =
        Array::from_shape_vec((2, 4), vec![1.5, -2.0, 0.5, 3.0, -1.0, 0.0, 2.5, -0.5])?.into_dyn();

    println!("Input activations:");
    println!("{:?}\n", activations);

    // 1. L1 Activity Regularization
    println!("1. L1 Activity Regularization (factor=0.1):");
    let l1_reg = L1ActivityRegularization::new(0.1, Some("l1_regularizer"))?;
    let l1_output = l1_reg.forward(&activations)?;
    let l1_loss = l1_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", l1_output.shape());
    println!("   L1 activity loss: {:.4}", l1_loss);
    println!("   Layer description: {}", l1_reg.layer_description());

    // 2. L2 Activity Regularization
    println!("\n2. L2 Activity Regularization (factor=0.05):");
    let l2_reg = L2ActivityRegularization::new(0.05, Some("l2_regularizer"))?;
    let l2_output = l2_reg.forward(&activations)?;
    let l2_loss = l2_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", l2_output.shape());
    println!("   L2 activity loss: {:.4}", l2_loss);
    println!("   Layer description: {}", l2_reg.layer_description());

    // 3. Combined L1 + L2 Activity Regularization
    println!("\n3. Combined L1+L2 Activity Regularization:");
    let combined_reg = ActivityRegularization::new(Some(0.1), Some(0.05), Some("combined_reg"))?;
    let combined_output = combined_reg.forward(&activations)?;
    let combined_loss = combined_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", combined_output.shape());
    println!("   Combined activity loss: {:.4}", combined_loss);
    println!("   Layer description: {}", combined_reg.layer_description());

    // Demonstrate backward pass
    println!("\n4. Backward Pass with Gradient Modification:");
    let grad_output = Array::ones(activations.raw_dim());
    let grad_input = combined_reg.backward(&activations, &grad_output)?;
    println!("   Gradient input shape: {:?}", grad_input.shape());
    println!(
        "   Sample gradient values: [{:.3}, {:.3}, {:.3}, {:.3}]",
        grad_input[[0, 0]],
        grad_input[[0, 1]],
        grad_input[[0, 2]],
        grad_input[[0, 3]]
    );

    println!("✅ Activity regularization demonstration completed!\n");
    Ok(())
}

pub fn name(&self) -> Option<&str>

Get the name of the layer

pub fn get_activity_loss(&self) -> Result<F>

Get the current activity loss

Examples found in repository

examples/new_features_showcase.rs (line 88)

fn demonstrate_activity_regularization() -> Result<(), Box<dyn std::error::Error>> {
    println!("🎯 Activity Regularization Demonstration");
    println!("=======================================\n");

    // Create some activations to regularize
    let activations =
        Array::from_shape_vec((2, 4), vec![1.5, -2.0, 0.5, 3.0, -1.0, 0.0, 2.5, -0.5])?.into_dyn();

    println!("Input activations:");
    println!("{:?}\n", activations);

    // 1. L1 Activity Regularization
    println!("1. L1 Activity Regularization (factor=0.1):");
    let l1_reg = L1ActivityRegularization::new(0.1, Some("l1_regularizer"))?;
    let l1_output = l1_reg.forward(&activations)?;
    let l1_loss = l1_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", l1_output.shape());
    println!("   L1 activity loss: {:.4}", l1_loss);
    println!("   Layer description: {}", l1_reg.layer_description());

    // 2. L2 Activity Regularization
    println!("\n2. L2 Activity Regularization (factor=0.05):");
    let l2_reg = L2ActivityRegularization::new(0.05, Some("l2_regularizer"))?;
    let l2_output = l2_reg.forward(&activations)?;
    let l2_loss = l2_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", l2_output.shape());
    println!("   L2 activity loss: {:.4}", l2_loss);
    println!("   Layer description: {}", l2_reg.layer_description());

    // 3. Combined L1 + L2 Activity Regularization
    println!("\n3. Combined L1+L2 Activity Regularization:");
    let combined_reg = ActivityRegularization::new(Some(0.1), Some(0.05), Some("combined_reg"))?;
    let combined_output = combined_reg.forward(&activations)?;
    let combined_loss = combined_reg.get_activity_loss()?;
    println!("   Output (unchanged): {:?}", combined_output.shape());
    println!("   Combined activity loss: {:.4}", combined_loss);
    println!("   Layer description: {}", combined_reg.layer_description());

    // Demonstrate backward pass
    println!("\n4. Backward Pass with Gradient Modification:");
    let grad_output = Array::ones(activations.raw_dim());
    let grad_input = combined_reg.backward(&activations, &grad_output)?;
    println!("   Gradient input shape: {:?}", grad_input.shape());
    println!(
        "   Sample gradient values: [{:.3}, {:.3}, {:.3}, {:.3}]",
        grad_input[[0, 0]],
        grad_input[[0, 1]],
        grad_input[[0, 2]],
        grad_input[[0, 3]]
    );

    println!("✅ Activity regularization demonstration completed!\n");
    Ok(())
}

Trait Implementations

impl<F: Clone + Float + Debug + Send + Sync> Clone for L1ActivityRegularization<F>

fn clone(&self) -> L1ActivityRegularization<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Float + Debug + Send + Sync> Debug for L1ActivityRegularization<F>

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

Formats the value using the given formatter.

impl<F: Float + Debug + ScalarOperand + Send + Sync + 'static> Layer<F> for L1ActivityRegularization<F>

fn as_any(&self) -> &dyn Any

Get the layer as a dyn Any for downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get the layer as a mutable dyn Any for downcasting

fn forward(&self, input: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Forward pass of the layer

fn backward( &self, input: &Array<F, IxDyn>, grad_output: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Backward pass of the layer to compute gradients

fn update(&mut self, learning_rate: F) -> Result<()>

Update the layer parameters with the given gradients

fn layer_type(&self) -> &str

Get the type of the layer (e.g., “Dense”, “Conv2D”)

fn parameter_count(&self) -> usize

Get the number of trainable parameters in this layer

fn layer_description(&self) -> String

Get a detailed description of this layer

fn params(&self) -> Vec<Array<F, IxDyn>>

Get the parameters of the layer

fn gradients(&self) -> Vec<Array<F, IxDyn>>

Get the gradients of the layer parameters

fn set_gradients(&mut self, _gradients: &[Array<F, IxDyn>]) -> Result<()>

Set the gradients of the layer parameters

fn set_params(&mut self, _params: &[Array<F, IxDyn>]) -> Result<()>

Set the parameters of the layer

fn set_training(&mut self, _training: bool)

Set the layer to training mode (true) or evaluation mode (false)

fn is_training(&self) -> bool

Get the current training mode