Salt la conținut

Arhitectura Transformer

AvansatLectură: 8 min

Pagina Avem nevoie doar de atenție? descrie Transformerul original din 2017, cu codificator și decodor, gândit pentru traducere. Aici ne uităm la arhitectura folosită azi de majoritatea modelelor de limbaj mari, Transformerul doar cu decodor (decoder-only Transformer). Componentele de bază sunt aceleași, dar aproape fiecare a fost modificată, ca modelul să calculeze mai eficient și să poată fi scalat mai ușor.

Exemplele numerice folosesc configurația publică a modelului SmolLM2 135M, cel din demo-ul de pe pagina despre LLM-uri. Familii de modele mai mari, de exemplu Llama, Qwen sau Mistral, folosesc aceleași componente, cu dimensiuni mai mari.

Un Transformer doar cu decodorTokenurile devin reprezentări vectoriale. Fiecare dintre cele N blocuri aplică RMSNorm, apoi atenție cauzală cu RoPE, și adună rezultatul la intrare. Apoi aplică din nou RMSNorm și rețeaua feed-forward SwiGLU și adună rezultatul. După ultimul bloc urmează un RMSNorm final și un strat liniar care dă scorurile pentru vocabular.Bloc decodorN ×Reprezentări vectorialeRMSNormAtenție cauzalăcu interogări grupate și RoPERMSNormRețea feed-forwardSwiGLURMSNorm finalStrat liniar → scoruri++Tokenuriaceeași matriceaceeași matriceflux rezidual
Un Transformer doar cu decodor, în forma folosită de modelele actuale. Săgețile din dreapta sunt conexiunile reziduale. Primul și ultimul strat folosesc aceeași matrice de reprezentări vectoriale.

Textul trece prin model în patru etape.

  1. Fiecare token este înlocuit cu rândul corespunzător din matricea de reprezentări vectoriale EE, de dimensiune V×dV \times d, unde VV este mărimea vocabularului, iar dd este dimensiunea modelului.
  2. Vectorii trec, pe rând, prin NN blocuri identice ca structură, dar cu ponderi diferite.
  3. După ultimul bloc, o normalizare finală pregătește vectorii pentru ieșire.
  4. Un strat liniar transformă vectorul ultimului token într-un scor pentru fiecare token din vocabular, iar softmax face din aceste scoruri probabilități.
MărimeSimbolSmolLM2 135M
Mărimea vocabularuluiVV49.152
Dimensiunea modeluluidd576
Numărul de blocuriNN30
Capete de interogarehh9
Perechi de chei și valorihkvh_{\text{kv}}3
Dimensiunea unui capdheadd_{\text{head}}64
Stratul ascuns al rețelei feed-forwarddffd_{\text{ff}}1.536
Fereastra de contextnmax⁡n_{\max}8.192

Fiecare token are un vector hh de dimensiune dd, care trece prin toate blocurile. O componentă nu înlocuiește vectorul, ci citește o versiune normalizată a vectorului și îi adaugă rezultatul.

Pentru curioșiFormula unui bloc
h←h+Attn⁡(RMSNorm⁡(h))h \leftarrow h + \operatorname{Attn}(\operatorname{RMSNorm}(h))h←h+FFN⁡(RMSNorm⁡(h))h \leftarrow h + \operatorname{FFN}(\operatorname{RMSNorm}(h))

unde Attn⁡\operatorname{Attn} este atenția, FFN⁡\operatorname{FFN} este rețeaua feed-forward, iar săgeata înseamnă că hh primește valoarea din dreapta.

Vectorul care se modifică astfel de la un bloc la altul se numește flux rezidual (residual stream). Fiecare componentă îi adaugă o corecție, iar componentele următoare citesc suma tuturor corecțiilor de până atunci.

Față de articolul din 2017, normalizarea s-a mutat înaintea componentei. Varianta numită pre-normalizare (pre-norm) lasă calea directă de la intrare la ieșire fără nicio normalizare, iar gradienții ajung mai ușor la primele straturi. Astfel, stivele adânci se antrenează mai stabil, după cum arată analiza lui Xiong și a colaboratorilor din 2020.

Normalizarea folosită este RMSNorm (root mean square normalization), propusă în 2019 de Zhang și Sennrich.

Vectorul xx este împărțit la rădăcina medie pătratică a componentelor lui xx, apoi fiecare componentă este înmulțită cu ponderea corespunzătoare din vectorul învățat gg.

Pentru curioșiFormula RMSNorm
RMSNorm⁡(x)=x1d∑i=1dxi2+ε⊙g\operatorname{RMSNorm}(x) = \frac{x}{\sqrt{\frac{1}{d} \sum_{i=1}^{d} x_i^2 + \varepsilon}} \odot g

Simbolul ⊙\odot înseamnă înmulțire element cu element, iar ε\varepsilon este o constantă mică, 10−510^{-5} la SmolLM2, care evită împărțirea la zero.

Față de normalizarea pe strat din 2017, RMSNorm nu scade media și nu are bias. Calculul este mai simplu, iar rezultatele sunt comparabile.

