0 dní v řadě · 0 bodů

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

Attention od nuly

Napíšeš scaled dot-product attention, masky, poziční kódování i více hlav v NumPy a natrénuješ model, který si sám najde správnou položku.

Hloubka
Úkoly
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)
Výstup
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")
Výstup
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.
text
skóre = Q @ Kᵀ / sqrt(d)
váhy  = softmax(skóre) po řádcích
výstup = váhy @ V

d 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ýstup
váhy: (2, 5)
výstup: (2, 6)
součty řádků: [1. 1.]
Doplň

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}")
Výstup
   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
Úkol

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

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])))
Výstup
(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)
Výstup
(50, 16)
pozice 10 a 11: 0.94
pozice 10 a 40: 0.34
všechny pozice různé: True
Kvíz

Co se stane se self-attention bez pozičního kódování, když přehodíš dvě slova ve vstupu?

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))
Výstup
[[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]]
Úkol

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

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.

text
(B, T, D)  →  (B, H, T, D/H)  →  attention  →  (B, T, D)  →  výstupní vrstva
import 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
výstup: (2, 6, 32)
váhy: (2, 4, 6, 6)
první token vidí jen sebe: True
Najdi chybu

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

text
∂ŷ/∂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))))
Výstup
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

python
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])
Spoj dvojice

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.

Kartičky

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.