Transformers i Models de Llenguatge

• Del processament seqüencial a l’atenció
  • El problema de les seqüències
  • La intuïció de l’atenció
• El mecanisme d’atenció
  • Queries, Keys i Values
  • Multi-Head Attention
  • Codificació posicional
• L’arquitectura Transformer
  • Bloc Encoder i Decoder
    • L’Encoder
    • El Decoder
  • Variants modernes
• Models de Llenguatge Grans (LLMs)
  • Tokenització: de text a nombres
  • Preentrenament
  • Fine-tuning i adaptació
  • Prompting i aprenentatge en context
  • Models de raonament
  • Alineament i post-entrenament
    • RLHF clàssic (SFT → Reward Model → PPO)
    • Entrenament per preferències sense RL (SFT → DPO)
  • Més enllà del text: multimodalitat i ús d’eines

Aquest document descriu com funcionen els models de llenguatge grans: les limitacions de les RNN que van motivar el mecanisme d’atenció, l’arquitectura transformer que en sorgeix, i com l’escalat d’aquesta arquitectura ha donat lloc als LLMs actuals amb les seves capacitats de tokenització, preentrenament, fine-tuning, prompting, raonament i alineament.

Del processament seqüencial a l’atenció

El problema de les seqüències

Moltes dades del món real són seqüencials: text (paraula rere paraula), àudio (mostra rere mostra), sèries temporals (valor rere valor). Les xarxes neuronals totalment connectades (MLP) no capturen l’ordre de les entrades — si barreges les paraules d’una frase, el MLP processa exactament els mateixos valors.

Per resoldre aquest problema, als anys 80-90 es van desenvolupar les xarxes neuronals recurrents (RNN). La idea central és senzilla: processar la seqüència element per element, mantenint un estat ocult (hidden state) que actua com a “memòria” del que s’ha vist fins ara. En cada pas temporal \(t\), una RNN calcula:

\[ h_t = f(W_h \cdot h_{t-1} + W_x \cdot x_t + b) \]

on \(h_t\) és l’estat ocult actual, \(h_{t-1}\) l’estat anterior i \(x_t\) l’entrada actual. Variants com LSTM (Long Short-Term Memory) i GRU (Gated Recurrent Unit) van millorar la capacitat de recordar dependències més llargues afegint mecanismes de “portes” que controlen quina informació es reté o s’oblida.

Però les RNN tenen tres problemes fonamentals:

1. Processament seqüencial: cada pas depèn de l’anterior, cosa que impedeix la paral·lelització. Entrenar amb seqüències llargues és molt lent perquè no podem aprofitar les GPU eficientment.

2. Coll d’ampolla de la informació: tota la informació de la seqüència s’ha de comprimir en un vector d’estat ocult de mida fixa. Per a seqüències llargues (un paràgraf, un document), les primeres paraules es “dilueixen” i es perden.

3. Desvaniment del gradient: durant l’entrenament amb backpropagation, els gradients es multipliquen repetidament a mesura que es propaguen cap enrere en el temps. Amb seqüències llargues, els gradients tendeixen a zero (vanishing gradient) o a infinit (exploding gradient), dificultant l’aprenentatge de dependències a llarg termini.

Aquestes limitacions van motivar la cerca d’un mecanisme que pogués accedir directament a qualsevol posició de la seqüència, sense haver de processar-la seqüencialment. Aquí entra el mecanisme d’atenció.

La intuïció de l’atenció

Quan llegeixes una frase com “El gat que va veure la Maria al jardí va saltar la tanca”, per entendre el verb “va saltar”, el teu cervell no processa tota la frase amb la mateixa intensitat. Hi centres l’atenció en “El gat” (el subjecte) molt més que en “la Maria” o “al jardí”.

El mecanisme d’atenció (attention) imita exactament aquest procés: per a cada element d’una seqüència, calcula quant de rellevants són tots els altres elements. Això produeix un conjunt de pesos d’atenció — valors entre 0 i 1 que indiquen quanta “atenció” s’ha de prestar a cada posició.

Avantatges clau respecte les RNN:

• Accés directe: qualsevol posició pot “mirar” directament qualsevol altra posició, sense importar la distància
• Paral·lelització: tots els càlculs d’atenció es poden fer simultàniament
• Dependències llargues: no hi ha pèrdua d’informació per compressió en un estat fix

El mecanisme d’atenció

