Struct MeanSquaredError 

pub struct MeanSquaredError;

Mean squared error loss function.

The MSE is calculated as the average of squared differences between predictions and targets: MSE = mean((predictions - targets)^2) It is commonly used for regression problems.

Examples

use scirs2_neural::losses::MeanSquaredError;
use scirs2_neural::losses::Loss;
use scirs2_core::ndarray::{Array, arr1};

let mse = MeanSquaredError::new();
let predictions = arr1(&[1.0, 2.0, 3.0]).into_dyn();
let targets = arr1(&[1.5, 1.8, 2.5]).into_dyn();
// Forward pass to calculate loss
let loss = mse.forward(&predictions, &targets).unwrap();
// Backward pass to calculate gradients
let gradients = mse.backward(&predictions, &targets).unwrap();

Implementations

impl MeanSquaredError

pub fn new() -> Self

Create a new mean squared error loss function

Examples found in repository

examples/improved_xor.rs (line 35)

    fn train(
        &mut self,
        inputs: &Array<f32, IxDyn>,
        targets: &Array<f32, IxDyn>,
        learning_rate: f32,
        epochs: usize,
    ) -> Result<()> {
        let loss_fn = MeanSquaredError::new();
        println!("Training for {epochs} epochs");
        for epoch in 0..epochs {
            // Forward pass
            let hidden_output = self.hidden_layer.forward(inputs)?;
            let final_output = self.output_layer.forward(&hidden_output)?;
            // Compute loss
            let loss = loss_fn.forward(&final_output, targets)?;
            if epoch % 500 == 0 || epoch == epochs - 1 {
                println!("Epoch {}/{epochs}: loss = {loss:.6}", epoch + 1);
            }
            // Backward pass
            let output_grad = loss_fn.backward(&final_output, targets)?;
            let hidden_grad = self.output_layer.backward(&hidden_output, &output_grad)?;
            let _input_grad = self.hidden_layer.backward(inputs, &hidden_grad)?;
            // Custom update using direct access to the layers' fields
            // Note: This is non-idiomatic as it breaks layer encapsulation
            // but necessary due to implementation limitations
            custom_update_layer(&mut self.hidden_layer, learning_rate)?;
            custom_update_layer(&mut self.output_layer, learning_rate)?;
        }
        Ok(())
    }

examples/manual_xor.rs (line 25)

fn main() -> Result<()> {
    println!("Manual XOR Neural Network Example");
    // Create a simple dataset for XOR problem
    let inputs = Array::from_shape_vec(
        IxDyn(&[4, 2]),
        vec![0.0f32, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0],
    )?;
    let targets = Array::from_shape_vec(IxDyn(&[4, 1]), vec![0.0f32, 1.0, 1.0, 0.0])?;
    println!("XOR problem dataset:");
    println!("Inputs:\n{inputs:?}");
    println!("Targets:\n{targets:?}");
    // Create neural network layers
    let mut rng = SmallRng::from_seed([42; 32]);
    let mut hidden_layer = Dense::new(2, 4, Some("relu"), &mut rng)?;
    let mut output_layer = Dense::new(4, 1, None, &mut rng)?;
    // Create loss function
    let loss_fn = MeanSquaredError::new();
    // Training parameters
    let learning_rate = 0.5f32;
    let num_epochs = 10000;
    println!("\nTraining for {num_epochs} epochs");
    for epoch in 0..num_epochs {
        // Forward pass through the network
        let hidden_output = hidden_layer.forward(&inputs)?;
        let final_output = output_layer.forward(&hidden_output)?;
        // Compute loss
        let loss = loss_fn.forward(&final_output, &targets)?;
        if epoch % 500 == 0 || epoch == num_epochs - 1 {
            println!("Epoch {}/{num_epochs}: loss = {loss:.6}", epoch + 1);
        }
        // Backward pass
        let output_grad = loss_fn.backward(&final_output, &targets)?;
        let hidden_grad = output_layer.backward(&hidden_output, &output_grad)?;
        let _input_grad = hidden_layer.backward(&inputs, &hidden_grad)?;
        // Update parameters
        hidden_layer.update(learning_rate)?;
        output_layer.update(learning_rate)?;
    }
    // Evaluate the model
    println!("\nEvaluation:");
    let hidden_output = hidden_layer.forward(&inputs)?;
    let final_output = output_layer.forward(&hidden_output)?;
    println!("Predictions:\n{final_output:.3?}");
    // Test with individual inputs
    println!("\nTesting with specific inputs:");
    let test_cases = vec![
        (0.0f32, 0.0f32),
        (0.0f32, 1.0f32),
        (1.0f32, 0.0f32),
        (1.0f32, 1.0f32),
    ];
    for (x1, x2) in test_cases {
        let test_input = Array::from_shape_vec(IxDyn(&[1, 2]), vec![x1, x2])?;
        let hidden_output = hidden_layer.forward(&test_input)?;
        let prediction = output_layer.forward(&hidden_output)?;
        let expected = if (x1 == 1.0 && x2 == 0.0) || (x1 == 0.0 && x2 == 1.0) {
            1.0
        } else {
            0.0
        };
        println!(
            "Input: [{x1:.1}, {x2:.1}], Predicted: {:.3}, Expected: {expected:.1}",
            prediction[[0, 0]]
        );
    }
    Ok(())
}

