Cómo funciona un LLM por dentro: de las matemáticas al siguiente token

Cuando le escribes a ChatGPT, Claude o Gemini parece que hay alguien pensando al otro lado. Pero por dentro solo hay sumas, multiplicaciones y una idea muy simple: adivinar la siguiente palabra. En este post vamos a abrir la caja negra sin dar nada por sabido: qué operaciones matemáticas hace, qué es un transformer, cómo se escala hasta convertirse en un LLM y, al final, haremos a mano todas las cuentas para que un modelo de juguete complete la frase "El gato come…".

La idea en una frase: predecir el siguiente token

Un LLM (Large Language Model, modelo de lenguaje grande) es, en esencia, el autocompletado del teclado del móvil llevado al extremo. Le das un texto y te devuelve una lista de probabilidades para lo que viene después. Elige una opción, la pega al final del texto y vuelve a empezar con el texto nuevo. Nada más.

Cuando ves que ChatGPT "escribe" palabra a palabra no es un efecto visual: está generando literalmente un token cada vez, y cada uno depende de todos los anteriores. Una respuesta de 500 palabras son unos cuantos cientos de vueltas del mismo cálculo.

Este es el viaje completo que hace una frase dentro del modelo, y que vamos a recorrer paso a paso:

Las únicas matemáticas que necesitas

Aquí viene la buena noticia: para entender un LLM no hace falta saber cálculo avanzado. Todo lo que hace durante una respuesta se reduce a cuatro ideas que se aprenden en el instituto.

1. Vectores. Un vector es simplemente una lista de números: [0.1, 0, 1, 0]. Sirve para describir algo con varias características a la vez, igual que describirías a una persona con [altura, edad, peso]. En un LLM, cada palabra se convierte en un vector.

2. La neurona: multiplicar, sumar y decidir. Una neurona recibe varios números, multiplica cada uno por un peso (lo importante que es esa entrada), lo suma todo, le añade un sesgo y pasa el resultado por una función de activación, que decide si "se enciende" o no. La más común, ReLU, es ridículamente simple: si el número es negativo lo convierte en 0 y si es positivo lo deja pasar.

Los pesos son los famosos parámetros del modelo. Cuando se dice que un modelo tiene 70.000 millones de parámetros, significa que tiene 70.000 millones de estos numeritos que se han ajustado durante el entrenamiento.

3. El producto escalar. Es la operación estrella. Coges dos vectores, multiplicas los componentes uno a uno y sumas los resultados. El número que sale te dice cuánto se parecen: si es grande apuntan en la misma dirección, si es 0 no tienen nada que ver y si es negativo son opuestos.

Fíjate en que la neurona de antes no es más que un producto escalar entre las entradas y los pesos. Esto se repite por todas partes: un LLM se pasa el día preguntando "¿cuánto se parece esto a aquello?".

4. Multiplicar por una matriz. Una matriz es una tabla de números. Multiplicar un vector por una matriz es hacer muchos productos escalares de golpe: uno por cada columna. Cada columna funciona como un "detector" y el resultado es un vector nuevo que dice cuánto se ha activado cada detector.

Un LLM es básicamente una cadena gigantesca de multiplicaciones de matrices. Por eso funcionan tan bien en las tarjetas gráficas: una GPU está diseñada precisamente para hacer millones de estas multiplicaciones en paralelo.

Bonus: softmax. Al final necesitamos convertir unas puntuaciones cualesquiera (que pueden ser negativas o enormes) en probabilidades que sumen 100%. Softmax lo hace en dos pasos: calcula e elevado a cada puntuación (así todo queda positivo y los grandes se hacen todavía más grandes) y divide cada resultado entre la suma total.

Y ya está. Con vectores, productos escalares, matrices y softmax tienes todas las herramientas. El resto es organizarlas bien, y eso es justo lo que hace el transformer.

Paso 1: de texto a números (tokenización)

Un ordenador no entiende letras, así que lo primero es trocear el texto en tokens y sustituir cada uno por un número. Un token puede ser una palabra entera, un trozo de palabra o un signo de puntuación. Las palabras frecuentes suelen ser un único token y las raras se parten en trozos.

Cada modelo tiene un vocabulario fijo, normalmente de entre 100.000 y 200.000 tokens, y cada token tiene su número de identificación. Curiosidad: por esto a veces los LLM fallan al contar las letras de una palabra. ¡No ven letras, ven trozos!

Paso 2: de números a significado (embeddings)

El número de un token no significa nada por sí solo: que "gato" sea el 34102 es tan arbitrario como el número de tu DNI. Así que el modelo tiene una tabla enorme, la tabla de embeddings, que asigna a cada token un vector de miles de números. Ese vector sí que representa su significado.