Ja hem vist la intuïció: cada token ha de poder “decidir” a quins altres tokens prestar atenció. Ara veurem com es tradueix aquesta idea en operacions matemàtiques concretes.

Queries, Keys i Values

El mecanisme d’atenció implementa la intuïció anterior amb tres conceptes: Query (Q), Key (K) i Value (V). Per entendre’ls, pensem en una analogia amb un motor de cerca:

• Query (consulta): és la pregunta que fem — “què estic buscant?”
• Key (clau): és l’etiqueta de cada element — “què ofereixo?”
• Value (valor): és el contingut real de cada element — “quina informació tinc?”

El procés és:

1. Comparem la Query amb totes les Keys per obtenir puntuacions de similitud
2. Normalitzem les puntuacions amb softmax per obtenir pesos d’atenció
3. Fem una suma ponderada dels Values amb aquests pesos

Formalització matemàtica:

Donada una seqüència d’entrada \(X\) (una matriu on cada fila és un token), calculem Q, K i V mitjançant projeccions lineals amb matrius de pesos apreses:

\[ Q = X W_Q, \quad K = X W_K, \quad V = X W_V \]

on \(W_Q, W_K \in \mathbb{R}^{d_{model} \times d_k}\) i \(W_V \in \mathbb{R}^{d_{model} \times d_v}\) són paràmetres entrenables.

La scaled dot-product attention es calcula com:

\[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V \]

on:

• \(Q K^T\) calcula el producte escalar entre cada query i cada key (matriu de similituds)
• \(\sqrt{d_k}\) és un factor d’escala que evita que els productes escalars siguin massa grans (cosa que faria que el softmax saturés i produís gradients molt petits)
• \(\text{softmax}\) normalitza cada fila perquè els pesos sumin 1

Exemple pas a pas:

Considerem una seqüència de 3 tokens amb \(d_k = 4\). Suposem que ja hem calculat Q, K i V:

