Salt la conținut

Avem nevoie doar de atenție?

IntermediarLectură: 9 min

Titlul paginii traduce titlul articolului „Attention Is All You Need”, publicat în 2017 de Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser și Illia Polosukhin, cercetători la Google Brain, Google Research și Universitatea din Toronto. Articolul a fost prezentat la conferința NeurIPS 2017.

Articolul a propus o arhitectură numită Transformer, construită în jurul unui singur mecanism, atenția (attention). Pe această arhitectură se bazează majoritatea modelelor de limbaj mari de astăzi.

Înainte de 2017, traducerea automată folosea mai ales rețele neuronale recurente (recurrent neural networks, RNN). O rețea recurentă citește textul token cu token și păstrează o stare internă, actualizată la fiecare pas. Calculul pentru al 50-lea token trebuie să aștepte rezultatul pentru al 49-lea, așa că antrenarea nu se poate paraleliza de-a lungul secvenței. În plus, informația despre începutul unei propoziții lungi trebuie să treacă prin toți pașii intermediari până la final.

Atenția era deja folosită alături de rețelele recurente. Încă din 2014, de la lucrarea lui Bahdanau, Cho și Bengio, un model de traducere putea să se uite direct la cuvintele din propoziția sursă ori de câte ori genera un cuvânt nou. Articolul din 2017 a renunțat complet la recurență. Fiecare token se uită direct la oricare alt token, iar toate pozițiile se calculează în paralel. De aici vine și titlul.

Atenția calculează pentru fiecare token o nouă reprezentare, ca medie ponderată a reprezentărilor tokenurilor din context. Ponderile nu sunt fixate dinainte, ci calculate din conținutul tokenurilor, și arată cât de relevant este fiecare token pentru cel curent.

În propoziția „Pisica nu a traversat strada pentru că ea era prea obosită”, pronumele „ea” se referă la pisică. Dacă ultimul cuvânt devine „lată”, același pronume se referă la stradă. Ambele substantive sunt feminine, deci gramatica nu ajută. Doar sensul restului propoziției decide. Exemplul este adaptat după prezentarea Transformerului de pe blogul Google, din 2017.

La ce se uită cuvântul „ea”

Ultimul cuvânt al propoziției
  1. Pisica46%
  2. nu3%
  3. a2%
  4. traversat5%
  5. strada12%
  6. pentru2%
  7. că3%
  8. ea10%
  9. era5%
  10. prea3%
  11. obosită9%

„ea” acordă cea mai mare pondere cuvântului „Pisica” (46%).

Ponderile sunt alese pentru ilustrare, nu calculate de un model. Suma ponderilor este 100%. Cuvântul „ea” este marcat cu un contur.

Un model antrenat poate învăța astfel de asocieri. Prin atenție, reprezentarea lui „ea” preia multă informație de la substantivul la care se referă, iar straturile următoare lucrează cu un „ea” care înseamnă deja „pisica” sau „strada”.

Mecanismul lucrează cu trei roluri, iar fiecare token produce câte un vector pentru fiecare rol.

  • Interogarea (query) descrie ce informație caută tokenul.
  • Cheia (key) descrie după ce îl pot găsi celelalte tokenuri.
  • Valoarea (value) este informația pe care tokenul o transmite.

O analogie bună este căutarea într-un dicționar. Interogarea se compară cu toate cheile, iar rezultatul combină valorile. Spre deosebire de un dicționar obișnuit, potrivirea nu este exactă, iar fiecare valoare contribuie cu atât mai mult cu cât cheia corespunzătoare se potrivește mai bine.

Cei trei vectori se obțin înmulțind reprezentarea tokenului cu trei matrice de ponderi, învățate la antrenare.

Pentru curioșiProiecțiile Q, K și V

Pentru toate tokenurile deodată, cu reprezentările așezate pe rândurile unei matrice XX, avem:

Q=XWQ,K=XWK,V=XWVQ = X W^Q, \quad K = X W^K, \quad V = X W^V

Articolul numește formula de bază atenție prin produs scalar scalat (scaled dot-product attention). Interogarea fiecărui token se compară, printr-un produs scalar, cu cheile tuturor tokenurilor. Scorurile obținute sunt împărțite la o constantă, iar softmax le transformă în ponderi pozitive, cu suma 1. Rezultatul este media ponderată a valorilor, cu aceste ponderi.