Lo mágico es que nadie escribe esos vectores a mano: se aprenden durante el entrenamiento, y las palabras que se usan en contextos parecidos acaban con vectores parecidos. Si pudiéramos dibujar ese espacio de miles de dimensiones en un plano veríamos algo así:

Las direcciones del espacio también tienen significado. El ejemplo clásico: si al vector de "rey" le restas el de "hombre" y le sumas el de "mujer", aterrizas muy cerca de "reina". Existe una dirección que codifica algo parecido a "femenino".

Falta un detalle: el orden. "El perro muerde al hombre" y "El hombre muerde al perro" tienen los mismos tokens, así que a cada vector se le añade información sobre su posición en la frase. En la práctica, se suma otro vector (o se aplica una rotación) que depende de la posición.

¿Qué es un transformer?

El transformer es la arquitectura que Google presentó en 2017 en el paper Attention Is All You Need y es la "T" de GPT (Generative Pre-trained Transformer). Antes de él, los modelos de lenguaje leían el texto palabra a palabra, en orden, y se les olvidaba el principio de las frases largas. El transformer lo procesa todo a la vez y deja que cada palabra mire directamente a cualquier otra, esté donde esté.

Un transformer es una pila de bloques iguales. Cada bloque recibe un vector por token y devuelve otro vector por token, del mismo tamaño pero con más contexto dentro. Cada bloque tiene dos piezas:

1. Atención: los tokens se miran entre sí e intercambian información.
2. Red feed-forward: cada token "piensa" por separado sobre lo que ha recogido.

Alrededor de cada pieza hay dos detalles técnicos que hacen que todo funcione. La conexión residual hace que el bloque no sustituya el vector, sino que le suma lo que ha calculado, así que cada bloque añade matices sin romper lo anterior. La normalización reescala los números para que no se disparen ni se hagan diminutos después de decenas de bloques.

La atención: cómo las palabras se miran entre sí

La atención es el corazón del transformer. Piensa en la palabra "banco". Por sí sola no sabemos si es para sentarse o para sacar dinero; lo decide el contexto. La atención es el mecanismo que permite a "banco" mirar a las palabras de alrededor y "teñirse" de su significado.

¿Cómo decide cada palabra a quién mirar? Con una especie de búsqueda. El vector de cada token se multiplica por tres matrices distintas (aprendidas en el entrenamiento) y salen tres vectores nuevos:

• Query (consulta): lo que este token está buscando. "Soy un verbo, ¿quién hace la acción?"
• Key (clave): lo que este token ofrece para que lo encuentren. "Soy un sustantivo, un animal."
• Value (valor): la información que entrega si alguien le presta atención.

El proceso para cada token es:

1. Hacer el producto escalar de su Query con la Key de todos los tokens. Cuanto más encajen, mayor puntuación.
2. Dividir entre la raíz cuadrada del tamaño de los vectores, para que los números no crezcan demasiado.
3. Aplicar softmax para convertir esas puntuaciones en porcentajes de atención que suman 100%.
4. Sumar los Values de todos los tokens ponderados por esos porcentajes.

El resultado es un vector que mezcla la información de los tokens relevantes. Un modelo real hace esto con decenas de "cabezas" de atención en paralelo (la multi-head attention), cada una con sus propias matrices. Así, una cabeza puede especializarse en encontrar el sujeto del verbo, otra en resolver a qué se refiere un "él" y otra en seguir la concordancia de género.

Hay una regla importante: un token solo puede mirar hacia atrás. Si durante el entrenamiento "come" pudiera ver que la palabra siguiente es "pescado", aprender a predecirla sería hacer trampa. Por eso se aplica una máscara causal que bloquea el futuro:

La red feed-forward: donde vive el conocimiento

Después de la atención, cada vector pasa por una red neuronal "clásica": una capa de neuronas que primero amplía el vector (normalmente a 4 veces su tamaño), aplica la activación y luego lo vuelve a comprimir a su tamaño original. Esta parte se aplica a cada token por separado, sin mirar a los demás.

Si la atención sirve para recoger contexto, la feed-forward sirve para procesarlo. Hay investigaciones que muestran que muchos datos concretos (que París es la capital de Francia, que los gatos comen pescado…) quedan guardados en los pesos de estas capas. Además, representan la mayor parte de los parámetros del modelo.

De transformer a LLM: escalar, escalar y escalar

Aquí viene lo sorprendente: los LLM actuales no son un invento radicalmente distinto del transformer de 2017. Son la misma receta, a lo bestia:

Modelo	Año	Bloques	Tamaño del vector	Parámetros
Transformer original	2017	6 (+6)	512	65 millones
GPT-2	2019	48	1.600	1.500 millones
GPT-3	2020	96	12.288	175.000 millones
Llama 3.1 405B	2024	126	16.384	405.000 millones