\[ Q = \begin{pmatrix} 1 & 0 & 1 & 0 \\ 0 & 1 & 0 & 1 \\ 1 & 1 & 0 & 0 \end{pmatrix}, \quad K = \begin{pmatrix} 1 & 1 & 0 & 0 \\ 0 & 0 & 1 & 1 \\ 1 & 0 & 1 & 0 \end{pmatrix}, \quad V = \begin{pmatrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \end{pmatrix} \]

Nota: \(d_v\) (dimensió dels values) pot ser diferent de \(d_k\). Aquí usem \(d_v = 2\) per simplicitat.

Pas 1: Calculem \(QK^T\) (producte escalar entre queries i keys):

\[ QK^T = \begin{pmatrix} 1 & 1 & 2 \\ 1 & 1 & 0 \\ 2 & 0 & 1 \end{pmatrix} \]

Per exemple, la posició (0,2) = 1·1 + 0·0 + 1·1 + 0·0 = 2, indicant alta similitud entre el token 0 (com a query) i el token 2 (com a key).

Pas 2: Dividim per \(\sqrt{d_k} = \sqrt{4} = 2\):

\[ \frac{QK^T}{\sqrt{d_k}} = \begin{pmatrix} 0.5 & 0.5 & 1.0 \\ 0.5 & 0.5 & 0.0 \\ 1.0 & 0.0 & 0.5 \end{pmatrix} \]

Pas 3: Apliquem softmax a cada fila per obtenir pesos d’atenció que sumen 1 (valors arrodonits a 2 decimals):

\[ \text{softmax} \approx \begin{pmatrix} 0.27 & 0.27 & 0.45 \\ 0.38 & 0.38 & 0.23 \\ 0.51 & 0.19 & 0.31 \end{pmatrix} \]

Observem que el token 0 presta més atenció al token 2 (pes 0.45), mentre que el token 1 distribueix l’atenció entre els tokens 0 i 1 (0.38 cadascun) i menys al token 2 (0.23).

Pas 4: Multipliquem la matriu de pesos d’atenció per \(V\) per obtenir la sortida. Calculem, per exemple, la primera fila (la representació de sortida del token 0):

\[ \text{sortida}_0 = 0.27 \cdot \begin{pmatrix} 1 \\ 2 \end{pmatrix} + 0.27 \cdot \begin{pmatrix} 3 \\ 4 \end{pmatrix} + 0.45 \cdot \begin{pmatrix} 5 \\ 6 \end{pmatrix} = \begin{pmatrix} 3.33 \\ 4.32 \end{pmatrix} \]

La sortida completa és:

\[ \text{Attention}(Q,K,V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right) V \approx \begin{pmatrix} 3.33 & 4.32 \\ 2.67 & 3.66 \\ 2.63 & 3.64 \end{pmatrix} \]

Observem que el token 0, que prestava més atenció al token 2 (pes 0.45), té una sortida més propera als values del token 2 (5, 6). Cada token rep una mitjana ponderada de tots els values, amb pesos proporcionals a la seva rellevància.

El cost de l’atenció: a l’exemple anterior, \(QK^T\) és una matriu \(3 \times 3\) (un token per fila i columna). Amb \(n\) tokens, aquesta matriu és \(n \times n\), de manera que el cost computacional i de memòria de self-attention és \(O(n^2)\). Per a seqüències curtes això no és un problema, però escala ràpidament: duplicar la longitud quadruplica el cost. Aquesta limitació és un dels factors principals (juntament amb la memòria de la KV cache i decisions d’enginyeria) pel qual els LLMs tenen finestres de context limitades (p.ex. 4K, 32K, 128K tokens) i ha motivat recerca en variants d’atenció eficient com sparse attention, linear attention o sliding window attention que redueixen el cost a \(O(n \log n)\) o \(O(n)\).

Multi-Head Attention

Una sola operació d’atenció captura un tipus de relació entre tokens (per exemple, relació gramatical subjecte-verb). Però el llenguatge té múltiples tipus de relacions simultànies: sintàctiques, semàntiques, de coreferència…

La solució és executar múltiples operacions d’atenció en paral·lel, cadascuna amb els seus propis pesos \(W_Q^i, W_K^i, W_V^i\). Cada operació s’anomena un cap (head):

\[ \text{head}_i = \text{Attention}(Q W_Q^i, K W_K^i, V W_V^i) \]

Els resultats de tots els caps es concatenen i es projecten amb una matriu addicional:

\[ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W_O \]

on \(h\) és el nombre de caps (típicament 8 o 16) i \(W_O\) és la matriu de projecció de sortida.

Cada cap pot aprendre a “mirar” coses diferents: un cap pot capturar dependències sintàctiques properes, un altre relacions semàntiques llunyanes, un altre coreferències… El model decideix automàticament durant l’entrenament què captura cada cap.

Codificació posicional

El mecanisme d’atenció tracta la seqüència com un conjunt — si intercanviem l’ordre dels tokens, els productes escalars \(QK^T\) no canvien. Però l’ordre és crucial: “el gat persegueix el gos” i “el gos persegueix el gat” tenen significats molt diferents.

Per resoldre-ho, afegim informació sobre la posició de cada token directament a la seva representació. La codificació posicional (positional encoding) suma un vector de posició a cada embedding de token.

L’article original “Attention Is All You Need” (Vaswani et al., 2017) utilitza funcions sinusoïdals per generar aquests vectors. La idea clau és que cada dimensió del vector de posició oscil·la a una freqüència diferent, cosa que permet al model aprendre a interpretar tant posicions absolutes com distàncies relatives entre tokens. No cal memoritzar les fórmules — l’important és entendre per què cal codificar posicions i què fan: assignen a cada posició un vector únic que el model pot usar per distingir l’ordre dels tokens.

📝 Referència: les fórmules originals de la codificació sinusoïdal són \(PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d_{model}})\) i \(PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d_{model}})\), on \(pos\) és la posició i \(i\) la dimensió.

Alternatives modernes: molts models actuals utilitzen codificacions posicionals apreses (vectors entrenables per a cada posició) o RoPE (Rotary Positional Embeddings), que codifica posicions relatives mitjançant rotacions en l’espai vectorial. RoPE és l’estàndard en models com LLaMA i la majoria d’LLMs moderns.

L’arquitectura Transformer

Ara que entenem el mecanisme d’atenció i els seus components (Q/K/V, multi-head, codificació posicional), veiem com s’integren en una arquitectura completa.

L’article “Attention Is All You Need” va proposar el Transformer, una arquitectura que elimina la recurrència i basa el modelatge de dependències entre tokens en el mecanisme d’atenció. L’arquitectura també inclou components essencials com xarxes feed-forward (FFN), connexions residuals i normalització de capes, però la innovació clau és substituir el processament seqüencial de les RNN per self-attention, permetent paral·lelització completa i accés directe entre qualsevol parell de posicions.

