0 dní v řadě · 0 bodů

Neuronové sítě a moderní AI · 35 min

PyTorch v praxi

Tenzory, autograd, moduly, DataLoader a trénovací smyčka. Přepíšeš síť z NumPy do PyTorch a poznáš chyby, které nehlásí žádná výjimka.

Hloubka
Úkoly
Lidsky řečeno

Síť v NumPy je jako postavit si kolo od rudy: poctivé, poučné a napodruhé to dělat nechceš. PyTorch je dílna s hotovými díly. Rám, řetěz a brzdy dostaneš z regálu a staráš se jen o to, kam chceš jet. Protože ale víš, jak se ten řetěz vyrábí, poznáš, když začne drhnout.

Co PyTorch přidává k NumPy

V předchozích lekcích jsi počítal gradienty ručně. U dvou vrstev to jde, u padesáti ne. PyTorch je knihovna, která řeší čtyři věci:

CoJak se tomu říkáCo za tebe udělá
pole číseltorch.Tensortotéž co NumPy, navíc i na grafické kartě
gradientyautogradspočítá derivace podle toho, co jsi počítal
vrstvytorch.nnhotové stavební díly a evidence parametrů
data a učeníDataLoader, torch.optimdávky, míchání, optimalizátory

PyTorch v prohlížeči neběží, je to velký balík s nativním kódem. Ukázky s torch proto jen čteš a spustíš si je doma. Každou myšlenku si ale hned vyzkoušíš na malé napodobenině v NumPy, která tady běží. Instalační příkaz se liší podle systému a grafické karty, proto si ho nech vygenerovat na pytorch.org. Nejjednodušší varianta vypadá takhle:

bash
python -m venv .venv
python -m pip install torch

Tenzory: pole, která umí víc

Tenzor je vícerozměrné pole čísel. Číslo, vektor, tabulka i hromádka obrázků jsou tenzory, liší se jen počtem os. Když umíš NumPy, umíš většinu práce s tenzory. Nejdřív si připomeň tvary. Tipni si výstup a teprve potom spusť.

import numpy as np

x = np.arange(12.0).reshape(3, 4)
print(x.shape)
print(x.mean(axis=0))
print(x.T.shape)
print((x @ x.T).shape)
Výstup
(3, 4)
[4. 5. 6. 7.]
(4, 3)
(3, 3)

V PyTorch vypadá totéž skoro stejně. Místo axis se běžně píše dim.

python
import numpy as np
import torch

x = torch.arange(12.0).reshape(3, 4)
print(x.shape)            # torch.Size([3, 4])
print(x.mean(dim=0))      # tensor([4., 5., 6., 7.])
print((x @ x.T).shape)    # torch.Size([3, 3])

a = torch.tensor([1, 2, 3])          # integers: torch.int64
b = torch.tensor([1.0, 2.0, 3.0])    # floats: torch.float32
print(b.dtype, b.device)             # torch.float32 cpu
print(b.sum().item())                # 6.0, a plain Python number

n = np.array([1.0, 2.0])             # NumPy default: float64
t = torch.from_numpy(n)              # shares memory, stays float64
t = torch.tensor(n, dtype=torch.float32)  # copy with the usual type

Rozdíly, na kterých se začátečník spálí:

  • NumPy má výchozí desetinný typ float64, PyTorch float32. Míchání typů končí chybou typu „expected Float but found Double“.
  • torch.from_numpy paměť sdílí. Změna jednoho změní i druhé. torch.tensor kopíruje.
  • Tenzor má své zařízení (device), tedy procesor nebo grafickou kartu. Počítat spolu můžou jen tenzory na stejném zařízení.
python
device = "cuda" if torch.cuda.is_available() else "cpu"

x = torch.randn(4, 2)
x = x.to(device)          # a tensor returns a NEW object, keep it
model = model.to(device)  # a module moves in place and returns itself

result = model(x).detach().cpu().numpy()   # the way back to NumPy
Kvíz

Co se stane po t = torch.from_numpy(a) a následném a[0] = 99?

Autograd: gradienty zadarmo

Když tenzoru nastavíš requires_grad=True, PyTorch si během výpočtu zapisuje, co se s ním dělo. Volání backward() pak ten záznam projde pozpátku a spočítá gradienty. Je to přesně backpropagation, jen ji nepíšeš ty.

python
import torch

