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
  • Tokenització: de text a nombres
  • El bloc Transformer
  • Variants modernes
• Models de llenguatge grans (LLMs)
  • Preentrenament
  • Alineament i post-entrenament
  • Fine-tuning i adaptació
  • Prompting i aprenentatge en context
  • Models de raonament
  • Més enllà del text: multimodalitat i ús d’eines
• 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. Variants com LSTM i GRU hi van afegir “portes” que decideixen quina informació es reté o s’oblida, i van millorar la capacitat de recordar dependències llargues.

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, tendeixen a zero (vanishing gradient) o a infinit (exploding gradient), i el model no aprèn 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 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?”

Cada token obté la seva query, la seva key i el seu value multiplicant el seu vector per tres matrius de pesos que el model aprèn durant l’entrenament. A partir d’aquí, l’atenció es calcula així:

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

on:

• \(Q, K, V\): les matrius de queries, keys i values, amb una fila per token
• \(Q K^T\): el producte escalar entre cada query i cada key, és a dir, una puntuació de similitud per a cada parell de tokens
• \(d_k\): la mida dels vectors de key; dividir per \(\sqrt{d_k}\) evita que les puntuacions siguin tan grans que el softmax es saturi
• softmax: converteix cada fila de puntuacions en pesos que sumen 1

En resum, per a cada token la fórmula fa quatre passos: (1) compara la seva query amb totes les keys 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 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 token amb tots els altres. Amb \(n\) tokens són \(n \times n\) comparacions, i el cost computacional i de memòria creix amb \(O(n^2)\): duplicar la longitud quadruplica el cost. Aquesta limitació, juntament amb la memòria de la KV cache, condiciona la finestra de context d’un model: quants tokens pot processar de cop. Optimitzacions com FlashAttention han fet aquest càlcul molt més eficient. 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, la 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 les seves pròpies matrius de pesos. Cada operació s’anomena un cap (head), i els resultats de tots els caps es combinen al final. L’article original en feia servir 8; els models actuals en tenen desenes. Cada cap pot aprendre a “mirar” coses diferents: dependències sintàctiques properes, relacions semàntiques llunyanes, coreferències. El model decideix automàticament durant l’entrenament què captura cadascun.

Quan el model genera text, guarda les keys i els values dels tokens anteriors per no haver-los de recalcular a cada paraula nova. Aquesta memòria és la KV cache, i és la que decideix quantes peticions simultànies caben en una GPU. Per reduir-la, gairebé tots els models actuals fan que diversos caps comparteixin un mateix parell key/value (grouped-query attention, GQA). Requisits de maquinari en quantifica l’efecte.

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) assigna a cada posició un vector únic que el model pot usar per distingir l’ordre dels tokens i les distàncies entre ells. L’article original ho feia amb funcions sinusoïdals; la majoria de models actuals fan servir RoPE (Rotary Positional Embeddings), que codifica les posicions relatives amb rotacions dels vectors.

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” (Vaswani et al., 2017) 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ó. La innovació clau és substituir el processament seqüencial de les RNN per self-attention, que permet 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:

import tiktoken

tokenizer = tiktoken.get_encoding("cl100k_base")
tokens = tokenizer.encode("Les xarxes neuronals aprenen representacions")
print(tokens)
# [24641, 865, 277, 90774, 49384, 1147, 1469, 1466, 268, 4097, 582, 919]
print([tokenizer.decode([t]) for t in tokens])
# ['Les', ' x', 'ar', 'xes', ' neuron', 'als', ' ap', 'ren', 'en', ' represent', 'ac', 'ions']

Cinc paraules s’han convertit en dotze tokens. Només “Les” es manté sencera; la resta es divideixen en fragments, i alguns coincideixen amb paraules angleses (“ neuron“, “ represent“). El vocabulari s’ha construït sobretot amb text en anglès, i per això un text en català sol ocupar més tokens que el mateix contingut en anglès, cosa que es nota en el cost i en l’espai de context. 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:

1. 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.
2. 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. 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.
• Normalització de capa: reescala les activacions a cada pas perquè es mantinguin en un rang estable, cosa que fa l’entrenament més robust (vegeu la 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, perquè 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:

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. 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.

En un model decoder-only, la tasca és predir el següent token. Donada la seqüència “El gat va”, el model aprèn que “saltar”, “caure” o “córrer” són continuacions probables. L’error es mesura amb la cross-entropy: com més probabilitat assigna el model al token que realment ve a continuació, menor és l’error. Els models encoder com BERT s’entrenen diferent: s’amaguen paraules a l’atzar (“El [MASK] va saltar la tanca”) i el model les ha d’endevinar mirant el context per les dues bandes.

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.

Tres eixos, no un. Durant uns anys “escalar” volia dir només això: més paràmetres i més dades de preentrenament. Avui se’n compten tres, i cadascun té la seva pròpia corba de millora. El preentrenament és el que acabem de descriure. El post-entrenament és l’esforç invertit a alinear i especialitzar el model un cop preentrenat, que veurem a la secció següent. I el còmput en temps d’inferència consisteix a deixar que el model dediqui més estona a pensar cada pregunta concreta, que és la idea dels models de raonament. Les millores dels darrers models venen sobretot dels dos últims eixos, perquè el primer topa amb el cost de l’entrenament i amb la quantitat de text de qualitat que existeix al món.

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). Els models de frontera anuncien finestres de l’ordre de milions de tokens, i la xifra puja a cada generació. 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. Si li escrius una pregunta, pot continuar-la amb més preguntes en lloc de respondre-la, generar informació falsa amb confiança o seguir instruccions nocives. Aquest model base és un simple predictor de text. La fase de post-entrenament el converteix en l’assistent conversacional que després podrem instruir amb prompts, i l’objectiu d’aquest procés, que el model sigui útil, honest i segur, s’anomena alineament (alignment).

El post-entrenament sol tenir tres etapes:

1. Fine-tuning supervisat (SFT): el model s’entrena amb milers de diàlegs d’alta qualitat escrits per humans. Aprèn el format d’una resposta d’assistent.
2. Preferències humanes: avaluadors humans comparen parelles de respostes i indiquen quina és millor. El model s’ajusta per produir més sovint les preferides. La tècnica clàssica és RLHF (Reinforcement Learning from Human Feedback), que entrena un model de recompensa i optimitza el LLM amb reinforcement learning. DPO (Direct Preference Optimization) arriba a un resultat similar sense reinforcement learning, i per això és més senzill i estable.
3. Recompenses verificables (RLVR): per a tasques on la resposta es pot comprovar automàticament, com un problema de matemàtiques amb solució coneguda o un codi que ha de passar uns tests, no cal cap avaluador humà. El model prova de resoldre milers de problemes i rep recompensa només quan el resultat és correcte. És la tècnica que ha fet possibles els models de raonament.

Preentrenament → SFT              → Preferències humanes → Recompenses verificables
(text massiu)    (diàlegs humans)   (RLHF o DPO)           (RLVR)
Prediu text      Aprèn el format    Aprèn què es prefereix Aprèn a resoldre problemes

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), vegeu 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è el canvi necessari per adaptar el model és molt més simple que el model sencer, i el nombre de paràmetres entrenables passa de milers de milions a uns pocs milions.

QLoRA combina LoRA amb quantització del model base a 4 bits, i permet fer fine-tuning de models de desenes de milers de milions de 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 Disseny de prompts.

Models de raonament

Els models de raonament (reasoning models) s’han consolidat com una de les categories principals i 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.

S’entrenen amb les recompenses verificables descrites a l’alineament: el model no aprèn a raonar copiant exemples humans, sinó perquè els raonaments que porten a la resposta correcta són els que reben recompensa. DeepSeek-R1 va demostrar que la tècnica funcionava també en un model de pesos oberts, i avui és una capacitat present tant als models comercials com als open weights.

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: per a tasques on la resposta depèn d’una cadena de passos coherent (matemàtiques, lògica, codi amb moltes restriccions), no per a respostes directes ni quan la latència i el cost són crítics. Els criteris detallats i les regles de prompting 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: els models de frontera actuals processen 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. Així el model pot 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 existeix el MCP (Model Context Protocol), un protocol obert que s’ha convertit en l’estàndard de facto de l’ecosistema d’agents.

Referències

• Attention Is All You Need (Vaswani et al., 2017)
• Visualizing Attention, a Transformer’s Heart (3Blue1Brown)
• Transformer Explainer (Polo Club of Data Science)