Training Loop في PyTorch

1. optimizer.zero_grad()           ← تصفير التدرّجات القديمة
2. y_hat = model(x)                ← forward pass
3. loss = criterion(y_hat, y)      ← حساب الخسارة
4. loss.backward()                 ← حساب التدرّجات (autograd)
5. optimizer.step()                ← تحديث الأوزان

Epoch   = مرور واحد على كامل بيانات التدريب
Batch   = دفعة (subset) من البيانات
Iteration = خطوة واحدة (معالجة دفعة واحدة)

Dataset = 1000 عيّنة
batch_size = 32
iterations لكل epoch = ceil(1000 / 32) = 32

import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader

torch.manual_seed(0)

# === بيانات وهمية ===
X = torch.randn(200, 4)
y = (X[:, 0] + X[:, 1] - X[:, 2] > 0).long()

ds = TensorDataset(X, y)
train_ds, val_ds = torch.utils.data.random_split(ds, [160, 40])
train_loader = DataLoader(train_ds, batch_size=16, shuffle=True)
val_loader = DataLoader(val_ds, batch_size=16)

# === نموذج بسيط ===
model = nn.Sequential(
    nn.Linear(4, 16),
    nn.ReLU(),
    nn.Linear(16, 2),
)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)
criterion = nn.CrossEntropyLoss()

# === حلقة التدريب ===
for epoch in range(5):
    # ===== TRAIN =====
    model.train()
    train_loss = 0.0
    n_train = 0
    for xb, yb in train_loader:
        optimizer.zero_grad()       # 1. تصفير
        y_hat = model(xb)           # 2. forward
        loss = criterion(y_hat, yb) # 3. loss
        loss.backward()             # 4. backward
        optimizer.step()            # 5. step
        train_loss += loss.item() * len(xb)
        n_train += len(xb)

    # ===== VALIDATE =====
    model.eval()
    val_loss = 0.0
    correct = 0
    n_val = 0
    with torch.no_grad():
        for xb, yb in val_loader:
            y_hat = model(xb)
            loss = criterion(y_hat, yb)
            val_loss += loss.item() * len(xb)
            correct += (y_hat.argmax(dim=1) == yb).sum().item()
            n_val += len(xb)

    print(
        f"epoch {epoch}: "
        f"train={train_loss/n_train:.4f} "
        f"val={val_loss/n_val:.4f} "
        f"val_acc={correct/n_val:.3f}"
    )

epoch 0: train=0.6587 val=0.5681 val_acc=0.700
epoch 1: train=0.4745 val=0.4124 val_acc=0.875
epoch 2: train=0.3302 val=0.2727 val_acc=0.925
epoch 3: train=0.2208 val=0.1974 val_acc=0.975
epoch 4: train=0.1569 val=0.1498 val_acc=0.975

model.train()    # Dropout يطبّق، BatchNorm يستخدم batch stats
# ... تدريب ...
model.eval()     # Dropout معطّل، BatchNorm يستخدم running stats
# ... تقييم ...

model.eval()
with torch.no_grad():
    y_hat = model(x_val)
    # y_hat.grad_fn = None
    # لا يمكن عمل .backward()

Iteration 1: w.grad =  2.0   (بعد backward)
Iteration 2: w.grad =  2.0 + 3.0 = 5.0   ← تدرّجات متراكمة!

# ❌ خطأ: يتراكم
for xb, yb in loader:
    loss = criterion(model(xb), yb)
    loss.backward()      # w.grad += new_grad
    optimizer.step()     # w -= lr * w.grad (المتراكم!)

# ✅ صحيح
for xb, yb in loader:
    optimizer.zero_grad()    # ← ضرورية
    loss = criterion(model(xb), yb)
    loss.backward()
    optimizer.step()

best_val = float("inf")

for epoch in range(max_epochs):
    # ... تدريب وتقييم ...
    if val_loss < best_val:
        best_val = val_loss
        torch.save(model.state_dict(), "best.pt")
        print(f"saved best at epoch {epoch}")