examples/loss_functions_example.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Loss functions example");
    // Mean Squared Error example
    println!("\n--- Mean Squared Error Example ---");
    let mse = MeanSquaredError::new();
    // Create sample data for regression
    let predictions = Array::from_vec(vec![1.0, 2.0, 3.0]).into_dyn();
    let targets = Array::from_vec(vec![1.5, 1.8, 2.5]).into_dyn();
    // Calculate loss
    let loss = mse.forward(&predictions, &targets)?;
    println!("Predictions: {predictions:?}");
    println!("Targets: {targets:?}");
    println!("MSE Loss: {loss:.4}");
    // Calculate gradients
    let gradients = mse.backward(&predictions, &targets)?;
    println!("MSE Gradients: {gradients:?}");
    // Cross-Entropy Loss example
    println!("\n--- Cross-Entropy Loss Example ---");
    let ce = CrossEntropyLoss::new(1e-10);
    // Create sample data for multi-class classification
    let predictions = Array::from_shape_vec(IxDyn(&[2, 3]), vec![0.7, 0.2, 0.1, 0.3, 0.6, 0.1])?;
    let targets = Array::from_shape_vec(IxDyn(&[2, 3]), vec![1.0, 0.0, 0.0, 0.0, 1.0, 0.0])?;
    let loss = ce.forward(&predictions, &targets)?;
    println!("Predictions (probabilities):");
    println!("{predictions:?}");
    println!("Targets (one-hot):");
    println!("{targets:?}");
    println!("Cross-Entropy Loss: {loss:.4}");
    let gradients = ce.backward(&predictions, &targets)?;
    println!("Cross-Entropy Gradients:");
    println!("{gradients:?}");
    // Focal Loss example
    println!("\n--- Focal Loss Example ---");
    let focal = FocalLoss::new(2.0, Some(0.25), 1e-10);
    // Create sample data for imbalanced classification
    let loss = focal.forward(&predictions, &targets)?;
    println!("Focal Loss (gamma=2.0, alpha=0.25): {loss:.4}");
    let _gradients = focal.backward(&predictions, &targets)?;
    println!("Focal Loss Gradients:");
    // Contrastive Loss example
    println!("\n--- Contrastive Loss Example ---");
    let contrastive = ContrastiveLoss::new(1.0);
    // Create sample data for similarity learning
    // Embedding pairs (batch_size x 2 x embedding_dim)
    let embeddings = Array::from_shape_vec(
        IxDyn(&[2, 2, 3]),
        vec![
            0.1, 0.2, 0.3, // First pair, first embedding
            0.1, 0.3, 0.3, // First pair, second embedding (similar)
            0.5, 0.5, 0.5, // Second pair, first embedding
            0.9, 0.8, 0.7, // Second pair, second embedding (dissimilar)
        ],
    )?;
    // Labels: 1 for similar pairs, 0 for dissimilar
    let labels = Array::from_shape_vec(IxDyn(&[2, 1]), vec![1.0, 0.0])?;
    let loss = contrastive.forward(&embeddings, &labels)?;
    println!("Embeddings (batch_size x 2 x embedding_dim):");
    println!("{embeddings:?}");
    println!("Labels (1 for similar, 0 for dissimilar):");
    println!("{labels:?}");
    println!("Contrastive Loss (margin=1.0): {loss:.4}");
    let gradients = contrastive.backward(&embeddings, &labels)?;
    println!("Contrastive Loss Gradients (first few):");
    let gradient_slice = gradients.slice(scirs2_core::ndarray::s![0, .., 0]);
    println!("{gradient_slice:?}");
    // Triplet Loss example
    println!("\n--- Triplet Loss Example ---");
    let triplet = TripletLoss::new(0.5);
    // Create sample data for triplet learning
    // Embedding triplets (batch_size x 3 x embedding_dim)
    let triplet_embeddings = Array3::from_shape_vec(
        (2, 3, 3),
        vec![
            0.1, 0.2, 0.3, // First triplet, anchor
            0.1, 0.3, 0.3, // First triplet, positive
            0.5, 0.5, 0.5, // First triplet, negative
            0.6, 0.6, 0.6, // Second triplet, anchor
            0.5, 0.6, 0.6, // Second triplet, positive
            0.1, 0.1, 0.1, // Second triplet, negative
        ],
    )?
    .into_dyn();
    // Dummy labels (not used by triplet loss)
    let dummy_labels = Array::zeros(IxDyn(&[2, 1]));
    let loss = triplet.forward(&triplet_embeddings, &dummy_labels)?;
    println!("Embeddings (batch_size x 3 x embedding_dim):");
    println!("  - First dimension: batch size");
    println!("  - Second dimension: [anchor, positive, negative]");
    println!("  - Third dimension: embedding components");
    println!("Triplet Loss (margin=0.5): {loss:.4}");
    let _gradients = triplet.backward(&triplet_embeddings, &dummy_labels)?;
    println!("Triplet Loss Gradients (first few):");
    Ok(())
}

Trait Implementations

impl Clone for MeanSquaredError

fn clone(&self) -> MeanSquaredError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MeanSquaredError

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

Formats the value using the given formatter.

impl Default for MeanSquaredError

fn default() -> Self

Returns the “default value” for a type.

impl<F: Float + Debug> Loss<F> for MeanSquaredError

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

Calculate the loss between predictions and targets

fn backward( &self, predictions: &Array<F, IxDyn>, targets: &Array<F, IxDyn>, ) -> Result<Array<F, IxDyn>>

Calculate the gradient of the loss with respect to the predictions This method computes ∂Loss/∂predictions, which is used in backpropagation to update the model parameters.

impl Copy for MeanSquaredError