Transformers i Models de Llenguatge
- Del processament seqüencial a l’atenció
- El mecanisme d’atenció
- L’arquitectura Transformer
- Models de Llenguatge Grans (LLMs)
- Referències
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:
-
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.
-
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.
-
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:
- Comparem la Query amb totes les Keys per obtenir puntuacions de similitud
- Normalitzem les puntuacions amb softmax per obtenir pesos d’atenció
- 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
En resum, per a cada token la fórmula fa quatre passos: (1) compara la seva query amb totes les keys (\(QK^T\)) per obtenir una puntuació de similitud amb cada token; (2) divideix per \(\sqrt{d_k}\) perquè les puntuacions no saturin el softmax; (3) aplica softmax per fila perquè els pesos sumin 1; i (4) en fa una mitjana ponderada dels values. El resultat és que cada token rep una barreja dels values de tota la seqüència, dominada pels tokens que li són més rellevants.
El cost de l’atenció: el pas (1) compara cada query amb cada key, de manera que \(QK^T\) és una matriu amb un token per fila i per columna. Amb \(n\) tokens és, doncs, una matriu \(n \times n\), i 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ó, juntament amb la memòria de la KV cache i decisions d’enginyeria, condiciona la finestra de context d’un model: quants tokens pot processar de cop. Per això s’han buscat variants d’atenció eficient que redueixen el cost a \(O(n \log n)\) o \(O(n)\), i optimitzacions com FlashAttention. Fins on han arribat aquestes finestres ho veurem en parlar de l’escala dels LLMs.
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) ho fa amb funcions sinusoïdals de freqüència diferent a cada dimensió. 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, i en captar tant la posició absoluta com les distàncies relatives.
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.
L’arquitectura original tenia dues parts: un encoder, que llegeix tota la seqüència d’entrada i en construeix una representació, i un decoder, que genera la seqüència de sortida token a token a partir d’aquella representació. Tots dos s’apilen amb el mateix tipus de bloc que descriurem tot seguit; més endavant veurem que cada part es pot usar per separat, cosa que dóna lloc a les diferents famílies de models.
Tokenització: de text a nombres
Abans de res, cal convertir el text en alguna cosa que el model pugui processar. Un Transformer no rep paraules sinó vectors numèrics, i el primer pas per arribar-hi és la tokenització.
📝 Nota: la tokenització és un pas previ comú a qualsevol model transformer (BERT, T5, GPT…), no només als LLMs; la presentem aquí perquè és la porta d’entrada a l’arquitectura.
El text es converteix primer en una seqüència de nombres enters. 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.
La majoria d’algorismes parteixen de fragments petits i fusionen iterativament els més freqüents fins a arribar al vocabulari desitjat. Els principals són BPE (Byte-Pair Encoding, usat per GPT), WordPiece (usat per BERT) i SentencePiece (ú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. Finalment, cada token es mapeja a un índex enter del vocabulari, i aquest índex es converteix en un embedding (vector numèric): l’entrada real que alimenta els blocs que veurem tot seguit.
El bloc Transformer
Un Transformer és una pila de blocs idèntics (de 6 a desenes); tots tenen la mateixa estructura, així que entendre un sol bloc és entendre tota l’arquitectura.
La intuïció central és que cada bloc fa dues coses, sempre en aquest ordre:
- Comunicació (self-attention): els tokens es miren entre ells i cadascun recull informació dels altres segons la rellevància, amb el mecanisme Q/K/V que acabem de veure. És l’únic moment en què la informació viatja d’una posició a una altra.
- Còmput (feed-forward, FFN): tot seguit, cada token “pensa” pel seu compte. Una petita xarxa MLP transforma la informació que el token ha recollit — la mateixa xarxa per a totes les posicions, però aplicada de manera independent a cadascuna. Aquí no hi ha cap intercanvi entre tokens.
Repetir aquest parell comunica → computa desenes de vegades és el que dóna potència al model: les capes inicials tendeixen a capturar relacions locals i sintàctiques, i les profundes, relacions semàntiques i més abstractes.
Perquè una pila tan profunda es pugui entrenar, cada bloc embolcalla aquestes dues operacions amb dos elements de suport:
- Connexions residuals: en lloc de substituir la representació, cada subcapa hi suma el seu resultat (\(x \leftarrow x + \text{subcapa}(x)\)). Pensa-hi com un corrent d’informació que travessa tot el model i que cada bloc va refinant una mica; així s’evita que el senyal — i el gradient durant l’entrenament — es perdi en xarxes molt profundes.
- Layer Normalization: reescala les activacions a cada pas perquè es mantinguin en un rang estable, fent l’entrenament més robust (veure metodologia pràctica).
Embeddings + Positional Encoding
│
▼
┌─────────────────────────────┐
│ Multi-Head Self-Attention │◄── comunicació: els tokens es miren
│ Add & LayerNorm │◄── residual + normalització
│ Feed-Forward (FFN) │◄── còmput: cada token pensa pel seu compte
│ Add & LayerNorm │◄── residual + normalització
└─────────────────────────────┘
│
▼ (repetir N vegades)
│
Linear + Softmax → següent token
Què pot mirar cada token? En un LLM la self-attention és emmascarada (masked): cada token només pot mirar enrere, mai els tokens futurs. Aquesta restricció és justament el que permet generar text token a token — el model prediu el següent a partir només dels anteriors — i, com veurem tot seguit, és la diferència principal entre les grans famílies d’arquitectures.
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:
| Família | Arquitectura | Entrenament | Fortaleses | Exemples |
|---|---|---|---|---|
| Encoder-only | Només encoder | Masked Language Model (predicció de paraules amagades) | Comprensió, classificació, NER | BERT, RoBERTa |
| Decoder-only | Només decoder | Next-token prediction (predicció del següent token) | Generació de text, raonament | GPT, LLaMA, Claude |
| Encoder-Decoder | Ambdós | Objectius text-to-text o denoising (varia segons model) | Traducció, resum, Q&A | T5, BART |
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à emmascarada 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 estàndard entre els models de frontera 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.
📝 Els encoders no queden obsolets amb l’arribada dels LLMs. La resta del document se centra en els models decoder-only generatius, però els models encoder (classificació de sentiment, zero-shot, embeddings, reranking) continuen sent una eina de producció de primera classe: ràpids, barats i predictibles allà on un model generatiu seria lent i car. En molts sistemes són el graó barat des del qual els patrons de cascada i d’encaminament híbrid escalen cap al model generatiu només per als casos difícils. La distinció útil a l’hora de dissenyar no és “NLP contra generació”, perquè tots dos fan NLP, sinó encoder (llegeix i classifica) contra generatiu (escriu): són dues famílies amb perfils de cost i de capacitat diferents que sovint es combinen en un mateix sistema.
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ó.
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.
| Aspecte | Ordre de magnitud (LLMs moderns) |
|---|---|
| Paràmetres | 7B - 400B+ |
| Tokens d’entrenament | 1T - 15T+ |
| Cost d’entrenament | milions de $ en GPUs |
| Temps d’entrenament | setmanes - mesos |
L’escala també s’ha traslladat a la finestra de context (el límit de tokens que un model processa de cop, condicionat pel cost \(O(n^2)\) de l’atenció que vam veure abans). Cap a 2026 els models de frontera anuncien finestres molt grans: 128K, 200K, fins a 1M+ de tokens, i algun model obert arriba a desenes de milions. Però cal distingir el context anunciat del context efectiu. Benchmarks de recuperació a llarg context (RULER, MRCR, NoLiMa) mostren que la precisió per recuperar fets concrets cau notablement a partir de ~200K tokens, força abans del límit nominal.
Alineament i post-entrenament
Un LLM acabat de preentrenar é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 (un simple predictor de text) en l’assistent conversacional que després podrem instruir amb prompts.
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.
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. N’hi ha prou amb una instrucció:
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:
Sobre aquesta base s’ha desenvolupat tota una família de tècniques: afegir exemples resolts al prompt (few-shot), demanar al model que raoni pas a pas abans de respondre (chain-of-thought), o fixar un rol i unes regles persistents per a tota la conversa (instruccions de sistema, system prompts). Totes comparteixen el mateix principi: canviar el comportament del model canviant només el text d’entrada, sense tocar els pesos. El tractament complet d’aquestes tècniques, amb exemples i criteris d’ús de cadascuna, és a Prompts i integració.
Models de raonament
Apareguts cap a 2024-2025, els models de raonament (reasoning models) s’han consolidat com una de les categories principals i, cap a 2026, són l’opció per defecte per a tasques difícils. 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 de pesos oberts és DeepSeek-R1, entrenat amb reinforcement learning sense supervisió humana directa, que va assolir resultats comparables als millors models comercials en benchmarks de raonament matemàtic i de codi. En l’àmbit comercial, models com els de OpenAI, Google o Anthropic ofereixen modes de raonament que segueixen el mateix paradigma.
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: la regla pràctica és reservar-los per a tasques on la resposta correcta depèn d’una cadena de passos que cal mantenir coherent (raonament matemàtic o lògic multi-pas, codi amb restriccions simultànies que interactuen) i evitar-los quan la resposta és directa (classificació, extracció, generació simple) o quan la latència i el cost són crítics: generen centenars o milers de tokens interns per petició. Els criteris detallats i les regles de prompting específiques per a aquesta família de models són a Models de raonament i prompting.
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-5.x, 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 que converteixen l’entrada en representacions vectorials compatibles amb el transformer de text. Per exemple, un Vision Transformer divideix la imatge en patches i els tracta com a “tokens” visuals. Les arquitectures concretes varien força (encoders externs, adaptadors, fusió tardana…), però totes permeten 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. Per estandarditzar com els models es connecten a eines i fonts de dades externes, cap a 2024-2025 va sorgir el MCP (Model Context Protocol), que s’ha convertit en un estàndard de facto en l’ecosistema d’agents.