Atenția, scrisă de mână
Prin atenție (attention), fiecare token al unui text poate prelua informație de la tokenurile aflate înaintea sa. Pagina Avem nevoie doar de atenție? explică mecanismul în teorie. În această etapă scriem calculul de mână, în fișierul attention.py, pe o propoziție de șase tokenuri, și comparăm rezultatul cu funcția pe care o folosește PyTorch. Apoi trecem la stratul de atenție cu șase capete din model.py, prima piesă a modelului GPT.
La redare, playerul se încarcă de pe YouTube (detalii).
Interogări, chei și valori
Secțiune intitulată „Interogări, chei și valori”În model, fiecare token ajunge la atenție ca un vector de numere, care descrie tokenul și poziția din propoziție. Trei matrice de ponderi, învățate la antrenare, transformă acest vector în trei vectori noi.
- Interogarea (query) descrie ce informație caută tokenul.
- Cheia (key) este vectorul cu care se compară interogările celorlalte tokenuri.
- Valoarea (value) este informația pe care tokenul o transmite mai departe.
Cât de mult se uită tokenul la tokenul depinde de un scor: produsul scalar dintre interogarea lui și cheia lui , împărțit la rădăcina pătrată a dimensiunii vectorilor. Produsul scalar este mare când cei doi vectori sunt orientați la fel, iar împărțirea păstrează scorurile la o scară potrivită pentru softmax, oricât de lungi ar fi vectorii. Pe fiecare rând de scoruri, softmax dă ponderi pozitive, cu suma 1, iar noul vector al tokenului este media valorilor, calculată cu aceste ponderi.
Un model de tip GPT scrie textul de la stânga la dreapta, așa că un token nu are voie să se uite la tokenurile de după poziția sa. La generare, acele tokenuri nu există încă, iar la antrenare ar dezvălui chiar tokenul care trebuie prezis. Masca cauzală (causal mask) pune scorurile acestor perechi la minus infinit, înainte de softmax, așa că ponderile corespunzătoare devin zero.
Pentru curioșiFormula atenției cauzale
Scorul dintre tokenul și tokenul este:
Softmax, aplicat doar pe tokenurile de până la poziția , dă ponderile:
Ieșirea pentru tokenul este media ponderată a valorilor:
unde este interogarea tokenului , și sunt cheia și valoarea tokenului , iar este dimensiunea acestor vectori. Pentru componente independente, cu media 0 și varianța 1, produsul scalar are varianța , iar împărțirea la readuce varianța la 1. Fără această scalare, pentru mare, softmax ar da aproape toată ponderea unui singur token.
Funcția attention
Secțiune intitulată „Funcția attention”def attention(q, k, v): T, d = q.shape scores = q @ k.T / math.sqrt(d) future = torch.triu(torch.ones(T, T, dtype=torch.bool), diagonal=1) scores = scores.masked_fill(future, float("-inf")) weights = F.softmax(scores, dim=-1) return weights @ v, weightsInterogările, cheile și valorile unei secvențe vin ca matrice, cu câte un rând pentru fiecare token. Produsul q @ k.T calculează dintr-o dată toate scorurile, într-o matrice de , în care rândul conține scorurile tokenului față de fiecare token. Apelul torch.triu(…, diagonal=1) marchează cu True pozițiile de deasupra diagonalei, adică perechile în care tokenul vine după tokenul , iar masked_fill pune acolo minus infinit. F.softmax(…, dim=-1) lucrează pe ultima dimensiune, deci pe fiecare rând, iar weights @ v face toate mediile ponderate. Funcția întoarce și ponderile, ca tabelul ponderilor să poată fi afișat.
O propoziție de șase tokenuri
Secțiune intitulată „O propoziție de șase tokenuri”Funcția show afișează ponderile ca tabel, cu un punct în locul ponderilor nule.
def show(tokens, weights): print(" " * 6 + "".join(f"{t:>7}" for t in tokens)) for token, row in zip(tokens, weights.tolist()): print(f"{token:>6}" + "".join(f"{w:7.2f}" if w > 0 else f"{'·':>7}" for w in row))Prima parte a scriptului aplică funcția attention propoziției „Lily has a red ball.”, împărțite în șase tokenuri.
if __name__ == "__main__": torch.manual_seed(0) tokens = ["Lily", "has", "a", "red", "ball", "."] d_model, d_head = 16, 8 x = torch.randn(len(tokens), d_model) W_q, W_k, W_v = (torch.randn(d_model, d_head) / math.sqrt(d_model) for _ in range(3)) q, k, v = x @ W_q, x @ W_k, x @ W_v out, weights = attention(q, k, v) print(f"x {tuple(x.shape)} | q, k, v {tuple(q.shape)} | ieșire {tuple(out.shape)}") show(tokens, weights) reference = F.scaled_dot_product_attention(q[None], k[None], v[None], is_causal=True)[0] print(f"diferența maximă față de PyTorch: {(out - reference).abs().max().item():.1e}")Ca exemplul să rămână mic, vectorii tokenurilor au doar 16 numere, iar interogările, cheile și valorile au câte 8. Vectorii și matricele de ponderi sunt aleatori, iar matricele sunt împărțite la , ca valorile să rămână mici. Apelul torch.manual_seed(0) face ca fiecare rulare să dea aceleași numere.
La final, același calcul este făcut de F.scaled_dot_product_attention, funcția pe care o folosește modelul, cu is_causal=True pentru masca cauzală. Funcția din PyTorch lucrează pe loturi de secvențe, așa că [None] adaugă dimensiunea lotului, iar [0] scoate această dimensiune din rezultat.
În directorul laboratorului, după pregătirea mediului, scriptul rulează în câteva secunde, pe orice calculator.
python attention.pyRezultatul de mai jos vine din seria video a laboratorului.
x (6, 16) | q, k, v (6, 8) | ieșire (6, 8) Lily has a red ball . Lily 1.00 · · · · · has 0.47 0.53 · · · · a 0.17 0.27 0.56 · · · red 0.06 0.26 0.57 0.12 · · ball 0.36 0.16 0.07 0.32 0.10 · . 0.04 0.21 0.40 0.08 0.07 0.20diferența maximă față de PyTorch: 2.4e-076 capete de câte 64: (2, 10, 384) -> (2, 10, 384), 591,360 parametriȘase tokenuri cu vectori de 16 numere dau interogări, chei și valori de câte 8 numere, iar ieșirea are tot câte 8 numere pentru fiecare token. Primul token, Lily, se vede doar pe sine, deci primește ponderea 1. Pe fiecare rând, ponderile au suma 1, iar deasupra diagonalei, unde tabelul arată un punct, sunt zero.
Ultimul rând este al punctului, care vede toată propoziția. Cea mai mare pondere merge la a, 0,40, urmată de has și de punctul însuși, cu aproximativ 0,2 fiecare. Matricele de ponderi sunt aleatoare, așa că tabelul arată mecanismul, nu un sens: nimic nu face din a cel mai important cuvânt pentru punct. Ponderile capătă sens abia după antrenare, cum se vede pe pagina despre generarea textului.
Calculul de mână și cel din PyTorch diferă cu cel mult , adică doar prin rotunjirile calculelor cu numere reale pe 32 de biți. Ultima linie vine de la stratul cu șase capete, explicat mai jos.
Atenția cu capete multiple (multi-head)
Secțiune intitulată „Atenția cu capete multiple (multi-head)”Un singur cap face, pentru fiecare token, o singură medie ponderată, deci poate urmări un singur fel de legătură între tokenuri. Modelul folosește atenția cu capete multiple: 6 capete calculează în paralel atenția, fiecare cu propriile ponderi, iar rezultatele capetelor sunt combinate la final. De exemplu, după antrenare, un cap poate urmări cuvântul de dinainte, iar altul, personajul despre care este vorba.
class CausalSelfAttention(nn.Module): def __init__(self, config): super().__init__() self.n_head = config.n_head self.q_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) self.k_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) self.v_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) self.o_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) self.dropout_p = config.dropout self.resid_dropout = nn.Dropout(config.dropout)
def forward(self, x): B, T, C = x.shape q = self.q_proj(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) k = self.k_proj(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) v = self.v_proj(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) y = F.scaled_dot_product_attention( q, k, v, dropout_p=self.dropout_p if self.training else 0.0, is_causal=True ) y = y.transpose(1, 2).contiguous().view(B, T, C) return self.resid_dropout(self.o_proj(y))Intrarea x are forma (B, T, C), cu B secvențe dintr-un lot, câte T tokenuri, fiecare cu un vector de C = 384 de valori. Stratul are patru straturi liniare: primele trei calculează interogările, cheile și valorile tuturor capetelor deodată, iar al patrulea, o_proj, face proiecția de ieșire. Configurația modelului, GPTConfig, este descrisă pe pagina următoare.
După fiecare proiecție, view împarte vectorii de 384 de valori în 6 capete de câte 64, iar transpose mută capetele înaintea tokenurilor, la forma (B, 6, T, 64). Funcția F.scaled_dot_product_attention face apoi, pentru fiecare cap, calculul din funcția attention, cu aceeași mască cauzală. PyTorch alege pentru această funcție cea mai rapidă implementare disponibilă pe dispozitiv. Pe plăcile grafice NVIDIA, poate folosi FlashAttention, care face același calcul pe blocuri, fără să păstreze întreagă matricea ponderilor, de , în memoria principală a plăcii. Dropout-ul pe ponderi este activ doar la antrenare.
Rezultatele capetelor se alătură la loc, cu transpose și view. Apelul contiguous copiază datele în noua ordine, pentru că view are nevoie de date așezate continuu în memorie. La final, o_proj amestecă informația venită de la cele 6 capete.
Mai jos, același calcul este scris pas cu pas în NumPy, pentru 4 tokenuri, vectori de 8 valori și 2 capete.
import numpy as np
rng = np.random.default_rng(seed=0)T, C, n_head = 4, 8, 2hs = C // n_head # dimensiunea unui capx = rng.normal(size=(T, C))W_q, W_k, W_v, W_o = (rng.normal(size=(C, C)) * 0.3 for _ in range(4))
def split_heads(m): # (T, C) -> (n_head, T, hs), ca view(...).transpose(1, 2) din model.py return m.reshape(T, n_head, hs).transpose(1, 0, 2)
q, k, v = split_heads(x @ W_q), split_heads(x @ W_k), split_heads(x @ W_v)scores = q @ k.transpose(0, 2, 1) / np.sqrt(hs)mask = np.tril(np.ones((T, T), dtype=bool)) # masca cauzalăscores = np.where(mask, scores, -np.inf)weights = np.exp(scores - scores.max(axis=-1, keepdims=True))weights /= weights.sum(axis=-1, keepdims=True)
y = (weights @ v).transpose(1, 0, 2).reshape(T, C) # capetele se alătură la locout = y @ W_o
np.set_printoptions(precision=2, suppress=True)print("Ponderile de atenție ale capului 0:")print(weights[0])print("Ponderile de atenție ale capului 1:")print(weights[1])print("Forma ieșirii:", out.shape)Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Deasupra diagonalei, ponderile sunt zero, deci niciun token nu vede tokenurile următoare. Cele două capete împart altfel atenția, pentru că au proiecții diferite.
Stratul, verificat
Secțiune intitulată „Stratul, verificat”Ultima parte a fișierului attention.py construiește un strat de atenție cu configurația implicită a modelului.
config = GPTConfig() layer = CausalSelfAttention(config).eval() x = torch.randn(2, 10, config.n_embd) params = sum(p.numel() for p in layer.parameters()) print(f"{config.n_head} capete de câte {config.n_embd // config.n_head}: {tuple(x.shape)} -> {tuple(layer(x).shape)}, " f"{params:,} parametri")Apelul .eval() oprește dropout-ul, iar intrarea este un lot de 2 secvențe a câte 10 tokenuri, cu vectori aleatori de 384 de valori. Ultima linie din rezultatul de mai sus arată că ieșirea are aceeași formă ca intrarea, (2, 10, 384). Datorită acestui lucru, straturile de atenție se pot așeza unul după altul, în blocurile modelului.
Stratul are 591.360 de parametri. Fiecare dintre cele 4 straturi liniare are o matrice de 384 × 384 de ponderi și 384 de valori de bias, adică . Numărul nu depinde de numărul capetelor, pentru că cele 6 capete împart aceleași 384 de dimensiuni, nu adaugă altele.
Pe pagina următoare, stratul de atenție devine prima parte a unui bloc Transformer, iar 6 blocuri formează modelul GPT complet.
Bibliografie
Secțiune intitulată „Bibliografie”- Dao, T. et al. (2022). FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness. NeurIPS 2022. ↩︎
- Vaswani, A. et al. (2017). Attention Is All You Need. NeurIPS 2017.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.