deep-learning

name	deep-learning
description	PyTorch, TensorFlow, neural networks, CNNs, transformers, and deep learning for production
sasmp_version	1.3.0
bonded_agent	06-ml-ai-engineer
bond_type	PRIMARY_BOND
skill_version	2.0.0
last_updated	2025-01
complexity	advanced
estimated_mastery_hours	200
prerequisites	["python-programming","machine-learning"]
unlocks	["llms-generative-ai","mlops"]

Deep Learning

Production-grade deep learning with PyTorch, neural network architectures, and modern training practices.

Quick Start

# PyTorch Production Training Loop
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR
import wandb

class TransformerClassifier(nn.Module):
    def __init__(self, vocab_size: int, d_model: int = 256, n_heads: int = 8, n_classes: int = 2):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = nn.Parameter(torch.randn(1, 512, d_model))
        encoder_layer = nn.TransformerEncoderLayer(d_model, n_heads, dim_feedforward=1024, batch_first=True)
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=6)
        self.classifier = nn.Linear(d_model, n_classes)
        self.dropout = nn.Dropout(0.1)

    def forward(self, x, mask=None):
        x = self.embedding(x) + self.pos_encoding[:, :x.size(1), :]
        x = .dropout(x)
        x = .transformer(x, src_key_padding_mask=mask)
        x = x.mean(dim=)  
         .classifier(x)


device = torch.device(  torch.cuda.is_available()  )
model = TransformerClassifier(vocab_size=).to(device)
optimizer = AdamW(model.parameters(), lr=, weight_decay=)
scheduler = CosineAnnealingLR(optimizer, T_max=)
criterion = nn.CrossEntropyLoss()


scaler = torch.cuda.amp.GradScaler()

 epoch  ():
    model.train()
     batch  train_loader:
        optimizer.zero_grad()
         torch.cuda.amp.autocast():
            logits = model(batch[].to(device))
            loss = criterion(logits, batch[].to(device))
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()
    scheduler.step()