PyTorch

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
import numpy as np
import pandas as pd
import torch
import torch.nn as nn

torch.set_num_threads(2)
print(f"PyTorch {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}  (this chapter uses the CPU)")

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

df = pd.read_csv(DATA / "uy_ijara.csv")
num = ["xonalar", "maydon_m2", "qavat", "qavatlar_soni", "metro_km", "mebel", "qurilgan_yil"]
X = SimpleImputer(strategy="median").fit_transform(df[num])
y = df["ijaraga_berildi_30k"].to_numpy(dtype="float32")
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
sc = StandardScaler().fit(X_tr)
Xt = torch.tensor(sc.transform(X_tr), dtype=torch.float32)
Yt = torch.tensor(y_tr).unsqueeze(1)
Xv = torch.tensor(sc.transform(X_te), dtype=torch.float32)
Yv = torch.tensor(y_te).unsqueeze(1)

def train_once(seed=42, epochs=150):
    torch.manual_seed(seed)
    model = nn.Sequential(nn.Linear(Xt.shape[1], 16), nn.ReLU(), nn.Linear(16, 1))
    opt = torch.optim.Adam(model.parameters(), lr=0.01)
    criterion = nn.BCEWithLogitsLoss()
    for _ in range(epochs):
        opt.zero_grad()
        loss = criterion(model(Xt), Yt)
        loss.backward()
        opt.step()
    with torch.no_grad():
        return float(criterion(model(Xv), Yv))

results = [round(train_once(), 6) for _ in range(3)]
print("The same seed, trained three times:")
print(f"  {results}")
print(f"  All the same: {len(set(results)) == 1}")

a = torch.tensor([[1., 2., 3.], [4., 5., 6.]])
print(f"shape : {a.shape}")
print(f"dtype : {a.dtype}")
print(f"device: {a.device}")
print()
print("Almost the same as numpy:")
print(f"  a @ a.T     ->\n{a @ a.T}")
print(f"  a.mean(0)   -> {a.mean(0)}")
print()
print("To numpy and back: THE MEMORY IS SHARED:")
n = a.numpy()
n[0, 0] = 999
print(f"  we changed the numpy array -> torch tensor: {a[0, 0]}")
print("  (if you need a copy: a.numpy().copy() or torch.tensor(n))")

show(pd.DataFrame([
    {"Addition": "1. requires_grad", "What it gives you": "Automatic differentiation (autograd)",
     "In numpy": "none: you write the gradient by hand (Chapter 13)"},
    {"Addition": "2. device", "What it gives you": "Moving to the GPU: .to('cuda')",
     "In numpy": "none: CPU only"},
]))

# repeat the example from Chapter 31: L = (w2*(w1*x)^2 - y)^2
x_, y_true = 2.0, 10.0
w1 = torch.tensor(3.0, requires_grad=True)
w2 = torch.tensor(0.5, requires_grad=True)

z1 = w1 * x_
a1 = z1 ** 2
z2 = w2 * a1
L = (z2 - y_true) ** 2
L.backward()                      # ONE call: the whole chain is computed

print(f"L = {float(L):.1f}")
print(f"  dL/dw1 = {float(w1.grad):.1f}")
print(f"  dL/dw2 = {float(w2.grad):.1f}")
print()
print("The values computed by hand in Chapter 31: dL/dw1 = 192.0, dL/dw2 = 576.0")
print(f"Do they match: {bool(abs(float(w1.grad) - 192.0) < 1e-4 and abs(float(w2.grad) - 576.0) < 1e-4)}")

print("The computation graph was built automatically:")
print(f"  L.grad_fn           : {L.grad_fn}")
print(f"  one step back       : {L.grad_fn.next_functions[0][0]}")
print()
print("Every operation is added to the graph, and backward() walks it in reverse, collecting gradients.")

w = torch.tensor(1.0, requires_grad=True)
print("If zero_grad() is NOT called:")
for i in range(3):
    loss = (w * 2) ** 2
    loss.backward()
    print(f"  call {i+1} -> w.grad = {float(w.grad):.1f}   (it ADDS UP each time)")
print()
w2_ = torch.tensor(1.0, requires_grad=True)
print("Clearing at every step:")
for i in range(3):
    if w2_.grad is not None:
        w2_.grad.zero_()
    loss = (w2_ * 2) ** 2
    loss.backward()
    print(f"  call {i+1} -> w.grad = {float(w2_.grad):.1f}   (correct)")

torch.manual_seed(42)
model = nn.Sequential(
    nn.Linear(Xt.shape[1], 32), nn.ReLU(),
    nn.Linear(32, 16), nn.ReLU(),
    nn.Linear(16, 1),
)
opt = torch.optim.Adam(model.parameters(), lr=0.01)
criterion = nn.BCEWithLogitsLoss()

