Struct Sequential

pub struct Sequential<F: Float + Debug + ScalarOperand> { /* private fields */ }

Sequential container for neural network layers

A Sequential model is a linear stack of layers where data flows through each layer in order. This is the most common way to build neural networks and is suitable for feed-forward architectures.

Features

• Linear topology: Layers are executed in the order they were added
• Automatic gradient flow: Backward pass automatically chains through all layers
• Training mode management: Sets all contained layers to training/evaluation mode
• Parameter aggregation: Collects parameters from all layers for optimization
• Memory efficient: Reuses intermediate tensors when possible

Examples

Building a Classifier

use scirs2_neural::layers::{Dense, Dropout, Layer};
use scirs2_neural::models::{Sequential, Model};
use ndarray::Array;
use rand::rngs::SmallRng;
use rand::SeedableRng;

let mut rng = SmallRng::seed_from_u64(42);
let mut model: Sequential<f32> = Sequential::new();

// Build a 3-layer classifier for MNIST (28x28 = 784 inputs, 10 classes)
model.add_layer(Dense::<f32>::new(784, 128, Some("relu"), &mut rng)?);
model.add_layer(Dropout::new(0.3, &mut rng)?);
model.add_layer(Dense::new(128, 64, Some("relu"), &mut rng)?);
model.add_layer(Dropout::new(0.3, &mut rng)?);
model.add_layer(Dense::<f32>::new(64, 10, Some("softmax"), &mut rng)?);

// Process a batch of images
let batch = Array::zeros((32, 784)).into_dyn(); // 32 samples
let predictions = model.forward(&batch)?;
assert_eq!(predictions.shape(), &[32, 10]);

println!("Model summary:");
println!("- Layers: {}", model.num_layers());

CNN for Image Recognition

use scirs2_neural::layers::{Conv2D, MaxPool2D, Dense, Dropout, Layer, PaddingMode};
use scirs2_neural::models::{Sequential, Model};
use ndarray::Array;
use rand::rngs::SmallRng;
use rand::SeedableRng;

let mut rng = SmallRng::seed_from_u64(42);
let mut cnn: Sequential<f32> = Sequential::new();

// Convolutional feature extractor
cnn.add_layer(Conv2D::new(3, 32, (3, 3), (1, 1), PaddingMode::Same, &mut rng)?); // 3->32 channels
cnn.add_layer(MaxPool2D::new((2, 2), (2, 2), None)?); // Downsample 2x
cnn.add_layer(Conv2D::new(32, 64, (3, 3), (1, 1), PaddingMode::Same, &mut rng)?); // 32->64 channels  
cnn.add_layer(MaxPool2D::new((2, 2), (2, 2), None)?); // Downsample 2x

// Classifier head (would need reshape layer in practice)
// cnn.add_layer(Flatten::new()); // Would flatten to 1D
// cnn.add_layer(Dense::new(64*8*8, 128, Some("relu"), &mut rng)?);
// cnn.add_layer(Dropout::new(0.5, &mut rng)?);
// cnn.add_layer(Dense::new(128, 10, None, &mut rng)?);

// Input: batch of 32x32 RGB images
let images = Array::zeros((16, 3, 32, 32)).into_dyn();
let features = cnn.forward(&images)?;
println!("Feature shape: {:?}", features.shape());

Training and Evaluation Modes

use scirs2_neural::layers::{Dense, Dropout, Layer};
use scirs2_neural::models::{Sequential, Model};
use ndarray::Array;
use rand::rngs::SmallRng;
use rand::SeedableRng;

let mut rng = SmallRng::seed_from_u64(42);
let mut model: Sequential<f32> = Sequential::new();
model.add_layer(Dense::new(10, 5, Some("relu"), &mut rng)?);
model.add_layer(Dropout::new(0.5, &mut rng)?); // 50% dropout
model.add_layer(Dense::<f32>::new(5, 1, None, &mut rng)?);

let input = Array::ones((4, 10)).into_dyn();

// Forward pass through the model
let output = model.forward(&input)?;
println!("Output shape: {:?}", output.shape());

Implementations

impl<F: Float + Debug + ScalarOperand> Sequential<F>

pub fn new() -> Self

Create a new Sequential container

Examples found in repository

examples/model_evaluation_example.rs (line 44)

    fn build(&self) -> Result<Self::Model> {
        let mut model = Sequential::new();

        let mut rng = SmallRng::seed_from_u64(42);
        model.add(Dense::<F>::new(
            self.input_dim,
            self.hidden_dim,
            Some("relu"),
            &mut rng,
        )?);

        model.add(Dropout::<F>::new(0.2, &mut rng)?);

        model.add(Dense::<F>::new(
            self.hidden_dim,
            self.output_dim,
            None,
            &mut rng,
        )?);

        Ok(model)
    }

examples/image_classification_complete.rs (line 156)

fn build_cnn_model(
    input_channels: usize,
    num_classes: usize,
    rng: &mut SmallRng,
) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // First convolutional block
    model.add(Dense::new(
        input_channels * 32 * 32,
        512,
        Some("relu"),
        rng,
    )?);
    model.add(Dropout::new(0.25, rng)?);

    // Hidden layers
    model.add(Dense::new(512, 256, Some("relu"), rng)?);
    model.add(Dropout::new(0.25, rng)?);

    model.add(Dense::new(256, 128, Some("relu"), rng)?);
    model.add(Dropout::new(0.25, rng)?);

    // Output layer
    model.add(Dense::new(128, num_classes, Some("softmax"), rng)?);

    Ok(model)
}

examples/advanced_training_example.rs (line 27)

fn create_regression_model<
    F: Float + Debug + ScalarOperand + Send + Sync + FromPrimitive + 'static,
>(
    input_dim: usize,
    hidden_dim: usize,
    output_dim: usize,
) -> Result<Sequential<F>> {
    let mut model = Sequential::new();

    // Create RNG for initializing layers
    let mut rng = SmallRng::seed_from_u64(42);

    // First dense layer with ReLU activation
    let dense1 = Dense::new(input_dim, hidden_dim, Some("relu"), &mut rng)?;
    model.add(dense1);

    // Dropout layer for regularization
    let dropout1 = Dropout::new(0.2, &mut rng)?;
    model.add(dropout1);

    // Second dense layer with ReLU activation
    let dense2 = Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), &mut rng)?;
    model.add(dense2);

    // Another dropout layer
    let dropout2 = Dropout::new(0.2, &mut rng)?;
    model.add(dropout2);

    // Output layer with no activation
    let dense3 = Dense::new(hidden_dim / 2, output_dim, None, &mut rng)?;
    model.add(dense3);

    Ok(model)
}

examples/text_classification_complete.rs (line 321)

fn build_text_model(
    _vocab_size: usize,
    embedding_dim: usize,
    hidden_dim: usize,
    num_classes: usize,
    max_length: usize,
    rng: &mut SmallRng,
) -> StdResult<Sequential<f32>> {
    let mut model = Sequential::new();

    // Note: This is a simplified version since our Sequential model expects specific layer types
    // In a real implementation, we'd need specialized text layers

    // Flatten the input tokens and use dense layers to simulate embedding and LSTM processing
    let input_size = max_length; // Each token position

    // Simulate embedding layer with dense transformation
    model.add(Dense::new(
        input_size,
        embedding_dim * 2,
        Some("relu"),
        rng,
    )?);
    model.add(Dropout::new(0.1, rng)?);

    // Simulate LSTM processing with dense layers
    model.add(Dense::new(
        embedding_dim * 2,
        hidden_dim,
        Some("tanh"),
        rng,
    )?);
    model.add(Dropout::new(0.2, rng)?);

    // Add attention-like mechanism with another dense layer
    model.add(Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), rng)?);
    model.add(Dropout::new(0.2, rng)?);

    // Classification head
    model.add(Dense::new(
        hidden_dim / 2,
        num_classes,
        Some("softmax"),
        rng,
    )?);

    Ok(model)
}

/// Build an advanced text model with attention
fn build_attention_text_model(
    _vocab_size: usize,
    embedding_dim: usize,
    hidden_dim: usize,
    num_classes: usize,
    max_length: usize,
    rng: &mut SmallRng,
) -> StdResult<Sequential<f32>> {
    let mut model = Sequential::new();

    // Simplified attention-based model using dense layers
    let input_size = max_length;

    // Multi-layer processing to simulate transformer-like behavior
    model.add(Dense::new(input_size, embedding_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Simulate self-attention with dense layers
    model.add(Dense::new(embedding_dim, hidden_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Second attention layer
    model.add(Dense::new(hidden_dim, hidden_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Global pooling simulation
    model.add(Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), rng)?);
    model.add(Dropout::new(0.2, rng)?);

    // Classification head
    model.add(Dense::new(
        hidden_dim / 2,
        num_classes,
        Some("softmax"),
        rng,
    )?);

    Ok(model)
}

examples/generative_models_complete.rs (line 167)

    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let (_height, _width) = config.input_size;

        // Feature extraction layers
        let mut feature_extractor = Sequential::new();
        feature_extractor.add(Conv2D::new(1, 32, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(32, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(32, 64, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 1e-5, 0.1, rng)?);

        feature_extractor.add(AdaptiveMaxPool2D::new((4, 4), None)?);

        // Calculate flattened feature size
        let feature_size = 128 * 4 * 4;

        // Mean head
        let mut mean_head = Sequential::new();
        mean_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        mean_head.add(Dropout::new(0.2, rng)?);
        mean_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        // Log variance head
        let mut logvar_head = Sequential::new();
        logvar_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        logvar_head.add(Dropout::new(0.2, rng)?);
        logvar_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        Ok(Self {
            feature_extractor,
            mean_head,
            logvar_head,
            config,
        })
    }

    pub fn forward(&self, input: &ArrayD<f32>) -> StdResult<(ArrayD<f32>, ArrayD<f32>)> {
        // Extract features
        let features = self.feature_extractor.forward(input)?;

        // Flatten features
        let batch_size = features.shape()[0];
        let feature_dim = features.len() / batch_size;
        let flattened = features
            .to_shape(IxDyn(&[batch_size, feature_dim]))?
            .to_owned();

        // Get mean and log variance
        let mean = self.mean_head.forward(&flattened)?;
        let logvar = self.logvar_head.forward(&flattened)?;

        Ok((mean, logvar))
    }
}

/// VAE Decoder that reconstructs images from latent codes
pub struct VAEDecoder {
    latent_projection: Sequential<f32>,
    feature_layers: Sequential<f32>,
    output_conv: Conv2D<f32>,
    config: GenerativeConfig,
}

impl VAEDecoder {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        // Project latent to feature space
        let mut latent_projection = Sequential::new();
        latent_projection.add(Dense::new(
            config.latent_dim,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        latent_projection.add(Dense::new(
            config.hidden_dims[0],
            128 * 4 * 4,
            Some("relu"),
            rng,
        )?);

        // Feature reconstruction layers (simplified transpose convolutions)
        let mut feature_layers = Sequential::new();
        feature_layers.add(Conv2D::new(
            128,
            64,
            (3, 3),
            (1, 1),
            PaddingMode::Same,
            rng,
        )?);
        feature_layers.add(BatchNorm::new(64, 1e-5, 0.1, rng)?);

        feature_layers.add(Conv2D::new(64, 32, (3, 3), (1, 1), PaddingMode::Same, rng)?);
        feature_layers.add(BatchNorm::new(32, 1e-5, 0.1, rng)?);

        // Output layer
        let output_conv = Conv2D::new(32, 1, (3, 3), (1, 1), PaddingMode::Same, rng)?;

        Ok(Self {
            latent_projection,
            feature_layers,
            output_conv,
            config,
        })
    }

    pub fn forward(&self, latent: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        // Project latent to feature space
        let projected = self.latent_projection.forward(latent)?;

        // Reshape to spatial format
        let batch_size = projected.shape()[0];
        let reshaped = projected.into_shape_with_order(IxDyn(&[batch_size, 128, 4, 4]))?;

        // Upsample to target size (simplified)
        let upsampled = self.upsample(&reshaped)?;

        // Apply feature layers
        let features = self.feature_layers.forward(&upsampled)?;

        // Generate output
        let output = self.output_conv.forward(&features)?;

        Ok(output)
    }

    fn upsample(&self, input: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        let shape = input.shape();
        let batch_size = shape[0];
        let channels = shape[1];
        let height = shape[2];
        let width = shape[3];

        let (target_height, target_width) = self.config.input_size;
        let scale_h = target_height / height;
        let scale_w = target_width / width;

        let mut upsampled =
            Array4::<f32>::zeros((batch_size, channels, target_height, target_width));

        for b in 0..batch_size {
            for c in 0..channels {
                for i in 0..height {
                    for j in 0..width {
                        let value = input[[b, c, i, j]];
                        for di in 0..scale_h {
                            for dj in 0..scale_w {
                                let new_i = i * scale_h + di;
                                let new_j = j * scale_w + dj;
                                if new_i < target_height && new_j < target_width {
                                    upsampled[[b, c, new_i, new_j]] = value;
                                }
                            }
                        }
                    }
                }
            }
        }

        Ok(upsampled.into_dyn())
    }
}

/// Complete VAE model
pub struct VAEModel {
    encoder: VAEEncoder,
    decoder: VAEDecoder,
    config: GenerativeConfig,
}

impl VAEModel {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let encoder = VAEEncoder::new(config.clone(), rng)?;
        let decoder = VAEDecoder::new(config.clone(), rng)?;

        Ok(Self {
            encoder,
            decoder,
            config,
        })
    }

    pub fn forward(
        &self,
        input: &ArrayD<f32>,
    ) -> StdResult<(ArrayD<f32>, ArrayD<f32>, ArrayD<f32>)> {
        // Encode
        let (mean, logvar) = self.encoder.forward(input)?;

        // Reparameterization trick (simplified)
        let latent = self.reparameterize(&mean, &logvar)?;

        // Decode
        let reconstruction = self.decoder.forward(&latent)?;

        Ok((reconstruction, mean, logvar))
    }

    fn reparameterize(&self, mean: &ArrayD<f32>, logvar: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        // Sample epsilon from standard normal
        let mut epsilon = Array::zeros(mean.raw_dim());
        let mut rng = SmallRng::seed_from_u64(42); // Fixed seed for reproducibility

        for elem in epsilon.iter_mut() {
            *elem = rng.random_range(-1.0..1.0); // Approximate normal
        }

        // z = mean + std * epsilon, where std = exp(0.5 * logvar)
        let mut result = Array::zeros(mean.raw_dim());
        for (((&m, &lv), &eps), res) in mean
            .iter()
            .zip(logvar.iter())
            .zip(epsilon.iter())
            .zip(result.iter_mut())
        {
            let std = (0.5 * lv).exp();
            *res = m + std * eps;
        }

        Ok(result)
    }

    /// Generate new samples from random latent codes
    pub fn generate(&self, batch_size: usize) -> StdResult<ArrayD<f32>> {
        // Sample random latent codes
        let mut latent = Array2::<f32>::zeros((batch_size, self.config.latent_dim));
        let mut rng = SmallRng::seed_from_u64(123);

        for elem in latent.iter_mut() {
            *elem = rng.random_range(-1.0..1.0);
        }

        let latent_dyn = latent.into_dyn();

        // Decode to generate images
        self.decoder.forward(&latent_dyn)
    }

    /// Interpolate between two latent codes
    pub fn interpolate(
        &self,
        latent1: &ArrayD<f32>,
        latent2: &ArrayD<f32>,
        steps: usize,
    ) -> StdResult<Vec<ArrayD<f32>>> {
        let mut results = Vec::new();

        for i in 0..steps {
            let alpha = i as f32 / (steps - 1) as f32;

            // Linear interpolation
            let mut interpolated = Array::zeros(latent1.raw_dim());
            for ((&l1, &l2), interp) in latent1
                .iter()
                .zip(latent2.iter())
                .zip(interpolated.iter_mut())
            {
                *interp = (1.0 - alpha) * l1 + alpha * l2;
            }

            let generated = self.decoder.forward(&interpolated)?;
            results.push(generated);
        }

        Ok(results)
    }
}

/// VAE Loss combining reconstruction and KL divergence
pub struct VAELoss {
    reconstruction_loss: MeanSquaredError,
    beta: f32,
}

impl VAELoss {
    pub fn new(beta: f32) -> Self {
        Self {
            reconstruction_loss: MeanSquaredError::new(),
            beta,
        }
    }

    pub fn compute_loss(
        &self,
        reconstruction: &ArrayD<f32>,
        target: &ArrayD<f32>,
        mean: &ArrayD<f32>,
        logvar: &ArrayD<f32>,
    ) -> StdResult<(f32, f32, f32)> {
        // Reconstruction loss
        let recon_loss = self.reconstruction_loss.forward(reconstruction, target)?;

        // KL divergence loss: -0.5 * sum(1 + logvar - mean^2 - exp(logvar))
        let mut kl_loss = 0.0f32;
        for (&m, &lv) in mean.iter().zip(logvar.iter()) {
            kl_loss += -0.5 * (1.0 + lv - m * m - lv.exp());
        }
        kl_loss /= mean.len() as f32; // Average over elements

        let total_loss = recon_loss + self.beta * kl_loss;

        Ok((total_loss, recon_loss, kl_loss))
    }
}

/// Simple GAN Generator
pub struct GANGenerator {
    layers: Sequential<f32>,
    config: GenerativeConfig,
}

impl GANGenerator {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let mut layers = Sequential::new();

        // Project noise to feature space
        layers.add(Dense::new(
            config.latent_dim,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        layers.add(BatchNorm::new(config.hidden_dims[0], 1e-5, 0.1, rng)?);

        layers.add(Dense::new(
            config.hidden_dims[0],
            config.hidden_dims[1] * 2,
            Some("relu"),
            rng,
        )?);
        layers.add(BatchNorm::new(config.hidden_dims[1] * 2, 1e-5, 0.1, rng)?);

        // Output layer
        let output_size = config.input_size.0 * config.input_size.1;
        layers.add(Dense::new(
            config.hidden_dims[1] * 2,
            output_size,
            Some("tanh"),
            rng,
        )?);

        Ok(Self { layers, config })
    }

    pub fn forward(&self, noise: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        let output = self.layers.forward(noise)?;

        // Reshape to image format
        let batch_size = output.shape()[0];
        let (height, width) = self.config.input_size;
        let reshaped = output
            .to_shape(IxDyn(&[batch_size, 1, height, width]))?
            .to_owned();

        Ok(reshaped)
    }
}

/// Simple GAN Discriminator
pub struct GANDiscriminator {
    layers: Sequential<f32>,
    config: GenerativeConfig,
}

impl GANDiscriminator {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let mut layers = Sequential::new();

        let input_size = config.input_size.0 * config.input_size.1;

        layers.add(Dense::new(
            input_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        layers.add(Dropout::new(0.3, rng)?);

        layers.add(Dense::new(
            config.hidden_dims[0],
            config.hidden_dims[1],
            Some("relu"),
            rng,
        )?);
        layers.add(Dropout::new(0.3, rng)?);

        // Output probability of being real
        layers.add(Dense::new(config.hidden_dims[1], 1, Some("sigmoid"), rng)?);

        Ok(Self { layers, config })
    }

examples/object_detection_complete.rs (line 180)

    pub fn new(config: DetectionConfig, rng: &mut SmallRng) -> StdResult<Self> {
        // Feature extraction backbone (simplified ResNet-like)
        let mut feature_extractor = Sequential::new();

        // Initial conv block
        feature_extractor.add(Conv2D::new(3, 64, (7, 7), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 0.1, 1e-5, rng)?);
        feature_extractor.add(MaxPool2D::new((2, 2), (2, 2), None)?);

        // Feature blocks
        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 0.1, 1e-5, rng)?);

        feature_extractor.add(Conv2D::new(
            128,
            256,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(256, 0.1, 1e-5, rng)?);

        // Global pooling to fixed size
        feature_extractor.add(AdaptiveMaxPool2D::new(config.feature_map_size, None)?);

        // Classification head
        let mut classifier_head = Sequential::new();
        let feature_dim = 256 * config.feature_map_size.0 * config.feature_map_size.1;
        classifier_head.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.5, rng)?);
        classifier_head.add(Dense::new(512, 256, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.3, rng)?);
        classifier_head.add(Dense::new(
            256,
            config.num_classes * config.max_objects,
            Some("softmax"),
            rng,
        )?);

        // Bounding box regression head
        let mut bbox_regressor = Sequential::new();
        bbox_regressor.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.5, rng)?);
        bbox_regressor.add(Dense::new(512, 256, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.3, rng)?);
        bbox_regressor.add(Dense::new(256, 4 * config.max_objects, None, rng)?); // 4 coordinates per object

        Ok(Self {
            feature_extractor,
            classifier_head,
            bbox_regressor,
            config,
        })
    }

Additional examples can be found in:

• examples/semantic_segmentation_complete.rs

pub fn add<L: Layer<F> + Send + Sync + 'static>(&mut self, layer: L)

Add a layer to the container

Examples found in repository

examples/model_evaluation_example.rs (lines 47-52)

    fn build(&self) -> Result<Self::Model> {
        let mut model = Sequential::new();

        let mut rng = SmallRng::seed_from_u64(42);
        model.add(Dense::<F>::new(
            self.input_dim,
            self.hidden_dim,
            Some("relu"),
            &mut rng,
        )?);

        model.add(Dropout::<F>::new(0.2, &mut rng)?);

        model.add(Dense::<F>::new(
            self.hidden_dim,
            self.output_dim,
            None,
            &mut rng,
        )?);

        Ok(model)
    }

examples/image_classification_complete.rs (lines 159-164)

fn build_cnn_model(
    input_channels: usize,
    num_classes: usize,
    rng: &mut SmallRng,
) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // First convolutional block
    model.add(Dense::new(
        input_channels * 32 * 32,
        512,
        Some("relu"),
        rng,
    )?);
    model.add(Dropout::new(0.25, rng)?);

    // Hidden layers
    model.add(Dense::new(512, 256, Some("relu"), rng)?);
    model.add(Dropout::new(0.25, rng)?);

    model.add(Dense::new(256, 128, Some("relu"), rng)?);
    model.add(Dropout::new(0.25, rng)?);

    // Output layer
    model.add(Dense::new(128, num_classes, Some("softmax"), rng)?);

    Ok(model)
}

examples/advanced_training_example.rs (line 34)

fn create_regression_model<
    F: Float + Debug + ScalarOperand + Send + Sync + FromPrimitive + 'static,
>(
    input_dim: usize,
    hidden_dim: usize,
    output_dim: usize,
) -> Result<Sequential<F>> {
    let mut model = Sequential::new();

    // Create RNG for initializing layers
    let mut rng = SmallRng::seed_from_u64(42);

    // First dense layer with ReLU activation
    let dense1 = Dense::new(input_dim, hidden_dim, Some("relu"), &mut rng)?;
    model.add(dense1);

    // Dropout layer for regularization
    let dropout1 = Dropout::new(0.2, &mut rng)?;
    model.add(dropout1);

    // Second dense layer with ReLU activation
    let dense2 = Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), &mut rng)?;
    model.add(dense2);

    // Another dropout layer
    let dropout2 = Dropout::new(0.2, &mut rng)?;
    model.add(dropout2);

    // Output layer with no activation
    let dense3 = Dense::new(hidden_dim / 2, output_dim, None, &mut rng)?;
    model.add(dense3);

    Ok(model)
}