Al escalar cambian tres cosas: más bloques apilados, vectores más grandes (más dimensiones para matizar el significado) y, sobre todo, muchos más datos de entrenamiento: GPT-3 se entrenó con unos 300.000 millones de tokens y Llama 3.1 con más de 15 billones. Lo más curioso es que las mejoras al escalar siguen unas curvas bastante predecibles (las llamadas scaling laws), y por eso las empresas se han lanzado a construir centros de datos cada vez más grandes. Los modelos más avanzados de hoy ya no publican estas cifras, pero sabemos que la receta de fondo sigue siendo esta.

¿Y de dónde salen los valores de todos esos parámetros? Del entrenamiento, que usa exactamente la misma tarea que ya conocemos. Se coge una cantidad descomunal de texto de internet, libros y código, se tapa la siguiente palabra y se le pide al modelo que la prediga. Luego se compara su predicción con la palabra real y se calcula el error. Con un algoritmo llamado retropropagación (backpropagation) se calcula cómo mover cada uno de los miles de millones de pesos para que el error baje un poquito, y se ajustan. Se repite esto billones de veces.

Al principio el modelo dice tonterías aleatorias. Tras ver suficiente texto, para predecir bien la siguiente palabra se ve obligado a aprender gramática, hechos del mundo, cómo razonar un problema de matemáticas o cómo se estructura un programa en Python. Nadie le enseña esas cosas explícitamente: le resultan útiles para acertar la siguiente palabra.

Ese modelo base solo sabe continuar textos. Para convertirlo en un asistente que responda preguntas se hace una segunda fase de entrenamiento con conversaciones de ejemplo y con valoraciones humanas de qué respuestas son mejores (lo que se conoce como fine-tuning y RLHF). Pero el motor de dentro es el mismo.

Manos a la obra: calculamos "El gato come…" a mano

Ahora que conocemos todas las piezas, vamos a hacer las cuentas de verdad. Como un modelo real tiene vectores de miles de números y no cabría aquí, usamos un modelo de juguete con vectores de solo 4 números, un único bloque transformer, una sola cabeza de atención y un vocabulario de 5 palabras. Además, para que se pueda seguir, cada número tiene un significado que podemos leer: [animal, acción, gramática, comida]. En un modelo real los números no tienen etiquetas tan claras, pero el cálculo es exactamente el mismo.

Esto es lo que vamos a hacer, en versión animada:

1. Tokens y vectores

Troceamos la frase en tres tokens y buscamos sus vectores. Ya les hemos sumado la información de posición:

Token	animal	acción	gramática	comida
El	0.1	0	1	0
gato	1	0.1	0	0.1
come	0	1	0.1	0.2

Tiene sentido: "El" es sobre todo gramatical, "gato" es un animal y "come" es una acción.

2. Atención

Nos interesa el último token, "come", porque es el que tiene que predecir lo que viene después. Su vector se multiplica por la matriz de Query, que en nuestro modelo ha aprendido a transformar "soy una acción" en "busco un animal". El resultado es la Query de "come": q = [3, 0, 0.1, 0]. Para simplificar, las Keys y los Values de cada token serán su propio vector.

Calculamos el producto escalar de la Query con cada Key, dividimos entre √4 = 2 y aplicamos softmax:

• El: 3·0.1 + 0·0 + 0.1·1 + 0·0 = 0.40 → ÷2 = 0.20 → e^0.20 = 1.22
• gato: 3·1 + 0·0.1 + 0.1·0 + 0·0.1 = 3.00 → ÷2 = 1.50 → e^1.50 = 4.48
• come: 3·0 + 0·1 + 0.1·0.1 + 0·0.2 = 0.01 → ÷2 = 0.005 → e^0.005 = 1.01

La suma es 1.22 + 4.48 + 1.01 = 6.71, así que los pesos de atención son 1.22/6.71 = 18% para "El", 4.48/6.71 = 67% para "gato" y 1.01/6.71 = 15% para "come". Como queríamos, "come" se fija sobre todo en quién come.

Ahora mezclamos los Values con esos pesos:

0.18·[0.1, 0, 1, 0] + 0.67·[1, 0.1, 0, 0.1] + 0.15·[0, 1, 0.1, 0.2] = [0.69, 0.22, 0.20, 0.10]

Y por la conexión residual, se lo sumamos al vector original de "come":

[0, 1, 0.1, 0.2] + [0.69, 0.22, 0.20, 0.10] = [0.69, 1.22, 0.30, 0.30]

"come" ha pasado de ser una acción cualquiera a ser una acción que hace un animal: ahora tiene 0.69 en la dimensión animal.

3. Red feed-forward

Nuestra red feed-forward tiene una neurona que ha aprendido a detectar "un animal haciendo una acción". Suma las dimensiones animal y acción, resta 1 como sesgo y aplica ReLU:

ReLU(0.69 + 1.22 − 1) = ReLU(0.91) = 0.91

