Struct Sequential

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

A sequential model that chains layers together in a linear sequence

Implementations

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

pub fn new() -> Self

Create a new empty sequential model

Examples found in repository

examples/model_visualization_simple.rs (line 48)

fn create_mlp_model<R: rand::Rng>(rng: &mut R) -> Result<Sequential<f64>> {
    let mut model = Sequential::new();

    // Input layer is implicitly defined by the first layer
    // Hidden layers
    model.add_layer(Dense::new(784, 128, Some("relu"), rng)?);
    model.add_layer(Dense::new(128, 64, Some("relu"), rng)?);

    // Output layer
    model.add_layer(Dense::new(64, 10, Some("softmax"), rng)?);

    Ok(model)
}

examples/advanced_callbacks.rs (line 40)

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

    // Input layer
    let dense1 = Dense::new(input_dim, 16, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layers
    let dense2 = Dense::new(16, 8, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer (linear activation for regression)
    let dense3 = Dense::new(8, 1, None, rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/scheduler_optimizer.rs (line 43)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/training_callbacks.rs (line 44)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/neural_network_xor.rs (line 86)

fn create_model<R: Rng>(rng: &mut R) -> Result<impl Model<f32>> {
    // Create a sequential model
    let mut model = Sequential::new();

    // First layer: 2 inputs -> 4 hidden neurons with ReLU activation
    // 2 inputs (x1, x2)
    let layer1 = Dense::new(2, 4, Some("relu"), rng)?;
    model.add_layer(layer1);

    // Output layer: 4 hidden neurons -> 1 output (no activation for regression)
    // No activation for simple regression
    let layer2 = Dense::new(4, 1, None, rng)?;
    model.add_layer(layer2);

    Ok(model)
}

examples/visualize_training_progress.rs (line 66)

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

    // Hidden layer with 16 neurons and ReLU activation
    let dense1 = Dense::new(input_dim, 16, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer with 8 neurons and ReLU activation
    let dense2 = Dense::new(16, 8, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron and linear activation
    let dense3 = Dense::new(8, 1, None, rng)?;
    model.add_layer(dense3);

    Ok(model)
}

Additional examples can be found in:

• examples/neural_confusion_matrix.rs
• examples/model_architecture_visualization.rs
• examples/improved_model_serialization.rs
• examples/model_visualization_cnn.rs
• examples/model_serialization_example.rs
• examples/advanced_optimizers_example.rs

pub fn from_layers(layers: Vec<Box<dyn Layer<F> + Send + Sync>>) -> Self

Create a new sequential model from existing layers

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

Add a layer to the model

Examples found in repository

examples/model_visualization_simple.rs (line 52)

fn create_mlp_model<R: rand::Rng>(rng: &mut R) -> Result<Sequential<f64>> {
    let mut model = Sequential::new();

    // Input layer is implicitly defined by the first layer
    // Hidden layers
    model.add_layer(Dense::new(784, 128, Some("relu"), rng)?);
    model.add_layer(Dense::new(128, 64, Some("relu"), rng)?);

    // Output layer
    model.add_layer(Dense::new(64, 10, Some("softmax"), rng)?);

    Ok(model)
}

examples/advanced_callbacks.rs (line 44)

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

    // Input layer
    let dense1 = Dense::new(input_dim, 16, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layers
    let dense2 = Dense::new(16, 8, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer (linear activation for regression)
    let dense3 = Dense::new(8, 1, None, rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/scheduler_optimizer.rs (line 47)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/training_callbacks.rs (line 48)

fn create_xor_model(rng: &mut SmallRng) -> Result<Sequential<f32>> {
    let mut model = Sequential::new();

    // Input layer with 2 neurons (XOR has 2 inputs)
    let dense1 = Dense::new(2, 8, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer
    let dense2 = Dense::new(8, 4, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron (XOR has 1 output)
    let dense3 = Dense::new(4, 1, Some("sigmoid"), rng)?;
    model.add_layer(dense3);

    Ok(model)
}

examples/neural_network_xor.rs (line 91)

fn create_model<R: Rng>(rng: &mut R) -> Result<impl Model<f32>> {
    // Create a sequential model
    let mut model = Sequential::new();

    // First layer: 2 inputs -> 4 hidden neurons with ReLU activation
    // 2 inputs (x1, x2)
    let layer1 = Dense::new(2, 4, Some("relu"), rng)?;
    model.add_layer(layer1);

    // Output layer: 4 hidden neurons -> 1 output (no activation for regression)
    // No activation for simple regression
    let layer2 = Dense::new(4, 1, None, rng)?;
    model.add_layer(layer2);

    Ok(model)
}

examples/visualize_training_progress.rs (line 70)

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

    // Hidden layer with 16 neurons and ReLU activation
    let dense1 = Dense::new(input_dim, 16, Some("relu"), rng)?;
    model.add_layer(dense1);

    // Hidden layer with 8 neurons and ReLU activation
    let dense2 = Dense::new(16, 8, Some("relu"), rng)?;
    model.add_layer(dense2);

    // Output layer with 1 neuron and linear activation
    let dense3 = Dense::new(8, 1, None, rng)?;
    model.add_layer(dense3);

    Ok(model)
}

Additional examples can be found in:

• examples/neural_confusion_matrix.rs
• examples/model_architecture_visualization.rs
• examples/improved_model_serialization.rs
• examples/model_visualization_cnn.rs
• examples/model_serialization_example.rs
• examples/advanced_optimizers_example.rs

pub fn num_layers(&self) -> usize

Get the number of layers in the model

Examples found in repository

examples/scheduler_optimizer.rs (line 129)

fn train_with_step_decay(rng: &mut SmallRng, x: &Array2<f32>, y: &Array2<f32>) -> Result<()> {
    println!("\n1. Training with Step Decay Learning Rate Scheduling");
    println!("--------------------------------------------------");

    let mut model = create_xor_model(rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer with step decay scheduling
    let loss_fn = MeanSquaredError::new();

    // Option 1: Using the helper function
    let epochs = 300;
    let mut optimizer = with_step_decay(
        Adam::new(0.1, 0.9, 0.999, 1e-8),
        0.1,    // Initial LR
        0.5,    // Factor (reduce by half)
        50,     // Step size (every 50 epochs)
        0.001,  // Min LR
        epochs, // Total steps
    );

    println!("Starting training with step decay LR scheduling...");
    println!("Initial LR: 0.1, Factor: 0.5, Step size: 50 epochs");
    let start_time = Instant::now();

    // Convert to dynamic arrays
    let x_dyn = x.clone().into_dyn();
    let y_dyn = y.clone().into_dyn();

    // Training loop with learning rate tracking
    let mut lr_history = Vec::<(usize, f32)>::new();

    for epoch in 0..epochs {
        // Train one batch
        let loss = model.train_batch(&x_dyn, &y_dyn, &loss_fn, &mut optimizer)?;

        // Record current learning rate
        let current_lr = optimizer.get_learning_rate();

        // Track learning rate changes
        if epoch == 0 || lr_history.is_empty() || lr_history.last().unwrap().1 != current_lr {
            lr_history.push((epoch, current_lr));
        }

        // Print progress
        if epoch % 50 == 0 || epoch == epochs - 1 {
            println!(
                "Epoch {}/{}: loss = {:.6}, lr = {:.6}",
                epoch + 1,
                epochs,
                loss,
                current_lr
            );
        }
    }

    let elapsed = start_time.elapsed();
    println!("Training completed in {:.2}s", elapsed.as_secs_f32());

    // Print learning rate history
    println!("\nLearning rate changes:");
    for (epoch, lr) in lr_history {
        println!("Epoch {}: lr = {:.6}", epoch + 1, lr);
    }

    // Evaluate the model
    evaluate_model(&model, x, y)?;

    Ok(())
}

// Train with cosine annealing learning rate scheduling
fn train_with_cosine_annealing(rng: &mut SmallRng, x: &Array2<f32>, y: &Array2<f32>) -> Result<()> {
    println!("\n2. Training with Cosine Annealing Learning Rate Scheduling");
    println!("--------------------------------------------------------");

    let mut model = create_xor_model(rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer with cosine annealing scheduling
    let loss_fn = MeanSquaredError::new();

    // Using the helper function for cosine annealing
    let epochs = 300;
    let cycle_length = 50;
    let mut optimizer = with_cosine_annealing(
        Adam::new(0.01, 0.9, 0.999, 1e-8),
        0.01,         // Max LR
        0.0001,       // Min LR
        cycle_length, // Cycle length
        epochs,       // Total steps
    );

    println!("Starting training with cosine annealing LR scheduling...");
    println!(
        "Max LR: 0.01, Min LR: 0.0001, Cycle length: {} epochs",
        cycle_length
    );
    let start_time = Instant::now();

    // Convert to dynamic arrays
    let x_dyn = x.clone().into_dyn();
    let y_dyn = y.clone().into_dyn();

    // Training loop with learning rate tracking
    let mut lr_samples = Vec::<(usize, f32)>::new();

    for epoch in 0..epochs {
        // Train one batch
        let loss = model.train_batch(&x_dyn, &y_dyn, &loss_fn, &mut optimizer)?;

        // Get current learning rate
        let current_lr = optimizer.get_learning_rate();

        // Record learning rate at specific points to show the cycle
        if epoch % 10 == 0 || epoch == epochs - 1 {
            lr_samples.push((epoch, current_lr));
        }

        // Print progress
        if epoch % 50 == 0 || epoch == epochs - 1 {
            println!(
                "Epoch {}/{}: loss = {:.6}, lr = {:.6}",
                epoch + 1,
                epochs,
                loss,
                current_lr
            );
        }
    }

    let elapsed = start_time.elapsed();
    println!("Training completed in {:.2}s", elapsed.as_secs_f32());

    // Print learning rate samples to demonstrate the cosine curve
    println!("\nLearning rate samples (showing cosine curve):");
    for (epoch, lr) in lr_samples {
        println!("Epoch {}: lr = {:.6}", epoch + 1, lr);
    }

    // Evaluate the model
    evaluate_model(&model, x, y)?;

    Ok(())
}

// Train with manual scheduler integration
fn train_with_manual_scheduler_integration(
    rng: &mut SmallRng,
    x: &Array2<f32>,
    y: &Array2<f32>,
) -> Result<()> {
    println!("\n3. Training with Manual Scheduler Integration");
    println!("-------------------------------------------");

    let mut model = create_xor_model(rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer
    let loss_fn = MeanSquaredError::new();
    let mut optimizer = Adam::new(0.01, 0.9, 0.999, 1e-8);

    // Create scheduler manually
    let epochs = 300;
    let scheduler = CosineAnnealingLR::new(
        0.01,   // Max LR
        0.0001, // Min LR
        100,    // Cycle length
        ScheduleMethod::Epoch,
        epochs, // Total steps
    );

    println!("Starting training with manual scheduler integration...");
    println!("Max LR: 0.01, Min LR: 0.0001, Cycle length: 100 epochs");
    let start_time = Instant::now();

    // Convert to dynamic arrays
    let x_dyn = x.clone().into_dyn();
    let y_dyn = y.clone().into_dyn();

    // Training loop with manual scheduler updates
    for epoch in 0..epochs {
        // Update learning rate using scheduler
        let current_lr = scheduler.calculate_lr(epoch);
        optimizer.set_learning_rate(current_lr);

        // Train one batch
        let loss = model.train_batch(&x_dyn, &y_dyn, &loss_fn, &mut optimizer)?;

        // Print progress
        if epoch % 50 == 0 || epoch == epochs - 1 {
            println!(
                "Epoch {}/{}: loss = {:.6}, lr = {:.6}",
                epoch + 1,
                epochs,
                loss,
                current_lr
            );
        }
    }

    let elapsed = start_time.elapsed();
    println!("Training completed in {:.2}s", elapsed.as_secs_f32());

    // Evaluate the model
    evaluate_model(&model, x, y)?;

    Ok(())
}

examples/training_callbacks.rs (line 132)

fn train_with_early_stopping(rng: &mut SmallRng, x: &Array2<f32>, y: &Array2<f32>) -> Result<()> {
    println!("\n1. Training with Early Stopping");
    println!("------------------------------");

    let mut model = create_xor_model(rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer
    let loss_fn = MeanSquaredError::new();
    let mut optimizer = Adam::new(0.01, 0.9, 0.999, 1e-8);

    // Setup early stopping callback
    // Stop training if loss doesn't improve for 20 epochs
    // with a minimum improvement of 0.0001
    let early_stopping = EarlyStopping::new(20, 0.0001, false);
    let mut callback_manager = CallbackManager::<f32>::new();
    callback_manager.add_callback(Box::new(early_stopping));

    println!("Starting training with early stopping (patience = 20 epochs)...");
    let start_time = Instant::now();

    // Set up batch training parameters
    let x_dyn = x.clone().into_dyn();
    let y_dyn = y.clone().into_dyn();
    let max_epochs = 200;

    // Training loop
    let mut epoch_metrics = HashMap::new();
    let mut stop_training = false;

    for epoch in 0..max_epochs {
        // Call callbacks before epoch
        callback_manager.on_epoch_begin(epoch)?;

        // Train one batch
        let loss = model.train_batch(&x_dyn, &y_dyn, &loss_fn, &mut optimizer)?;

        // Update metrics
        epoch_metrics.insert("loss".to_string(), loss);

        // Call callbacks after epoch
        let should_stop = callback_manager.on_epoch_end(epoch, &epoch_metrics)?;

        if should_stop {
            println!("Early stopping triggered after {} epochs", epoch + 1);
            stop_training = true;
        }

        // Print progress
        if epoch % 20 == 0 || epoch == max_epochs - 1 || stop_training {
            println!("Epoch {}/{}: loss = {:.6}", epoch + 1, max_epochs, loss);
        }

        if stop_training {
            break;
        }
    }

    let elapsed = start_time.elapsed();
    println!(
        "Training completed in {:.2}s{}",
        elapsed.as_secs_f32(),
        if stop_training {
            " (early stopped)"
        } else {
            ""
        }
    );

    // Evaluate the model
    evaluate_model(&model, x, y)?;

    Ok(())
}

examples/advanced_callbacks.rs (line 129)

fn train_with_early_stopping(
    rng: &mut SmallRng,
    x_train: &Array2<f32>,
    y_train: &Array2<f32>,
    x_val: &Array2<f32>,
    y_val: &Array2<f32>,
) -> Result<Sequential<f32>> {
    let mut model = create_regression_model(x_train.ncols(), rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer
    let loss_fn = MeanSquaredError::new();
    let mut optimizer = Adam::new(0.01, 0.9, 0.999, 1e-8);

    // Setup early stopping callback
    // Stop training if validation loss doesn't improve for 30 epochs
    let early_stopping = EarlyStopping::new(30, 0.0001, true);
    let mut callback_manager = CallbackManager::<f32>::new();
    callback_manager.add_callback(Box::new(early_stopping));

    println!("Starting training with early stopping (patience = 30 epochs)...");
    let start_time = Instant::now();

    // Convert to dynamic arrays
    let x_train_dyn = x_train.clone().into_dyn();
    let y_train_dyn = y_train.clone().into_dyn();

    // Set up training parameters
    let max_epochs = 500;

    // Training loop with validation
    let mut epoch_metrics = HashMap::new();
    let mut best_val_loss = f32::MAX;
    let mut stop_training = false;

    for epoch in 0..max_epochs {
        // Call callbacks before epoch
        callback_manager.on_epoch_begin(epoch)?;

        // Train one epoch
        let train_loss = model.train_batch(&x_train_dyn, &y_train_dyn, &loss_fn, &mut optimizer)?;

        // Validate
        let val_loss = calculate_mse(&model, x_val, y_val)?;

        // Update metrics
        epoch_metrics.insert("loss".to_string(), train_loss);
        epoch_metrics.insert("val_loss".to_string(), val_loss);

        // Call callbacks after epoch
        let should_stop = callback_manager.on_epoch_end(epoch, &epoch_metrics)?;

        if should_stop {
            println!("Early stopping triggered after {} epochs", epoch + 1);
            stop_training = true;
        }

        // Track best validation loss
        if val_loss < best_val_loss {
            best_val_loss = val_loss;
        }

        // Print progress
        if epoch % 50 == 0 || epoch == max_epochs - 1 || stop_training {
            println!(
                "Epoch {}/{}: train_loss = {:.6}, val_loss = {:.6}",
                epoch + 1,
                max_epochs,
                train_loss,
                val_loss
            );
        }

        if stop_training {
            break;
        }
    }

    let elapsed = start_time.elapsed();
    println!("Training completed in {:.2}s", elapsed.as_secs_f32());
    println!("Best validation MSE: {:.6}", best_val_loss);

    Ok(model)
}

examples/model_serialization_example.rs (line 46)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("Model Serialization Example");

    // Initialize random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // 1. Create a simple neural network model
    let mut model = Sequential::new();

    // Add layers
    let input_dim = 784; // MNIST image size: 28x28 = 784
    let hidden_dim_1 = 256;
    let hidden_dim_2 = 128;
    let output_dim = 10; // 10 classes for digits 0-9

    // Input layer to first hidden layer
    let dense1 = Dense::new(input_dim, hidden_dim_1, Some("relu"), &mut rng)?;
    model.add_layer(dense1);

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

    // First hidden layer to second hidden layer
    let dense2 = Dense::new(hidden_dim_1, hidden_dim_2, Some("relu"), &mut rng)?;
    model.add_layer(dense2);

    // Layer normalization
    let layer_norm = LayerNorm::new(hidden_dim_2, 1e-5, &mut rng)?;
    model.add_layer(layer_norm);

    // Second hidden layer to output layer
    let dense3 = Dense::new(hidden_dim_2, output_dim, Some("softmax"), &mut rng)?;
    model.add_layer(dense3);

    println!(
        "Created a neural network with {} layers",
        model.num_layers()
    );

    // 2. Test the model with some dummy input
    let batch_size = 2;
    let input = Array2::<f32>::from_elem((batch_size, input_dim), 0.1);
    let output = model.forward(&input.clone().into_dyn())?;

    println!("Model output shape: {:?}", output.shape());
    println!("First few output values:");
    for i in 0..batch_size {
        print!("Sample {}: [ ", i);
        for j in 0..5 {
            // Print first 5 values
            print!("{:.6} ", output[[i, j]]);
        }
        println!("... ]");
    }

    // 3. Save the model to a file
    let model_path = Path::new("mnist_model.json");
    serialization::save_model(&model, model_path, SerializationFormat::JSON)?;

    println!("\nModel saved to {}", model_path.display());

    // 4. Load the model from the file
    let loaded_model = serialization::load_model::<f32, _>(model_path, SerializationFormat::JSON)?;

    println!(
        "Model loaded successfully with {} layers",
        loaded_model.num_layers()
    );

    // 5. Test the loaded model with the same input
    let loaded_output = loaded_model.forward(&input.into_dyn())?;

    println!("\nLoaded model output shape: {:?}", loaded_output.shape());
    println!("First few output values:");
    for i in 0..batch_size {
        print!("Sample {}: [ ", i);
        for j in 0..5 {
            // Print first 5 values
            print!("{:.6} ", loaded_output[[i, j]]);
        }
        println!("... ]");
    }

    // 6. Compare original and loaded model outputs
    let mut max_diff = 0.0;
    for i in 0..batch_size {
        for j in 0..output_dim {
            let diff = (output[[i, j]] - loaded_output[[i, j]]).abs();
            if diff > max_diff {
                max_diff = diff;
            }
        }
    }

    println!(
        "\nMaximum difference between original and loaded model outputs: {:.6}",
        max_diff
    );

    if max_diff < 1e-6 {
        println!("Models are identical! Serialization and deserialization worked correctly.");
    } else {
        println!("Warning: There are differences between the original and loaded models.");
        println!(
            "This might be due to numerical precision issues or a problem with serialization."
        );
    }

    Ok(())
}

examples/improved_model_serialization.rs (line 178)

fn main() -> Result<()> {
    println!("Improved Model Serialization and Loading Example");
    println!("===============================================\n");

    // Initialize random number generator
    let mut rng = SmallRng::seed_from_u64(42);

    // 1. Create XOR datasets
    let (x_train, y_train) = create_xor_dataset();
    println!("XOR dataset created");

    // 2. Create and train the model
    let mut model = create_xor_model(&mut rng)?;
    println!("Model created with {} layers", model.num_layers());

    // Train the model
    train_model(&mut model, &x_train, &y_train, 2000)?;

    // 3. Evaluate the model before saving
    println!("\nEvaluating model before saving:");
    evaluate_model(&model, &x_train, &y_train)?;

    // 4. Save the model in different formats
    println!("\nSaving model in different formats...");

    // Save in JSON format (human-readable)
    let json_path = Path::new("xor_model.json");
    serialization::save_model(&model, json_path, SerializationFormat::JSON)?;
    println!("Model saved to {} in JSON format", json_path.display());

    // Save in CBOR format (compact binary)
    let cbor_path = Path::new("xor_model.cbor");
    serialization::save_model(&model, cbor_path, SerializationFormat::CBOR)?;
    println!("Model saved to {} in CBOR format", cbor_path.display());

    // Save in MessagePack format (efficient binary)
    let msgpack_path = Path::new("xor_model.msgpack");
    serialization::save_model(&model, msgpack_path, SerializationFormat::MessagePack)?;
    println!(
        "Model saved to {} in MessagePack format",
        msgpack_path.display()
    );

    // 5. Load models from each format and evaluate
    println!("\nLoading and evaluating models from each format:");

    // Load and evaluate JSON model
    println!("\n--- JSON Format ---");
    let json_model = serialization::load_model::<f32, _>(json_path, SerializationFormat::JSON)?;
    println!("JSON model loaded with {} layers", json_model.num_layers());
    evaluate_model(&json_model, &x_train, &y_train)?;

    // Load and evaluate CBOR model
    println!("\n--- CBOR Format ---");
    let cbor_model = serialization::load_model::<f32, _>(cbor_path, SerializationFormat::CBOR)?;
    println!("CBOR model loaded with {} layers", cbor_model.num_layers());
    evaluate_model(&cbor_model, &x_train, &y_train)?;

    // Load and evaluate MessagePack model
    println!("\n--- MessagePack Format ---");
    let msgpack_model =
        serialization::load_model::<f32, _>(msgpack_path, SerializationFormat::MessagePack)?;
    println!(
        "MessagePack model loaded with {} layers",
        msgpack_model.num_layers()
    );
    evaluate_model(&msgpack_model, &x_train, &y_train)?;

    // 6. Test with a larger, noisy dataset to verify model works with unseen data
    println!("\nTesting with larger, noisy dataset:");
    let (x_test, y_test) = create_noisy_xor_dataset(100, 0.2, &mut rng);
    evaluate_model(&model, &x_test, &y_test)?;

    // File sizes for comparison
    let json_size = std::fs::metadata(json_path)?.len();
    let cbor_size = std::fs::metadata(cbor_path)?.len();
    let msgpack_size = std::fs::metadata(msgpack_path)?.len();

    println!("\nSerialization Format Comparison:");
    println!("  JSON:       {} bytes", json_size);
    println!(
        "  CBOR:       {} bytes ({:.1}% of JSON)",
        cbor_size,
        (cbor_size as f64 / json_size as f64) * 100.0
    );
    println!(
        "  MessagePack: {} bytes ({:.1}% of JSON)",
        msgpack_size,
        (msgpack_size as f64 / json_size as f64) * 100.0
    );

    println!("\nModel serialization and loading example completed successfully!");
    Ok(())
}

examples/visualize_training_progress.rs (line 105)

fn main() -> Result<()> {
    println!("Training Visualization Example");
    println!("==============================\n");

    // Initialize RNG with a fixed seed for reproducibility
    let mut rng = SmallRng::seed_from_u64(42);

    // Generate synthetic data
    let num_samples = 200;
    let (x, y) = generate_nonlinear_data(num_samples, &mut rng);
    println!("Generated synthetic dataset with {} samples", num_samples);

    // Split data into training and validation sets
    let (x_train, y_train, x_val, y_val) = train_val_split(&x, &y, 0.8);
    println!(
        "Split data: {} training samples, {} validation samples",
        x_train.shape()[0],
        x_val.shape()[0]
    );

    // Create model
    let mut model = create_regression_model(1, &mut rng)?;
    println!("Created model with {} layers", model.num_layers());

    // Setup loss function and optimizer
    let loss_fn = MeanSquaredError::new();
    let mut optimizer = Adam::new(0.01, 0.9, 0.999, 1e-8);

    // Training parameters
    let epochs = 100;

    // Configure learning rate scheduler
    let mut scheduler = StepDecay::new(
        0.01, // Initial learning rate
        0.5,  // Decay factor
        30,   // Step size
        ScheduleMethod::Epoch,
        1e-4, // Min learning rate
    );

    // Add visualization callback
    let mut visualization_cb =
        VisualizationCallback::new(5) // Show every 5 epochs
            .with_tracked_metrics(vec!["train_loss".to_string(), "val_loss".to_string()])
            .with_plot_options(PlotOptions {
                width: 80,
                height: 15,
                max_x_ticks: 10,
                max_y_ticks: 5,
                line_char: '─',
                point_char: '●',
                background_char: ' ',
                show_grid: true,
                show_legend: true,
            })
            .with_save_path("training_plot.txt");

    // Train the model manually
    let mut epoch_history = HashMap::new();
    epoch_history.insert("train_loss".to_string(), Vec::new());
    epoch_history.insert("val_loss".to_string(), Vec::new());

    // Convert data to dynamic arrays and ensure they are owned (not views)
    let x_train_dyn = x_train.clone().into_dyn();
    let y_train_dyn = y_train.clone().into_dyn();
    let x_val_dyn = x_val.clone().into_dyn();
    let y_val_dyn = y_val.clone().into_dyn();

    println!("\nStarting training with visualization...");

    // Manual training loop
    println!("\nStarting training loop...");
    for epoch in 0..epochs {
        // Update learning rate with scheduler
        let current_lr = scheduler.get_lr();
        optimizer.set_learning_rate(current_lr);

        // Train for one epoch (batch size = full dataset in this example)
        let train_loss = model.train_batch(&x_train_dyn, &y_train_dyn, &loss_fn, &mut optimizer)?;

        // Compute validation loss
        let predictions = model.forward(&x_val_dyn)?;
        let val_loss = loss_fn.forward(&predictions, &y_val_dyn)?;

        // Store metrics
        epoch_history
            .get_mut("train_loss")
            .unwrap()
            .push(train_loss);
        epoch_history.get_mut("val_loss").unwrap().push(val_loss);

        // Update the scheduler
        scheduler.update_lr(epoch);

        // Print progress
        if epoch % 10 == 0 || epoch == epochs - 1 {
            println!(
                "Epoch {}/{}: train_loss = {:.6}, val_loss = {:.6}, lr = {:.6}",
                epoch + 1,
                epochs,
                train_loss,
                val_loss,
                current_lr
            );
        }

        // Visualize progress (manually calling the visualization callback)
        if epoch % 5 == 0 || epoch == epochs - 1 {
            let mut context = CallbackContext {
                epoch,
                total_epochs: epochs,
                batch: 0,
                total_batches: 1,
                batch_loss: None,
                epoch_loss: Some(train_loss),
                val_loss: Some(val_loss),
                metrics: vec![],
                history: &epoch_history,
                stop_training: false,
                model: None,
            };

            visualization_cb.on_event(CallbackTiming::AfterEpoch, &mut context)?;
        }
    }

    // Final visualization
    let mut context = CallbackContext {
        epoch: epochs - 1,
        total_epochs: epochs,
        batch: 0,
        total_batches: 1,
        batch_loss: None,
        epoch_loss: Some(*epoch_history.get("train_loss").unwrap().last().unwrap()),
        val_loss: Some(*epoch_history.get("val_loss").unwrap().last().unwrap()),
        metrics: vec![],
        history: &epoch_history,
        stop_training: false,
        model: None,
    };

    visualization_cb.on_event(CallbackTiming::AfterTraining, &mut context)?;

    println!("\nTraining complete!");

    // Export history to CSV
    export_history_to_csv(&epoch_history, "training_history.csv")?;
    println!("Exported training history to training_history.csv");

    // Analyze training results
    let analysis = analyze_training_history(&epoch_history);
    println!("\nTraining Analysis:");
    println!("------------------");
    for issue in analysis {
        println!("{}", issue);
    }

    // Make predictions on validation data
    println!("\nMaking predictions on validation data...");
    let predictions = model.forward(&x_val_dyn)?;

    // Calculate and display final metrics
    let mse = loss_fn.forward(&predictions, &y_val_dyn)?;
    println!("Final validation MSE: {:.6}", mse);

    // Display a few sample predictions
    println!("\nSample predictions:");
    println!("------------------");
    println!("  X  |  True Y  | Predicted Y ");
    println!("---------------------------");

    // Show first 5 predictions
    let num_samples_to_show = std::cmp::min(5, x_val.shape()[0]);
    for i in 0..num_samples_to_show {
        println!(
            "{:.4} | {:.4}   | {:.4}",
            x_val[[i, 0]],
            y_val[[i, 0]],
            predictions[[i, 0]]
        );
    }

    println!("\nVisualization demonstration complete!");
    Ok(())
}

Additional examples can be found in:

• examples/neural_confusion_matrix.rs

pub fn layers(&self) -> &[Box<dyn Layer<F> + Send + Sync>]

Get the layers in the model

pub fn layers_mut(&mut self) -> &mut Vec<Box<dyn Layer<F> + Send + Sync>>

Get a mutable reference to the layers in the model

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 + 'static> Default for Sequential<F>

fn default() -> Self

Returns the “default value” for a type.

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

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

Forward pass through the model

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

Backward pass to compute gradients

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

Update the model parameters with the given learning rate

fn train_batch( &mut self, inputs: &Array<F, IxDyn>, targets: &Array<F, IxDyn>, loss_fn: &dyn Loss<F>, optimizer: &mut dyn Optimizer<F>, ) -> Result<F>

Train the model on a batch of data

fn predict(&self, inputs: &Array<F, IxDyn>) -> Result<Array<F, IxDyn>>

Predict the output for a batch of inputs

fn evaluate( &self, inputs: &Array<F, IxDyn>, targets: &Array<F, IxDyn>, loss_fn: &dyn Loss<F>, ) -> Result<F>

Evaluate the model on a batch of data