Burn Training

Burn Training

Knowledge for training neural networks with Burn's Learner abstraction and custom loops.

Learner Setup

The Learner orchestrates training with built-in features:

let learner = LearnerBuilder::new(artifact_dir)
    // Metrics
    .metric_train_numeric(AccuracyMetric::new())
    .metric_valid_numeric(AccuracyMetric::new())
    .metric_train_numeric(LossMetric::new())
    // Checkpointing
    .with_file_checkpointer(CompactRecorder::new())
    // Configuration
    .devices(vec![device.clone()])
    .num_epochs(config.num_epochs)
    .summary()
    .build(model, optim, lr_scheduler);

// Train
let trained_model = learner.fit(dataloader_train, dataloader_valid);

Dataset Implementation

Implement the Dataset trait:

pub struct MyDataset {
    items: Vec<MyItem>,
}

impl Dataset<MyItem> for MyDataset {
    fn get(&self, index: usize) -> Option<MyItem> {
        self.items.get(index).cloned()
    }

    fn len(&self) -> usize {
        self.items.len()
    }
}

Batcher

Convert dataset items to tensors:

#[derive(Clone)]
pub struct MyBatcher<B: Backend> {
    device: B::Device,
}

impl<B: Backend> Batcher<MyItem, MyBatch<B>> for MyBatcher<B> {
    fn batch(&self, items: Vec<MyItem>) -> MyBatch<B> {
        // Convert items to tensors
        let inputs = items.iter().map(|i| i.input.clone()).collect();
        let targets = items.iter().map(|i| i.target).collect();

        MyBatch {
            inputs: Tensor::stack(inputs, 0).to_device(&self.device),
            targets: Tensor::from_data(targets, &self.device),
        }
    }
}

Metrics

Built-in metrics:

• AccuracyMetric — Classification accuracy
• LossMetric — Training/validation loss
• LearningRateMetric — Current LR

Custom metrics implement the Metric trait (not MetricEntry).

Custom Training Loops

For advanced scenarios (multiple optimizers, GAN training):

for epoch in 0..num_epochs {
    for batch in dataloader.iter() {
        // Forward
        let output = model.forward(batch.inputs);
        let loss = output.cross_entropy(batch.targets);

        // Backward
        let grads = loss.backward();

        // Update
        model = optim.step(lr, model, grads);
    }
}

Additional Resources

Consult references/topic-map-training.md for:

• Advanced Learner configuration
• Learning rate schedulers
• Multi-GPU training
• Checkpointing strategies

Converted and distributed by TomeVault — claim your Tome and manage your conversions.