Se enciende. Y su salida está conectada, con peso 2, a la dimensión comida: añade 2 × 0.91 = 1.82. Con la conexión residual, el vector queda:

[0.69, 1.22, 0.30, 0.30 + 1.82] = [0.69, 1.22, 0.30, 2.12]

El modelo "sabe" que cuando un animal come, lo que viene después suele ser comida. Ese conocimiento estaba guardado en los pesos de la neurona.

4. Logits: comparar con el vocabulario

Ahora hay que convertir este vector en una puntuación para cada palabra del vocabulario. Cada palabra tiene su propio vector de salida y hacemos el producto escalar del vector final con cada uno. Otra vez la misma pregunta de siempre: ¿cuánto se parecen?

Palabra	Vector de la palabra	Producto escalar con [0.69, 1.22, 0.30, 2.12]	Logit
pescado	[0.5, 0, 0, 1.5]	0.69·0.5 + 2.12·1.5	3.53
croquetas	[0.3, 0, 0, 1.4]	0.69·0.3 + 2.12·1.4	3.18
el	[0, 0.5, 1, 0.3]	1.22·0.5 + 0.30·1 + 2.12·0.3	1.55
rápido	[0, 1, 0, 0]	1.22·1	1.22
mesa	[0, 0, 0.5, 0.2]	0.30·0.5 + 2.12·0.2	0.57

Las palabras de comida ganan con claridad porque el vector tiene un 2.12 en la dimensión comida. "pescado" saca un poco más que "croquetas" porque además tiene algo de animal: es comida típica de gato.

5. Softmax y elección

Calculamos e elevado a cada logit y dividimos entre la suma:

Palabra	Logit	e^logit	Probabilidad
pescado	3.53	34.1	50.2%
croquetas	3.18	24.0	35.3%
el	1.55	4.7	6.9%
rápido	1.22	3.4	5.0%
mesa	0.57	1.8	2.6%

¡Tenemos predicción! El modelo cree que la frase sigue con "pescado" con un 50% de probabilidad. Se elige un token, se añade a la frase ("El gato come pescado") y todo el proceso vuelve a empezar para predecir el siguiente.

El toque final: la temperatura

¿Siempre se elige la más probable? No necesariamente. Antes del softmax se pueden dividir los logits entre un número llamado temperatura. Con temperatura baja (por ejemplo 0.5), "pescado" sube al 65% y "croquetas" baja al 33%: el modelo se vuelve más predecible. Con temperatura alta (2), se reparte más (36% y 31%) y hasta "mesa" llega al 8%: más variedad, pero también más riesgo de decir tonterías.

Por eso si le haces la misma pregunta dos veces a un chatbot, la respuesta no es exactamente igual: está eligiendo al azar según esas probabilidades.

De nuestro juguete a un modelo real

Lo que acabamos de hacer a mano es, literalmente, lo que hace un LLM. Las diferencias son de escala:

• En lugar de vectores de 4 números, miles (4.096 en un modelo de 8.000 millones de parámetros).
• En lugar de un bloque, decenas apilados, cada uno refinando un poco más el significado.
• En lugar de una cabeza de atención, decenas por bloque, cada una fijándose en una cosa distinta.
• En lugar de 5 palabras, un vocabulario de más de 100.000 tokens, así que el softmax final reparte la probabilidad entre todos ellos.
• Y en lugar de pesos elegidos a mano, miles de millones de pesos aprendidos a base de leer billones de palabras.

Para hacerse una idea, cada token que genera un modelo de 8.000 millones de parámetros necesita unas 16.000 millones de operaciones (una multiplicación y una suma por cada parámetro). Cada palabra que lees en la respuesta de un chatbot ha costado miles de millones de multiplicaciones como las que hemos hecho aquí a mano.

Y aun así, no deja de ser asombroso: con productos escalares, sumas y un softmax, repetidos a una escala descomunal, aparece algo capaz de explicar física cuántica, escribir código o contar un chiste. Nadie programó esas habilidades una a una: surgieron de aprender a predecir la siguiente palabra.

Para seguir aprendiendo

Si te has quedado con ganas de más, estos son los mejores recursos que conozco para seguir tirando del hilo:

• Transformer Explainer: un GPT-2 que funciona en tu navegador y te enseña todas las operaciones mientras escribes.
• LLM Visualization: un modelo en 3D por el que puedes navegar bloque a bloque y ver cada multiplicación.
• The Illustrated Transformer, de Jay Alammar: el clásico para entender el transformer con dibujos.
• El paper original, Attention Is All You Need.

Y para verlo en vídeo, la serie de 3Blue1Brown es probablemente la mejor explicación visual que existe:

Y si quieres programarlo tú mismo desde cero, Andrej Karpathy construye un GPT completo en Python en este vídeo: