Lidsky řečeno
Představ si poradu, kde každý účastník může kdykoli požádat kohokoli o informaci a všichni si své poznámky upravují současně. Nikdo nečeká, až k němu informace dojde přes pět dalších lidí. To je transformer: každé slovo se v jednom kroku může zeptat všech ostatních slov. Porada se pak několikrát opakuje a poznámky jsou po každém kole přesnější.
Co transformer je a co mu chybí
Transformer je typ neuronové sítě pro posloupnosti: text, zvuk i obrázek rozřezaný na kousky. Představil ho v roce 2017 článek Attention Is All You Need a stojí na něm dnešní jazykové modely. Jeho jádro znáš z lekce Attention od nuly: každý prvek posloupnosti, kterému se říká token, si spočítá, kterým ostatním tokenům má věnovat pozornost, a podle toho si vezme kus jejich informace.
Samotná attention má ale zvláštní slepotu. Nevidí pořadí. Pracuje jen s tím, jak jsou si vektory podobné, a je jí jedno, kde v řadě stojí. Věty „Petr má jen psa“ a „jen Petr má psa“ obsahují stejná slova a znamenají něco jiného. Zkus, co s nimi udělá attention.
import numpy as np
def self_attention(x):
scores = x @ x.T / np.sqrt(x.shape[1])
weights = np.exp(scores)
weights = weights / weights.sum(axis=1, keepdims=True)
return weights @ x
rng = np.random.RandomState(0)
vocab = {"Petr": 0, "má": 1, "jen": 2, "psa": 3}
embeddings = rng.normal(size=(4, 8))
sentence_a = "Petr má jen psa".split()
sentence_b = "jen Petr má psa".split()
out_a = self_attention(embeddings[[vocab[w] for w in sentence_a]])
out_b = self_attention(embeddings[[vocab[w] for w in sentence_b]])
for word in vocab:
same = np.allclose(out_a[sentence_a.index(word)], out_b[sentence_b.index(word)])
print(f"{word:5} má v obou větách stejný výsledek: {same}")
Petr má v obou větách stejný výsledek: True má má v obou větách stejný výsledek: True jen má v obou větách stejný výsledek: True psa má v obou větách stejný výsledek: True
Každé slovo dostalo v obou větách přesně stejný vektor. Pro síť jsou to tytéž věty. Odborně: self-attention je ekvivariantní vůči permutaci, takže když prohodíš vstupy, jen se stejně prohodí výstupy. Transformer proto musí pořadí dostat zvenčí.
Poziční kódování: razítko s číslem místa
Řešení je prosté. Ke každému tokenu přičteme vektor, který říká, na kterém místě stojí. Tomu se říká poziční kódování. Slovo „jen“ na první pozici pak má jiný vektor než „jen“ na třetí.
Původní článek použil pevné vlny sinu a kosinu s různými frekvencemi. Nízké dimenze se mění rychle, vysoké pomalu, trochu jako vteřinová, minutová a hodinová ručička.
PE(pozice, 2i) = sin(pozice / 10000^(2i / d))
PE(pozice, 2i+1) = cos(pozice / 10000^(2i / d))import numpy as np
def positional_encoding(length, d):
positions = np.arange(length)[:, None]
rates = 1 / 10000 ** (np.arange(0, d, 2) / d)
pe = np.zeros((length, d))
pe[:, 0::2] = np.sin(positions * rates)
pe[:, 1::2] = np.cos(positions * rates)
return pe
pe = positional_encoding(50, 16)
print("tvar:", pe.shape)
unit = pe / np.linalg.norm(pe, axis=1, keepdims=True)
for other in [10, 11, 12, 15, 20, 40]:
print(f"podobnost pozice 10 a {other:2}: {unit[10] @ unit[other]:.3f}")
tvar: (50, 16) podobnost pozice 10 a 10: 1.000 podobnost pozice 10 a 11: 0.936 podobnost pozice 10 a 12: 0.796 podobnost pozice 10 a 15: 0.767 podobnost pozice 10 a 20: 0.456 podobnost pozice 10 a 40: 0.337
Blízké pozice mají podobné vektory a vzdálené se liší, takže síť umí poznat „hned vedle“ i „daleko“. Dnes se často používá jednodušší varianta: naučená poziční tabulka, tedy matice s jedním vektorem na každou pozici, kterou síť ladí stejně jako embeddingy slov. Její nevýhoda je jasná: pro pozici, která v tabulce není, nemá co použít.
Vrať větám pořadí
Napiš funkci add_positions(x, pe), která k matici tokenů x tvaru (T, d) přičte prvních T řádků z poziční tabulky pe. Tabulka může být delší než věta. Vstupní pole neměň.
import numpy as np
def add_positions(x, pe):
# doplň
return x
Proč se k tokenům přidává poziční kódování?
Attention porovnává jen obsah vektorů. Informace o místě v řadě se do nich musí dostat přičtením poziční složky.
Více hlav: několik otázek najednou
Jedna attention umí položit jeden druh otázky. Slovo ale může potřebovat víc věcí současně: kdo je podmět, ke kterému jménu patří zájmeno, co stálo těsně před ním. Multi-head attention proto vektor rozdělí na několik menších částí, hlav, a každá hlava počítá vlastní attention nezávisle. Nakonec se výsledky slepí zpátky.
Sleduj tvary polí. Tohle je místo, kde se v implementacích chybuje nejčastěji. Posuvníkem měň počet hlav.
import numpy as np
rng = np.random.RandomState(0)
T, d = 6, 64
heads = 2 ** k
head_dim = d // heads
x = rng.normal(size=(T, d))
W_q, W_k, W_v, W_o = rng.normal(size=(4, d, d)) / np.sqrt(d)
def split(m):
return m.reshape(T, heads, head_dim).transpose(1, 0, 2)
Q, K, V = split(x @ W_q), split(x @ W_k), split(x @ W_v)
scores = Q @ K.transpose(0, 2, 1) / np.sqrt(head_dim)
weights = np.exp(scores - scores.max(axis=-1, keepdims=True))
weights = weights / weights.sum(axis=-1, keepdims=True)
out = weights @ V
joined = out.transpose(1, 0, 2).reshape(T, d) @ W_o
print("hlav:", heads, "| rozměr jedné hlavy:", head_dim)
print("Q:", Q.shape, "(hlavy, tokeny, rozměr)")
print("váhy:", weights.shape, "(hlavy, tokeny, tokeny)")
print("výstup:", joined.shape)
print("parametrů:", W_q.size + W_k.size + W_v.size + W_o.size)
hlav: 4 | rozměr jedné hlavy: 16 Q: (4, 6, 16) (hlavy, tokeny, rozměr) váhy: (4, 6, 6) (hlavy, tokeny, tokeny) výstup: (6, 64) parametrů: 16384
Všimni si posledního řádku. Počet parametrů na počtu hlav nezávisí. Víc hlav nestojí víc paměti pro váhy, jen každá hlava pracuje v užším prostoru.
Rozděl vektor na hlavy
Matice m má tvar (T, d). Doplň výpočet rozměru hlavy a přeskupení, aby výsledek měl tvar (hlavy, T, rozměr hlavy).
Pod kapotou · kolik stojí attention a proč sqrt(d)
Jeden průchod attention stojí O(T² · d) času a matice vah O(T² · h) paměti, takže délka kontextu je drahá kvadraticky. Dělení odmocninou rozměru drží rozptyl skóre přibližně nezávislý na d. U dvou vektorů s nezávislými složkami s jednotkovým rozptylem má skalární součin rozptyl d, bez korekce by softmax saturoval a gradienty mizely.
Hlavy nejsou zaručeně „specializované“. Interpretace typu „tahle hlava hledá podmět“ platí jen u části z nich a je potřeba ji ověřovat zásahem do modelu, ne pohledem na heatmapu. Velké váhy attention samy o sobě nedokazují, že token ovlivnil výstup, protože do výsledku vstupuje i velikost vektoru V a následné vrstvy.
Maska: nekoukej do budoucnosti
Když se model učí předpovídat další slovo, nesmí vidět slova, která teprve přijdou. Bylo by to jako psát test s řešením na lavici. Kauzální maska proto zakáže každému tokenu dívat se doprava. Zakázaným políčkům dáme skóre minus nekonečno, takže po softmaxu mají váhu přesně nula.
Než kód spustíš, tipni si: jakou váhu bude mít první řádek matice na své první pozici?
import numpy as np
T = 4
scores = np.array([[0.5, 2.0, 1.0, 0.1],
[1.0, 0.2, 3.0, 0.4],
[0.3, 0.3, 0.3, 2.0],
[1.0, 0.0, 0.5, 1.5]])
mask = np.tril(np.ones((T, T), dtype=bool))
masked = np.where(mask, scores, -np.inf)
weights = np.exp(masked)
weights = weights / weights.sum(axis=1, keepdims=True)
print(mask.astype(int))
print(weights.round(2))
[[1 0 0 0] [1 1 0 0] [1 1 1 0] [1 1 1 1]] [[1. 0. 0. 0. ] [0.69 0.31 0. 0. ] [0.33 0.33 0.33 0. ] [0.28 0.1 0.17 0.46]]
První token nemá koho jiného poslouchat, takže má na sobě váhu 1. Poslední vidí všechny. Každý řádek dává po normalizaci součet 1.
Attention s maskou
Napiš funkci masked_attention(scores, mask). Dostane čtvercovou matici skóre a stejně velkou logickou masku, kde True znamená „smí se dívat“. Vrátí matici vah: v každém řádku softmax přes povolená políčka, zakázaná mají přesně 0.
import numpy as np
def masked_attention(scores, mask):
# doplň
return scores
Váhy, které nedávají smysl
Funkce má z matice skóre udělat váhy tak, aby se každý token rozdělil mezi ostatní, tedy aby součet v každém řádku byl 1. Na symetrických datech to vypadalo správně, na reálných ne.
Blok transformeru
Attention nestačí. Tokeny si v ní jen vyměňují informace, ale nic s nimi pak nedělají. Jeden blok proto obsahuje dvě části a dvě pomůcky:
- Attention: tokeny si vymění informace.
- Feed-forward síť: malá dvouvrstvá síť, kterou projde každý token zvlášť a zpracuje, co se dozvěděl.
- Reziduální spojení: k původnímu vektoru se změna jen přičte. Informace i gradient tak mají volnou cestu přes celou síť.
- Layer normalization: drží čísla v rozumném rozsahu tím, že každý vektor posune na průměr 0 a rozptyl 1.
vstup ──┬─ LayerNorm ─ Attention ──(+)──┬─ LayerNorm ─ Feed-forward ──(+)── výstup
└───────────────────────────┘ └──────────────────────────────┘Celý model je pak jen několik takových bloků za sebou. Následující kód je skutečný průchod transformerem, bez tréninku. Na konci ověří, že maska funguje: změna posledního tokenu nesmí ovlivnit výstup tokenů před ním.
import numpy as np
def layer_norm(x):
return (x - x.mean(-1, keepdims=True)) / (x.std(-1, keepdims=True) + 1e-6)
class Block:
def __init__(self, d, heads, rng):
self.heads, self.head_dim = heads, d // heads
scale = 1 / np.sqrt(d)
self.W_q, self.W_k, self.W_v, self.W_o = rng.normal(0, scale, (4, d, d))
self.W_in = rng.normal(0, scale, (d, 4 * d))
self.W_out = rng.normal(0, scale, (4 * d, d))
def attention(self, x, mask):
T, d = x.shape
split = lambda m: m.reshape(T, self.heads, self.head_dim).transpose(1, 0, 2)
Q, K, V = split(x @ self.W_q), split(x @ self.W_k), split(x @ self.W_v)
s = Q @ K.transpose(0, 2, 1) / np.sqrt(self.head_dim)
s = np.where(mask, s, -np.inf)
w = np.exp(s - s.max(-1, keepdims=True))
w = w / w.sum(-1, keepdims=True)
return (w @ V).transpose(1, 0, 2).reshape(T, d) @ self.W_o
def feed_forward(self, x):
return np.maximum(x @ self.W_in, 0) @ self.W_out
def __call__(self, x, mask):
x = x + self.attention(layer_norm(x), mask)
return x + self.feed_forward(layer_norm(x))
def size(self):
return sum(w.size for w in (self.W_q, self.W_k, self.W_v, self.W_o, self.W_in, self.W_out))
rng = np.random.RandomState(1)
T, d = 5, 32
blocks = [Block(d, 4, rng) for _ in range(3)]
mask = np.tril(np.ones((T, T), dtype=bool))
def model(x):
for block in blocks:
x = block(x, mask)
return x
x = rng.normal(size=(T, d))
changed = x.copy()
changed[-1] += 1.0
a, b = model(x), model(changed)
print("vstup:", x.shape, "výstup:", a.shape)
print("parametrů ve 3 blocích:", sum(b.size() for b in blocks))
print("tokeny 0 až 3 beze změny:", np.allclose(a[:-1], b[:-1]))
print("poslední token se změnil:", not np.allclose(a[-1], b[-1]))
vstup: (5, 32) výstup: (5, 32) parametrů ve 3 blocích: 36864 tokeny 0 až 3 beze změny: True poslední token se změnil: True
Slož blok transformeru
Slož funkci bloku ve variantě, kde se normalizuje před každou částí.
Layer normalization
Napiš funkci layer_norm(x, eps=1e-6). Pro každý vektor v posledním rozměru odečte jeho průměr a vydělí ho jeho směrodatnou odchylkou zvětšenou o eps. Funkce musí fungovat pro tvary (d), (T, d) i (B, T, d).
import numpy as np
def layer_norm(x, eps=1e-6):
# doplň
return x
Malý trénink: pozice rozhoduje
Teď to, co jsme na začátku jen tvrdili, ověříme učením. Model dostane pět náhodných tokenů a má vrátit ten na třetím místě. Úloha se nedá vyřešit bez znalosti pozic. Trénujeme zjednodušený model s jednou attention: jediný naučený dotaz q se ptá všech tokenů, kam se má dívat. Gradienty jsou spočítané ručně, stejně jako v lekci o backpropagation.
import numpy as np
VOCAB, LENGTH, DIM, TARGET = 6, 5, 16, 2
def softmax(s):
e = np.exp(s - s.max(-1, keepdims=True))
return e / e.sum(-1, keepdims=True)
def forward(X, E, P, q, W):
h = E[X] + P
attn = softmax(h @ q / np.sqrt(DIM))
context = (attn[..., None] * h).sum(1)
return h, attn, context, softmax(context @ W.T)
def train(use_positions, steps=300, lr=0.5):
rng = np.random.RandomState(0)
X, X_test = rng.randint(0, VOCAB, (2, 400, LENGTH))
y, y_test = X[:, TARGET], X_test[:, TARGET]
E = rng.normal(0, 0.3, (VOCAB, DIM))
P = rng.normal(0, 0.3, (LENGTH, DIM)) * use_positions
q = rng.normal(0, 0.3, DIM)
W = rng.normal(0, 0.3, (VOCAB, DIM))
n, rows = len(X), np.arange(len(X))
for _ in range(steps):
h, attn, c, p = forward(X, E, P, q, W)
err = p.copy()
err[rows, y] -= 1
g = err @ W
dscore = attn * ((g[:, None] * h).sum(-1) - (g * c).sum(-1, keepdims=True))
dh = attn[..., None] * g[:, None] + dscore[..., None] * q / np.sqrt(DIM)
dE = np.zeros_like(E)
np.add.at(dE, X, dh)
E -= lr * dE / n
W -= lr * (err.T @ c) / n
q -= lr * (dscore[..., None] * h).sum((0, 1)) / np.sqrt(DIM) / n
if use_positions:
P -= lr * dh.sum(0) / n
_, attn, _, p = forward(X_test, E, P, q, W)
return (p.argmax(1) == y_test).mean(), attn.mean(0)
for use_positions in (False, True):
accuracy, attention = train(use_positions)
print("s pozicemi:" if use_positions else "bez pozic: ", f"přesnost {accuracy:.0%}")
print(" průměrná pozornost na místa 1 až 5:", attention.round(2).tolist())
bez pozic: přesnost 40% průměrná pozornost na místa 1 až 5: [0.2, 0.2, 0.2, 0.2, 0.2] s pozicemi: přesnost 100% průměrná pozornost na místa 1 až 5: [0.02, 0.02, 0.93, 0.02, 0.01]
Bez pozic model rozdělí pozornost rovnoměrně a může jen hádat z tokenů, které ve vstupu vidí. S pozicemi se sám naučí dívat na třetí místo, přestože mu to nikdo neřekl. Tohle je podstata celého přístupu: strukturu pozornosti neprogramuješ, vznikne tréninkem. Skutečný znakový model si postavíš v závěrečné misi.
Co přesně zaručuje kauzální maska?
Maska vynuluje váhy směrem doprava. V ukázce to bylo vidět: změna posledního tokenu výstupy před ním neovlivnila.
Rodina transformerů
Stejné bloky se skládají různě podle úlohy.
Spoj varianty s použitím
Přiřaď každé variantě, co dělá.
Jazykové modely, které generují text, jsou v jádru dekodéry. Modely pro klasifikaci nebo vyhledávání bývají enkodéry, které vidí celou větu naráz. Překladové architektury spojují oba světy přes křížovou attention, kde Q pochází z jedné posloupnosti a K a V z druhé.
V praxi transformer nepíšeš ručně. V PyTorch stačí pár řádků. Tenhle kód běží jen na tvém počítači s nainstalovaným PyTorch.
import torch
from torch import nn
class TinyTransformer(nn.Module):
def __init__(self, vocab_size, max_len, d=128, heads=4, layers=3):
super().__init__()
self.token = nn.Embedding(vocab_size, d)
self.position = nn.Embedding(max_len, d)
layer = nn.TransformerEncoderLayer(
d_model=d, nhead=heads, dim_feedforward=4 * d,
dropout=0.1, activation="gelu",
batch_first=True, norm_first=True,
)
self.blocks = nn.TransformerEncoder(
layer, num_layers=layers, norm=nn.LayerNorm(d),
enable_nested_tensor=False,
)
self.head = nn.Linear(d, vocab_size, bias=False)
self.head.weight = self.token.weight # weight tying
def forward(self, ids):
T = ids.size(1)
x = self.token(ids) + self.position(torch.arange(T, device=ids.device))
mask = nn.Transformer.generate_square_subsequent_mask(T, device=ids.device)
return self.head(self.blocks(x, mask=mask, is_causal=True))
model = TinyTransformer(vocab_size=100, max_len=64)
ids = torch.randint(0, 100, (2, 16))
print(model(ids).shape) # torch.Size([2, 16, 100])Hotový předtrénovaný model načteš knihovnou transformers:
import torch
from transformers import AutoModel, AutoTokenizer
name = "distilbert/distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(name)
model = AutoModel.from_pretrained(name).eval()
batch = tokenizer(["a short sentence", "another one"], padding=True, return_tensors="pt")
with torch.inference_mode():
output = model(**batch)
print(output.last_hidden_state.shape) # (batch, tokens, hidden size)Pod kapotou · pasti, které v tutoriálech nebývají
Význam logické masky se liší podle API. V nn.MultiheadAttention a nn.Transformer* znamená True „zakázáno“. Ve torch.nn.functional.scaled_dot_product_attention znamená True „smí se účastnit“. Přepis mezi nimi bez negace masky vytvoří model, který se dívá přesně tam, kam nemá, a přitom běží.
Pre-norm a post-norm. Původní článek normalizoval až po sečtení s reziduem. Varianta norm_first=True nechává reziduální cestu čistou a hluboké sítě se s ní obvykle trénují stabilněji. Na konci pak potřebuje ještě jednu LayerNorm.
Proč LayerNorm, ne BatchNorm. Statistiky přes dávku by míchaly různě dlouhé sekvence a padding a při generování po jednom tokenu by se chovaly jinak než při tréninku.
Rychlá cesta. F.scaled_dot_product_attention umí podle platformy zvolit optimalizovanou implementaci. Když v nn.MultiheadAttention potřebuješ rychlost, nech need_weights=False, jinak si vynutíš výpočet a vrácení vah.
Sdílení vah. Spojení embeddingu s výstupní vrstvou šetří V · d parametrů, ale u inicializace a ukládání si hlídej, že se váhy po načtení opravdu sdílejí. Nástroje pro serializaci sdílené tenzory řeší různě.
Pozice. Mnoho současných modelů nepřičítá pozice k embeddingům a používá relativní schémata typu RoPE, která otáčí vektory Q a K uvnitř attention. Odpadá tím pevná tabulka, efektivní chování na délkách daleko za tréninkovými ale zaručené není.