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:
| Co | Jak se tomu říká | Co za tebe udělá |
|---|---|---|
| pole čísel | torch.Tensor | totéž co NumPy, navíc i na grafické kartě |
| gradienty | autograd | spočítá derivace podle toho, co jsi počítal |
| vrstvy | torch.nn | hotové stavební díly a evidence parametrů |
| data a učení | DataLoader, torch.optim | dá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:
python -m venv .venv
python -m pip install torchTenzory: 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)
(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.
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 typeRozdíly, na kterých se začátečník spálí:
- NumPy má výchozí desetinný typ
float64, PyTorchfloat32. Míchání typů končí chybou typu „expected Float but found Double“. torch.from_numpypaměť sdílí. Změna jednoho změní i druhé.torch.tensorkopíruje.- Tenzor má své zařízení (
device), tedy procesor nebo grafickou kartu. Počítat spolu můžou jen tenzory na stejném zařízení.
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 NumPyCo se stane po t = torch.from_numpy(a) a následném a[0] = 99?
from_numpy data nekopíruje. Je to rychlé, ale musíš s tím počítat. Kopii vytvoří torch.tensor(a).
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.
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))
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))
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ě.
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.
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.
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
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()))
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.
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])
breakUvnitř 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)])
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ší.
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))
Trénovací smyčka
Celý trénink je pět kroků, které se opakují pro každou dávku:
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?
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}")
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ž 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))
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ží.
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))
[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.
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.
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?
Při vyhodnocení se váhy nemění, gradienty s tím nesouvisí. Náhodnost přináší dropout, který zůstal zapnutý.
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š.
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.
torch.save({
"epoch": epoch,
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
}, "checkpoint.pt")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.
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.