w = torch.tensor(2.0, requires_grad=True)
x, target = 3.0, 10.0

loss = (w * x - target) ** 2
loss.backward()

print(loss.item())   # 16.0
print(w.grad)        # tensor(-24.)

Výsledek si ověř bez PyTorch. Vzorec říká 2 * (w*x - t) * x. Druhá kontrola je numerická: posuneš w o maličko a změříš, jak se změnila ztráta.

w, x, target = 2.0, 3.0, 10.0

def loss(w):
    return (w * x - target) ** 2

by_formula = 2 * (w * x - target) * x
eps = 1e-6
numeric = (loss(w + eps) - loss(w - eps)) / (2 * eps)

print("ztráta:", loss(w))
print("vzorec:", by_formula)
print("numericky:", round(numeric, 4))
Výstup
ztráta: 16.0
vzorec: -24.0
numericky: -24.0

Gradienty se sčítají

Tohle je nejznámější past PyTorch. backward() nový gradient přičte k tomu, co už v .grad leží. Hodí se to, když chceš skládat gradienty z více průchodů, ale v běžném tréninku je musíš před každým krokem vynulovat. Malá napodobenina ukazuje, co se stane, když na to zapomeneš. Projdi si ji i tlačítkem krokovat.

class Param:
    def __init__(self, value):
        self.value = value
        self.grad = 0.0

def train(reset_grad):
    w = Param(0.0)
    x, target = 2.0, 6.0          # the right answer is w = 3
    for step in range(40):
        if reset_grad:
            w.grad = 0.0
        pred = w.value * x
        w.grad += 2 * (pred - target) * x
        w.value -= 0.02 * w.grad
    return round(w.value, 3)

print("s nulováním:", train(True))
print("bez nulování:", train(False))
Výstup
s nulováním: 2.997
bez nulování: 5.524

Bez nulování se gradient chová jako setrvačnost bez tření a parametr kolem řešení pořád přelétává. Program přitom nespadne a nic nehlásí. Ztráta jen vypadá divně.

Najdi chybu

Nulování na špatném místě

Parametr w se má dostat k hodnotě 3. Autor na nulování nezapomněl, přesto učení nekonverguje. Najdi řádek, který je špatně.

Pod kapotou · jak autograd funguje a kde se láme

Autograd staví graf dynamicky: každá operace na tenzoru s requires_grad přidá uzel s grad_fn. Po backward() se mezivýsledky grafu uvolní, proto druhý backward() přes tentýž graf skončí chybou, pokud nepředáš retain_graph=True. Je to reverzní automatické derivování, cena jednoho průchodu je malý násobek ceny dopředného výpočtu bez ohledu na počet parametrů.

Klasický únik paměti v tréninku je total += loss. Tím si držíš celý graf každé dávky. Správně je total += loss.item(). Stejný princip platí pro ukládání výstupů do seznamu: použij .detach().

Operace na místě (x += 1, x.add_(1)) můžou přepsat hodnotu, kterou zpětný průchod potřebuje. PyTorch to hlídá čítačem verzí a vyhodí RuntimeError, tichá chyba to tedy obvykle není. Pro hledání míst, kde vzniká nan, slouží torch.autograd.set_detect_anomaly(True), ale výrazně zpomaluje, takže ho nenechávej zapnutý.

Model jako třída

Síť je v PyTorch třída odvozená od nn.Module. V __init__ vytvoříš vrstvy, ve forward popíšeš, jak jimi tečou data. Pro prostý řetěz vrstev stačí nn.Sequential.

python
from torch import nn

class Circle(nn.Module):
    def __init__(self, hidden=16):
        super().__init__()
        self.input = nn.Linear(2, hidden)
        self.act = nn.ReLU()
        self.output = nn.Linear(hidden, 2)

    def forward(self, x):
        return self.output(self.act(self.input(x)))

model = Circle()
same_shape = nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 2))

print(sum(p.numel() for p in model.parameters()))   # 82
logits = model(torch.randn(5, 2))                   # call the model, not .forward
print(logits.shape)                                 # torch.Size([5, 2])

Odkud se vzalo číslo 82? Vrstva Linear(a, b) má a * b vah a b posunů (bias). Tady tedy 2*16 + 16 a 16*2 + 2.

Úkol

Spočítej parametry