Bloc Encoder i Decoder

L’arquitectura original del Transformer té dues parts: un encoder que processa la seqüència d’entrada i un decoder que genera la seqüència de sortida.

L’Encoder

L’encoder està format per una pila de blocs idèntics (típicament 6 o 12). Cada bloc conté:

1. Multi-Head Self-Attention: cada token de l’entrada calcula atenció sobre tots els altres tokens de la mateixa seqüència
2. Feed-Forward Network (FFN): una xarxa MLP de dues capes aplicada independentment a cada posició
3. Connexions residuals: la sortida de cada subcapa se suma a la seva entrada (\(output = sublayer(x) + x\)), facilitant l’entrenament de xarxes profundes
4. Layer Normalization: normalitza les activacions per estabilitzar l’entrenament (veure metodologia pràctica per més detalls)

Input Embeddings + Positional Encoding
        │
        ▼
┌────────────────────────┐
│  Multi-Head Attention  │◄── Self-Attention
│  Add & LayerNorm       │◄── Connexió residual
│  Feed-Forward (FFN)    │
│  Add & LayerNorm       │◄── Connexió residual
└────────────────────────┘
        │
        ▼ (repetir N vegades)
        │
    Encoder Output

El Decoder

El decoder també és una pila de blocs, però cada bloc té una capa addicional:

1. Masked Multi-Head Self-Attention: igual que a l’encoder, però amb una màscara que impedeix que cada posició “vegi” tokens futurs. Això és essencial perquè durant la generació, el model ha de predir el següent token basant-se només en els anteriors.

2. Multi-Head Cross-Attention: les queries venen del decoder, però les keys i values venen de la sortida de l’encoder. Això permet al decoder “mirar” l’entrada original quan genera cada token de sortida. Per exemple, en una traducció de català a anglès, quan el decoder està generant la paraula “cat”, la seva query busca entre les keys de l’encoder i assigna un pes alt al token “gat” de l’entrada original — el mecanisme d’atenció “connecta” automàticament cada paraula generada amb les parts rellevants de la frase font.

3. Feed-Forward Network + residuals + LayerNorm: igual que a l’encoder.

Output Embeddings + Positional Encoding
        │
        ▼
┌─────────────────────────────┐
│  Masked Multi-Head Attention│◄── Self-Attention (mascarada)
│  Add & LayerNorm            │
│  Multi-Head Attention       │◄── Cross-Attention (amb encoder)
│  Add & LayerNorm            │
│  Feed-Forward (FFN)         │
│  Add & LayerNorm            │
└─────────────────────────────┘
        │
        ▼ (repetir N vegades)
        │
    Linear + Softmax → Predicció

Variants modernes

L’arquitectura original encoder-decoder es va dissenyar per a traducció, però aviat es va descobrir que les seves parts eren útils per separat. Avui existeixen tres grans famílies:

Encoder-only (BERT): Processa tota la seqüència d’entrada bidireccionalment — cada token pot veure tots els altres. Excel·lent per a tasques on cal entendre text (classificació de sentiment, extracció d’entitats, cerca semàntica).

Decoder-only (GPT, LLaMA, Claude): Processa la seqüència d’esquerra a dreta, generant un token a la vegada. L’atenció està mascarada perquè cada token només veu els anteriors. Dominant en generació de text i raonament. Amb escalat suficient de dades i paràmetres, els models decoder-only s’han convertit en l’arquitectura estàndard per als LLMs.

Encoder-Decoder (T5): Combina ambdós. L’encoder processa l’entrada i el decoder genera la sortida condicionada en la representació de l’encoder. Ideal per a tasques on l’entrada i la sortida són seqüències diferents (traducció, resum).

A banda de les tres famílies anteriors, hi ha tècniques arquitectòniques que es poden combinar amb qualsevol d’elles:

Mixture of Experts (MoE): una tècnica cada cop més estesa (Mixtral, DeepSeek, i sovint atribuïda a models com GPT-4) on el model conté múltiples sub-xarxes FFN (experts) per capa, però només n’activa unes poques per a cada token. Això permet tenir models amb molts paràmetres (i per tant més capacitat) sense el cost computacional proporcional — un model MoE de 400B paràmetres pot tenir un cost d’inferència similar a un model dens de 70B.

Models de Llenguatge Grans (LLMs)