Pentru curioșiFormula atenției
Attention⁡(Q,K,V)=softmax⁡(QK⊤dk)V\operatorname{Attention}(Q, K, V) = \operatorname{softmax}\left(\frac{Q K^\top}{\sqrt{d_k}}\right) V

Produsul QK⊤Q K^\top conține produsele scalare dintre fiecare interogare și fiecare cheie. Elementul de pe rândul ii și coloana jj măsoară cât de bine se potrivește interogarea tokenului ii cu cheia tokenului jj. Softmax se aplică pe fiecare rând și transformă scorurile în ponderi pozitive, cu suma 1. Înmulțirea cu VV face apoi media ponderată a valorilor.

Mărimea dkd_k este dimensiunea vectorilor cheie. Dacă vectorii au componente independente, cu media 0 și varianța 1, produsul scalar al vectorilor are varianța dkd_k. Pentru dkd_k mare, scorurile devin mari în valoare absolută, iar softmax dă aproape toată ponderea unui singur token. În această zonă, gradienții sunt foarte mici și antrenarea încetinește. Împărțirea la dk\sqrt{d_k} readuce varianța la 1.

Atenția prin produs scalar scalatQ și K se înmulțesc, rezultatul se împarte la radical din d indice k, se aplică opțional o mască, apoi softmax. Ponderile obținute se înmulțesc cu V și dau ieșirea.Înmulțire Q · KᵀÎmpărțire la √dₖMască (opțional)SoftmaxÎnmulțire cu Vscoruridoar în decodorponderi de atențieQKVIeșire
Pașii formulei de atenție, de jos în sus, după figura 2 din articol.

Codul de mai jos implementează formula cu NumPy, pentru 4 tokenuri. Matricele de ponderi sunt aleatorii, nu învățate, așa că ponderile de atenție nu au un sens lingvistic. Codul poate fi modificat și rulat direct în pagină.

import numpy as np
def softmax(x):
# Se scade maximul pe fiecare rând, pentru stabilitate numerică.
e = np.exp(x - x.max(axis=-1, keepdims=True))
return e / e.sum(axis=-1, keepdims=True)
def attention(Q, K, V, mask=None):
d_k = Q.shape[-1]
scores = Q @ K.T / np.sqrt(d_k)
if mask is not None:
# Pozițiile ascunse primesc -inf, deci pondere zero după softmax.
scores = np.where(mask, scores, -np.inf)
weights = softmax(scores)
return weights @ V, weights
rng = np.random.default_rng(seed=0)
n, d_model, d_k = 4, 8, 4 # 4 tokenuri, reprezentări de dimensiune 8
X = rng.normal(size=(n, d_model))
W_Q, W_K, W_V = (rng.normal(size=(d_model, d_k)) for _ in range(3))
Q, K, V = X @ W_Q, X @ W_K, X @ W_V
output, weights = attention(Q, K, V)
np.set_printoptions(precision=2, suppress=True)
print("Ponderile de atenție (un rând pentru fiecare token):")
print(weights)
print("Suma fiecărui rând:", weights.sum(axis=1))
print("Forma ieșirii:", output.shape)

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Pentru curioșiFormula măștii cauzale

Elementul MijM_{ij} se adună la scorul dintre interogarea tokenului ii și cheia tokenului jj.

