train-model
Execute model training with optimization algorithms. Use when running training loops on datasets.
When & Why to Use This Skill
The train-model skill streamlines the machine learning lifecycle by automating the implementation and execution of training loops. It handles complex tasks such as forward and backward passes, gradient updates, and checkpoint management. By integrating optimization algorithms like SGD and Adam, it allows developers to focus on model architecture while ensuring robust tracking of loss values, validation metrics, and learning curves for effective experiment analysis.
Use Cases
- End-to-End Training Pipelines: Automate the full process of loading datasets, initializing neural networks, and executing training cycles with real-time progress monitoring.
- Model Fine-Tuning: Efficiently adapt pretrained models to specialized datasets or domain-specific tasks to improve predictive accuracy.
- Hyperparameter Optimization: Systematically test variations in learning rates, batch sizes, and optimizers to identify the most effective configuration for a given model.
- Research Reproduction: Implement standardized training workflows to reproduce results from academic papers and validate model performance against benchmarks.
| name | train-model |
|---|---|
| description | "Execute model training with optimization algorithms. Use when running training loops on datasets." |
| mcp_fallback | none |
| category | ml |
| tier | 2 |
| user-invocable | false |
Train Model
Implement and execute model training loops including forward/backward passes, gradient updates, and checkpoint management.
When to Use
- Running full training pipeline on datasets
- Fine-tuning pretrained models
- Experimenting with hyperparameter variations
- Reproducing paper results
Quick Reference
# Mojo training loop pattern
struct Trainer:
var model: NeuralNetwork
var optimizer: Optimizer
var loss_fn: LossFn
fn train_epoch(mut self, mut dataloader: BatchLoader) -> Float32:
var total_loss: Float32 = 0.0
var batches: Int = 0
for batch in dataloader:
var predictions = self.model(batch.inputs)
var loss = self.loss_fn(predictions, batch.targets)
# Backward pass and optimization
total_loss += loss
batches += 1
return total_loss / Float32(batches)
Workflow
- Prepare data pipeline: Load and batch training data
- Initialize model: Create network with specified architecture
- Set up optimizer: Choose optimizer (SGD, Adam) with learning rate
- Implement training loop: Forward pass, compute loss, backward pass, update weights
- Monitor progress: Log loss, save checkpoints, validate periodically
Output Format
Training report:
- Loss values per epoch
- Training time per epoch
- Validation metrics (accuracy, loss)
- Learning curves (loss vs epoch)
- Final model performance
- Checkpoint locations
References
- See
prepare-datasetskill for data pipeline setup - See
evaluate-modelskill for validation - See CLAUDE.md > Mojo for training loop patterns