history = {"train": [], "val": []}
for epoch in range(200):
    model.train()
    opt.zero_grad()                       # 1. clear the gradient
    output = model(Xt)                    # 2. forward
    loss = criterion(output, Yt)          # 3. compute the loss
    loss.backward()                       # 4. backward
    opt.step()                            # 5. update the weights

    model.eval()
    with torch.no_grad():
        history["train"].append(float(loss))
        history["val"].append(float(criterion(model(Xv), Yv)))

with torch.no_grad():
    acc = float(((torch.sigmoid(model(Xv)) > 0.5).float() == Yv).float().mean())
print(f"Final train loss : {history['train'][-1]:.4f}")
print(f"Final val loss   : {history['val'][-1]:.4f}")
print(f"Test accuracy    : {acc:.4f}")

show(pd.DataFrame([
    {"Step": "opt.zero_grad()", "Why": "So gradients don't accumulate"},
    {"Step": "output = model(X)", "Why": "The forward pass; the graph is built"},
    {"Step": "loss = criterion(...)", "Why": "Computing the loss"},
    {"Step": "loss.backward()", "Why": "Computing the gradients (autograd)"},
    {"Step": "opt.step()", "Why": "Updating the weights (the Chapter 13 rule)"},
]))

def sigmoid_test(twice):
    torch.manual_seed(42)
    layers = [nn.Linear(Xt.shape[1], 16), nn.ReLU(), nn.Linear(16, 1)]
    if twice:
        layers.append(nn.Sigmoid())          # then BCEWithLogits applies sigmoid again
    m = nn.Sequential(*layers)
    opt_ = torch.optim.Adam(m.parameters(), lr=0.01)
    k = nn.BCEWithLogitsLoss()
    for _ in range(200):
        opt_.zero_grad(); k(m(Xt), Yt).backward(); opt_.step()
    m.eval()
    with torch.no_grad():
        out = m(Xv)
        pred = (torch.sigmoid(out) > 0.5).float() if not twice else (out > 0.5).float()
        return float(((pred == Yv).float().mean()))

print(f"Right (Linear + BCEWithLogits)   : {sigmoid_test(False):.4f}")
print(f"WRONG (Sigmoid + BCEWithLogits)  : {sigmoid_test(True):.4f}")

from torch.utils.data import TensorDataset, DataLoader

ds_tr = TensorDataset(Xt, Yt)
ds_te = TensorDataset(Xv, Yv)
dl_tr = DataLoader(ds_tr, batch_size=64, shuffle=True,
                   generator=torch.Generator().manual_seed(42))
dl_te = DataLoader(ds_te, batch_size=64)

print(f"Train samples    : {len(ds_tr)}")
print(f"Batch size       : 64")
print(f"Number of batches: {len(dl_tr)}")
print()
for xb, yb in dl_tr:
    print(f"One batch's shape: X={tuple(xb.shape)}  y={tuple(yb.shape)}")
    break

def train_dataloader(epochs=60):
    torch.manual_seed(42)
    m = nn.Sequential(nn.Linear(Xt.shape[1], 32), nn.ReLU(),
                      nn.Dropout(0.2), nn.Linear(32, 1))
    opt_ = torch.optim.Adam(m.parameters(), lr=0.01)
    k = nn.BCEWithLogitsLoss()
    hist = []
    for _ in range(epochs):
        m.train()
        loss_total = 0.0
        for xb, yb in dl_tr:
            opt_.zero_grad()
            loss_ = k(m(xb), yb)
            loss_.backward()
            opt_.step()
            loss_total += float(loss_) * len(xb)
        hist.append(loss_total / len(ds_tr))
    m.eval()
    with torch.no_grad():
        correct = sum(float(((torch.sigmoid(m(xb)) > .5).float() == yb).float().sum()) for xb, yb in dl_te)
    return m, hist, correct / len(ds_te)

m_dl, hist_dl, acc_dl = train_dataloader()
print(f"Test accuracy with mini-batches : {acc_dl:.4f}")
print(f"With full-batch (above)         : {acc:.4f}")

class MyLayer(nn.Module):
    """Linear + ReLU + a residual connection (the ResNet idea from Chapter 34)."""
    def __init__(self, n):
        super().__init__()
        self.linear = nn.Linear(n, n)
        self.norm = nn.LayerNorm(n)

    def forward(self, x):
        return x + torch.relu(self.norm(self.linear(x)))   # x + ... = residual