L’arquitectura decoder-only, combinada amb l’escalat massiu de dades i paràmetres, ha donat lloc als Large Language Models (LLMs). La idea fonamental és senzilla: un model que prediu el següent token d’una seqüència acaba aprenent una representació rica del llenguatge — gramàtica, fets, raonament — com a efecte secundari d’aquesta tasca de predicció.

Tokenització: de text a nombres

📝 Nota: tot i que presentem la tokenització aquí en el context dels LLMs, és un pas previ per a qualsevol model transformer (BERT, T5, etc.).

Abans d’entrar al model, el text s’ha de convertir en una seqüència de nombres enters. Aquest procés s’anomena tokenització. Un token no és necessàriament una paraula sencera — els models moderns utilitzen algorismes de tokenització per subparaules que divideixen el text en fragments freqüents.

Per què no paraules senceres? Perquè un vocabulari de paraules completes seria enorme (milions d’entrades) i no podria gestionar paraules noves o rares. Amb subparaules, un vocabulari de 30.000-100.000 tokens pot representar qualsevol text.

Algorismes principals:

• BPE (Byte-Pair Encoding): comença amb caràcters individuals i fusiona iterativament els parells més freqüents. Els models GPT utilitzen variants de BPE a nivell de bytes.
• WordPiece: similar a BPE però selecciona fusions que maximitzen la probabilitat del corpus. Usat per BERT. Els fragments no inicials es marquen amb ## (p.ex. “running” → ["run", "##ning"]).
• SentencePiece: opera directament sobre text sense preprocessament (sense separar per espais), útil per a llengües sense espais com el japonès o xinès.

Exemple pràctic:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-multilingual-cased")
tokens = tokenizer.tokenize("Les xarxes neuronals aprenen representacions")
print(tokens)
# ['Les', 'xa', '##rx', '##es', 'neuro', '##nal', '##s', 'aprenen', 'represent', '##acions']

Observem que paraules menys freqüents com “xarxes” es divideixen en subparaules, mentre que paraules comunes com “aprenen” es mantenen senceres. Cada token es mapeja a un índex enter del vocabulari, i aquest índex es converteix en un embedding (vector numèric) que és l’entrada real al transformer.

Preentrenament

El preentrenament és la fase on el model aprèn representacions generals del llenguatge a partir de grans volums de text no etiquetat. És un procés auto-supervisat: les etiquetes es generen automàticament a partir del propi text.

Next-token prediction (models decoder-only, p.ex. GPT):

Donat un text, el model aprèn a predir la pròxima paraula (token). Per exemple, donada la seqüència “El gat va”, el model aprèn que “saltar”, “caure” o “córrer” són continuacions probables.

La funció de pèrdua és la cross-entropy entre la distribució predita i el token real:

\[ \mathcal{L} = -\sum_{t=1}^{T} \log P(x_t | x_1, \dots, x_{t-1}) \]

Masked Language Modeling (models encoder-only, p.ex. BERT):

S’amaguen aleatòriament el 15% dels tokens i el model ha de predir-los a partir del context circundant (bidireccional). Per exemple: “El [MASK] va saltar la tanca” → el model prediu “gat”.

L’escala importa: els LLMs moderns s’entrenen amb bilions de tokens de text i tenen centenars de milers de milions de paràmetres. Les lleis d’escala (scaling laws) mostren que el rendiment del model millora de forma previsible amb més dades, més paràmetres i més computació, sense saturar-se de manera ràpida. Això ha motivat la cursa per construir models cada cop més grans.

Fine-tuning i adaptació

Un model preentrenat té coneixement general del llenguatge, però pot no ser prou bo per a una tasca específica. El fine-tuning adapta el model a un domini o tasca concreta amb un dataset més petit i específic.

📝 Nota: Per una visió general de transfer learning i les estratègies d’aplicació (feature extraction, fine-tuning, gradual unfreezing), consulta la Metodologia pràctica.

Fine-tuning complet: es reentrenen tots els paràmetres del model amb dades de la tasca objectiu i un learning rate petit. Requereix molta memòria GPU perquè cal emmagatzemar els gradients de tots els paràmetres.

Fine-tuning eficient amb LoRA/QLoRA:

En lloc de modificar tots els paràmetres, LoRA (Low-Rank Adaptation) congela el model original i afegeix petites matrius entrenables a cada capa. La intuïció és senzilla: en lloc d’actualitzar una matriu enorme de milions de valors, actualitzem dues matrius petites el producte de les quals aproxima el canvi necessari. Això funciona perquè els canvis requerits per adaptar el model tenen un rang baix — es poden representar amb molts menys paràmetres que la matriu original.

Formalment, per a una capa amb matriu de pesos \(W \in \mathbb{R}^{d \times d}\), LoRA afegeix:

\[ W’ = W + \Delta W = W + BA \]

on \(B \in \mathbb{R}^{d \times r}\) i \(A \in \mathbb{R}^{r \times d}\) amb \(r \ll d\) (típicament \(r = 8\) o \(r = 16\)). Això redueix enormement el nombre de paràmetres entrenables (de milers de milions a milions).

QLoRA combina LoRA amb quantització del model base a 4 bits, permetent fer fine-tuning de models de 70B paràmetres en una sola GPU.

Prompting i aprenentatge en context

Una de les propietats més sorprenents dels LLMs és la seva capacitat d’aprendre en context (in-context learning): podem fer que el model realitzi tasques noves simplement descrivint-les al prompt, sense modificar cap pes.

Zero-shot: descrivim la tasca directament, sense exemples.

Classifica el sentiment del següent text com a "positiu", "negatiu" o "neutre":
Text: "El restaurant tenia una decoració preciosa però el menjar era fred i insípid."
Sentiment:

Few-shot: proporcionem alguns exemples abans de la tasca real.

Classifica el sentiment:
Text: "M'ha encantat la pel·lícula!" → positiu
Text: "No la tornaria a veure" → negatiu
Text: "Estava bé, res especial" → neutre
Text: "El concert va ser increïble, la millor nit de l'any!" →

Chain-of-Thought (CoT): demanem al model que “raoni pas a pas” abans de donar la resposta final. Aquesta tècnica és especialment útil en tasques de raonament matemàtic o lògic multi-pas i amb models grans, on pot millorar significativament la qualitat de la resposta. Tanmateix, el benefici no és universal: en tasques de classificació simple o amb models petits, CoT pot no aportar millora. En general, val la pena provar-ho en tasques que requereixin múltiples passos de raonament.

Pregunta: Si tinc 3 caixes amb 4 pomes cadascuna i en dono la meitat, quantes pomes em queden?
Raona pas a pas:
- 3 caixes × 4 pomes = 12 pomes en total
- La meitat de 12 = 6
- Em queden 6 pomes
Resposta: 6

Instruccions de sistema (system prompts): els LLMs moderns permeten definir un “rol” o context persistent que guia el comportament del model durant tota la conversa. Per exemple: “Ets un assistent expert en dret laboral català. Respon sempre en català i cita les lleis rellevants.”

Models de raonament

A partir de 2024-2025, una nova categoria ha guanyat rellevància: els models de raonament (reasoning models). A diferència dels models estàndard, que generen directament la resposta final, aquests models produeixen primer una cadena de pensament interna — un esborrany extens de raonament pas a pas que el model usa per arribar a la resposta però que habitualment no es mostra a l’usuari.

El referent OSS és DeepSeek-R1 (pesos públics sota Apache 2.0), entrenat amb GRPO — una variant de reinforcement learning sense supervisió humana directa — que va assolir resultats comparables als millors models comercials en benchmarks de raonament matemàtic i de codi. QwQ-32B de Qwen és una altra opció de pesos oberts que pot córrer en hardware accessible. Tots dos es poden desplegar amb vLLM o Ollama com qualsevol altre model. En l’àmbit comercial, models com o1/o3 (OpenAI) o el mode extended thinking de Claude segueixen el mateix paradigma però sense accés als pesos.

La idea subjacent a tots és la mateixa: dedicar còmput addicional a l’hora de la inferència (test-time compute) en lloc de requerir-lo tot durant l’entrenament.

Quan usar-los:

• Classificació, extracció, generació de text → model estàndard. Tasques on la resposta és directa i no requereix passos intermedis: classificar el sentiment d’una ressenya, extreure entitats d’un contracte, generar la descripció d’un producte. El model respon en un sol pas; un model de raonament generaria milers de tokens interns innecessaris per arribar a la mateixa resposta.

• Raonament matemàtic o lògic multi-pas → model de raonament. Tasques on la resposta correcta depèn d’una cadena de passos que cal mantenir coherents: resoldre un problema d’optimització, verificar la correcció d’un algorisme, combinar múltiples restriccions lògiques. Els models estàndard tendeixen a saltar-se passos o a cometre errors a meitat de la cadena sense detectar-los.

