Contextul: de ce a fost nevoie de Transformers?
Înainte de 2017, modelele dominante pentru procesarea secvențelor (text, audio, video) erau RNN-urile (Recurrent Neural Networks) și varianta lor îmbunătățită, LSTM-urile (Long Short-Term Memory).
Problema fundamentală a RNN-urilor:
Cuvânt 1 → [RNN] → Cuvânt 2 → [RNN] → ... → Cuvânt N → [RNN] → Output
Fiecare pas depinde de pasul anterior — procesarea e secvențială. Nu poți paraleliza. Iar informația de la începutul secvenței se „diluează" pe măsură ce treci prin sute de pași.
Transformers au schimbat paradigma: în loc de procesare secvențială, toată secvența e procesată simultan, fiecare element „uitându-se" direct la orice alt element. Asta permite paralelizare masivă și capturarea dependențelor la distanțe oricât de mari.
Lucrarea „Attention Is All You Need" (Vaswani et al., Google Brain, 2017) a introdus arhitectura care a stat la baza GPT, BERT, T5, Claude, DeepSeek, Gemini, LLaMA și practic orice model AI modern.
1. Intuiția din spatele atenției
Imaginează-te traducând propoziția: „Animalul nu a traversat strada pentru că era obosit."
La cuvântul „era", mintea ta se întoarce automat la „animalul" (nu la „strada"). Știi că „era obosit" se referă la animal, nu la stradă. Atenția capturează exact aceasta: la procesarea fiecărui cuvânt, modelul determină cât de relevante sunt celelalte cuvinte din secvență.
Formal: Atenția e o funcție care mapează o interogare (query) la o sumă ponderată de valori (values), ponderile fiind determinate de similaritatea dintre query și un set de chei (keys).
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$
2. Scaled Dot-Product Attention — matematica completă
Reprezentările vectoriale
Fie o secvență de $n$ tokeni. Fiecare token $i$ este transformat în trei vectori:
- Query $q_i \in \mathbb{R}^{d_k}$ — „Ce caut?"
- Key $k_i \in \mathbb{R}^{d_k}$ — „Ce ofer?"
- Value $v_i \in \mathbb{R}^{d_v}$ — „Ce conținut furnizez?"
Aceștia se obțin prin proiecții liniare din reprezentarea tokenului $x_i \in \mathbb{R}^{d_{model}}$:
$$q_i = x_i W_Q, \quad k_i = x_i W_K, \quad v_i = x_i W_V$$
unde $W_Q, W_K \in \mathbb{R}^{d_{model} \times d_k}$ și $W_V \in \mathbb{R}^{d_{model} \times d_v}$.
Matricele Q, K, V
Grupăm toți tokenii:
$$Q = XW_Q \in \mathbb{R}^{n \times d_k}, \quad K = XW_K \in \mathbb{R}^{n \times d_k}, \quad V = XW_V \in \mathbb{R}^{n \times d_v}$$
Calculul atenției pas cu pas
Pas 1 — Scores: Calculăm similaritatea dot-product între fiecare pereche query-key:
$$\text{Scores} = QK^T \in \mathbb{R}^{n \times n}$$
$\text{Scores}_{ij}$ măsoară cât de mult ar trebui tokenul $i$ să acorde atenție tokenului $j$.
Pas 2 — Scalare: Împărțim la $\sqrt{d_k}$:
$$\text{Scores}_{\text{scaled}} = \frac{QK^T}{\sqrt{d_k}}$$
De ce $\sqrt{d_k}$? Cu $d_k = 64$ (tipic), produsul dot are varianță $d_k$. Fără scalare, valorile mari fac softmax-ul să satureze la zone cu gradient ≈ 0, blocând învățarea.
Pas 3 — Softmax (per rând): Transformăm scores în distribuție de probabilitate:
$$A_{i} = \text{softmax}\left(\frac{Q_i K^T}{\sqrt{d_k}}\right) \in \mathbb{R}^n, \quad \sum_j A_{ij} = 1$$
Pas 4 — Agregare: Fiecare token primește o sumă ponderată a valorilor:
$$\text{Output}i = \sum_j A{ij} V_j$$
Complet matricial:
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \in \mathbb{R}^{n \times d_v}$$
Vizualizare
„Animalul nu a traversat strada pentru că era obosit"
era → Query: [0.8, 0.2, ...]
Scores cu toți tokenii:
era ↔ Animalul: 0.72 ← HIGH
era ↔ nu: 0.05
era ↔ traversat: 0.08
era ↔ strada: 0.15 ← mai mic
After softmax: era „acordă atenție" 70% lui „Animalul"
3. Multi-Head Attention
O singură capăt de atenție e limitată — poate captura o singură relație. Multi-head attention rulează $h$ capete în paralel, fiecare cu propriile matrici $W_Q^i, W_K^i, W_V^i$:
$$\text{head}_i = \text{Attention}(QW_Q^i, KW_K^i, VW_V^i)$$
$$\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W_O$$
De ce mai multe capete?
Fiecare cap poate învăța să acorde atenție unor aspecte diferite:
- Cap 1: referințe pronominale (cine e „el/ea")
- Cap 2: relații sintactice (subiect-verb)
- Cap 3: relații semantice (sinonime, antonime)
- Cap 4: relații de distanță (la început vs la sfârșit)
Dimensiuni: Dacă $d_{model} = 512$ și $h = 8$ capete, atunci $d_k = d_v = 512/8 = 64$ per cap. Totalul de parametri e similar cu un singur cap de dimensiune 512.
Complexitate: $O(n^2 \cdot d_{model})$ — pătratică în lungimea secvenței. La $n = 1000$, avem $10^6$ operații per strat. Ăsta e bottleneck-ul principal al transformerilor.
4. Positional Encoding
Spre deosebire de RNN-uri, transformerul procesează toți tokenii simultan — nu există ordonare implicită. Trebuie să îi spunem explicit unde e fiecare token în secvență.
Sinusoidal Positional Encoding (original)
Adăugăm un vector de poziție $PE_{pos}$ la fiecare embedding:
$$PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$
$$PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$$
Proprietăți cheie:
- Dimensiunile cu indice mic capturează poziții locale (frecvențe înalte)
- Dimensiunile cu indice mare capturează poziții globale (frecvențe joase)
- Modelul poate generaliza la secvențe mai lungi decât cele văzute la antrenare
- $PE_{pos+k}$ poate fi exprimat ca transformare liniară a $PE_{pos}$ — modelul poate invăța să ragioneze relativ
Rotary Positional Embedding (RoPE) — varianta modernă
Folosit de LLaMA, DeepSeek, Qwen. În loc de adunare, aplică o rotație în spațiul complex:
$$q_m = f_q(x_m, m), \quad k_n = f_k(x_n, n)$$
$$\text{Re}[q_m \bar{k}_n] = |q||k|\cos(\theta_m - \theta_n)$$
Avantaj major: relativă implicit — atenția depinde de $m - n$ (distanța), nu de pozițiile absolute. Generalizează mai bine la context lung.
5. Arhitectura completă a unui bloc Transformer
Un bloc Transformer standard conține:
Input x
│
▼
┌──────────────────────────────┐
│ LayerNorm(x) │
│ │ │
│ Multi-Head Self-Attention │ + x (residual)
│ │ │
└───────┼──────────────────────┘
│
▼ y = x + Attention(LayerNorm(x))
│
┌──────────────────────────────┐
│ LayerNorm(y) │
│ │ │
│ Feed-Forward Network (FFN) │ + y (residual)
│ │ │
└───────┼──────────────────────┘
│
▼ Output
Feed-Forward Network (FFN)
$$\text{FFN}(x) = \max(0, xW_1 + b_1)W_2 + b_2$$
Sau cu activare SwiGLU (modern, DeepSeek, LLaMA):
$$\text{SwiGLU}(x, W, V, b) = \text{Swish}(xW + b) \odot (xV)$$
De ce FFN? Atenția e bună la agregarea informației de la diferiți tokeni. FFN-ul procesează tokenul individual, aplicând transformări non-liniare pentru „raționament" local.
Proporție tipică: $d_{ffn} = 4 \times d_{model}$. La $d_{model} = 4096$, FFN-ul are 16.384 neuroni — ~2/3 din parametrii totali ai modelului.
Residual connections și Layer Normalization
Residual connections (x + f(x)) rezolvă problema gradientului vanishing — gradientul poate circula direct prin skip connection fără să se atenueze.
Pre-LN vs Post-LN:
| Varianta | Formulă | Stabilitate | |---|---|---| | Post-LN (original) | $x = \text{LN}(x + f(x))$ | Instabilă la antrenare | | Pre-LN (modern) | $x = x + f(\text{LN}(x))$ | Stabilă, gradienți mai uniformi |
Toate modelele moderne (LLaMA, DeepSeek, Qwen) folosesc Pre-LN.
6. Encoder vs Decoder vs Encoder-Decoder
Există trei familii arhitecturale:
| Tip | Modele | Caracteristică | Folosit pentru | |---|---|---|---| | Encoder-only | BERT, RoBERTa | Atenție bidirecțională | Clasificare, NER, embeddings | | Decoder-only | GPT, LLaMA, DeepSeek | Atenție cauzală (masked) | Text generation, chat | | Encoder-Decoder | T5, BART | Cross-attention | Traducere, sumarizare |
Causal Masking (Decoder-only)
La decoder-only (GPT, LLaMA), tokenul $i$ poate vedea doar tokenii $\leq i$, nu și viitorii:
$$\text{Mask}_{ij} = \begin{cases} 0 & \text{dacă } j \leq i \ -\infty & \text{dacă } j > i \end{cases}$$
Adăugăm masca la scores:
$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}} + \text{Mask}\right)V$$
$-\infty$ face ca softmax să returneze 0 pentru tokenii viitori — modelul nu poate „trișa" uitându-se în viitor.
7. Antrenamentul: Next-Token Prediction
Obiectivul: La fiecare token din secvență, modelul trebuie să prezică tokenul următor.
Loss function: Cross-entropy între distribuția predicțiilor și tokenul real:
$$\mathcal{L} = -\frac{1}{T}\sum_{t=1}^{T} \log P_\theta(x_t | x_1, \dots, x_{t-1})$$
De ce funcționează? Această sarcină simplă îl obligă pe model să înțeleagă:
- Gramatică (pentru a prezice cuvintele corect gramatical)
- Factologie (pentru a prezice fapte corecte)
- Raționament (pentru a prezice concluzii logice)
- Stilul unui autor (pentru a continua un text în același stil)
Toată inteligența e emergentă din sarcina de a prezice tokeni.
Tokenizarea
Înainte de a antrena, textul trebuie convertit în tokeni numerici. Metoda standard: Byte-Pair Encoding (BPE).
"transformers" → ["trans", "form", "ers"] (subword tokenization)
BPE îmbină iterativ perechile de caractere/subword-uri cel mai frecvente, până ajunge la un vocabular de dimensiune fixă (tipic 32K-128K tokeni).
De ce nu cuvinte întregi? Cuvintele noi, tehnice sau în alte limbi ar fi OOV (out-of-vocabulary). BPE rezolvă asta — orice text poate fi tokenizat.
Scaling laws
Kaplan et al. (OpenAI, 2020) a descoperit că performanța modelului urmează legi de putere în funcție de parametri $N$, date $D$ și compute $C$:
$$\mathcal{L}(N) \sim N^{-\alpha_N}, \quad \mathcal{L}(D) \sim D^{-\alpha_D}$$
Chinchilla (DeepMind, 2022) a rafinat: pentru un buget de compute fix, modelul optim are $N$ parametri și $D = 20N$ tokeni de antrenare. GPT-4 și DeepSeek au urmat aceste legi în mod demonstrabil.
8. Emergent Capabilities
Un fenomen neașteptat: la anumite scări de parametri, apar capacități care nu existau la scale mai mici — fără să fie antrenate explicit:
| Capacitate | Apare la | |---|---| | In-context learning (câteva exemple → generalizare) | ~7B parametri | | Chain-of-thought reasoning | ~100B parametri | | Instrucțiuni complexe, multi-step | ~100B+ parametri | | Aritmetică de mai multe cifre | ~540B parametri |
Mecanismul exact rămâne necunoscut — interpretability e domeniul activ de cercetare care încearcă să înțeleagă ce se întâmplă în interiorul rețelei.
9. Limitele arhitecturii și soluțiile moderne
Problema O(n²)
Complexitatea atenției e $O(n^2)$ în memorie și $O(n^2 \cdot d)$ în compute. La $n = 128.000$ tokeni: $128.000^2 = 16.4$ miliarde de elemente.
Flash Attention (Dao et al., 2022):
Reformulare matematică care calculează atenția în blocuri, evitând materializarea matricei $n \times n$ în memorie:
- $O(n)$ memorie HBM în loc de $O(n^2)$
- ~3-6× mai rapid pe hardware real
- Standard în toți transformerii moderni
Grouped Query Attention (GQA):
În loc de $h$ perechi independente $(K, V)$, grupezi mai multe query-uri să împartă aceleași $K$ și $V$. Reduce KV cache cu 4-8×. Folosit de LLaMA 3, Gemini.
Multi-head Latent Attention (MLA):
Varianta DeepSeek — comprimă $K$ și $V$ într-un spațiu latent de dimensiune mică. KV cache redus cu ~75%. (Detalii în articolul Cum funcționează DeepSeek.)
Limitele fundamentale
-
Cunoaștere statică: Modelul știe ce era în datele de antrenare. Nu poate actualiza în timp real.
-
Halucinații: Generarea de text plauzibil statistic, chiar dacă incorect factual. Transformerul nu are un „senzor de adevăr" separat.
-
Raționament vs statistică: Există dezbateri active dacă transformerele chiar „raționează" sau fac recunoaștere de pattern la scară mare. (Benchmark-urile de olimpiadă matematică sugerează că raționamentul e real; bug-urile stupide sugerează altceva.)
-
Context window limitat: Chiar cu RoPE și Flash Attention, la sute de mii de tokeni performanța scade. Informația din mijlocul contextului e mai greu de recuperat decât de la capete.
Concluzie: De ce contează transformerul?
Transformerul e poate cel mai important progres în AI din ultimii 30 de ani. A înlocuit concomitent:
- RNN/LSTM pentru secvențe
- CNN pentru imagini (Vision Transformers)
- GAN pentru generare (Diffusion Transformers)
- Sisteme de reguli pentru NLP
Aproape orice sarcină cognitivă la care excelează AI-ul modern folosește, la bază, mecanismul de atenție descris în acest articol.
Dacă ai înțeles cum funcționează atenția, ai înțeles fundamentul pe care stau GPT-4, Claude, Gemini, DeepSeek, Stable Diffusion și Sora.
Referințe
- Vaswani, A. et al. Attention Is All You Need (NeurIPS, 2017) — lucrarea originală
- Devlin, J. et al. BERT: Pre-training of Deep Bidirectional Transformers (2018)
- Brown, T. et al. Language Models are Few-Shot Learners (GPT-3, 2020)
- Kaplan, J. et al. Scaling Laws for Neural Language Models (2020)
- Hoffmann, J. et al. Training Compute-Optimal Large Language Models (Chinchilla, 2022)
- Dao, T. et al. FlashAttention: Fast and Memory-Efficient Exact Attention (2022)
- Su, J. et al. RoFormer: Enhanced Transformer with Rotary Position Embedding (RoPE, 2021)
- Ainslie, J. et al. GQA: Training Generalized Multi-Query Transformer Models (2023)