Classify sentiment:
Text: 'This is amazing!' -> Positive
Text: 'Not what I expected' -> Negative
Text: 'It's okay' -> Neutral
Text: 'Best purchase ever!' -> ?

from sklearn.metrics import precision_score, recall_score, f1_score, classification_report

y_true = [0, 1, 1, 0, 1, 1]
y_pred = [0, 1, 0, 0, 1, 1]

p = precision_score(y_true, y_pred) # 1.0 (No False Positives)
r = recall_score(y_true, y_pred)    # 0.75 (Missed one positive)
f1 = f1_score(y_true, y_pred)       # 0.857

# In production, always look at the full report:
print(classification_report(y_true, y_pred))

# L2 is built into optimizers as 'weight_decay'
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3, weight_decay=1e-5)

# L1 must be added manually to the loss
l1_lambda = 1e-5
l1_norm = sum(p.abs().sum() for p in model.parameters())
loss = criterion(output, target) + l1_lambda * l1_norm

from sklearn.decomposition import PCA
import numpy as np

pca = PCA(n_components=0.95)  # Keep 95% of variance
X_reduced = pca.fit_transform(X_scaled)
print(f"Reduced from {X_scaled.shape[1]} to {X_reduced.shape[1]} dimensions")
print(f"Explained variance per component: {pca.explained_variance_ratio_}")

# Conv2d: 3 input channels (RGB), 16 output filters, 3x3 kernel
conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)
# With padding=1 and stride=1: output spatial dims = input spatial dims
# Parameters: 3 * 16 * 3 * 3 + 16(bias) = 448 parameters

Production Data -> Feature Statistics Computation -> Statistical Tests (PSI, KS) -> Alert if threshold exceeded -> Trigger retraining pipeline

FROM python:3.9-slim
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# Multi-stage build to reduce final image size
FROM python:3.9-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM nvidia/cuda:11.8.0-runtime-ubuntu22.04
# Copy only the installed packages, not pip cache
COPY --from=builder /usr/local/lib/python3.9 /usr/local/lib/python3.9
COPY --from=builder /usr/local/bin /usr/local/bin
WORKDIR /app
COPY . .
# Don't run as root in production
RUN useradd -m appuser && chown -R appuser /app
USER appuser
EXPOSE 8000
HEALTHCHECK CMD curl -f http://localhost:8000/health || exit 1
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

class ImageDataset(Dataset):
    def __init__(self, image_paths, labels, transform=None):
        self.paths = image_paths
        self.labels = labels
        self.transform = transform

    def __getitem__(self, idx):
        # Lazy loading: read image only when accessed
        image = Image.open(self.paths[idx])
        if self.transform:
            image = self.transform(image)
        return image, self.labels[idx]

    def __len__(self):
        return len(self.paths)

loader = DataLoader(
    dataset,
    batch_size=32,
    shuffle=True,          # Shuffle for training, not for eval
    num_workers=4,         # Parallel data loading processes
    pin_memory=True,       # Faster CPU->GPU transfer
    drop_last=True,        # Drop incomplete last batch (for BN stability)
    prefetch_factor=2,     # Prefetch 2 batches per worker
)

model.train()  # Enable dropout, batch norm uses batch stats
for epoch in range(num_epochs):
    for batch_x, batch_y in train_loader:
        batch_x, batch_y = batch_x.to(device), batch_y.to(device)

        optimizer.zero_grad()       # 1. Clear accumulated gradients
        output = model(batch_x)     # 2. Forward pass
        loss = criterion(output, batch_y)  # 3. Compute loss
        loss.backward()             # 4. Backward pass (compute gradients)
        optimizer.step()            # 5. Update weights

    # Validation after each epoch
    model.eval()  # Disable dropout, BN uses running stats
    with torch.no_grad():  # Disable gradient computation (save memory)
        val_loss = sum(criterion(model(vx.to(device)), vy.to(device))
                      for vx, vy in val_loader) / len(val_loader)
    model.train()  # Switch back for next epoch

# Mixed precision training (2x faster, half memory)
scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    output = model(batch_x)
    loss = criterion(output, batch_y)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

