Generate Production-Ready PyTorch Model Templates

This skill acts as a PyTorch model template expert, generating modular, maintainable deep learning code that follows a consistent structure: a BaseModel class with device management and shared training/validation step logic, concrete architecture templates (CNN, Transformer), a full Trainer class handling optimizer/scheduler/criterion creation, epoch training, validation with accuracy tracking, checkpoint saving, and a config-driven setup for hyperparameters.

class BaseModel(nn.Module):
    """Base model class with common functionality."""
    
    def __init__(self, config: Dict):
        super().__init__()
        self.config = config
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        raise NotImplementedError
        
    def training_step(self, batch: Tuple, criterion: nn.Module) -> Dict:
        """Single training step."""
        inputs, targets = batch
        inputs, targets = inputs.to(self.device), targets.to(self.device)
        
        outputs = self(inputs)
        loss = criterion(outputs, targets)
        
        return {'loss': loss, 'outputs': outputs, 'targets': targets}
        
    def validation_step(self, batch: Tuple, criterion: nn.Module) -> Dict:
        """Single validation step."""
        with torch.no_grad():
            return self.training_step(batch, criterion)

The CNN template builds a convolutional feature extractor with batch norm and adaptive pooling plus a dropout classifier head; the Transformer template builds an embedding layer with sinusoidal positional encoding, a TransformerEncoder stack, and a linear classifier over the mean-pooled output. The Trainer supports Adam and SGD optimizers, cosine annealing or step learning-rate schedulers, cross-entropy or MSE criteria, gradient clipping, and saves both the latest and best checkpoints keyed on validation loss.

Use it when starting a new PyTorch deep learning project and you want a modular skeleton - base model class, CNN or Transformer architecture, and a full training loop with checkpointing - that already follows best practices like device-agnostic tensor placement, torch.no_grad() during validation, gradient clipping, and config-driven hyperparameters, instead of writing the training boilerplate from scratch.

It is not a hyperparameter tuning or AutoML tool, and it does not include data loading/preprocessing pipelines beyond the DataLoader/Dataset interface - you supply your own dataset and the concrete architecture layers beyond the CNN/Transformer templates provided.

Input is the model type (CNN, Transformer, or a custom architecture following the BaseModel pattern) and a config dict specifying architecture, optimizer, scheduler, and training hyperparameters. Output is PyTorch source code: a BaseModel subclass, an architecture-specific model class, a Trainer class implementing train_epoch/validate/fit/save_checkpoint, and a config template covering model, training, optimizer, scheduler, and data settings.

ML engineers and researchers starting a new PyTorch project who want a modular, best-practices training and model structure - device management, checkpointing, gradient clipping, config-driven hyperparameters - instead of assembling the training loop and model scaffolding by hand each time.