examples/text_classification_complete.rs (lines 330-335)

fn build_text_model(
    _vocab_size: usize,
    embedding_dim: usize,
    hidden_dim: usize,
    num_classes: usize,
    max_length: usize,
    rng: &mut SmallRng,
) -> StdResult<Sequential<f32>> {
    let mut model = Sequential::new();

    // Note: This is a simplified version since our Sequential model expects specific layer types
    // In a real implementation, we'd need specialized text layers

    // Flatten the input tokens and use dense layers to simulate embedding and LSTM processing
    let input_size = max_length; // Each token position

    // Simulate embedding layer with dense transformation
    model.add(Dense::new(
        input_size,
        embedding_dim * 2,
        Some("relu"),
        rng,
    )?);
    model.add(Dropout::new(0.1, rng)?);

    // Simulate LSTM processing with dense layers
    model.add(Dense::new(
        embedding_dim * 2,
        hidden_dim,
        Some("tanh"),
        rng,
    )?);
    model.add(Dropout::new(0.2, rng)?);

    // Add attention-like mechanism with another dense layer
    model.add(Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), rng)?);
    model.add(Dropout::new(0.2, rng)?);

    // Classification head
    model.add(Dense::new(
        hidden_dim / 2,
        num_classes,
        Some("softmax"),
        rng,
    )?);

    Ok(model)
}