# Gradient accumulation (simulate larger batch size)
accumulation_steps = 4
for i, (batch_x, batch_y) in enumerate(loader):
    loss = criterion(model(batch_x), batch_y) / accumulation_steps
    loss.backward()
    if (i + 1) % accumulation_steps == 0:
        optimizer.step()
        optimizer.zero_grad()

from torch.nn.utils.rnn import pad_sequence

# Sequences of different lengths
seqs = [torch.tensor([1, 2, 3]), torch.tensor([4, 5]), torch.tensor([6, 7, 8, 9])]
padded = pad_sequence(seqs, batch_first=True, padding_value=0)
# tensor([[1, 2, 3, 0],
#         [4, 5, 0, 0],
#         [6, 7, 8, 9]])

attention_mask = (padded != 0).long()
# tensor([[1, 1, 1, 0],
#         [1, 1, 0, 0],
#         [1, 1, 1, 1]])

# Warmup + Cosine (Transformer standard)
from transformers import get_cosine_schedule_with_warmup

scheduler = get_cosine_schedule_with_warmup(
    optimizer,
    num_warmup_steps=1000,    # ~5-10% of total steps
    num_training_steps=20000
)

# In training loop:
optimizer.step()
scheduler.step()  # Call after optimizer.step()

# Save (weights only)
torch.save(model.state_dict(), 'model.pth')

# Load (requires model class definition)
model = MyModel()  # Must define architecture first
model.load_state_dict(torch.load('model.pth', weights_only=True))
model.eval()  # Don't forget!

# Save everything needed to resume
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'scheduler_state_dict': scheduler.state_dict(),
    'loss': loss,
    'best_val_loss': best_val_loss,
}, 'checkpoint.pth')

model.eval()                          # Switch mode
with torch.no_grad():                 # Disable gradient tracking (save memory + speed)
    output = model(input_tensor)      # Forward pass
# model.eval() and torch.no_grad() are independent!
# eval() changes layer behavior. no_grad() saves memory.

# DDP setup (per process)
import torch.distributed as dist
dist.init_process_group("nccl")
model = model.to(local_rank)
model = DistributedDataParallel(model, device_ids=[local_rank])

# Use DistributedSampler to shard data across processes
sampler = DistributedSampler(dataset)
loader = DataLoader(dataset, sampler=sampler, batch_size=32)

# Take ONE batch and train on it for 100 steps
batch_x, batch_y = next(iter(train_loader))
for i in range(100):
    loss = train_step(batch_x, batch_y)
    if i % 10 == 0: print(f"Step {i}: Loss = {loss:.4f}")
# If loss doesn't go to ~0, your model/loss/data has a bug

from peft import LoraConfig, get_peft_model

config = LoraConfig(
    r=16,               # Rank (higher = more capacity, more params)
    lora_alpha=32,       # Scaling factor (alpha/r scales the update)
    target_modules=["q_proj", "v_proj"],  # Which layers to adapt
    lora_dropout=0.05,
)
model = get_peft_model(base_model, config)
model.print_trainable_parameters()
# trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.062%

Step 1: ["The" (0.4), "A" (0.3)]
Step 2: ["The cat" (0.35), "The dog" (0.32)] (from "The")
        ["A cat" (0.28), "A big" (0.25)] (from "A")
        Keep top 2: ["The cat" (0.35), "The dog" (0.32)]
Step 3: Continue expanding...

For each node v:
    1. Aggregate: a_v = AGG({h_u : u in Neighbors(v)})
    2. Update: h_v = UPDATE(h_v, a_v)

Thought: I need to find the current stock price of AAPL.
Action: search_api("AAPL stock price")
Observation: AAPL is currently $185.50
Thought: Now I need to compare to last month's price.
Action: search_api("AAPL stock price 30 days ago")
Observation: AAPL was $178.20 thirty days ago.
Thought: I can now calculate the change.
Answer: AAPL is up $7.30 (4.1%) over the past month.

import wandb

wandb.init(project="my-project", config={
    "lr": 1e-3,
    "batch_size": 32,
    "model": "resnet50",
    "dataset_version": "v2.3",
})

for epoch in range(num_epochs):
    train_loss = train_one_epoch()
    val_loss, val_acc = evaluate()
    wandb.log({"train_loss": train_loss, "val_loss": val_loss, "val_acc": val_acc})

wandb.finish()