0 dní v řadě · 0 bodů

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

Transformery

Z attention složíš celý transformer: pozice, více hlav, maska budoucnosti, blok a malý trénink v NumPy.

Hloubka
Úkoly
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}")
Výstup
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.

text
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}")
Výstup
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.

Úkol

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
Výstup
Kvíz

Proč se k tokenům přidává poziční kódování?

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)
Výstup
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.

Doplň

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))
Výstup
[[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.

Úkol

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ýstup
Najdi chybu

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.
text
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]))
Výstup
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ž kód

Slož blok transformeru

Slož funkci bloku ve variantě, kde se normalizuje před každou částí.

Úkol

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
Výstup

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())
Výstup
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.

Kvíz

Co přesně zaručuje kauzální maska?

Rodina transformerů

Stejné bloky se skládají různě podle úlohy.

Spoj dvojice

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.

python
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:

python
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í.

Kartičky

Opakování