/// Build an advanced text model with attention
fn build_attention_text_model(
    _vocab_size: usize,
    embedding_dim: usize,
    hidden_dim: usize,
    num_classes: usize,
    max_length: usize,
    rng: &mut SmallRng,
) -> StdResult<Sequential<f32>> {
    let mut model = Sequential::new();

    // Simplified attention-based model using dense layers
    let input_size = max_length;

    // Multi-layer processing to simulate transformer-like behavior
    model.add(Dense::new(input_size, embedding_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Simulate self-attention with dense layers
    model.add(Dense::new(embedding_dim, hidden_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Second attention layer
    model.add(Dense::new(hidden_dim, hidden_dim, Some("relu"), rng)?);
    model.add(Dropout::new(0.1, rng)?);

    // Global pooling simulation
    model.add(Dense::new(hidden_dim, hidden_dim / 2, Some("relu"), rng)?);
    model.add(Dropout::new(0.2, rng)?);

    // Classification head
    model.add(Dense::new(
        hidden_dim / 2,
        num_classes,
        Some("softmax"),
        rng,
    )?);

    Ok(model)
}

examples/generative_models_complete.rs (line 168)

    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let (_height, _width) = config.input_size;

        // Feature extraction layers
        let mut feature_extractor = Sequential::new();
        feature_extractor.add(Conv2D::new(1, 32, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(32, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(32, 64, (3, 3), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 1e-5, 0.1, rng)?);

        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 1e-5, 0.1, rng)?);

        feature_extractor.add(AdaptiveMaxPool2D::new((4, 4), None)?);

        // Calculate flattened feature size
        let feature_size = 128 * 4 * 4;

        // Mean head
        let mut mean_head = Sequential::new();
        mean_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        mean_head.add(Dropout::new(0.2, rng)?);
        mean_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        // Log variance head
        let mut logvar_head = Sequential::new();
        logvar_head.add(Dense::new(
            feature_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        logvar_head.add(Dropout::new(0.2, rng)?);
        logvar_head.add(Dense::new(
            config.hidden_dims[0],
            config.latent_dim,
            None,
            rng,
        )?);

        Ok(Self {
            feature_extractor,
            mean_head,
            logvar_head,
            config,
        })
    }

    pub fn forward(&self, input: &ArrayD<f32>) -> StdResult<(ArrayD<f32>, ArrayD<f32>)> {
        // Extract features
        let features = self.feature_extractor.forward(input)?;

        // Flatten features
        let batch_size = features.shape()[0];
        let feature_dim = features.len() / batch_size;
        let flattened = features
            .to_shape(IxDyn(&[batch_size, feature_dim]))?
            .to_owned();

        // Get mean and log variance
        let mean = self.mean_head.forward(&flattened)?;
        let logvar = self.logvar_head.forward(&flattened)?;

        Ok((mean, logvar))
    }
}

/// VAE Decoder that reconstructs images from latent codes
pub struct VAEDecoder {
    latent_projection: Sequential<f32>,
    feature_layers: Sequential<f32>,
    output_conv: Conv2D<f32>,
    config: GenerativeConfig,
}

impl VAEDecoder {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        // Project latent to feature space
        let mut latent_projection = Sequential::new();
        latent_projection.add(Dense::new(
            config.latent_dim,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        latent_projection.add(Dense::new(
            config.hidden_dims[0],
            128 * 4 * 4,
            Some("relu"),
            rng,
        )?);

        // Feature reconstruction layers (simplified transpose convolutions)
        let mut feature_layers = Sequential::new();
        feature_layers.add(Conv2D::new(
            128,
            64,
            (3, 3),
            (1, 1),
            PaddingMode::Same,
            rng,
        )?);
        feature_layers.add(BatchNorm::new(64, 1e-5, 0.1, rng)?);

        feature_layers.add(Conv2D::new(64, 32, (3, 3), (1, 1), PaddingMode::Same, rng)?);
        feature_layers.add(BatchNorm::new(32, 1e-5, 0.1, rng)?);

        // Output layer
        let output_conv = Conv2D::new(32, 1, (3, 3), (1, 1), PaddingMode::Same, rng)?;

        Ok(Self {
            latent_projection,
            feature_layers,
            output_conv,
            config,
        })
    }

    pub fn forward(&self, latent: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        // Project latent to feature space
        let projected = self.latent_projection.forward(latent)?;

        // Reshape to spatial format
        let batch_size = projected.shape()[0];
        let reshaped = projected.into_shape_with_order(IxDyn(&[batch_size, 128, 4, 4]))?;

        // Upsample to target size (simplified)
        let upsampled = self.upsample(&reshaped)?;

        // Apply feature layers
        let features = self.feature_layers.forward(&upsampled)?;

        // Generate output
        let output = self.output_conv.forward(&features)?;

        Ok(output)
    }

    fn upsample(&self, input: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        let shape = input.shape();
        let batch_size = shape[0];
        let channels = shape[1];
        let height = shape[2];
        let width = shape[3];

        let (target_height, target_width) = self.config.input_size;
        let scale_h = target_height / height;
        let scale_w = target_width / width;

        let mut upsampled =
            Array4::<f32>::zeros((batch_size, channels, target_height, target_width));

        for b in 0..batch_size {
            for c in 0..channels {
                for i in 0..height {
                    for j in 0..width {
                        let value = input[[b, c, i, j]];
                        for di in 0..scale_h {
                            for dj in 0..scale_w {
                                let new_i = i * scale_h + di;
                                let new_j = j * scale_w + dj;
                                if new_i < target_height && new_j < target_width {
                                    upsampled[[b, c, new_i, new_j]] = value;
                                }
                            }
                        }
                    }
                }
            }
        }

        Ok(upsampled.into_dyn())
    }
}

/// Complete VAE model
pub struct VAEModel {
    encoder: VAEEncoder,
    decoder: VAEDecoder,
    config: GenerativeConfig,
}

impl VAEModel {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let encoder = VAEEncoder::new(config.clone(), rng)?;
        let decoder = VAEDecoder::new(config.clone(), rng)?;

        Ok(Self {
            encoder,
            decoder,
            config,
        })
    }

    pub fn forward(
        &self,
        input: &ArrayD<f32>,
    ) -> StdResult<(ArrayD<f32>, ArrayD<f32>, ArrayD<f32>)> {
        // Encode
        let (mean, logvar) = self.encoder.forward(input)?;

        // Reparameterization trick (simplified)
        let latent = self.reparameterize(&mean, &logvar)?;

        // Decode
        let reconstruction = self.decoder.forward(&latent)?;

        Ok((reconstruction, mean, logvar))
    }

    fn reparameterize(&self, mean: &ArrayD<f32>, logvar: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        // Sample epsilon from standard normal
        let mut epsilon = Array::zeros(mean.raw_dim());
        let mut rng = SmallRng::seed_from_u64(42); // Fixed seed for reproducibility

        for elem in epsilon.iter_mut() {
            *elem = rng.random_range(-1.0..1.0); // Approximate normal
        }

        // z = mean + std * epsilon, where std = exp(0.5 * logvar)
        let mut result = Array::zeros(mean.raw_dim());
        for (((&m, &lv), &eps), res) in mean
            .iter()
            .zip(logvar.iter())
            .zip(epsilon.iter())
            .zip(result.iter_mut())
        {
            let std = (0.5 * lv).exp();
            *res = m + std * eps;
        }

        Ok(result)
    }

    /// Generate new samples from random latent codes
    pub fn generate(&self, batch_size: usize) -> StdResult<ArrayD<f32>> {
        // Sample random latent codes
        let mut latent = Array2::<f32>::zeros((batch_size, self.config.latent_dim));
        let mut rng = SmallRng::seed_from_u64(123);

        for elem in latent.iter_mut() {
            *elem = rng.random_range(-1.0..1.0);
        }

        let latent_dyn = latent.into_dyn();

        // Decode to generate images
        self.decoder.forward(&latent_dyn)
    }

    /// Interpolate between two latent codes
    pub fn interpolate(
        &self,
        latent1: &ArrayD<f32>,
        latent2: &ArrayD<f32>,
        steps: usize,
    ) -> StdResult<Vec<ArrayD<f32>>> {
        let mut results = Vec::new();

        for i in 0..steps {
            let alpha = i as f32 / (steps - 1) as f32;

            // Linear interpolation
            let mut interpolated = Array::zeros(latent1.raw_dim());
            for ((&l1, &l2), interp) in latent1
                .iter()
                .zip(latent2.iter())
                .zip(interpolated.iter_mut())
            {
                *interp = (1.0 - alpha) * l1 + alpha * l2;
            }

            let generated = self.decoder.forward(&interpolated)?;
            results.push(generated);
        }

        Ok(results)
    }
}

/// VAE Loss combining reconstruction and KL divergence
pub struct VAELoss {
    reconstruction_loss: MeanSquaredError,
    beta: f32,
}

impl VAELoss {
    pub fn new(beta: f32) -> Self {
        Self {
            reconstruction_loss: MeanSquaredError::new(),
            beta,
        }
    }

    pub fn compute_loss(
        &self,
        reconstruction: &ArrayD<f32>,
        target: &ArrayD<f32>,
        mean: &ArrayD<f32>,
        logvar: &ArrayD<f32>,
    ) -> StdResult<(f32, f32, f32)> {
        // Reconstruction loss
        let recon_loss = self.reconstruction_loss.forward(reconstruction, target)?;

        // KL divergence loss: -0.5 * sum(1 + logvar - mean^2 - exp(logvar))
        let mut kl_loss = 0.0f32;
        for (&m, &lv) in mean.iter().zip(logvar.iter()) {
            kl_loss += -0.5 * (1.0 + lv - m * m - lv.exp());
        }
        kl_loss /= mean.len() as f32; // Average over elements

        let total_loss = recon_loss + self.beta * kl_loss;

        Ok((total_loss, recon_loss, kl_loss))
    }
}

/// Simple GAN Generator
pub struct GANGenerator {
    layers: Sequential<f32>,
    config: GenerativeConfig,
}

impl GANGenerator {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let mut layers = Sequential::new();

        // Project noise to feature space
        layers.add(Dense::new(
            config.latent_dim,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        layers.add(BatchNorm::new(config.hidden_dims[0], 1e-5, 0.1, rng)?);

        layers.add(Dense::new(
            config.hidden_dims[0],
            config.hidden_dims[1] * 2,
            Some("relu"),
            rng,
        )?);
        layers.add(BatchNorm::new(config.hidden_dims[1] * 2, 1e-5, 0.1, rng)?);

        // Output layer
        let output_size = config.input_size.0 * config.input_size.1;
        layers.add(Dense::new(
            config.hidden_dims[1] * 2,
            output_size,
            Some("tanh"),
            rng,
        )?);

        Ok(Self { layers, config })
    }

    pub fn forward(&self, noise: &ArrayD<f32>) -> StdResult<ArrayD<f32>> {
        let output = self.layers.forward(noise)?;

        // Reshape to image format
        let batch_size = output.shape()[0];
        let (height, width) = self.config.input_size;
        let reshaped = output
            .to_shape(IxDyn(&[batch_size, 1, height, width]))?
            .to_owned();

        Ok(reshaped)
    }
}

/// Simple GAN Discriminator
pub struct GANDiscriminator {
    layers: Sequential<f32>,
    config: GenerativeConfig,
}

impl GANDiscriminator {
    pub fn new(config: GenerativeConfig, rng: &mut SmallRng) -> StdResult<Self> {
        let mut layers = Sequential::new();

        let input_size = config.input_size.0 * config.input_size.1;

        layers.add(Dense::new(
            input_size,
            config.hidden_dims[0],
            Some("relu"),
            rng,
        )?);
        layers.add(Dropout::new(0.3, rng)?);

        layers.add(Dense::new(
            config.hidden_dims[0],
            config.hidden_dims[1],
            Some("relu"),
            rng,
        )?);
        layers.add(Dropout::new(0.3, rng)?);

        // Output probability of being real
        layers.add(Dense::new(config.hidden_dims[1], 1, Some("sigmoid"), rng)?);

        Ok(Self { layers, config })
    }

examples/object_detection_complete.rs (line 183)

    pub fn new(config: DetectionConfig, rng: &mut SmallRng) -> StdResult<Self> {
        // Feature extraction backbone (simplified ResNet-like)
        let mut feature_extractor = Sequential::new();

        // Initial conv block
        feature_extractor.add(Conv2D::new(3, 64, (7, 7), (2, 2), PaddingMode::Same, rng)?);
        feature_extractor.add(BatchNorm::new(64, 0.1, 1e-5, rng)?);
        feature_extractor.add(MaxPool2D::new((2, 2), (2, 2), None)?);

        // Feature blocks
        feature_extractor.add(Conv2D::new(
            64,
            128,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(128, 0.1, 1e-5, rng)?);

        feature_extractor.add(Conv2D::new(
            128,
            256,
            (3, 3),
            (2, 2),
            PaddingMode::Same,
            rng,
        )?);
        feature_extractor.add(BatchNorm::new(256, 0.1, 1e-5, rng)?);

        // Global pooling to fixed size
        feature_extractor.add(AdaptiveMaxPool2D::new(config.feature_map_size, None)?);

        // Classification head
        let mut classifier_head = Sequential::new();
        let feature_dim = 256 * config.feature_map_size.0 * config.feature_map_size.1;
        classifier_head.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.5, rng)?);
        classifier_head.add(Dense::new(512, 256, Some("relu"), rng)?);
        classifier_head.add(Dropout::new(0.3, rng)?);
        classifier_head.add(Dense::new(
            256,
            config.num_classes * config.max_objects,
            Some("softmax"),
            rng,
        )?);

        // Bounding box regression head
        let mut bbox_regressor = Sequential::new();
        bbox_regressor.add(Dense::new(feature_dim, 512, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.5, rng)?);
        bbox_regressor.add(Dense::new(512, 256, Some("relu"), rng)?);
        bbox_regressor.add(Dropout::new(0.3, rng)?);
        bbox_regressor.add(Dense::new(256, 4 * config.max_objects, None, rng)?); // 4 coordinates per object

        Ok(Self {
            feature_extractor,
            classifier_head,
            bbox_regressor,
            config,
        })
    }

Additional examples can be found in:

• examples/semantic_segmentation_complete.rs

pub fn len(&self) -> usize

Get the number of layers

Examples found in repository

examples/text_classification_complete.rs (line 510)

fn train_text_classifier() -> StdResult<()> {
    println!("📝 Starting Text Classification Training Example");
    println!("{}", "=".repeat(60));

    let mut rng = SmallRng::seed_from_u64(42);

    // Dataset parameters
    let num_samples = 800;
    let num_classes = 3;
    let max_length = 20;
    let embedding_dim = 64;
    let hidden_dim = 128;

    println!("📊 Dataset Configuration:");
    println!("   - Samples: {}", num_samples);
    println!(
        "   - Classes: {} (Positive, Negative, Neutral)",
        num_classes
    );
    println!("   - Max sequence length: {}", max_length);
    println!("   - Embedding dimension: {}", embedding_dim);

    // Create synthetic text dataset
    println!("\n🔄 Creating synthetic text dataset...");
    let dataset = TextDataset::create_synthetic_dataset(num_samples, num_classes, max_length);
    let (train_dataset, val_dataset) = dataset.train_val_split(0.2);

    println!("   - Vocabulary size: {}", dataset.vocab.vocab_size);
    println!("   - Training samples: {}", train_dataset.len());
    println!("   - Validation samples: {}", val_dataset.len());

    // Show some example texts
    println!("\n📄 Sample texts:");
    for i in 0..3.min(train_dataset.texts.len()) {
        println!(
            "   [Class {}]: {}",
            train_dataset.labels[i], train_dataset.texts[i]
        );
    }

    // Build model
    println!("\n🏗️  Building text classification model...");
    let model = build_text_model(
        dataset.vocab.vocab_size,
        embedding_dim,
        hidden_dim,
        num_classes,
        max_length,
        &mut rng,
    )?;

    let total_params: usize = model.params().iter().map(|p| p.len()).sum();
    println!("   - Model layers: {}", model.len());
    println!("   - Total parameters: {}", total_params);

    // Training configuration
    let config = TrainingConfig {
        batch_size: 16,
        epochs: 30,
        learning_rate: 0.001,
        shuffle: true,
        verbose: 1,
        validation: Some(ValidationSettings {
            enabled: true,
            validation_split: 0.2,
            batch_size: 32,
            num_workers: 0,
        }),
        gradient_accumulation: None,
        mixed_precision: None,
        num_workers: 0,
    };

    println!("\n⚙️  Training Configuration:");
    println!("   - Batch size: {}", config.batch_size);
    println!("   - Learning rate: {}", config.learning_rate);
    println!("   - Epochs: {}", config.epochs);

    // Set up training
    let loss_fn = CrossEntropyLoss::new(1e-7);
    let optimizer = Adam::new(config.learning_rate as f32, 0.9, 0.999, 1e-8);

    let mut trainer = Trainer::new(model, optimizer, loss_fn, config);

    // Train the model
    println!("\n🏋️  Starting training...");
    println!("{}", "-".repeat(40));

    let training_session = trainer.train(&train_dataset, Some(&val_dataset))?;

    println!("\n✅ Training completed!");
    println!("   - Epochs trained: {}", training_session.epochs_trained);

    // Evaluate model
    println!("\n📊 Final Evaluation:");
    let val_metrics = trainer.validate(&val_dataset)?;

    for (metric, value) in &val_metrics {
        println!("   - {}: {:.4}", metric, value);
    }

    // Test on sample texts
    println!("\n🔍 Sample Predictions:");
    let sample_indices = vec![0, 1, 2, 3, 4];

    // Manually collect batch since get_batch is not part of Dataset trait
    let mut batch_tokens = Vec::new();
    let mut batch_targets = Vec::new();

    for &idx in &sample_indices {
        let (tokens, targets) = val_dataset.get(idx)?;
        batch_tokens.push(tokens);
        batch_targets.push(targets);
    }

    // Concatenate into batch arrays
    let sample_tokens = ndarray::concatenate(
        ndarray::Axis(0),
        &batch_tokens.iter().map(|a| a.view()).collect::<Vec<_>>(),
    )?;
    let sample_targets = ndarray::concatenate(
        ndarray::Axis(0),
        &batch_targets.iter().map(|a| a.view()).collect::<Vec<_>>(),
    )?;

    let model = trainer.get_model();
    let predictions = model.forward(&sample_tokens)?;

    let class_names = ["Positive", "Negative", "Neutral"];

    for i in 0..sample_indices.len().min(val_dataset.texts.len()) {
        let pred_row = predictions.slice(s![i, ..]);
        let target_row = sample_targets.slice(s![i, ..]);

        let pred_class = pred_row
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(i, _)| i)
            .unwrap_or(0);

        let true_class = target_row
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(i, _)| i)
            .unwrap_or(0);

        let confidence = pred_row[pred_class];

        if sample_indices[i] < val_dataset.texts.len() {
            println!("   Text: \"{}\"", val_dataset.texts[sample_indices[i]]);
            println!(
                "   Predicted: {} (confidence: {:.3})",
                class_names[pred_class], confidence
            );
            println!("   Actual: {}", class_names[true_class]);
            println!();
        }
    }

    // Calculate detailed metrics
    let detailed_metrics = calculate_text_metrics(&predictions, &sample_targets);
    println!("📈 Detailed Metrics:");
    for (metric, value) in &detailed_metrics {
        println!("   - {}: {:.4}", metric, value);
    }

    Ok(())
}

examples/image_classification_complete.rs (line 266)

fn train_image_classifier() -> Result<()> {
    println!("🚀 Starting Image Classification Training Example");
    println!("{}", "=".repeat(60));

    // Set up reproducible random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // Dataset parameters
    let num_samples = 1000;
    let num_classes = 5;
    let image_size = (32, 32);
    let input_channels = 3;

    println!("📊 Dataset Configuration:");
    println!("   - Samples: {}", num_samples);
    println!("   - Classes: {}", num_classes);
    println!("   - Image Size: {}x{}", image_size.0, image_size.1);
    println!("   - Channels: {}", input_channels);

    // Create synthetic dataset
    println!("\n🔄 Creating synthetic dataset...");
    let dataset = SyntheticImageDataset::new(num_samples, num_classes, image_size);
    let (train_dataset, val_dataset) = dataset.train_val_split(0.2);

    println!("   - Training samples: {}", train_dataset.len());
    println!("   - Validation samples: {}", val_dataset.len());

    // Build model
    println!("\n🏗️  Building CNN model...");
    let model = build_cnn_model(input_channels, num_classes, &mut rng)?;

    // Count parameters
    let total_params: usize = model.params().iter().map(|p| p.len()).sum();
    println!("   - Model layers: {}", model.len());
    println!("   - Total parameters: {}", total_params);

    // Create training configuration
    let config = create_training_config();
    println!("\n⚙️  Training Configuration:");
    println!("   - Batch size: {}", config.batch_size);
    println!("   - Learning rate: {}", config.learning_rate);
    println!("   - Epochs: {}", config.epochs);
    println!(
        "   - Validation split: {:.1}%",
        config.validation.as_ref().unwrap().validation_split * 100.0
    );

    // Set up training components
    let loss_fn = CrossEntropyLoss::new(1e-7);
    let optimizer = Adam::new(config.learning_rate as f32, 0.9, 0.999, 1e-8);

    // Create trainer
    let mut trainer = Trainer::new(model, optimizer, loss_fn, config);

    // Add callbacks
    trainer.add_callback(Box::new(|| {
        // Custom callback for additional logging
        println!("🔄 Epoch completed");
        Ok(())
    }));

    // Train the model
    println!("\n🏋️  Starting training...");
    println!("{}", "-".repeat(40));

    let training_session = trainer.train(&train_dataset, Some(&val_dataset))?;

    println!("\n✅ Training completed!");
    println!("   - Epochs trained: {}", training_session.epochs_trained);
    println!(
        "   - Final learning rate: {:.6}",
        training_session.initial_learning_rate
    );

    // Evaluate on validation set
    println!("\n📊 Final Evaluation:");
    let val_metrics = trainer.validate(&val_dataset)?;

    for (metric, value) in &val_metrics {
        println!("   - {}: {:.4}", metric, value);
    }

    // Test predictions on a few samples
    println!("\n🔍 Sample Predictions:");
    let sample_indices = vec![0, 1, 2, 3, 4];

    // Manually collect batch since get_batch is not part of Dataset trait
    let mut batch_images = Vec::new();
    let mut batch_targets = Vec::new();

    for &idx in &sample_indices {
        let (img, target) = val_dataset.get(idx)?;
        batch_images.push(img);
        batch_targets.push(target);
    }

    // Concatenate into batch arrays
    let sample_images = ndarray::concatenate(
        Axis(0),
        &batch_images.iter().map(|a| a.view()).collect::<Vec<_>>(),
    )?;
    let sample_targets = ndarray::concatenate(
        Axis(0),
        &batch_targets.iter().map(|a| a.view()).collect::<Vec<_>>(),
    )?;

    let model = trainer.get_model();
    let predictions = model.forward(&sample_images)?;

    for i in 0..sample_indices.len() {
        let pred_row = predictions.slice(s![i, ..]);
        let target_row = sample_targets.slice(s![i, ..]);

        let pred_class = pred_row
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(i, _)| i)
            .unwrap_or(0);

        let target_class = target_row
            .iter()
            .enumerate()
            .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
            .map(|(i, _)| i)
            .unwrap_or(0);

        let confidence = pred_row[pred_class];

        println!(
            "   Sample {}: Predicted={}, Actual={}, Confidence={:.3}",
            i + 1,
            pred_class,
            target_class,
            confidence
        );
    }

    // Calculate overall accuracy
    let overall_predictions = trainer.get_model().forward(&sample_images)?;
    let accuracy = calculate_accuracy(&overall_predictions, &sample_targets);
    println!("\n🎯 Sample Accuracy: {:.2}%", accuracy * 100.0);

    // Model summary
    println!("\n📋 Training Summary:");
    let session = trainer.get_session();
    if let Some(loss_history) = session.get_metric("loss") {
        if !loss_history.is_empty() {
            println!("   - Initial loss: {:.4}", loss_history[0]);
            println!(
                "   - Final loss: {:.4}",
                loss_history[loss_history.len() - 1]
            );
        }
    }

    if let Some(val_loss_history) = session.get_metric("val_loss") {
        if !val_loss_history.is_empty() {
            println!(
                "   - Final validation loss: {:.4}",
                val_loss_history[val_loss_history.len() - 1]
            );
        }
    }

    println!("\n🎉 Image classification example completed successfully!");

    Ok(())
}

pub fn is_empty(&self) -> bool

Check if there are no layers

Trait Implementations

impl<F: Float + Debug + ScalarOperand + 'static> Clone for Sequential<F>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Float + Debug + ScalarOperand> Debug for Sequential<F>

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

Formats the value using the given formatter.

impl<F: Float + Debug + ScalarOperand> Default for Sequential<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Float + Debug + ScalarOperand> Layer<F> for Sequential<F>

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 params(&self) -> Vec<Array<F, IxDyn>>

Get 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

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 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 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

impl<F: Float + Debug + ScalarOperand + 'static> ParamLayer<F> for Sequential<F>

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

Get the parameters of the layer as a vector of arrays

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

Get the gradients of the parameters

fn set_parameters(&mut self, params: Vec<Array<F, IxDyn>>) -> Result<()>

Set the parameters of the layer