Struct Trainer

pub struct Trainer<F: Float + Debug + ScalarOperand + FromPrimitive + Send + Sync + Display> { /* private fields */ }

Trainer for a neural network model

Implementations

impl<F: Float + Debug + ScalarOperand + FromPrimitive + Display + Send + Sync> Trainer<F>

pub fn new<L, O, LF>( model: L, optimizer: O, loss_fn: LF, config: TrainingConfig, ) -> Self

where L: ParamLayer<F> + Send + Sync + 'static, O: Optimizer<F> + Send + Sync + 'static, LF: Loss<F> + Send + Sync + 'static,

Create a new trainer

Examples found in repository

examples/text_classification_complete.rs (line 540)

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

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(())
}

examples/advanced_training_example.rs (line 169)

fn main() -> Result<()> {
    println!("Advanced Training Examples");
    println!("-------------------------");

    // 1. Gradient Accumulation
    println!("\n1. Training with Gradient Accumulation:");

    // Generate synthetic dataset
    let _dataset = generate_regression_dataset::<f32>(1000, 10, 2)?;
    let _val_dataset = generate_regression_dataset::<f32>(200, 10, 2)?;

    // Create model, optimizer, and loss function
    let model = create_regression_model::<f32>(10, 64, 2)?;
    let optimizer = Adam::new(0.001_f32, 0.9_f32, 0.999_f32, 1e-8_f32);
    let loss_fn = MSELoss::new();

    // Create gradient accumulation config
    let ga_config = GradientAccumulationConfig {
        accumulation_steps: 4,
        average_gradients: true,
        zero_gradients_after_update: true,
        clip_gradients: true,
        max_gradient_norm: Some(1.0),
        log_gradient_stats: true,
    };

    // Create training config
    let training_config = TrainingConfig {
        batch_size: 32,
        shuffle: true,
        num_workers: 0,
        learning_rate: 0.001,
        epochs: 5,
        verbose: 1,
        validation: Some(ValidationSettings {
            enabled: true,
            validation_split: 0.0, // Use separate validation dataset
            batch_size: 32,
            num_workers: 0,
        }),
        gradient_accumulation: Some(ga_config),
        mixed_precision: None,
    };

    // Create trainer
    let _trainer = Trainer::new(model, optimizer, loss_fn, training_config);

    // Note: To properly use callbacks, we would need to implement the appropriate trait interfaces
    // Here we're simplifying for the example

    // We'll use a simple closure to describe the early stopping callback
    println!("Note: We would add callbacks like EarlyStopping and ModelCheckpoint here");
    println!("For example: EarlyStopping with patience=5, min_delta=0.001");

    // Create learning rate scheduler - we'll just demonstrate its usage
    let _lr_scheduler = CosineAnnealingScheduler::new(0.001_f32, 0.0001_f32);
    println!("Using CosineAnnealingScheduler with initial_lr=0.001, min_lr=0.0001");

    // Train model
    println!("\nTraining model with gradient accumulation...");

    // For demonstration purposes, show what would happen with real training
    println!("Would execute: trainer.train(&dataset, Some(&val_dataset))?");

    // Since we're not actually training, just show example output
    println!("\nExample of training output that would be shown:");
    println!("Training completed in 3 epochs");
    println!("Final loss: 0.0124");
    println!("Final validation loss: 0.0156");

    // 2. Manual Gradient Accumulation
    println!("\n2. Manual Gradient Accumulation:");

    // Create model, optimizer, and loss function
    let model = create_regression_model::<f32>(10, 64, 2)?;
    let _optimizer = Adam::new(0.001_f32, 0.9_f32, 0.999_f32, 1e-8_f32);
    let _loss_fn = MSELoss::new();

    // Create gradient accumulator
    let mut accumulator = GradientAccumulator::new(GradientAccumulationConfig {
        accumulation_steps: 4,
        average_gradients: true,
        zero_gradients_after_update: true,
        clip_gradients: false,
        max_gradient_norm: None,
        log_gradient_stats: false,
    });

    // Initialize accumulator
    accumulator.initialize(&model)?;

    // We would use a DataLoader in real code, but here we'll simulate it
    println!("Creating data loader with batch_size=32, shuffle=true");

    println!("\nTraining for 1 epoch with manual gradient accumulation...");

    let mut total_loss = 0.0_f32;
    let mut processed_batches = 0;

    // Train for one epoch
    // This is a simplified example - in practice you would iterate through DataLoader batches
    // Simulated loop to demonstrate the concept:
    let total_batches = 5;
    for batch_idx in 0..total_batches {
        // In a real implementation we would get inputs and targets from data_loader
        println!("Batch {} - Accumulating gradients...", batch_idx + 1);

        // Simulate a loss value
        let loss = 0.1 * (batch_idx as f32 + 1.0).powf(-0.5);
        total_loss += loss;
        processed_batches += 1;

        // Simulate gradient stats
        println!(
            "Batch {} - Gradient stats: min={:.4}, max={:.4}, mean={:.4}, norm={:.4}",
            batch_idx + 1,
            -0.05 * (batch_idx as f32 + 1.0).powf(-0.5),
            0.05 * (batch_idx as f32 + 1.0).powf(-0.5),
            0.01 * (batch_idx as f32 + 1.0).powf(-0.5),
            0.2 * (batch_idx as f32 + 1.0).powf(-0.5)
        );

        // Update if needed - this is conceptual
        if (batch_idx + 1) % 4 == 0 || batch_idx == total_batches - 1 {
            println!(
                "Applying accumulated gradients after {} batches",
                (batch_idx + 1) % 4
            );
            // In a real implementation we would apply gradients:
            // accumulator.apply_gradients(&mut model, &mut optimizer)?;
        }

        // Early stopping for example
        if batch_idx >= 10 {
            break;
        }
    }

    if processed_batches > 0 {
        println!("Average loss: {:.4}", total_loss / processed_batches as f32);
    }

    // 3. Mixed Precision (not fully implemented, pseudocode)
    println!("\n3. Mixed Precision Training (Pseudocode):");

    println!(
        "// Create mixed precision config
let mp_config = MixedPrecisionConfig {{
    dynamic_loss_scaling: true,
    initial_loss_scale: 65536.0,
    scale_factor: 2.0,
    scale_window: 2000,
    min_loss_scale: 1.0,
    max_loss_scale: 2_f64.powi(24),
    verbose: true,
}};

// Create high precision and low precision models
let high_precision_model = create_regression_model::<f32>(10, 64, 2)?;
let low_precision_model = create_regression_model::<f16>(10, 64, 2)?;

// Create mixed precision model
let mut mixed_model = MixedPrecisionModel::new(
    high_precision_model,
    low_precision_model,
    mp_config,
)?;

// Create optimizer and loss function
let mut optimizer = Adam::new(0.001);
let loss_fn = MSELoss::new();

// Train for one epoch
mixed_model.train_epoch(
    &mut optimizer,
    &dataset,
    &loss_fn,
    32,
    true,
)?;"
    );

    // 4. Gradient Clipping
    println!("\n4. Gradient Clipping:");

    // Create model, optimizer, and loss function
    let model = create_regression_model::<f32>(10, 64, 2)?;
    let optimizer = Adam::new(0.001_f32, 0.9_f32, 0.999_f32, 1e-8_f32);
    let loss_fn = MSELoss::new();

    // Create training config - we need two separate instances
    let gradient_clipping_config = TrainingConfig {
        batch_size: 32,
        shuffle: true,
        num_workers: 0,
        learning_rate: 0.001,
        epochs: 5,
        verbose: 1,
        validation: Some(ValidationSettings {
            enabled: true,
            validation_split: 0.0, // Use separate validation dataset
            batch_size: 32,
            num_workers: 0,
        }),
        gradient_accumulation: None,
        mixed_precision: None,
    };

    // Create a separate configuration for the value clipping example
    let value_clipping_config = TrainingConfig {
        batch_size: 32,
        shuffle: true,
        num_workers: 0,
        learning_rate: 0.001,
        epochs: 5,
        verbose: 1,
        validation: Some(ValidationSettings {
            enabled: true,
            validation_split: 0.0, // Use separate validation dataset
            batch_size: 32,
            num_workers: 0,
        }),
        gradient_accumulation: None,
        mixed_precision: None,
    };

    // Create trainer
    let _trainer = Trainer::new(model, optimizer, loss_fn, gradient_clipping_config);

    // Instead of adding callbacks directly, we'll just demonstrate the concept
    println!("If callbacks were fully implemented, we would add gradient clipping:");
    println!("GradientClipping::by_global_norm(1.0_f32, true) // Max norm, log_stats");

    println!("\nTraining model with gradient clipping by global norm...");

    // Train model for a few epochs
    let _dataset_small = generate_regression_dataset::<f32>(500, 10, 2)?;
    let _val_dataset_small = generate_regression_dataset::<f32>(100, 10, 2)?;
    println!("Would train the model with dataset_small and val_dataset_small");
    // In a real implementation:
    // let session = trainer.train(&dataset_small, Some(&val_dataset_small))?;

    // Since we're not actually training, just show example output
    println!("\nExample of training output that would be shown:");
    println!("Training completed in 3 epochs");
    println!("Final loss: 0.0124");
    println!("Final validation loss: 0.0156");

    // Example with value clipping
    println!("\nExample with gradient clipping by value:");

    // Create model and trainer with value clipping
    let model = create_regression_model::<f32>(10, 64, 2)?;
    let optimizer = Adam::new(0.001_f32, 0.9_f32, 0.999_f32, 1e-8_f32);
    let _trainer = Trainer::new(model, optimizer, loss_fn, value_clipping_config);

    // Instead of actual callbacks, show how we would use them
    println!("For gradient clipping by value, we would use:");
    println!("GradientClipping::by_value(0.5_f32, true) // Max value, log_stats");

    println!("\nDemonstration of how to set up gradient clipping by value:");
    println!("trainer.add_callback(Box::new(GradientClipping::by_value(");
    println!("    0.5_f32, // Max value");
    println!("    true,    // Log stats");
    println!(")));");

    // Demonstrate the training utilities
    println!("\nAdvanced Training Examples Completed Successfully!");

    Ok(())
}