Atenția din fiecare bloc este cea descrisă pe pagina despre articolul din 2017, cu interogări, chei și valori, produs scalar scalat, softmax și masca cauzală. Diferența apare la numărul de chei și valori.

În atenția clasică cu capete multiple (multi-head attention), fiecare dintre cele hh capete are propriile proiecții pentru interogări, chei și valori. În atenția cu interogări grupate (grouped-query attention), descrisă de Ainslie și colaboratorii în 2023, capetele de interogare sunt împărțite în hkvh_{\text{kv}} grupuri, iar capetele dintr-un grup folosesc în comun aceleași chei și valori.

La SmolLM2, cele 9 capete de interogare formează 3 grupuri de câte 3. Matricea WQW^Q are dimensiunea 576×576576 \times 576, iar WKW^K și WVW^V au doar 576×192576 \times 192, adică 3 capete de câte 64 de valori. Calitatea scade foarte puțin, dar cheile și valorile păstrate la generare ocupă de 3 ori mai puțină memorie. Cele două extreme sunt atenția clasică (hkv=hh_{\text{kv}} = h) și atenția cu o singură interogare comună (multi-query attention, hkv=1h_{\text{kv}} = 1), propusă de Shazeer în 2019.

Modelul din 2017 aduna o codificare pozițională la reprezentările vectoriale, o singură dată, la intrare. Codificarea pozițională rotativă (rotary position embedding, RoPE), propusă de Su și colaboratorii în 2021, codifică poziția direct în fiecare strat de atenție, prin rotirea vectorilor de interogare și de cheie.

Componentele unui vector sunt grupate în perechi. Pentru tokenul de pe poziția mm, fiecare pereche ii este rotită în propriul plan cu unghiul mθim \theta_i.

Pentru curioșiFormula rotirii

Pentru vectorul de interogare qq, rotirea perechii ii este o înmulțire cu o matrice de rotație. Cheile se rotesc la fel.

(q2i′q2i+1′)=(cos⁡mθi−sin⁡mθisin⁡mθicos⁡mθi)(q2iq2i+1)\begin{pmatrix} q'_{2i} \\ q'_{2i+1} \end{pmatrix} = \begin{pmatrix} \cos m\theta_i & -\sin m\theta_i \\ \sin m\theta_i & \cos m\theta_i \end{pmatrix} \begin{pmatrix} q_{2i} \\ q_{2i+1} \end{pmatrix}θi=b−2i/dhead\theta_i = b^{-2i / d_{\text{head}}}

Baza bb era 10.000 în articolul original. SmolLM2 folosește 100.000.

Primele perechi se rotesc repede de la o poziție la alta, iar ultimele foarte încet, ca acele unui ceas. Implementările diferă prin felul în care grupează componentele în perechi, dar principiul este același.

Proprietatea importantă apare în produsul scalar dintre o interogare de pe poziția mm și o cheie de pe poziția nn. Rotirea cu unghiul mθim\theta_i și rotirea cu nθin\theta_i se combină într-o singură rotire cu (n−m)θi(n - m)\theta_i, așa că scorul de atenție depinde doar de distanța dintre tokenuri, nu de pozițiile absolute. Valorile nu sunt rotite, deci informația transmisă rămâne neschimbată.

Rețeaua feed-forward din fiecare bloc folosește o variantă cu poartă, numită SwiGLU, studiată de Shazeer în 2020.

Pentru curioșiFormula SwiGLU
FFN⁡(x)=(SiLU⁡(xWgate)⊙xWup)Wdown\operatorname{FFN}(x) = \big(\operatorname{SiLU}(x W_{\text{gate}}) \odot x W_{\text{up}}\big) W_{\text{down}}SiLU⁡(z)=z⋅σ(z)\operatorname{SiLU}(z) = z \cdot \sigma(z)

unde σ\sigma este funcția sigmoidă.

Vectorul xx este proiectat de două ori în dimensiunea dffd_{\text{ff}}. O proiecție trece prin SiLU și devine o „poartă”, care decide cât din cealaltă proiecție trece mai departe. Rezultatul este proiectat înapoi în dimensiunea dd prin WdownW_{\text{down}}.

Sunt trei matrice în loc de două, așa că dffd_{\text{ff}} se alege de obicei în jur de 83d\frac{8}{3} d, pentru ca numărul de parametri să rămână apropiat de cel al rețelei clasice cu dff=4dd_{\text{ff}} = 4d. La SmolLM2, dff=1.536=83⋅576d_{\text{ff}} = 1.536 = \frac{8}{3} \cdot 576. Ca la multe modele actuale, niciun strat liniar nu are bias. Rețeaua feed-forward conține aproximativ trei sferturi din parametrii unui bloc.

După ultimul bloc, vectorul trece prin RMSNorm-ul final și apoi printr-un strat liniar care dă câte un scor pentru fiecare token din vocabular.

Pentru curioșiFormula stratului de ieșire
z=h E⊤z = h\, E^\top