class MyNetwork(nn.Module):
    def __init__(self, n_in, hidden=32, n_blocks=3):
        super().__init__()
        self.inp = nn.Linear(n_in, hidden)
        self.blocks = nn.ModuleList([MyLayer(hidden) for _ in range(n_blocks)])
        self.out = nn.Linear(hidden, 1)

    def forward(self, x):
        x = torch.relu(self.inp(x))
        for b in self.blocks:
            x = b(x)
        return self.out(x)

torch.manual_seed(42)
mt = MyNetwork(Xt.shape[1])
print(f"Number of parameters: {sum(p.numel() for p in mt.parameters())}")
opt_mt = torch.optim.Adam(mt.parameters(), lr=0.01)
k_mt = nn.BCEWithLogitsLoss()
for _ in range(200):
    mt.train(); opt_mt.zero_grad(); k_mt(mt(Xt), Yt).backward(); opt_mt.step()
mt.eval()
with torch.no_grad():
    acc_mt = float(((torch.sigmoid(mt(Xv)) > .5).float() == Yv).float().mean())
print(f"Residual network test accuracy: {acc_mt:.4f}")
print(f"Plain Sequential (above)      : {acc:.4f}")

path = ISH / "model.pt"
torch.save(model.state_dict(), path)
print(f"Saved: {path.name}  ({path.stat().st_size / 1024:.0f} KB)")
print()
# loading NEEDS the architecture
torch.manual_seed(0)      # a different seed, so the weights are different
fresh = nn.Sequential(nn.Linear(Xt.shape[1], 32), nn.ReLU(),
                      nn.Linear(32, 16), nn.ReLU(), nn.Linear(16, 1))
with torch.no_grad():
    before = float(nn.BCEWithLogitsLoss()(fresh(Xv), Yv))
fresh.load_state_dict(torch.load(path))
fresh.eval()
with torch.no_grad():
    after = float(nn.BCEWithLogitsLoss()(fresh(Xv), Yv))
print(f"Val loss BEFORE loading     : {before:.4f}")
print(f"Val loss AFTER loading      : {after:.4f}")
print(f"Same as the original model  : {bool(abs(after - history['val'][-1]) < 1e-5)}")

print("When the architecture doesn't match:")
wrong = nn.Sequential(nn.Linear(Xt.shape[1], 64), nn.ReLU(), nn.Linear(64, 1))
try:
    wrong.load_state_dict(torch.load(path))
except RuntimeError as e:
    print(f"  RuntimeError: {str(e).splitlines()[0][:72]}")

show(pd.DataFrame([
    {"": "Keras", "Training loop": "model.fit(): automatic",
     "Reproducible": "NO (Chapter 32)", "Flexibility": "Medium",
     "When": "Standard tasks, quick prototypes"},
    {"": "PyTorch", "Training loop": "By hand: 5 lines",
     "Reproducible": "YES (manual_seed)", "Flexibility": "Full",
     "When": "Research, non-standard architectures, LLMs"},
]))

import time
from sklearn.linear_model import LogisticRegression

print(f"{'model':<36} {'test accuracy':>14} {'time':>8}")
print("-" * 62)
t0 = time.perf_counter()
lr_m = LogisticRegression(max_iter=3000).fit(sc.transform(X_tr), y_tr)
print(f"{'LogisticRegression (Chapter 16)':<36} {lr_m.score(sc.transform(X_te), y_te):>14.4f} {time.perf_counter()-t0:>7.2f}s")
print(f"{'PyTorch Sequential (32-16)':<36} {acc:>14.4f} {'—':>8}")
print(f"{'PyTorch + DataLoader + Dropout':<36} {acc_dl:>14.4f} {'—':>8}")
print(f"{'PyTorch residual (my own layer)':<36} {acc_mt:>14.4f} {'—':>8}")

show(pd.DataFrame([
    {"Concept": "Reproducibility", "In one sentence": "PyTorch reproduces exactly with manual_seed; TF doesn't"},
    {"Concept": "Tensor", "In one sentence": "numpy + requires_grad + device"},
    {"Concept": "Autograd", "In one sentence": "backward() squeezes the hand work from Chapter 31 into one line"},
    {"Concept": "zero_grad()", "In one sentence": "Gradients ACCUMULATE: clearing them is mandatory"},
    {"Concept": "The training loop", "In one sentence": "zero_grad -> forward -> loss -> backward -> step"},
    {"Concept": "BCEWithLogitsLoss", "In one sentence": "The sigmoid is inside: DON'T add a sigmoid layer"},
    {"Concept": "nn.Module", "In one sentence": "Ordinary Python inside forward(): full freedom"},
    {"Concept": "state_dict", "In one sentence": "Weights only; you need the architecture code separately"},
]))