Napiš funkci pocet_parametru(velikosti, bias=True). Dostane seznam velikostí vrstev, například [2, 16, 2], a vrátí počet parametrů odpovídajících lineárních vrstev. S bias=False se posuny nepočítají.

def pocet_parametru(velikosti, bias=True):
    # projdi dvojice sousedních velikostí
    return 0
Výstup
Pod kapotou · jak nn.Module najde tvoje parametry

Žádná magie: nn.Module přepisuje __setattr__. Když do atributu přiřadíš Parameter nebo jiný modul, zapíše si ho do interního slovníku. Princip se vejde na pár řádků a rovnou ukazuje slavnou chybu se seznamem vrstev.

class Parameter:
    def __init__(self, size):
        self.size = size

class Module:
    def __init__(self):
        object.__setattr__(self, "_items", {})

    def __setattr__(self, name, value):
        if isinstance(value, (Parameter, Module)):
            self._items[name] = value
        object.__setattr__(self, name, value)

    def parameters(self):
        for item in self._items.values():
            if isinstance(item, Parameter):
                yield item
            else:
                yield from item.parameters()

class Linear(Module):
    def __init__(self, a, b):
        super().__init__()
        self.weight = Parameter(a * b)
        self.bias = Parameter(b)

class Good(Module):
    def __init__(self):
        super().__init__()
        self.first = Linear(2, 4)
        self.second = Linear(4, 1)

class Bad(Module):
    def __init__(self):
        super().__init__()
        self.layers = [Linear(2, 4), Linear(4, 1)]    # a plain list

print("Good:", sum(p.size for p in Good().parameters()))
print("Bad:", sum(p.size for p in Bad().parameters()))
Výstup
Good: 17
Bad: 0

V opravdovém PyTorch se to chová stejně. Vrstvy v obyčejném list optimalizátor nedostane, neuloží se ve state_dict a nepřesune je .to(device). Výsledkem je model, který běží a neučí se, případně padá na rozdílných zařízeních. Řešení je nn.ModuleList a nn.ModuleDict. Tenzory, které nejsou učitelné, ale patří ke stavu modelu, registruj přes register_buffer.

Model volej jako model(x), ne model.forward(x). __call__ spouští i hooky, na kterých stojí řada nástrojů.

Data po dávkách

Síť se neučí z celé datové sady naráz, ale po malých dávkách. Dataset umí říct, kolik má položek, a vrátit jednu z nich. DataLoader z nich skládá dávky a míchá je.

python
from torch.utils.data import Dataset, DataLoader

class Points(Dataset):
    def __init__(self, X, y):
        self.X, self.y = X, y

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

    def __getitem__(self, i):
        return self.X[i], self.y[i]

loader = DataLoader(Points(X, y), batch_size=32, shuffle=True, drop_last=False)

for xb, yb in loader:
    print(xb.shape, yb.shape)   # torch.Size([32, 2]) torch.Size([32])
    break

Uvnitř se neděje nic složitého. Zamíchají se indexy a po kouscích se z nich berou položky.

import numpy as np

def batches(X, y, size, rng):
    order = rng.permutation(len(X))
    for start in range(0, len(X), size):
        i = order[start:start + size]
        yield X[i], y[i]

X = np.arange(14).reshape(7, 2)
y = np.arange(7)
rng = np.random.RandomState(0)

for epoch in range(2):
    print("epocha", epoch, [yb.tolist() for _, yb in batches(X, y, 3, rng)])
Výstup
epocha 0 [[6, 2, 1], [3, 0, 5], [4]]
epocha 1 [[1, 0, 6], [3, 4, 2], [5]]

Všimni si dvou věcí. Každá epocha má jiné pořadí a poslední dávka je menší.

Úkol

Zahoď neúplnou dávku

Napiš generátor davky(n, velikost, drop_last), který vrací seznamy indexů 0 až n-1 po dávkách, zatím bez míchání. Když je drop_last pravdivé, neúplnou poslední dávku nevrátí.

def davky(n, velikost, drop_last):
    yield list(range(n))
Výstup

Trénovací smyčka

Celý trénink je pět kroků, které se opakují pro každou dávku:

text
1. předpověď        logits = model(xb)
2. ztráta           loss = loss_fn(logits, yb)
3. vynulování       optimizer.zero_grad()
4. gradienty        loss.backward()
5. úprava vah       optimizer.step()

