Lidsky řečeno
V knihovně se zeptáš na „knihy o včelách“. Knihovník porovná tvůj dotaz se štítky na regálech, u včelařství se zastaví, u botaniky trochu, u detektivek vůbec. Pak ti přinese hlavně obsah těch nejvhodnějších regálů. Attention dělá totéž, jen místo jedné knihy vrátí směs obsahu podle toho, jak dobře který štítek sedí.
Slovo potřebuje okolí
Slovo zámek znamená něco jiného ve větě „klíč v zámku u dveří“ a něco jiného ve větě „král má zámek na kopci“. Běžný embedding mu dá pokaždé stejný vektor. Chceme, aby se vektor slova upravil podle slov kolem něj, a to hlavně podle těch, na kterých záleží.
Základ je vážený průměr. Každé položce dáš váhu, váhy dají dohromady 1 a výsledek je součet váha * hodnota.
import numpy as np
vahy = np.array([0.25, 0.75])
hodnoty = np.array([10.0, 20.0])
print(vahy @ hodnoty)
17.5
Celá attention řeší jedinou otázku: odkud vzít ty váhy. Odpověď zní: spočítej, jak moc si slova odpovídají, a výsledek převeď funkcí softmax na čísla, která jsou kladná a mají součet 1.
Vyzkoušej to na ručně vyrobených vektorech. Jejich tři osy znamenají zhruba historie, mechanika a krajina. Posuvník ostrost určuje, jak moc se váhy soustředí na nejlepší shodu.
import numpy as np
E = {
"zámek": [0.7, 0.7, 0.0],
"klíč": [0.0, 1.0, 0.0],
"dveře": [0.2, 0.9, 0.0],
"král": [1.0, 0.0, 0.1],
"kopec": [0.3, 0.0, 1.0],
}
E = {w: np.array(v) for w, v in E.items()}
def softmax(z):
e = np.exp(z - z.max())
return e / e.sum()
def in_context(word, sentence):
M = np.array([E[w] for w in sentence])
weights = softmax(ostrost * (M @ E[word]))
print(" ".join(f"{w}={a:.2f}" for w, a in zip(sentence, weights)))
return weights @ M
castle = np.array([1.0, 0.0, 0.2])
lock = np.array([0.0, 1.0, 0.0])
for sentence in (["klíč", "zámek", "dveře"], ["král", "zámek", "kopec"]):
v = in_context("zámek", sentence)
print(" vektor:", np.round(v, 2))
print(" blíž k:", "hrad" if v @ castle > v @ lock else "mechanismus")
klíč=0.19 zámek=0.57 dveře=0.25 vektor: [0.45 0.8 0. ] blíž k: mechanismus král=0.24 zámek=0.73 kopec=0.03 vektor: [0.76 0.51 0.06] blíž k: hrad
Stejné slovo dostalo v každé větě jiný vektor. Přesně to potřebujeme.
Dotaz, klíč, hodnota
Attention dává každé položce tři role, stejně jako v knihovně:
- Query (dotaz): co hledám.
- Key (klíč): štítek, podle kterého mě lze najít.
- Value (hodnota): obsah, který předám, když mě někdo vybere.
skóre = Q @ Kᵀ / sqrt(d)
váhy = softmax(skóre) po řádcích
výstup = váhy @ Vd je délka vektorů. Tvary jsou to hlavní, co si musíš hlídat. Pro n dotazů a m položek vznikne matice vah n × m.
import numpy as np
def softmax(z, axis=-1):
e = np.exp(z - z.max(axis=axis, keepdims=True))
return e / e.sum(axis=axis, keepdims=True)
def attention(Q, K, V):
d = Q.shape[-1]
scores = Q @ K.swapaxes(-1, -2) / np.sqrt(d)
weights = softmax(scores)
return weights @ V, weights
rng = np.random.RandomState(0)
Q = rng.randn(2, 4) # 2 queries
K = rng.randn(5, 4) # 5 keys
V = rng.randn(5, 6) # 5 values, they may have another size
out, weights = attention(Q, K, V)
print("váhy:", weights.shape)
print("výstup:", out.shape)
print("součty řádků:", np.round(weights.sum(axis=1), 6))
váhy: (2, 5) výstup: (2, 6) součty řádků: [1. 1.]
Doplň výpočet skóre
Doplň škálované skóre a převod na váhy.
Proč dělit odmocninou
Se zvětšující se délkou vektorů rostou i skalární součiny. Náhodné součty kolísají zhruba jako sqrt(d). Velká skóre udělají ze softmaxu téměř tvrdý výběr jedné položky a gradienty ostatních skoro zmizí.
import numpy as np
def softmax(z):
e = np.exp(z - z.max(axis=-1, keepdims=True))
return e / e.sum(axis=-1, keepdims=True)
rng = np.random.RandomState(0)
print(" d rozptyl max váha bez škálování se škálováním")
for d in (4, 64, 512):
q = rng.randn(400, d)
k = rng.randn(8, d)
s = q @ k.T
raw = softmax(s).max(axis=1).mean()
scaled = softmax(s / np.sqrt(d)).max(axis=1).mean()
print(f"{d:4d} {s.std():7.1f} {raw:22.2f} {scaled:13.2f}")
d rozptyl max váha bez škálování se škálováním 4 2.0 0.53 0.34 64 8.1 0.88 0.37 512 22.5 0.96 0.36
Attention s maskou
Napiš funkci attention(Q, K, V, maska=None), která vrátí dvojici (vystup, vahy). Q, K a V mají tvar (..., položky, d). Skóre škáluj odmocninou z d. Maska je pole hodnot True/False stejného tvaru jako skóre a False znamená „sem se nedívej“: takové položce dej skóre -np.inf.
import numpy as np
def attention(Q, K, V, maska=None):
return V, None
Self-attention
Když Q, K i V pocházejí ze stejných vektorů, jde o self-attention: každé slovo se dívá na všechna slova ve větě, včetně sebe. Aby role byly opravdu různé, vznikají přes tři naučené matice. Tím si model sám určí, co u slova znamená „ptát se“ a co „nabízet“.
import numpy as np
class SelfAttention:
def __init__(self, dim, rng):
self.Wq = rng.randn(dim, dim) / np.sqrt(dim)
self.Wk = rng.randn(dim, dim) / np.sqrt(dim)
self.Wv = rng.randn(dim, dim) / np.sqrt(dim)
def __call__(self, x):
Q, K, V = x @ self.Wq, x @ self.Wk, x @ self.Wv
s = Q @ K.swapaxes(-1, -2) / np.sqrt(x.shape[-1])
e = np.exp(s - s.max(axis=-1, keepdims=True))
a = e / e.sum(axis=-1, keepdims=True)
return a @ V, a
rng = np.random.RandomState(1)
layer = SelfAttention(8, rng)
x = rng.randn(5, 8)
out, a = layer(x)
print(out.shape, a.shape)
order = np.array([4, 2, 0, 1, 3])
out2, _ = layer(x[order])
print("stejné vektory, jen v jiném pořadí:", bool(np.allclose(out2, out[order])))
(5, 8) (5, 5) stejné vektory, jen v jiném pořadí: True
Výsledek poslední řádky je důležitý. Přeházíš-li vstup, výstup se přehází úplně stejně. Attention sama o sobě nezná pořadí. „Dvě mínus tři“ a „tři mínus dvě“ by pro ni byla stejná množina slov. Proto se k embeddingům přičítá informace o pozici.
Poziční kódování
Klasické řešení přidá každé pozici vektor ze sinů a kosinů různých frekvencí. Vektory pozic jsou odlišné a blízké pozice si jsou podobnější než vzdálené.
import numpy as np
def positional(n, dim):
pos = np.arange(n)[:, None]
freq = 1 / 10000 ** (np.arange(0, dim, 2) / dim)
P = np.zeros((n, dim))
P[:, 0::2] = np.sin(pos * freq)
P[:, 1::2] = np.cos(pos * freq)
return P
P = positional(50, 16)
U = P / np.linalg.norm(P, axis=1, keepdims=True)
print(P.shape)
print("pozice 10 a 11:", round(float(U[10] @ U[11]), 2))
print("pozice 10 a 40:", round(float(U[10] @ U[40]), 2))
print("všechny pozice různé:", len(np.unique(np.round(P, 6), axis=0)) == 50)
(50, 16) pozice 10 a 11: 0.94 pozice 10 a 40: 0.34 všechny pozice různé: True
Co se stane se self-attention bez pozičního kódování, když přehodíš dvě slova ve vstupu?
Self-attention je ekvivariantní vůči permutaci: každý token dostane stejný výsledek, jen je na jiném místě.
Masky: kam se nesmí dívat
Dva důvody jsou běžné. Výplň: věty v dávce mají různou délku a kratší se doplňují prázdnými tokeny, na které se nikdo dívat nemá. Budoucnost: model, který předpovídá další slovo, nesmí vidět slova, která teprve přijdou. K tomu slouží kauzální maska, dolní trojúhelník.
import numpy as np
n = 4
maska = np.tril(np.ones((n, n), dtype=bool))
print(maska.astype(int))
skore = np.zeros((n, n))
skore = np.where(maska, skore, -np.inf)
e = np.exp(skore)
vahy = e / e.sum(axis=1, keepdims=True)
print(np.round(vahy, 2))
[[1 0 0 0] [1 1 0 0] [1 1 1 0] [1 1 1 1]] [[1. 0. 0. 0. ] [0.5 0.5 0. 0. ] [0.33 0.33 0.33 0. ] [0.25 0.25 0.25 0.25]]
Maska pro výplň
Napiš funkci maska_vyplne(ids, pad=0). ids je pole tvaru (B, T) s čísly tokenů. Funkce vrátí pole (B, T, T) s hodnotami True/False, kde True je jen tam, kde řádkový ani sloupcový token není výplň.
import numpy as np
def maska_vyplne(ids, pad=0):
return ids != pad
Více hlav
Jedna sada vah zachytí jeden druh vztahu. Multi-head attention rozdělí vektor na několik menších částí a na každé počítá attention zvlášť. Jedna hlava se může naučit sledovat podmět, jiná sousední slovo. Výsledky se spojí a projdou lineární vrstvou.
(B, T, D) → (B, H, T, D/H) → attention → (B, T, D) → výstupní vrstvaimport numpy as np
class MultiHead:
def __init__(self, dim, heads, rng):
assert dim % heads == 0
self.h, self.d = heads, dim // heads
self.Wq, self.Wk, self.Wv, self.Wo = rng.randn(4, dim, dim) / np.sqrt(dim)
def split(self, x):
B, T, _ = x.shape
return x.reshape(B, T, self.h, self.d).transpose(0, 2, 1, 3)
def __call__(self, x, mask=None):
Q = self.split(x @ self.Wq)
K = self.split(x @ self.Wk)
V = self.split(x @ self.Wv)
s = Q @ K.swapaxes(-1, -2) / np.sqrt(self.d)
if mask is not None:
s = np.where(mask, s, -np.inf)
e = np.exp(s - s.max(axis=-1, keepdims=True))
a = e / e.sum(axis=-1, keepdims=True)
out = (a @ V).transpose(0, 2, 1, 3)
B, T, _, _ = out.shape
return out.reshape(B, T, -1) @ self.Wo, a
rng = np.random.RandomState(0)
layer = MultiHead(dim=32, heads=4, rng=rng)
x = rng.randn(2, 6, 32)
causal = np.tril(np.ones((6, 6), dtype=bool))
out, a = layer(x, causal)
print("výstup:", out.shape)
print("váhy:", a.shape)
print("první token vidí jen sebe:", bool(np.allclose(a[:, :, 0, 0], 1)))
výstup: (2, 6, 32) váhy: (2, 4, 6, 6) první token vidí jen sebe: True
Hlavy se pomíchaly
Funkce má z tvaru (B, T, D) udělat (B, H, T, D/H) tak, aby hlava h u tokenu t obsahovala právě příslušný kousek vektoru tokenu t. Tvar vychází správně, data ale ne.
Attention, která se sama naučí hledat
Teď to celé oživíš. Úkol vypadá jako slovník: model dostane čtyři dvojice (klíč, hodnota) a jeden hledaný klíč a má vrátit příslušnou hodnotu. Nikdo mu neřekne, co znamená „shoda“. Na začátku má jen náhodné vektory dotazů a klíčů.
Gradient se dá odvodit ručně. Předpověď je ŷ = Σ aᵢ vᵢ a pro softmax platí:
∂ŷ/∂sᵢ = aᵢ (vᵢ - ŷ)
∂L/∂sᵢ = 2 (ŷ - y) aᵢ (vᵢ - ŷ) kde L = (ŷ - y)²Skóre je sᵢ = q · kᵢ / sqrt(d), takže gradient pro vektor dotazu je Σ ∂L/∂sᵢ · kᵢ / sqrt(d) a pro klíč obdobně.
import numpy as np
KEYS, ITEMS, DIM, BATCH = 6, 4, 8, 64
rng = np.random.RandomState(1)
Wq = rng.normal(0, 0.1, (KEYS, DIM))
Wk = rng.normal(0, 0.1, (KEYS, DIM))
scale = np.sqrt(DIM)
def sample(m):
keys = np.array([rng.permutation(KEYS)[:ITEMS] for _ in range(m)])
values = rng.uniform(-1, 1, (m, ITEMS))
pick = rng.randint(ITEMS, size=m)
rows = np.arange(m)
return keys, values, keys[rows, pick], values[rows, pick], pick
def forward(keys, values, query):
s = np.sum(Wq[query][:, None] * Wk[keys], axis=-1) / scale
e = np.exp(s - s.max(axis=1, keepdims=True))
a = e / e.sum(axis=1, keepdims=True)
return a, np.sum(a * values, axis=1)
def evaluate():
keys, values, query, y, pick = sample(500)
a, pred = forward(keys, values, query)
return np.mean((pred - y) ** 2), np.mean(a.argmax(axis=1) == pick)
mse, hit = evaluate()
print(f"před učením: chyba {mse:.3f}, správný klíč {hit:.0%}")
for step in range(800):
keys, values, query, y, _ = sample(BATCH)
a, pred = forward(keys, values, query)
dL_ds = 2 * (pred - y)[:, None] * a * (values - pred[:, None])
grad_q = np.zeros_like(Wq)
grad_k = np.zeros_like(Wk)
np.add.at(grad_q, query, np.sum(dL_ds[..., None] * Wk[keys], axis=1) / scale)
np.add.at(grad_k, keys.ravel(), (dL_ds[..., None] * Wq[query][:, None]).reshape(-1, DIM) / scale)
Wq -= 6 * grad_q / BATCH
Wk -= 6 * grad_k / BATCH
mse, hit = evaluate()
print(f"po učení: chyba {mse:.3f}, správný klíč {hit:.0%}")
keys, values, query, y, _ = sample(1)
a, pred = forward(keys, values, query)
print("klíče: ", keys[0].tolist(), " hledám:", int(query[0]))
print("hodnoty:", np.round(values[0], 2).tolist())
print("váhy: ", np.round(a[0], 2).tolist())
print("výstup:", round(float(pred[0]), 2), " správně:", round(float(y[0]), 2))
S = Wq @ Wk.T / scale
print("největší skóre leží na diagonále:", bool(np.all(S.argmax(axis=1) == np.arange(KEYS))))
před učením: chyba 0.269, správný klíč 16% po učení: chyba 0.000, správný klíč 100% klíče: [1, 2, 0, 3] hledám: 1 hodnoty: [0.03, 0.16, 0.57, -0.83] váhy: [0.98, 0.0, 0.01, 0.01] výstup: 0.03 správně: 0.03 největší skóre leží na diagonále: True
Model si sám vytvořil vektory tak, že dotaz na klíč 3 má největší součin právě s klíčem 3. Z nediferencovatelné operace „najdi v tabulce“ se stala měkká, spojitá verze, kterou lze učit gradientem. To je jádro celé myšlenky.
Attention v PyTorch
import torch
import torch.nn.functional as F
from torch import nn
x = torch.randn(2, 5, 16) # (batch, tokens, dim)
# Functional form, uses optimized kernels when available
out = F.scaled_dot_product_attention(x, x, x)
print(out.shape) # torch.Size([2, 5, 16])
# Here True means: this position may be used
allowed = torch.tril(torch.ones(5, 5, dtype=torch.bool))
out = F.scaled_dot_product_attention(x, x, x, attn_mask=allowed)
# Complete layer with projections and heads
mha = nn.MultiheadAttention(embed_dim=16, num_heads=4, batch_first=True)
# Here True means: this position is BLOCKED
blocked = torch.triu(torch.ones(5, 5, dtype=torch.bool), diagonal=1)
out, weights = mha(x, x, x, attn_mask=blocked, average_attn_weights=False)
print(out.shape, weights.shape) # torch.Size([2, 5, 16]) torch.Size([2, 4, 5, 5])Kdo co dělá
Spoj pojem s jeho úlohou.
Pod kapotou · co rozhodne v reálném nasazení
Složitost. Self-attention je O(T²) v čase i paměti pro matici vah. Dvojnásobná délka sekvence znamená čtyřnásobek. Odtud plyne tlak na limity kontextu a na alternativy (posuvná okna, řídké varianty). Multi-head přitom při rozdělení D mezi hlavy počet parametrů projekcí nezvyšuje: váhy D × D zůstávají stejné.
Váhy attention nejsou vysvětlení. Jain a Wallace (2019, Attention is not Explanation) ukázali, že různé rozložení vah může vést ke stejné předpovědi. Wiegreffe a Pinter (2019, Attention is not not Explanation) tento závěr upřesnili. Heatmapu ber jako nápovědu, ne jako důkaz, zvlášť když hodnoty V už prošly předchozími vrstvami a míchají informace z více tokenů.
Historie a varianty. Bahdanau a kol. (2014) počítali skóre malou sítí (aditivní attention). Skalární součin s dělením odmocninou zpopularizoval článek Attention Is All You Need (Vaswani a kol., 2017). Dělení je motivované předpokladem jednotkového rozptylu složek, který s normalizací vrstev přibližně platí.
Numerika. Se smíšenou přesností se hodnoty jako -1e9 pro maskování nemusí vejít do float16. Používej -inf nebo masked_fill s hodnotou odvozenou z typu. Softmax vždy počítej až po maskování.
Výkon v PyTorch. F.scaled_dot_product_attention si umí vybrat optimalizovanou implementaci podle hardwaru a vstupu. Některé z nich nevrací matici vah, proto tahle funkce váhy nevrací vůbec. Pokud je nepotřebuješ v nn.MultiheadAttention, předej need_weights=False, jinak se zbytečně počítají.
Únik přes masku. Kauzální maska chrání jen attention. Budoucnost může do modelu proniknout i normalizací přes celou sekvenci nebo chybně posunutými cíli. Rychlý test: změň poslední token a ověř, že se výstupy na dřívějších pozicích nezměnily.
Opakování
Vyzkoušej si: Co čemu věnuje pozornost
Ukázková věta s ilustračními vektory. Škálovaný skalární součin ukáže teplotní mapu a výpočet Q, K a V.