Mij={0pentru j≤i−∞pentru j>iM_{ij} = \begin{cases} 0 & \text{pentru } j \le i \\ -\infty & \text{pentru } j > i \end{cases}softmax⁡(QK⊤dk+M)V\operatorname{softmax}\left(\frac{Q K^\top}{\sqrt{d_k}} + M\right) V

După softmax, pozițiile cu −∞-\infty primesc ponderea 0.

Prin mască, tokenurile de după poziția curentă primesc ponderea 0. Codul de mai jos continuă exemplul anterior. Funcțiile și matricele din primul bloc sunt create automat înainte de rulare, așa că blocul funcționează și singur.

# Masca cauzală: tokenul i vede doar pozițiile 0, 1, …, i.
mask = np.tril(np.ones((n, n), dtype=bool))
print(mask.astype(int))
_, masked_weights = attention(Q, K, V, mask)
np.set_printoptions(precision=2, suppress=True)
print("Ponderile cu mască:")
print(masked_weights)

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Primul token se vede doar pe sine, deci primește ponderea 1. Ultimul rând nu se schimbă, pentru că ultimul token vede oricum tot contextul.

O operație de atenție calculează pentru fiecare token o singură medie ponderată, deci poate surprinde un singur tip de relație între tokenuri. Atenția cu capete multiple (multi-head attention) rulează în paralel hh atenții independente, numite capete de atenție, fiecare cu propriile proiecții liniare învățate.

Pentru curioșiFormula atenției cu capete multiple
head⁡i=Attention⁡(QWiQ,KWiK,VWiV)\operatorname{head}_i = \operatorname{Attention}(Q W_i^Q, K W_i^K, V W_i^V)MultiHead⁡(Q,K,V)=Concat⁡(head⁡1,…,head⁡h)WO\operatorname{MultiHead}(Q, K, V) = \operatorname{Concat}(\operatorname{head}_1, \ldots, \operatorname{head}_h) W^O

Rezultatele capetelor se concatenează, iar matricea de proiecție WOW^O le combină înapoi în spațiul modelului.

Rezultatele capetelor sunt apoi combinate într-un singur vector pentru fiecare token. În articolul original, h=8h = 8, dimensiunea modelului este dmodel=512d_{\text{model}} = 512, iar fiecare cap lucrează cu vectori de dimensiune dk=dv=dmodel/h=64d_k = d_v = d_{\text{model}} / h = 64. Astfel, costul computațional total este comparabil cu cel al unei singure atenții pe dimensiunea completă, dar modelul poate urmări în același timp relații diferite, de exemplu sintactice și semantice.

Atenția cu capete multiple (multi-head)V, K și Q trec fiecare prin câte o proiecție liniară pentru fiecare dintre cele h capete. Fiecare cap calculează atenția prin produs scalar scalat. Rezultatele capetelor se concatenează și trec printr-o ultimă proiecție liniară.LiniarLiniarLiniarAtenție prin produs scalar scalatConcatenareLiniarh capeteVKQIeșire
Atenția cu capete multiple, după figura 2 din articol. Capetele lucrează în paralel.

Modelul din articol a fost gândit pentru traducere automată. Codificatorul (encoder) prelucrează propoziția sursă, iar decodorul (decoder) scrie traducerea, token cu token.

Arhitectura TransformerÎn stânga, în codificator, tokenurile de intrare devin reprezentări vectoriale, primesc codificarea pozițională și trec printr-un bloc repetat de N ori, cu atenție cu capete multiple și o rețea feed-forward, fiecare urmată de adunare și normalizare. În dreapta, în decodor, tokenurile generate până acum trec prin atenție mascată, atenție încrucișată, care primește cheile și valorile de la codificator, și o rețea feed-forward. La final, un strat liniar și softmax dau probabilitățile următorului token.CodificatorDecodorN ×N ×Reprezentări vectorialeAtenție cu capete multipleAdunare și normalizareRețea feed-forwardAdunare și normalizareReprezentări vectorialeAtenție mascatăcu capete multipleAdunare și normalizareAtenție încrucișatăcu capete multipleAdunare și normalizareRețea feed-forwardAdunare și normalizareStrat liniarSoftmax++CodificarepoziționalăCodificarepoziționalăK, VQTokenurile de intrareTokenurile generate până acumProbabilitățile următorului token
Arhitectura Transformer, simplificată după figura 1 din articol. Blocurile din chenarele punctate se repetă de N ori (în articol, N = 6). Săgețile laterale sunt conexiunile reziduale.

Codificatorul are N=6N = 6 straturi identice, fiecare cu două blocuri. Primul este auto-atenția (self-attention) cu capete multiple, în care interogările, cheile și valorile vin din aceeași secvență. Al doilea este o rețea feed-forward (feed-forward network), aplicată separat fiecărei poziții.

Pentru curioșiFormula rețelei feed-forward
FFN⁡(x)=max⁡(0, xW1+b1)W2+b2\operatorname{FFN}(x) = \max(0,\, x W_1 + b_1) W_2 + b_2

unde xx este vectorul unei poziții, W1W_1 și W2W_2 sunt matrice de ponderi, b1b_1 și b2b_2 sunt vectori de bias, iar max⁡(0,⋅)\max(0, \cdot) aplică funcția ReLU fiecărei componente.

Rețeaua are un strat ascuns de dimensiune dff=2048d_{\text{ff}} = 2048 și funcția de activare ReLU. Atenția amestecă informația între poziții, iar rețeaua feed-forward o prelucrează în fiecare poziție.

Decodorul are tot 6 straturi, cu trei componente. Prima este auto-atenția mascată, cu masca cauzală de mai sus. A doua este atenția încrucișată (cross-attention), în care interogările vin din decodor, iar cheile și valorile vin de la ieșirea codificatorului. Prin atenția încrucișată, fiecare token al traducerii consultă propoziția sursă. A treia este rețeaua feed-forward.

Fiecare componentă este înconjurată de o conexiune reziduală (residual connection) și urmată de o normalizare pe strat (layer normalization).

Pentru curioșiConexiunea reziduală și normalizarea
LayerNorm⁡(x+Sublayer⁡(x))\operatorname{LayerNorm}(x + \operatorname{Sublayer}(x))

unde xx este intrarea componentei, iar Sublayer⁡\operatorname{Sublayer} este componenta însăși, adică atenția sau rețeaua feed-forward.

Conexiunea reziduală adună intrarea la rezultat, așa că fiecare componentă adaugă o corecție în loc să înlocuiască reprezentarea. Gradienții trec astfel mai ușor prin multe straturi. Normalizarea menține valorile pe o scară stabilă. La capătul decodorului, un strat liniar și softmax dau probabilitățile următorului token. Articolul folosește aceeași matrice de ponderi pentru reprezentările vectoriale și pentru acest strat liniar.

Articolul adaugă la reprezentările vectoriale o codificare pozițională (positional encoding), formată din sinusuri și cosinusuri.

Pentru curioșiFormula codificării poziționale
PE(pos, 2i)=sin⁡(pos100002i/dmodel)PE_{(pos,\, 2i)} = \sin\left(\frac{pos}{10000^{2i / d_{\text{model}}}}\right)PE(pos, 2i+1)=cos⁡(pos100002i/dmodel)PE_{(pos,\, 2i+1)} = \cos\left(\frac{pos}{10000^{2i / d_{\text{model}}}}\right)

unde pospos este poziția tokenului, iar ii indică perechea de dimensiuni din vector. Autorii au ales această formă pentru că, pentru orice deplasare fixă kk, PEpos+kPE_{pos+k} este o funcție liniară de PEposPE_{pos}, deci modelul poate învăța ușor poziții relative.

Fiecare pereche de dimensiuni din vector oscilează cu altă frecvență, ca acele unui ceas care se rotesc cu viteze diferite. Autorii au testat și poziții învățate la antrenare, cu rezultate aproape identice.

Experimentele au folosit seturile de traducere WMT 2014. Scorul BLEU (bilingual evaluation understudy) compară traducerea automată cu traduceri de referință făcute de oameni. Un scor mai mare este mai bun.

  • Pentru traducerea din engleză în germană, varianta mare a modelului a obținut 28,4 BLEU, cu peste 2 puncte mai mult decât cele mai bune rezultate anterioare, inclusiv combinațiile de modele.
  • Pentru traducerea din engleză în franceză, a obținut 41,8 BLEU, un nou record pentru un singur model, după 3,5 zile de antrenare pe opt plăci grafice NVIDIA P100.
  • Varianta de bază, cu circa 65 de milioane de parametri, s-a antrenat în 12 ore pe aceleași opt plăci grafice. Varianta mare are circa 213 milioane de parametri.

Costul de antrenare a fost o mică parte din cel al celor mai bune modele anterioare. Autorii au aplicat arhitectura și la analiza sintactică a propozițiilor în engleză, cu rezultate bune.

După 2017, arhitectura s-a ramificat. BERT (Google, 2018) păstrează doar codificatorul și este folosit pentru înțelegerea textului, de exemplu pentru clasificare. GPT (OpenAI, 2018) păstrează doar decodorul, fără atenția încrucișată, și generează text. Majoritatea modelelor de limbaj mari de astăzi folosesc doar decodorul.

Modelele actuale au păstrat structura generală, dar au înlocuit multe componente, precum normalizarea, codificarea pozițională, rețeaua feed-forward și felul în care sunt calculate cheile și valorile. Pagina Arhitectura Transformer le descrie pe rând, cu dimensiunile reale ale modelului din demo.