Takhle vypadá kompletní program. Úkol je záměrně hračka: leží bod uvnitř kruhu?

python
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset, random_split

torch.manual_seed(42)
device = "cuda" if torch.cuda.is_available() else "cpu"

X = torch.randn(1000, 2)
y = (X.pow(2).sum(dim=1) < 1.4).long()

train_data, val_data = random_split(TensorDataset(X, y), [800, 200])
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
val_loader = DataLoader(val_data, batch_size=256)

model = nn.Sequential(nn.Linear(2, 16), nn.ReLU(), nn.Linear(16, 2)).to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)

for epoch in range(30):
    model.train()
    total = 0.0
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        logits = model(xb)
        loss = loss_fn(logits, yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        total += loss.item() * len(xb)

    model.eval()
    correct = 0
    with torch.inference_mode():
        for xb, yb in val_loader:
            xb, yb = xb.to(device), yb.to(device)
            correct += (model(xb).argmax(dim=1) == yb).sum().item()

    print(epoch, round(total / len(train_data), 4), correct / len(val_data))

Stejný úkol a stejná struktura v NumPy běží přímo tady. Gradienty jsou ručně, zbytek odpovídá řádek po řádku. Zahýbej rychlostí učení a počtem skrytých neuronů.

import numpy as np

rng = np.random.RandomState(42)
X = rng.randn(600, 2)
y = (np.sum(X ** 2, axis=1) < 1.4).astype(float)
X_train, y_train, X_val, y_val = X[:480], y[:480], X[480:], y[480:]

H = int(skryte)
W1, b1 = rng.randn(2, H) * 0.5, np.zeros(H)
W2, b2 = rng.randn(H, 1) * 0.5, 0.0

def forward(x):
    hidden = np.maximum(x @ W1 + b1, 0)
    return hidden, (hidden @ W2 + b2).ravel()

for epoch in range(40):
    order = rng.permutation(len(X_train))
    for start in range(0, len(order), 32):
        i = order[start:start + 32]
        xb, yb = X_train[i], y_train[i]

        hidden, logits = forward(xb)                 # 1. prediction
        p = 1 / (1 + np.exp(-logits))                # 2. loss is built from p
        e = (p - yb)[:, None]                        # 3.+4. fresh gradients
        grad_W2 = hidden.T @ e / len(xb)
        grad_b2 = e.mean()
        through = (e @ W2.T) * (hidden > 0)
        grad_W1 = xb.T @ through / len(xb)
        grad_b1 = through.mean(axis=0)

        W1 -= lr * grad_W1                           # 5. update
        b1 -= lr * grad_b1
        W2 -= lr * grad_W2
        b2 -= lr * grad_b2

    if epoch % 13 == 0 or epoch == 39:
        acc = np.mean((forward(X_val)[1] > 0) == y_val)
        print(f"epocha {epoch:2d}  přesnost na validaci {acc:.2f}")
Výstup
epocha  0  přesnost na validaci 0.77
epocha 13  přesnost na validaci 0.97
epocha 26  přesnost na validaci 0.98
epocha 39  přesnost na validaci 0.98

Se dvěma nebo třemi neurony se kruh popisuje špatně, s osmi už slušně. Příliš velká rychlost učení výsledek rozhází. Stejné experimenty budeš dělat v PyTorch, jen na větších datech.

Slož kód

Slož trénovací smyčku

Slož program, který gradientním sestupem najde w tak, aby platilo y = w * x. Výsledek má být blízko 2. Jeden řádek navíc do programu nepatří.

Proč model vrací logity

nn.CrossEntropyLoss čeká logity, tedy surová skóre před softmaxem, a cílové třídy jako celá čísla. Softmax si udělá uvnitř. Když ho přidáš do modelu i ty, kód běží dál, jen se špatně učí. Tady je vidět proč.

import numpy as np

def softmax(z):
    e = np.exp(z - z.max())
    return e / e.sum()

def cross_entropy(logits, target):
    return -np.log(softmax(logits)[target])

logits = np.array([8.0, 0.0, 0.0])    # model is very sure and right
print("správně:", round(cross_entropy(logits, 0), 4))

twice = softmax(logits)               # softmax in the model as well
print("dvojitý softmax:", round(cross_entropy(twice, 0), 4))

perfect = np.array([1.0, 0.0, 0.0])   # the best possible output of softmax
print("nejlepší možné:", round(cross_entropy(perfect, 0), 4))
Výstup
správně: 0.0007
dvojitý softmax: 0.5519
nejlepší možné: 0.5514

S dvojitým softmaxem ani dokonale jistý a správný model nedostane ztrátu k nule. Gradienty přitom slábnou a učení se plouží.

Doplň

Křížová entropie pro dávku

Doplň výpočet průměrné ztráty. Pro každý řádek se vybere pravděpodobnost správné třídy.

train, eval a no_grad

Některé vrstvy se chovají jinak při učení a jinak při používání. Dropout během učení náhodně vypíná neurony, aby na sebe síť příliš nespoléhala. Při předpovědi vypnutý být nesmí. Přepínač je model.train() a model.eval().

import numpy as np

def dropout(x, p, training, rng):
    if not training:
        return x
    keep = rng.random_sample(x.shape) >= p
    return x * keep / (1 - p)

rng = np.random.RandomState(1)
x = np.ones(6)

print(dropout(x, 0.5, False, rng))
print(dropout(x, 0.5, False, rng))
print(dropout(x, 0.5, True, rng))
print(dropout(x, 0.5, True, rng))
Výstup
[1. 1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1. 1.]
[0. 2. 0. 0. 0. 0.]
[0. 0. 0. 2. 0. 2.]

Dělení 1 - p drží průměrnou hodnotu stejnou, takže další vrstvy nedostanou při předpovědi nečekaně jiná čísla.

Roztřiď

Co dělá který přepínač

Oba se při vyhodnocení používají spolu, každý ale dělá něco jiného. Roztřiď jejich účinky.

Kvíz

Validační přesnost při každém spuštění trochu kolísá, i když data i váhy jsou pořád stejné. Co je nejpravděpodobnější příčina?

Ukládání a provoz

Ukládej slovník vah (state_dict), ne celý objekt modelu. Při načtení vytvoříš model kódem a váhy do něj nahraješ.

python
torch.save(model.state_dict(), "model.pt")

model = Circle()
state = torch.load("model.pt", map_location="cpu", weights_only=True)
model.load_state_dict(state)
model.eval()

Pokud chceš v tréninku pokračovat, ulož i optimalizátor a číslo epochy.

python
torch.save({
    "epoch": epoch,
    "model": model.state_dict(),
    "optimizer": optimizer.state_dict(),
}, "checkpoint.pt")
Spoj dvojice

Co patří k čemu

Spoj nástroj s jeho účelem.

Pod kapotou · rychlost a věci, které bolí až v produkci

Úzké hrdlo bývá v datech. Když GPU zahálí, zvyš num_workers, zapni persistent_workers=True a pro přenos na GPU pin_memory=True spolu s x.to(device, non_blocking=True). Na Windows a macOS se dělníci startují metodou spawn, takže skript potřebuje if __name__ == "__main__": a dataset musí jít serializovat přes pickle.

Smíšená přesnost ušetří paměť i čas. Pozor na pořadí u ořezu gradientů: nejdřív unscale_, jinak ořezáváš škálované hodnoty.

python
scaler = torch.amp.GradScaler("cuda")

for xb, yb in train_loader:
    optimizer.zero_grad()
    with torch.amp.autocast("cuda"):
        loss = loss_fn(model(xb), yb)
    scaler.scale(loss).backward()
    scaler.unscale_(optimizer)
    nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    scaler.step(optimizer)
    scaler.update()

torch.compile(model) může zrychlit běh, ale první dávky trvají déle, dynamický tok řízení kompilaci komplikuje a klíče ve state_dict zabaleného modelu dostanou předponu _orig_mod.. Ukládej proto původní modul.

zero_grad() od verze 2.0 ve výchozím stavu nastavuje .grad na None, ne na nuly. Je to levnější, ale kód, který čte p.grad hned po vynulování, musí None zvládnout.

Reprodukovatelnost: torch.manual_seed nestačí. Řeš i generátor pro DataLoader a seedy dělníků. Na GPU je úplná determinističnost drahá a mezi verzemi knihovny ani hardwarem se nezaručuje.

První ladicí krok: přeuč model na jedné dávce. Když ztráta na několika příkladech neklesne skoro k nule, chyba je v kódu, v tvarech nebo v popiscích, a ladit hyperparametry nemá smysl.

Kartičky

Opakování