Struct TrainingSession

pub struct TrainingSession<F: Float + Debug + ScalarOperand> {
    pub history: HashMap<String, Vec<F>>,
    pub initial_learning_rate: F,
    pub epochs_trained: usize,
    pub batches_per_epoch: usize,
    pub total_parameters: usize,
    pub config: TrainingConfig,
}

Training session for tracking training history

Fields

history: HashMap<String, Vec<F>>

Training metrics history

initial_learning_rate: F

Initial learning rate

epochs_trained: usize

Number of epochs trained

batches_per_epoch: usize

Number of batches per epoch

total_parameters: usize

Total number of parameters

config: TrainingConfig

Training configuration

Implementations

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

pub fn new(config: TrainingConfig) -> Self

Create a new training session

pub fn add_metric(&mut self, name: &str, value: F)

Add a metric to history

pub fn get_metric(&self, name: &str) -> Option<&[F]>

Get metric history

Examples found in repository

examples/image_classification_complete.rs (line 379)

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

Trait Implementations

impl<F: Clone + Float + Debug + ScalarOperand> Clone for TrainingSession<F>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.