pub fn add_callback( &mut self, callback: Box<dyn Fn() -> Result<()> + Send + Sync>, )

Add a callback to the trainer

Examples found in repository

examples/image_classification_complete.rs (lines 288-292)

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 train<D: Dataset<F> + Clone>( &mut self, dataset: &D, validation_dataset: Option<&D>, ) -> Result<TrainingSession<F>>

Train the model

Examples found in repository

examples/text_classification_complete.rs (line 546)

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

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 validate<D: Dataset<F>>( &mut self, dataset: &D, ) -> Result<HashMap<String, F>>

Validate the model on a dataset

Examples found in repository

examples/text_classification_complete.rs (line 553)

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

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 get_model(&self) -> &dyn Layer<F>

Get the model

Examples found in repository

examples/text_classification_complete.rs (line 583)

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

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 get_model_mut(&mut self) -> &mut dyn Layer<F>

Get the model (mutable)

pub fn get_optimizer(&self) -> &dyn Optimizer<F>

Get the optimizer

pub fn get_optimizer_mut(&mut self) -> &mut dyn Optimizer<F>

Get the optimizer (mutable)

pub fn get_loss_fn(&self) -> &dyn Loss<F>

Get the loss function

pub fn get_session(&self) -> &TrainingSession<F>

Get the current training session

Examples found in repository

examples/image_classification_complete.rs (line 378)

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(())
}