Chapter 15

ট্রেনিং পাইপলাইন

Training Pipeline

🎬 ছোট ছোট কোড থেকে production pipeline

একটি professional DL প্রজেক্টে শুধু মডেল না — ডেটা লোডিং, augmentation, training loop, logging, checkpoint, evaluation — সব একসাথে কাজ করে। এই অধ্যায়ে আমরা সেই complete pipeline বানাব।

Pipeline-এর ৫টি ধাপ

Data Loading

Dataset + DataLoader, augmentation।

Model + Optimizer

Architecture, loss, optimizer setup।

Train + Validate Loop

Epoch by epoch + metrics tracking।

Checkpoint + Logging

Best model save, TensorBoard log।

Reusable Training Function

import torch
from torch.utils.data import DataLoader

def train_one_epoch(model, loader, loss_fn, optimizer, device):
    model.train()
    total_loss, correct = 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        pred = model(x)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * len(x)
        correct += (pred.argmax(1) == y).sum().item()
    return total_loss / len(loader.dataset), correct / len(loader.dataset)


@torch.no_grad()
def evaluate(model, loader, loss_fn, device):
    model.eval()
    total_loss, correct = 0, 0
    for x, y in loader:
        x, y = x.to(device), y.to(device)
        pred = model(x)
        total_loss += loss_fn(pred, y).item() * len(x)
        correct += (pred.argmax(1) == y).sum().item()
    return total_loss / len(loader.dataset), correct / len(loader.dataset)

সম্পূর্ণ Pipeline

def fit(model, train_loader, val_loader, epochs=10, lr=1e-3, device="cuda"):
    model = model.to(device)
    opt = torch.optim.Adam(model.parameters(), lr=lr)
    loss_fn = nn.CrossEntropyLoss()
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs)

    best_acc = 0
    history = {"train_loss": [], "val_loss": [], "train_acc": [], "val_acc": []}

    for ep in range(epochs):
        tr_loss, tr_acc = train_one_epoch(model, train_loader, loss_fn, opt, device)
        val_loss, val_acc = evaluate(model, val_loader, loss_fn, device)
        scheduler.step()

        history["train_loss"].append(tr_loss)
        history["val_loss"].append(val_loss)
        history["train_acc"].append(tr_acc)
        history["val_acc"].append(val_acc)

        if val_acc > best_acc:
            best_acc = val_acc
            torch.save(model.state_dict(), "best.pt")

        print(f"Epoch {ep+1}/{epochs} | "
              f"train loss {tr_loss:.4f} acc {tr_acc:.3f} | "
              f"val loss {val_loss:.4f} acc {val_acc:.3f}")

    return history

Logging — TensorBoard

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("runs/exp1")

# inside epoch loop
writer.add_scalar("Loss/train", tr_loss, ep)
writer.add_scalar("Loss/val", val_loss, ep)
writer.add_scalar("Acc/val", val_acc, ep)

# তারপর terminal-এ:
# tensorboard --logdir=runs

Reproducibility

def set_seed(seed=42):
    import random, numpy as np
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True

🔑 Pipeline-এর সেরা practice