• Codi complex amb restriccions simultànies → model de raonament. Escriure codi que ha de satisfer múltiples requisits que interactuen (thread-safe i eficient en memòria i compatible amb una interfície concreta). Un model estàndard sovint genera codi que sembla correcte però viola una restricció; un model de raonament pot verificar la seva pròpia solució durant la generació.

• Latència crítica o cost baix → model estàndard. En aplicacions interactives (xat, autocompletat) o processos en lot d’alt volum, els models de raonament no són adequats: generen centenars o milers de tokens interns per petició, cosa que multiplica la latència i el cost respecte a un model estàndard.

Alineament i post-entrenament

Un LLM preentrenat és bo predient text, però no necessàriament és útil ni segur. Pot generar informació falsa amb confiança, reproduir biaixos presents a les dades d’entrenament, o seguir instruccions nocives. L’alineament (alignment) és el procés d’ajustar el model perquè sigui útil, honest i segur. Aquesta fase de post-entrenament és la que converteix un model base en un assistent conversacional.

Hi ha diversos mètodes per aconseguir-ho, tots partint de preferències humanes sobre quines respostes són millors:

RLHF clàssic (SFT → Reward Model → PPO)

1. SFT (Supervised Fine-Tuning): es fa fine-tuning del model preentrenat amb un dataset de diàlegs d’alta qualitat escrits per humans. Això ensenya al model el format de resposta desitjat.

2. Model de recompensa: avaluadors humans comparen parelles de respostes del model i indiquen quina és millor. Amb aquestes preferències s’entrena un model de recompensa que aprèn a puntuar respostes segons la qualitat percebuda pels humans.

3. Optimització per polítiques (PPO): s’utilitza PPO (Proximal Policy Optimization), un algoritme de reinforcement learning, per ajustar el model de manera que maximitzi la puntuació del model de recompensa, mantenint-se proper al model SFT per evitar comportaments degenerats.

Preentrenament         SFT              Reward Model            PPO
(text massiu) → (diàlegs humans) → (preferències humanes) → (optimització RL)
     │                  │                     │                     │
  Prediu text    Aprèn format         Aprèn a puntuar      Maximitza puntuació

Entrenament per preferències sense RL (SFT → DPO)

DPO (Direct Preference Optimization) és una alternativa que simplifica el procés eliminant tant el model de recompensa com l’entrenament per RL. A partir de les mateixes dades de preferències humanes, DPO optimitza directament el model de llenguatge amb una funció de pèrdua derivada analíticament. Això redueix la complexitat del pipeline i la inestabilitat típica de l’entrenament amb RL.

Preentrenament         SFT              DPO
(text massiu) → (diàlegs humans) → (preferències → optimització directa)
     │                  │                     │
  Prediu text    Aprèn format         Aprèn qualitat sense RL

DPO ha guanyat popularitat per la seva simplicitat, i variants com IPO o KTO continuen explorant maneres d’entrenar models a partir de preferències humanes sense la complexitat del reinforcement learning.

Més enllà del text: multimodalitat i ús d’eines

Els LLMs moderns han evolucionat significativament més enllà del processament de text pur.

Models multimodals: arquitectures com GPT-4o, Claude o Gemini poden processar text, imatges, àudio i vídeo dins del mateix model. L’enfocament més comú és afegir encoders específics per a cada modalitat (p.ex. un Vision Transformer que divideix la imatge en patches i els tracta com a “tokens” visuals) que converteixen l’entrada en representacions vectorials compatibles amb el transformer de text, tot i que les arquitectures concretes varien força (encoders externs, adaptadors, fusió tardana…). Això permet tasques com descriure imatges, analitzar gràfics, o respondre preguntes sobre documents amb figures.

Ús d’eines (tool use / function calling): una capacitat clau dels LLMs actuals és poder invocar eines externes — calculadores, APIs, bases de dades, intèrprets de codi — quan la tasca ho requereix. En lloc de respondre directament, el model genera una crida estructurada (p.ex. en JSON) que el sistema executa i retorna el resultat al model. Això compensa limitacions inherents dels LLMs (càlcul exacte, informació en temps real) i és la base dels agents d’IA, sistemes que combinen LLMs amb eines per resoldre tasques complexes de forma autònoma.