unde hh este vectorul tokenului după RMSNorm-ul final, iar zz conține câte un scor pentru fiecare token din vocabular.

La SmolLM2, acest strat folosește chiar matricea de reprezentări vectoriale EE de la intrare, transpusă. Ponderile sunt legate (tied embeddings), ceea ce economisește aproximativ 28 de milioane de parametri. Scorurile zz trec apoi prin softmax, ca în secțiunea despre generarea textului.

Codul de mai jos numără parametrii modelului SmolLM2 135M pornind doar de la valorile din configurația modelului.

# Configurația publică a modelului SmolLM2-135M-Instruct (config.json).
vocab_size = 49152
d_model = 576
n_layers = 30
n_heads = 9
n_kv_heads = 3
d_head = d_model // n_heads # 64
d_ff = 1536
embeddings = vocab_size * d_model
# W_Q și W_O au h capete, W_K și W_V doar h_kv capete.
attention = 2 * d_model * n_heads * d_head + 2 * d_model * n_kv_heads * d_head
feed_forward = 3 * d_model * d_ff # W_gate, W_up, W_down
norms = 2 * d_model # două RMSNorm în fiecare bloc
block = attention + feed_forward + norms
total = embeddings + n_layers * block + d_model # plus RMSNorm-ul final
print(f"Reprezentări vectoriale: {embeddings:,}")
print(f"Un bloc: {block:,} (atenție {attention:,}, feed-forward {feed_forward:,})")
print(f"Total: {total:,} parametri")
print(f"Partea reprezentărilor vectoriale: {embeddings / total:.1%}")

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

Rezultatul, 134.515.008 parametri, explică numele „135M”. La un model atât de mic, tabelul de reprezentări vectoriale are aproximativ o cincime din parametri. La modelele de zeci de miliarde de parametri, partea tabelului devine mică, pentru că vocabularul crește mult mai încet decât restul modelului.

La antrenare, toată secvența este prelucrată deodată. Datorită măștii cauzale, fiecare poziție vede doar tokenurile anterioare, așa că o secvență de nn tokenuri dă nn predicții calculate în paralel, una pentru fiecare token următor.

La inferență, adică la generarea textului, lucrurile se petrec în două faze. În faza de procesare a promptului (prefill), toate tokenurile primite sunt prelucrate deodată, ca la antrenare. În faza de decodare (decoding), modelul generează câte un singur token pe pas, iar fiecare token nou trece prin toate blocurile.

La fiecare pas de decodare, tokenul nou are nevoie de cheile și valorile tuturor tokenurilor anterioare, în fiecare strat. Datorită măștii cauzale, acestea nu se schimbă când apar tokenuri noi, așa că pot fi calculate o singură dată și păstrate. Memoria în care sunt păstrate se numește memorie cache pentru chei și valori (KV cache). Fără această memorie, fiecare pas ar recalcula tot contextul.

Memoria ocupată crește cu lungimea contextului nn.

Pentru curioșiFormula memoriei cache
M=2⋅N⋅hkv⋅dhead⋅n⋅bM = 2 \cdot N \cdot h_{\text{kv}} \cdot d_{\text{head}} \cdot n \cdot b

unde factorul 2 vine de la chei și valori, iar bb este numărul de octeți pentru o valoare, de exemplu 4 pentru numerele pe 32 de biți.

n_layers, n_heads, n_kv_heads, d_head = 30, 9, 3, 64
bytes_per_value = 4 # float32
per_token = 2 * n_layers * n_kv_heads * d_head # chei și valori, în toate straturile
print(f"Valori păstrate pentru fiecare token: {per_token:,}")
for n in [100, 1000, 8192]:
size = per_token * n * bytes_per_value
print(f"{n:>5} tokenuri: {size / 1e6:7.1f} MB")
without_gqa = 2 * n_layers * n_heads * d_head * 8192 * bytes_per_value
print(f"Fără interogări grupate, la 8192 de tokenuri: {without_gqa / 1e6:.1f} MB")

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

O estimare folosită des, de exemplu în studiul lui Kaplan și al colaboratorilor din 2020, spune că prelucrarea unui token costă aproximativ 2P2P operații în virgulă mobilă, unde PP este numărul de parametri, deoarece fiecare parametru participă la o înmulțire și la o adunare. Antrenarea costă aproximativ 6P6P operații pe token, pentru că include și calculul gradienților.

Pentru SmolLM2 135M, asta înseamnă circa 270 de milioane de operații pentru fiecare token generat. Antrenarea pe aproximativ 2.000 de miliarde de tokenuri a costat, după aceeași estimare, în jur de 1,6⋅10211{,}6 \cdot 10^{21} operații.

Estimarea ignoră atenția. Pentru un token nou, scorurile de atenție se calculează față de toate tokenurile anterioare, deci costul acestui pas crește liniar cu lungimea contextului. Pentru o secvență întreagă, costul atenției crește cu pătratul lungimii secvenței. De aceea, contextele foarte lungi sunt scumpe, iar unele modele limitează o parte din straturi la o fereastră locală de tokenuri.