De un texto a una respuesta, paso a paso.

Un LLM (large language model, modelo de lenguaje grande) hace una sola cosa: mira un texto y calcula, para cada trozo posible, la probabilidad de que sea el siguiente. Elige uno, lo pega al final y vuelve a empezar. Conversar, resumir, traducir o programar no son funciones aparte: salen de hacer esa única cosa extraordinariamente bien.

Lo de «grande» va por dos lados. Por los parámetros, los números ajustables que guardan todo lo que el modelo sabe: los de los chats tienen de miles de millones a billones. Y por los datos: se entrenan leyendo una fracción considerable de todo el texto público que existe. Rukh es pequeño en ambos: 39 millones de parámetros y unos cientos de millones de jugadas. Pero es la misma máquina, y por eso sirve para entenderla.

El viaje completo

Un modelo no nace sabiendo conversar. Pasa por siete estaciones, y esta página las recorre en orden. El capítulo 1 cuenta qué es una red neuronal, los capítulos 2 a 7 abren la máquina por dentro (cómo lee y cómo «piensa»); del 8 en adelante, cómo se le enseña, cómo se le mide y cómo se pone a funcionar.

Por dentro, un LLM es una red neuronal: un programa que no tiene reglas escritas a mano, solo muchísimos números que multiplican y suman. Antes de abrir la máquina conviene tener claras cuatro palabras que salen en todos los capítulos siguientes. No hace falta más matemática que esta.

Vectores, matrices y pesos

Un vector es una lista de números, sin más. Una receta es un vector: 200 g de harina, 3 huevos, 100 ml de leche. Si escribes siempre los ingredientes en el mismo orden, [200, 3, 100] es la receta entera. En un LLM, cada palabra acaba convertida en un vector de cientos o miles de números (capítulo 3). Una matriz es una tabla de números: filas y columnas, como una hoja de cálculo.

Un vector también se puede leer como una flecha. [1, 2] es «un paso a la derecha y dos hacia arriba»: si lo dibujas desde el origen, es una flecha con una dirección y un largo. Cuando en los capítulos siguientes se diga que dos vectores «apuntan hacia el mismo sitio», que están «cerca» o que uno «gira», se habla de estas flechas. Con 512 números ya no se puede dibujar, porque harían falta 512 ejes, pero la idea es exactamente la misma.

Un peso (o parámetro) es uno de esos números de la tabla que la red aprende: nadie lo escribe a mano. Cuando se dice que un modelo tiene «7 000 millones de parámetros» se habla de eso, de 7 000 millones de números ajustables.

Una neurona: multiplicar, sumar y doblar

La pieza básica es la neurona, y hace algo muy simple. Recibe unos números, multiplica cada uno por su peso, lo suma todo, añade un número más (el sesgo) y pasa el resultado por una curva. La más sencilla, la ReLU, deja pasar lo positivo y convierte lo negativo en cero: la neurona «se calla».

Esa curva parece un detalle y es lo que lo hace todo posible. Sin ella, apilar neuronas solo daría otra suma de multiplicaciones: diez capas equivaldrían a una, y la red solo podría separar las cosas con líneas rectas, como quien intenta rodear un grupo de puntos con una regla. Con ella, cada capa puede hacer una curva, y muchas capas juntas trazan fronteras tan retorcidas como haga falta.

Capas

Las neuronas se organizan en capas. Todas las neuronas de una capaCapa (layer)Cada uno de los bloques que se apilan para formar la red; en inglés, layer. Un bloque del decoder de Rukh es atención más MLP con sus dos normalizaciones, y small apila doce de 512 dimensiones y ocho cabezas. También se llama capa a una transformación suelta, como la lineal final que convierte el vector de la última posición en logits. leen todas las salidas de la anterior, y eso, escrito con números, es multiplicar un vector por una matriz de pesos. Una red es una cadena de capas: los números entran por un lado, cada capa los transforma y salen por el otro convertidos en una respuesta.

El producto escalar: cuánto se parecen dos vectores

Hay una operación que conviene reconocer porque el capítulo 5 se apoya en ella. El producto escalar de dos vectores multiplica sus números uno a uno y suma: [1, 2] · [3, 1] = 1×3 + 2×1 = 5. Visto con flechas, sale grande si las dos apuntan hacia el mismo lado, cero si forman un ángulo recto y negativo si van en sentidos opuestos. Es la forma más barata de preguntar cuánto se parecen dos listas de números, y una neurona hace exactamente eso: el producto escalar entre lo que llega y sus pesos.

Entrenar: girar millones de perillas a la vez

Al principio los pesos son números al azar y la red contesta tonterías. Entrenarla es enseñarle ejemplos, medir cuánto se equivoca (la pérdidaPérdida (loss)El número que el entrenamiento minimiza: cuánto se equivoca el modelo sobre un lote; en inglés, loss. En el decoder es la entropía cruzada entre los logits y el token que venía de verdad, y las posiciones de relleno no cuentan (ignore_index). No se lee sola: una pérdida de 2,1 no significa nada sin saber sobre qué vocabulario se calculó, y por eso el curso la convierte en perplejidad para compararla.) y calcular, para cada peso, hacia dónde habría que moverlo para equivocarse un poco menos. Se mueven todos un pasito, se pasa al siguiente ejemplo y se repite millones de veces. Ese método se llama el descenso de gradienteDescenso de gradienteLa manera de entrenar una red: calcular hacia dónde crece la pérdida respecto a cada peso (el gradiente, que se obtiene por retropropagación) y mover todos los pesos un pasito en sentido contrario. Repetido millones de veces sobre lotes distintos, la pérdida baja. AdamW es la variante que usa Rukh., y el capítulo 8 lo cuenta despacio.

Una red neuronal solo sabe multiplicar y sumar números. Antes de nada, el texto tiene que convertirse en una lista de enteros. El programa que lo hace es el tokenizador, y cada trozo en el que corta el texto es un tokenTokenUnidad mínima que el modelo lee y escribe. En Rukh, por defecto, un token es una jugada completa en notación UCI (e2e4); en otras tokenizaciones puede ser un carácter o un trozo de texto aprendido por BPE. El modelo nunca ve letras ni tableros: ve identificadores enteros de tokens.. La lista cerrada de todos los trozos que conoce es su vocabularioVocabularioLa lista de todos los tokens que el modelo conoce, cada uno con un id entero fijo. En Rukh el vocabulario UCI tiene 2 030 entradas: 8 tokens especiales, 54 tramos de Elo y las 1 968 jugadas posibles, enumeradas sin mirar datos. Su tamaño fija el de la capa de embeddings y el de la capa de salida., y cada trozo tiene su número fijo.

¿Por dónde cortar? Por letras sale un vocabulario diminuto, pero las secuencias se hacen larguísimas y el modelo gasta su esfuerzo en deletrear. Por palabras enteras, las secuencias son cortas, pero el vocabulario se dispara y cualquier palabra nueva («gatito», un nombre propio, una errata) no tiene número. Los LLM de hoy se quedan en medio: trozos de palabra.

BPE: que los datos decidan los trozos

El método más usado se llama BPEBPE (byte-pair encoding)Tokenizador aprendido de los datos: parte de los caracteres, fusiona una y otra vez el par de tokens adyacentes más frecuente y guarda cada fusión en orden hasta llegar al tamaño de vocabulario pedido (4 096 en Rukh). Sobre texto UCI redescubre primero las casillas, luego las jugadas y al final trozos de apertura. Nada queda fuera de vocabulario: lo raro se parte en trozos más cortos. (byte-pair encoding). Empieza con las letras sueltas como vocabulario, cuenta qué pareja de símbolos aparece junta más a menudo en todo el texto de entrenamiento y la fusionaFusión de BPE (merge)Cada una de las uniones de un par de tokens que el BPE aprende, guardada en el orden en que la aprendió; en inglés, merge, que es como se llama en el fichero merges.txt y en la variable merges del lab. Tokenizar es aplicarlas en ese mismo orden: aplicar una tardía antes que una temprana da otra segmentación y peor. En Rukh son 4 069 para un vocabulario de 4 096. en un símbolo nuevo. Luego vuelve a contar y repite, miles de veces, hasta llegar al tamaño de vocabulario deseado (entre 100 000 y 200 000 trozos en los modelos grandes). Lo frecuente acaba siendo un solo token («␣que», «ción»); lo raro se sigue pudiendo escribir con trozos más pequeños.

Tokens que no son texto

Además de los trozos, el vocabulario reserva tokens especiales que nadie escribe: inicio y fin de secuencia, relleno, y marcas como «aquí habla el usuario» o «aquí responde el asistente». Son el panel de control del modelo; en el capítulo 11 vuelven como la plantilla de chat. Y todo cuenta contra la ventana de contextoVentana de contextoNúmero máximo de tokens que el modelo puede ver a la vez; en Rukh, 200 (el bloque del dataloader). Lo que no cabe se trunca. Como la atención cuesta el cuadrado de la longitud, una ventana cuatro veces mayor es dieciséis veces más cara, y por eso importa que el 99,8 % de las partidas del recorte quepan en 200 tokens UCI (medido sobre 20 000 partidas de enero; por carácter solo cabe el 7,77 %)., el número máximo de tokens que el modelo puede mirar de una vez.

El tokenizador ha convertido el texto en enteros, pero un entero suelto no sirve de mucho: que «gato» sea el 7412 y «perro» el 7415 no dice que se parezcan, solo que alguien los numeró seguidos. La red necesita algo con lo que se pueda medir parecido.

La solución es una tabla con una fila de números por cada token del vocabulario. El id del token dice qué fila leer, y esa fila, una lista de cientos o miles de números reales, es lo que entra en la red en lugar de la palabra. Esa fila se llama embeddingEmbeddingTabla que asigna un vector aprendido a cada id del vocabulario, y por extensión ese vector. En rukh-small la tabla es de 2 030 × 512: cada jugada UCI entra en el modelo como un punto en un espacio de 512 dimensiones, aprendido a la vez que el resto de la red., y la tabla entera también. Cada número de la fila es una dimensión (una columna de la tabla): un plano tiene dos ejes, este mapa tiene cientos, y cada token es un punto en él.

Nadie rellena esa tabla a mano. Empieza siendo ruido y se aprende a la vez que el resto del modelo, con la misma regla de siempre: acertar el siguiente token. Como «gato» y «perro» aparecen en frases parecidas («el … duerme en el sofá»), empujarlos hacia el mismo sitio ayuda a predecir lo que viene después, y el entrenamiento los acaba juntando. Al final, la tabla es un mapa: cada token es un punto y la cercanía entre puntos es parecido de uso.

Con el mapa hecho se pueden hacer dos cosas que parecen magia y son geometría. La primera, preguntar quién vive cerca de una palabra. La segunda, sumar y restar direcciones: si de «hombre» a «rey» hay una flecha, esa misma flecha puesta en «mujer» lleva cerca de «reina».

El mismo mapa sirve para buscar

Lo de «cerca en el mapa = parecido en el uso» se aprovecha fuera del modelo. Si conviertes frases o párrafos enteros en un vector, puedes buscar por significado en vez de por palabras exactas: «receta sin horno» encuentra «tarta de nevera». Es la base de los buscadores semánticos y del RAG (capítulo 15).

Con solo los embeddings, «el perro muerde al hombre» y «el hombre muerde al perro» le llegan a la red como el mismo montón de vectores. La pieza que viene en el capítulo siguiente, la atención, mezcla posiciones con una suma ponderada, y a una suma le da igual el orden de los sumandos. Un modelo sin noción de posición es una bolsa de palabras muy cara.

• el
• perro
• muerde
• al
• hombre
• ≠
• el
• hombre
• muerde
• al
• perro

Hay que inyectar el orden. Se hace de dos maneras.

Opción 1: numerar los asientos

La más sencilla es una segunda tabla, igual que la de embeddings pero indexada por posición: la fila 0 significa «estar el primero», la fila 1 «estar el segundo», y así hasta el último hueco de la ventana de contexto. Se suma al vector del token y listo. Es lo que hacía GPT-2. La pega: no hay fila para una posición que no estaba en la tabla, así que el modelo no puede leer textos más largos que su ventana de contextoVentana de contextoNúmero máximo de tokens que el modelo puede ver a la vez; en Rukh, 200 (el bloque del dataloader). Lo que no cabe se trunca. Como la atención cuesta el cuadrado de la longitud, una ventana cuatro veces mayor es dieciséis veces más cara, y por eso importa que el 99,8 % de las partidas del recorte quepan en 200 tokens UCI (medido sobre 20 000 partidas de enero; por carácter solo cabe el 7,77 %)., y las posiciones del fondo se entrenan poco porque pocos textos llegan hasta ahí.

Opción 2: girar los vectores (RoPE)

La que usan casi todos los LLM de hoy (Llama, Mistral, Qwen) se llama RoPERoPECodificación de posición rotatoria (rotary position embedding): en vez de sumar un vector de posición, rota por pares las dimensiones de las consultas y las claves con un ángulo proporcional a la posición. El producto escalar entre dos posiciones depende entonces solo de su distancia, y no hace falta una tabla de posiciones. En Rukh es la alternativa a las posiciones aprendidas (pos: rope).. Recuerda que un vector es también una flecha (capítulo 1). RoPE no le suma nada: la gira. El token de la posición 0 no se gira, el de la 1 se gira un poco, el de la 2 un poco más, y así, cada posición un paso más que la anterior.

La gracia está en lo que ve quien compara dos tokens: no cuánto ha girado cada uno, sino el hueco entre las dos flechas, y ese hueco solo depende de cuántas posiciones los separan. La jugada 5 mirando a la 3 ve lo mismo que la 50 mirando a la 48. Eso es justo lo que interesa: «dos antes que yo» significa lo mismo en cualquier punto del texto.

Hasta aquí cada token es un vector que no sabe nada de sus vecinos: «banco» es el mismo vector en «me senté en el banco» y en «pedí un préstamo al banco». La atenciónAtenciónOperación que mezcla las posiciones de una secuencia: cada posición emite una consulta (Q), cada una ofrece una clave (K) y un valor (V); el producto escalar entre consulta y claves, escalado por 1/√d y pasado por softmax, da los pesos con los que se promedian los valores. Es la única parte del Transformer donde las posiciones se hablan entre sí. es el paso en el que las palabras se miran entre sí y cada una se reescribe con lo que ha aprendido de las demás. Es la pieza central del transformer; casi todo lo demás es fontanería alrededor.

Consulta, clave y valor

Cada token fabrica tres vectores a partir del suyo, con tres matrices que se aprenden en el entrenamiento:

• Q, la consulta: qué estoy buscando («¿quién hace la acción?»).
• K, la clave: qué ofrezco a quien me busque («soy un animal, y soy el sujeto»).
• V, el valor: qué información entrego si me eligen.

Para cada token, su consulta se compara con las claves de todos (un producto escalar, capítulo 1: cuanto más apuntan en la misma dirección, más parecido). Esos parecidos pasan por un softmaxSoftmaxFunción que convierte una lista de puntuaciones (logits) en probabilidades que suman 1: exponencia cada número y divide por la suma. Agranda las diferencias, así que el favorito se lleva más de lo que su ventaja bruta sugiere. Aparece dos veces en cada paso: dentro de la atención y al final, para elegir el siguiente token., que los convierte en porcentajes de atención que suman 100 %, y la salida es la mezcla de los valores con esos porcentajes. No elige una palabra: se lleva un promedio de todas, pesado por lo bien que encajaba cada una.

El softmax cabe en un ejemplo. Si los parecidos con tres palabras son 3, 1 y 0, se eleva e (un número fijo, 2,72) a cada uno, lo que da 20,1, 2,7 y 1, y se divide cada resultado por la suma, 23,8. Salen un 84 %, un 11 % y un 4 %. Dos cosas a notar: todo queda positivo y sumando 100 %, y el favorito se lleva mucho más de lo que su ventaja bruta sugiere.

Ojo con una palabra: a estos porcentajes a veces se les llama «pesos de atención», pero no son los pesos del capítulo 1. Los pesos que el entrenamiento aprende son los de las tres matrices que fabrican Q, K y V; los porcentajes se calculan de nuevo para cada frase, cada vez que el modelo lee.

Varias cabezas, varias preguntas

Una sola atención solo puede hacer una pregunta a la vez. Por eso se usan varias cabezasCabeza de atenciónUna atención completa calculada en un subespacio de la representación. rukh-small parte sus 512 dimensiones en 8 cabezas de 64: cada una aprende su propio criterio de parecido y sus propios pesos, y sus salidas se concatenan y se vuelven a proyectar. Mismo coste que una cabeza de 512, ocho patrones distintos por capa. en paralelo: el vector se parte en trozos y cada trozo hace su propia atención, con sus propias Q, K y V. Una cabeza puede aprender a buscar el sujeto, otra a mirar la palabra de justo antes, otra a emparejar comillas. Al final las salidas de todas se juntan. No cuesta más parámetros: es la misma cuenta, leída por trozos.

La máscara causal: prohibido mirar el futuro

Un modelo que escribe de izquierda a derecha no puede ver las palabras que todavía no existen. En el entrenamiento sí las tiene delante (le damos el texto entero), así que hay que taparlas: la máscara causalMáscara causalRestricción que impide a cada posición mirar hacia delante: antes del softmax, los pesos de las claves futuras se ponen a menos infinito. Sin ella el modelo vería la jugada que tiene que predecir y la pérdida bajaría sin que aprendiese nada. En Rukh la aplica F.scaled_dot_product_attention(..., is_causal=True). Es lo que hace «causal» a un modelo: en M3 el encoder es el mismo bloque con causal=False, y cada posición ve la secuencia entera. pone a cero el porcentaje de todo token posterior. Sin ella, predecir la palabra siguiente sería copiarla, y el modelo aprendería a hacer trampa.

Un transformerTransformerArquitectura de red en la que casi todos los LLM de hoy se basan: una pila de bloques iguales, cada uno con una capa de atención (las posiciones se miran entre sí) y una red feed-forward (cada posición se procesa por separado), unidas por conexiones residuales y normalización. El decoder de M2 y el encoder de M3 son dos transformers que solo se diferencian en la máscara de atención. no es una pieza gigante, sino la misma pieza repetida: el bloque. Se apilan uno encima de otro (doce en rukh-small, más de cien en los modelos más grandes) y el vector de cada token los atraviesa uno detrás de otro. Cada bloque hace dos cosas, siempre en el mismo orden.

1. Atención. Cada posición mira a las demás y se trae lo que le interesa de ellas (capítulo 5). Es el único momento en que los tokens se hablan entre sí.
2. MLP (o red feed-forward). Cada posición, por separado, procesa lo que la atención le trajo: una red pequeña que expande el vector a cuatro veces su anchura, lo pasa por una no linealidad (la «curva» de la neurona del capítulo 1) y lo vuelve a comprimir. Tiene dos tercios de los parámetros del bloque, y a menudo se describe como la memoria del modelo: donde se guardan los datos sueltos que ha aprendido.

La atención reparte información entre posiciones; el MLP la digiere en cada una. Repetido doce o cien veces, lo que empezó siendo «el vector de la palabra banco» acaba siendo «el vector de banco en el sentido de sentarse, en esta frase, justo antes de un verbo».

La cinta que no se corta

El detalle que hace que todo esto se pueda entrenar es cómo se conectan las piezas. Ninguna estación sustituye el vector que le llega: calcula una corrección y la suma. El vector viaja por un camino recto, la corriente residual, y cada atención y cada MLP leen una copia, proponen un retoque y lo añaden. Es la conexión residualConexión residualSuma de la entrada de una subcapa a su salida (x + f(x)). La derivada de esa suma es la identidad más la de f, así que el gradiente llega íntegro a las capas de abajo aunque f aporte poco; el flujo de vectores que atraviesa el modelo de principio a fin se llama por eso corriente residual..

¿Por qué importa? Porque al entrenar, la señal de error tiene que viajar hacia atrás desde el final hasta el primer bloque (la retropropagación del capítulo 8). Si cada bloque la transformara, llegaría deformada o casi a cero tras doce pasos, y los primeros bloques no aprenderían nada. Con la suma, la señal tiene una autopista directa de vuelta, y cada bloque solo tiene que aprender su pequeño retoque.

La otra pieza de fontanería es la normalización: antes de que una estación lea su copia, se le ajusta el volumen para que ningún número se haga enorme ni se quede en casi nada, como quien iguala el nivel de una grabación antes de pasarla. Se ajusta la copia, nunca la cinta: la cinta sigue intacta y la señal del entrenamiento vuelve por ella sin obstáculos. A eso se le llama pre-normPre-normOrden de un bloque Transformer en el que la normalización va antes de la subcapa y su salida se suma a la entrada: x = x + attn(ln1(x)). Deja un camino sin obstáculos entre la pérdida y las primeras capas, y es lo que permite apilar doce bloques y entrenarlos sin trucos. La variante contraria (post-norm) es la del artículo original y necesita mucho más cuidado., y es lo que hacen GPT-2, Llama y casi todos los LLM actuales.

Al final de la pila, una última capa convierte el vector de la última posición en una puntuación para cada token del vocabulario, los logitsLogitsPuntuación bruta que el modelo asigna a cada token del vocabulario antes de convertirla en probabilidades (con softmax). En Rukh hay un logit por jugada UCI posible; la demo pone a menos infinito los de las jugadas ilegales antes de muestrear, y la temperatura y el top-k actúan sobre ellos., que el capítulo 9 convierte en una palabra.

La máquina entera

Con el bloque ya están todas las piezas de dentro. Antes de pasar a cómo se entrena, conviene verlas juntas una vez, en el orden en que las recorre un token: del texto a los números, de los números a los vectores, por la pila de bloques, y de vuelta a una palabra que se pega al texto para empezar otra vuelta. Los capítulos 9 y 10 cuentan la parte de abajo; el resto ya lo has visto.

Con los bloques del capítulo anterior se construyen modelos muy distintos, y lo que los separa es casi siempre una sola decisión: a quién puede mirar cada posición en la atención. Esa regla se llama máscara.

Un decoderDecoderArquitectura Transformer con atención causal: cada posición solo mira hacia atrás, así que sirve para generar de izquierda a derecha. GPT es un decoder; MoveDecoder, el modelo de Rukh, también., como los de los chats, tiene máscara causal: cada token solo ve los anteriores y a sí mismo. Tiene que ser así, porque su trabajo es predecir el siguiente; si pudiera mirar a su derecha, al entrenar vería la respuesta y aprendería a copiarla, no a predecirla. Un encoderEncoderTransformer con atención bidireccional: cada posición ve toda la secuencia. No genera; representa. En Rukh el encoder lee una partida entera y produce un vector por posición del que salen el valor y la detección de errores. quita esa restricción: cada token mira a todos, antes y después. No sirve para escribir (al generar, lo de la derecha todavía no existe), pero entiende mejor lo que ya está escrito.

Cómo se entrena un encoder

Si no puede predecir el siguiente token, ¿qué aprende? A rellenar huecos. Se tapan al azar unas cuantas palabras (en BERT, el 15 %) y el modelo tiene que reconstruirlas mirando a los dos lados. Es el MLMMLM (masked language modeling)Objetivo de preentrenamiento de BERT: se esconde una parte de los tokens y el modelo, que ve la secuencia por los dos lados, tiene que reconstruirlos. En Rukh se llama masked move modeling porque el token es una jugada: se tapa el 15 % de las jugadas de la partida y de esas el 80 % se sustituye por <mask>, el 10 % por otra jugada al azar y el 10 % se deja tal cual. Los tokens de control (<bos>, Elo, resultado, <eos>) nunca se tapan: son la condición, no la señal., masked language modeling:

• El
• gato
• [tapado]
• subió
• al
• tejado
• → se

Al terminar, el encoder no se usa para rellenar huecos, sino por lo que aprendió al hacerlo: un vector por token que resume la frase entera desde su punto de vista. Encima se montan una o varias «cabezas» pequeñas y baratas que clasifican («¿es spam?», «¿quién va ganando?»), o se resume todo en un vector para buscar textos parecidos.

Cuidado con la palabra, que aquí significa otra cosa. Las cabezas de atención del capítulo 5 están dentro de cada bloque y reparten la atención en varias preguntas. Una cabezaCabeza (head)La capa final que traduce la representación en la salida de una tarea concreta; en inglés, head. El encoder de M3 lleva tres sobre el mismo tronco —valor, resultado y error garrafal— y cada una es una sola capa lineal, a propósito: si una lineal acierta, la información ya estaba en la representación. No confundir con la cabeza de atención, que es otra cosa. de salida está encima de todo el modelo: una capa pequeña que convierte su vector final en la respuesta a una pregunta concreta, como un enchufe distinto para cada aparato.

Las tres ramas

La tercera rama junta las dos: un encoder lee la entrada completa (una frase en inglés, un audio) y un decoder escribe la salida token a token, consultando lo que el encoder entendió. Fue la arquitectura del transformer original, pensado para traducir. Hoy la moda está en los decoder puros, porque generar es lo más general, pero para «dame un vector de esto» un encoder pequeño sigue siendo más barato y mejor.

Recién creado, un modelo es un montón de números al azar: ante «me llevo el» reparte la probabilidad casi a partes iguales entre las decenas de miles de tokens de su vocabulario. El preentrenamientoPreentrenamientoPrimera y más cara fase de un modelo de lenguaje: aprender a predecir el siguiente token (o el token tapado, en un encoder) sobre una montaña de texto sin etiquetar. Deja un modelo que conoce el idioma, o el ajedrez, pero que todavía no sigue instrucciones. En Rukh es el entrenamiento del decoder en M2 y el masked move modeling de M3. lo convierte en algo útil con una tarea de una simplicidad casi ridícula: adivinar el token siguiente, sobre montañas de texto, millones de veces.

Cada acierto y cada fallo, en un número

Se toma un trozo de texto, el modelo predice en cada posición qué viene después y se mira qué venía de verdad. La pérdidaPérdida (loss)El número que el entrenamiento minimiza: cuánto se equivoca el modelo sobre un lote; en inglés, loss. En el decoder es la entropía cruzada entre los logits y el token que venía de verdad, y las posiciones de relleno no cuentan (ignore_index). No se lee sola: una pérdida de 2,1 no significa nada sin saber sobre qué vocabulario se calculó, y por eso el curso la convierte en perplejidad para compararla. mide la sorpresa: si al token correcto le había dado un 90 %, la pérdida es pequeña; si le había dado un 0,1 %, es grande (en la jerga se llama entropía cruzada, pero no hace falta el nombre para entenderla). No hace falta que nadie etiquete nada: el propio texto trae la respuesta, que es lo que permite entrenar con todo lo escrito que se pueda reunir.

Y un solo texto da muchos ejemplos a la vez. La respuesta de cada posición es el token que tiene justo a su derecha, así que basta con poner el texto dos veces, la segunda desplazada un sitio: una frase de seis tokens son cinco preguntas con su respuesta, y el modelo las contesta todas en la misma pasada. La máscara causal del capítulo 5 es lo que impide que cada posición mire su propia respuesta en la fila de arriba.

¿Y desde dónde se empieza? Un modelo recién creado no prefiere nada: reparte la probabilidad a partes iguales entre los V tokens de su vocabulario. Su pérdida inicial es, por tanto, la de adivinar al azar entre V opciones, un número que se sabe de antemano (es el logaritmo de V, de ahí que se escriba ln V). Con un vocabulario de unos 50 000 tokens, como el de GPT-2, sale 10,8; con las 2 030 jugadas de Rukh, 7,6. Si la primera pérdida que imprime un entrenamiento no se parece a ese número, algo está mal montado antes de empezar.

Luego viene el ajuste. Con el descenso de gradienteDescenso de gradienteLa manera de entrenar una red: calcular hacia dónde crece la pérdida respecto a cada peso (el gradiente, que se obtiene por retropropagación) y mover todos los pesos un pasito en sentido contrario. Repetido millones de veces sobre lotes distintos, la pérdida baja. AdamW es la variante que usa Rukh. se calcula, para cada uno de los millones de pesos, hacia dónde habría que moverlo para que la pérdida bajase un poco, y se mueven todos un pasito en esa dirección; lo largo de ese pasito es la tasa de aprendizaje. Luego otro loteLote (batch)Las muestras que el modelo ve de una vez antes de un paso del optimizador; en inglés, batch, que es como se llama en el código (batch_size). La GPU quiere tensores rectangulares, así que un lote es una matriz de forma fija: en Rukh, 64 secuencias de 200 tokens. Cuanto más grande, menos ruido tiene el gradiente y más memoria cuesta; cuando no cabe, la acumulación de gradiente simula uno mayor sumando varios lotes pequeños antes del paso. (un puñado de trozos de texto que se procesan juntos), otro cálculo, otro pasito. Nadie programa la gramática ni las aperturas de ajedrez: aparecen porque ayudan a acertar.

¿Cómo sabe cada perilla hacia dónde girar?

El descenso de gradiente pide, para cada peso, su pendiente: si lo subo un poquito, ¿la pérdida sube o baja, y cuánto? Con millones de pesos, probarlos uno a uno (mover uno, volver a pasar el texto, medir) costaría millones de pasadas por cada paso de entrenamiento. La retropropagación (backpropagationRetropropagaciónEl cálculo que dice a cada peso hacia dónde moverse. Tras medir el error a la salida, se recorre la red una vez hacia atrás multiplicando, eslabón a eslabón, cuánto influyó cada pieza en la siguiente (la regla de la cadena); cada peso recibe así su parte de la culpa y su signo. Cuesta del orden de una pasada hacia delante más, y es lo que hace posible entrenar millones de pesos a la vez; en Rukh lo hace PyTorch con loss.backward().) lo resuelve en una sola vuelta hacia atrás.

La red es una cadena de operaciones sencillas, y cada una sabe cuánto influye lo que le entra en lo que le sale. El error se mide al final y viaja de vuelta: cada eslabón recibe la culpa que le llega por detrás, la multiplica por cuánto influyó él y la pasa al anterior. Un peso que empujaba hacia el fallo recibe mucha culpa; uno cuyo camino pasaba por una neurona apagada (una ReLU en cero, del capítulo 1) no recibe ninguna. Al llegar a la entrada, cada peso tiene su parte y su signo, y el descenso de gradiente los mueve todos a la vez.

Con números se ve mejor. La cadena más pequeña que tiene todo: una entrada, un peso, una ReLU, otro peso y una predicción que se compara con lo que debía salir. Haz el ciclo a mano, paso a paso, y repítelo.

Entrénalo tú

Lo que sigue es un entrenamiento de verdad, en tu navegador: un modelo diminuto que solo mira la letra anterior para adivinar la siguiente (un bigrama), aprendiendo de unas frases en español. Es muchísimo más tonto que un transformer, pero el bucle es el mismo: predecir, medir la pérdida, mover los pesos un pasito y repetir.

Al final del preentrenamiento sale un modelo base: sabe continuar textos (o partidas) con muchísima soltura, pero no sabe que tiene que obedecer ni contestar. Eso llega después.

Tras la última capa, el modelo no devuelve una palabra: devuelve una puntuación para cada token del vocabulario, decenas de miles de números llamados logitsLogitsPuntuación bruta que el modelo asigna a cada token del vocabulario antes de convertirla en probabilidades (con softmax). En Rukh hay un logit por jugada UCI posible; la demo pone a menos infinito los de las jugadas ilegales antes de muestrear, y la temperatura y el top-k actúan sobre ellos.. Un softmaxSoftmaxFunción que convierte una lista de puntuaciones (logits) en probabilidades que suman 1: exponencia cada número y divide por la suma. Agranda las diferencias, así que el favorito se lleva más de lo que su ventaja bruta sugiere. Aparece dos veces en cada paso: dentro de la atención y al final, para elegir el siguiente token. los convierte en probabilidades que suman uno. Queda la última decisión, que no es de la red sino de quien la usa: qué token escribir con esas probabilidades.

La opción obvia es coger siempre el más probable. Funciona para respuestas cortas y exactas, pero en textos largos se vuelve repetitiva y plana, porque la frase más probable palabra a palabra no es la más natural. Así que se muestrea: se tira un dado cargado con esas probabilidades. Y antes de tirarlo se ajustan tres perillas, las mismas que ofrece cualquier API de un LLM.

Tres perillas

• TemperaturaTemperaturaDivisor que se aplica a los logits antes del softmax. Por debajo de 1 concentra la probabilidad en las jugadas que el modelo prefiere (con temperatura 0 es directamente el argmax) y por encima de 1 la reparte. En Rukh el valor por defecto es 0,6: juego variado pero no temerario.. Divide los logits antes del softmax. Por debajo de 1 concentra la probabilidad en el favorito (con 0, siempre gana él); por encima de 1 la reparte y lo raro gana opciones. Nunca cambia el orden: solo cuánto manda el primero.
• Top-kTop-kTruncamiento del muestreo: solo se conservan los k tokens de mayor probabilidad y el resto pasa a probabilidad cero antes de sortear. Con k = 20 el modelo nunca juega una ocurrencia de la cola de la distribución, que es de donde salen casi todas las jugadas absurdas.. Se queda con los k candidatos mejores y descarta el resto. Corta la cola larga de opciones absurdas que, sumadas, podrían salir de vez en cuando.
• Top-pTop-p (nucleus)Filtro de muestreo que se queda con el grupo más pequeño de tokens cuya probabilidad acumulada llega a p (por ejemplo 0,9) y descarta el resto. A diferencia de top-k, el número de candidatos se adapta: pocos cuando el modelo está seguro, muchos cuando duda. El curso usa top-k; top-p es el habitual en los chats.. Se queda con los candidatos justos para sumar una probabilidad p (por ejemplo 0,9). Si el modelo está seguro, quedan uno o dos; si duda, muchos. Es el recorte que se adapta.

Tras recortar, lo que queda se vuelve a repartir para que sume otra vez uno, y se tira el dado.

La temperatura se suele llamar «creatividad», y la palabra engaña: el modelo no aprende palabras nuevas al subirla, solo baja más por la lista que ya tenía. Por eso para programar o extraer datos se usa temperatura baja, y para escribir un poema algo más alta.

El capítulo anterior elegía un token. Una respuesta entera sale de repetirlo en bucle: el token elegido se pega al final del texto, el texto más largo vuelve a entrar en el modelo, sale una nueva distribución, se muestrea otro token, y así sucesivamente. Por eso a estos modelos se les llama autorregresivos: cada paso se apoya en lo que ellos mismos escribieron en los pasos anteriores. Y por eso las respuestas de un chat aparecen palabra a palabra: no es un efecto de la interfaz, es literalmente como se fabrican.

¿Cuándo para? Cuando el modelo elige un token especial de fin (el mismo que vio al final de cada ejemplo durante el entrenamiento), cuando se alcanza un tope de longitud que fija quien lo ejecuta, o cuando el texto llena la ventana de contextoVentana de contextoNúmero máximo de tokens que el modelo puede ver a la vez; en Rukh, 200 (el bloque del dataloader). Lo que no cabe se trunca. Como la atención cuesta el cuadrado de la longitud, una ventana cuatro veces mayor es dieciséis veces más cara, y por eso importa que el 99,8 % de las partidas del recorte quepan en 200 tokens UCI (medido sobre 20 000 partidas de enero; por carácter solo cabe el 7,77 %).. Lo que no cabe en la ventana simplemente no existe para el modelo: si una conversación se alarga más allá, hay que recortar o resumir lo más antiguo.

La KV cache: no recalcular lo que ya sabías

Hecho a lo bruto, el bucle es un despilfarro: en cada paso la red vuelve a calcular todo el texto, aunque la parte antigua sale idéntica a la del paso anterior. Lo único que el token nuevo necesita de los antiguos son sus claves y valores de atención (capítulo 5), así que se guardan en memoria: esa memoria es la KV cacheKV cacheMemoria de las claves (K) y valores (V) de atención de los tokens ya procesados. Al generar token a token, el modelo solo calcula K y V del token nuevo y reutiliza los guardados, en vez de recalcular toda la secuencia en cada paso. Cambia memoria por tiempo: es lo que hace rápidos a los chats y lo que llena la GPU con contextos largos.. Con ella, cada paso calcula un solo token nuevo y lee el resto de lo guardado. El trato es tiempo a cambio de memoria.

Recién preentrenado, un modelo es un loro culto: ha leído muchísimo y continúa cualquier texto con soltura, pero no sabe que tú le estás pidiendo algo. Pregúntale «¿Cuál es la capital de Galicia?» y puede que conteste, o que siga con tres preguntas más de examen, porque en internet las preguntas suelen venir en lista. Convertirlo en un asistente es afinarlo, hacerle un fine-tuningFine-tuningSeguir entrenando un modelo ya entrenado sobre datos más específicos o con un objetivo distinto. Puede tocar todos los pesos (completo) o solo unos pocos (parcial, LoRA). En Rukh, el decoder base se afina con partidas de maestros y con tokens de Elo objetivo.: seguir entrenándolo, con el mismo bucle y la misma pérdida, pero con otros datos y durante mucho menos tiempo.

El afinado que enseña a obedecer se llama SFTSFT (supervised fine-tuning)Seguir entrenando un modelo ya preentrenado con el mismo objetivo —predecir el siguiente token— pero sobre un corpus elegido. No cambia la pérdida ni la arquitectura: cambia de qué distribución salen los ejemplos, y eso es todo lo que hace falta para mover el comportamiento. En Rukh son los dos afinados del hito: medium-masters sobre partidas de élite y medium-elo sobre un corpus plano en Elo. (supervised fine-tuning), también instruction tuningInstruction tuningAfinado supervisado (SFT) sobre pares instrucción → respuesta, para que un LLM obedezca lo que se le pide en la propia entrada en vez de limitarse a continuar texto. Rukh no lo hace tal cual: sus dos tokens de cabecera <wXXXX> <bXXXX> son condicionamiento con tokens de control, el pariente más pequeño de un prompt de sistema. Comparten la lección práctica: una instrucción solo funciona si el entrenamiento vio ejemplos de ella, y los tramos por debajo de 1800 no los vio hasta M4.: decenas o cientos de miles de ejemplos de conversación escritos o revisados por personas, cada uno con una petición y la respuesta que querríamos. El modelo no aprende hechos nuevos; aprende un formato y un comportamiento: esperar su turno, contestar a lo que se pregunta, pararse al terminar.

Una conversación es una sola tira de tokens

El modelo no tiene ventanas de chat ni sabe qué es un «rol». La conversación se aplana en una secuencia y unos tokens especiales marcan quién habla: es la plantilla de chat (chat templatePlantilla de chatFormato fijo con tokens especiales que marca quién habla en una conversación (sistema, usuario, asistente) y que el modelo aprende en el afinado. Para el modelo, un chat es una sola secuencia plana de tokens: la plantilla es la misma idea que los tokens de control de Elo de Rukh.). Durante el SFT, la pérdida solo se cuenta sobre la parte del asistente: la pregunta se lee, pero lo que se aprende a escribir es la respuesta.

Afinar tiene un riesgo con nombre, el olvido catastróficoOlvido catastróficoCuando afinar un modelo con datos nuevos le hace perder lo que sabía. No avisa: la pérdida sobre los datos nuevos baja mientras la capacidad vieja se deshace. La defensa no es una técnica sino una medición: se afina con tasa baja, pocos pasos, y se vuelve a medir contra el listón anterior. En M4 el listón es el Elo del modelo base; si el afinado por Elo lo hundiera, el eje habría salido caro.: lo que el modelo pierde de lo que ya sabía mientras aprende lo nuevo. La defensa es aburrida y funciona: pasos más pequeños que en el preentrenamiento, pocos, y volver a medir lo de antes.

LoRA: no tocar el modelo, añadirle una pieza

Afinar el modelo entero da una copia nueva por cada variante: cinco estilos son cinco modelos. La LoRALoRALow-Rank Adaptation: en vez de modificar una matriz de pesos W, se aprende una corrección B·A de rango r (A de r × d, B de d × r, con B inicializada a cero para que el modelo adaptado sea el base en el paso 0) y se suma a W escalada por alpha/r. Entrena pocos parámetros —en medium, 393 216 con r = 8 sobre consulta y valor, el 0,34 %—, se guarda como un adaptador de 1,6 MB y se puede cambiar en caliente. QLoRA hace lo mismo sobre un modelo base cuantizado a 4 bits. congela todos los pesos originales y, al lado de algunas matrices, entrena una corrección fabricada con dos matrices estrechas, B y A. Su producto tiene el tamaño de la matriz original, pero solo puede empujarla en unas pocas direcciones independientes; cuántas, es su rango, r. Con r = 8, la corrección se mueve en 8 direcciones de las 768 que tiene cada matriz. Cada variante es un adaptador pequeño que se enchufa y desenchufa sobre un único modelo base.

La QLoRAQLoRALoRA sobre un modelo base cuantizado a 4 bits: los pesos congelados ocupan una cuarta parte y los adaptadores siguen entrenándose en 16 bits, así que cabe en la GPU un modelo que en fp16 no cabría. El ahorro se nota cuando el peso está en las capas lineales; a 0,6 B parámetros, con una tabla de embeddings que es el 26 % del modelo y no se cuantiza, el ahorro medido fueron 341 MB de pesos (29 %) y 7 MB del pico de memoria (0,4 %). El nombre promete más de lo que da a esa escala, y decirlo forma parte de usarlo bien. da un paso más: guarda el modelo base congelado con menos precisión, 4 bits por número en vez de 16 o 32 (es cuantizar, capítulo 14), y entrena los adaptadores en precisión normal. Así caben en una sola tarjeta gráfica modelos que de otra forma no cabrían; es como se afinan hoy la mayoría de modelos abiertos fuera de los grandes laboratorios.

Un modelo afinado ya sigue instrucciones, pero imita: escribe como los ejemplos que vio, con sus virtudes y sus defectos. Para muchas cosas no hay un ejemplo perfecto que copiar, pero sí es fácil decir cuál de dos respuestas es mejor. Eso es el alineamientoAlineamientoCambiar lo que un modelo prefiere, no lo que sabe. El preentrenamiento y el afinado ajustan la probabilidad de la siguiente jugada para parecerse a un corpus; el alineamiento la ajusta para parecerse a un criterio: cuál de dos jugadas es mejor (DPO), o cuánto vale una jugada según una función (GRPO). La diferencia práctica es de dónde sale la señal: de imitar a alguien, o de una comparación que nadie jugó nunca.: empujar al modelo hacia lo que preferimos (más útil, más honesto, menos dañino; en Rukh, mejores jugadas) usando comparaciones en lugar de ejemplos.

La materia prima es el par de preferenciaPar de preferenciaDos respuestas a la misma entrada, una marcada como mejor (chosen) y otra como peor (rejected). En Rukh son dos jugadas legales en la misma posición, con la diferencia en centipeones que el motor les puso. Un par no dice cuánto vale una jugada: dice cuál de las dos gana, y eso basta para Bradley-Terry.: dos respuestas a la misma pregunta, una marcada mejor que la otra. El par solo dice cuál gana, no cuánto vale ninguna.

Empujar hacia la preferida

Con los pares se entrena igual que siempre, con otra pérdida. La forma más directa hoy se llama DPODPODirect Preference Optimization: entrena la política directamente sobre los pares, sin reward model y sin bucle de refuerzo. La referencia es implícita —una copia congelada de los pesos de partida— y β mide cuánto se le deja alejarse de ella. Con una jugada por respuesta, la pérdida se reduce a comparar dos log-probabilidades en una sola posición.: con cada par, el modelo sube un poco la probabilidad de escribir la respuesta preferida y baja la de la otra. Nada más. Miles de pares después, el modelo tiende a contestar como las respuestas que ganaron.

A veces ni siquiera hacen falta pares. Si hay una regla que comprueba sola si una respuesta es buena («el código pasa los tests», «la jugada es legal y el motor la aprueba»), el modelo puede probar varias respuestas y reforzar las que salieron mejor que las demás. Es la recompensa verificable (verifiable rewardRecompensa verificableUna recompensa que calcula un programa y se puede comprobar, en vez de estimarla un modelo entrenado con opiniones. El ajedrez es uno de los pocos sitios donde se puede escribir entera: una jugada es legal o no, un mate es un mate, y el motor pone un número a la posición. Lo que gana es que no puede equivocarse como se equivoca un modelo aprendido; lo que no gana es inmunidad al reward hacking, porque sigue siendo un diseño humano.), y está detrás de los modelos que razonan del capítulo 15.

La correa y la trampa

Cualquier recompensa es un proxyProxyUn número que se mueve en la misma dirección que lo que importa, casi siempre, hasta que deja de hacerlo. La pérdida de validación es el proxy de la fuerza; el top-1 lo es de la calidad. Rukh tiene dos contraejemplos medidos: el mismo checkpoint con dos muestreos se lleva unos 180 Elo con la misma pérdida (1359 con muestreo casi determinista frente a 1181 con la temperatura 0,6 de la demo, D-047), y GRPO subió la recompensa que optimizaba mientras colapsaba la política (M5). La regla: mide la métrica de dominio, y usa el proxy para decidir cuándo medirla. de lo que queremos, y un optimizador potente encuentra sus agujeros. Si el reward model premia las respuestas largas, el modelo aprende a enrollarse; si la recompensa no castiga bien lo ilegal, el modelo descubre que le sale a cuenta. Eso es el reward hackingReward hackingQue el modelo maximice el número en vez de hacer la tarea. En Rukh se midió sin entrenar nada: seis recompensas, cinco de ellas rotas a propósito, sobre el mismo grupo de candidatas. Las seis coronan la misma jugada —el daño no está en la cima— y las rotas se ven en la forma del grupo: una sola candidata catastrófica se lleva el 46 % de la ventaja, y el valor de una recompensa sin tope se mueve 47 veces su intervalo legal al cambiar la profundidad del motor.: la nota sube y lo que querías, no.

La defensa común es la penalización KLPenalización KLLa divergencia KL mide cuánto se aleja una distribución de otra: Σ p · log(p/q), cero si son iguales y mayor cuanto más difieren (no es simétrica, así que no es una distancia en sentido estricto). La penalización KL es el término que ata la política a la copia congelada de donde salió; sin él, una recompensa verificable es una invitación a dejar de jugar al ajedrez y ponerse a cultivar el número. Rukh usa el estimador k3, exp(d) − d − 1 con d = log π_ref − log π, que es no negativo por construcción: la diferencia de log-probabilidades a secas es negativa la mitad de las veces y pagaría al modelo precisamente por alejarse.. KL es una medida de cuánto se ha alejado el modelo de cómo era antes de alinearlo, y el entrenamiento le resta puntos en proporción: cuanto más se aparta de su versión de partida, más le cuesta. Es una correa que le deja ir hacia lo que puntúa bien sin perder lo que ya sabía hacer.

Medir un modelo de lenguaje es más difícil de lo que parece, porque el número que el entrenamiento optimiza no es el que te importa. La pérdida y la perplejidad son un proxyProxyUn número que se mueve en la misma dirección que lo que importa, casi siempre, hasta que deja de hacerlo. La pérdida de validación es el proxy de la fuerza; el top-1 lo es de la calidad. Rukh tiene dos contraejemplos medidos: el mismo checkpoint con dos muestreos se lleva unos 180 Elo con la misma pérdida (1359 con muestreo casi determinista frente a 1181 con la temperatura 0,6 de la demo, D-047), y GRPO subió la recompensa que optimizaba mientras colapsaba la política (M5). La regla: mide la métrica de dominio, y usa el proxy para decidir cuándo medirla.: se mueven en la misma dirección que la calidad, casi siempre, hasta que dejan de hacerlo. Por eso a los modelos se les evalúa con pruebas de la tarea: baterías de preguntas con respuesta conocida (los famosos benchmarks), problemas de programación que tienen que pasar sus tests, jueces humanos o automáticos que comparan respuestas.

Eso último tiene nombre: contaminación, o fuga de datosFuga de datosCualquier camino por el que información del conjunto de validación llega al de entrenamiento. No falla: los números mejoran, y se descubre cuando el modelo sale al mundo. En Rukh se evita partiendo por mes (enero entrena; de febrero, desde M2 parte 4, validan las primeras 100 000 partidas y el resto del mes entrena), por PuzzleId con semilla en los puzles, entrenando el BPE solo con datos de enero y, en M3, repartiendo la tabla de posiciones por game_id con un CRC-32 de la semilla y el id, nunca por posición: dos posiciones consecutivas de la misma partida se diferencian en una jugada. El umbral del detector se elige además en una mitad tune y se mide en otra score, partidas también por partida.. Si las preguntas de evaluación estaban en los datos de entrenamiento, la nota mide memoria, no capacidad. Nunca se manifiesta como un error: los números mejoran, las curvas salen bonitas y el problema aparece cuando el modelo sale al mundo. En los LLM es un problema serio, porque se entrenan con casi todo lo publicado, benchmarks incluidos.

Una nota, siempre con su margen de error

Una métrica útil responde a una pregunta concreta, y conviene tener varias, porque un modelo puede mejorar en una y empeorar en otra a la vez: responder mejor y a la vez inventarse más cosas, por ejemplo.

La que mide jugar de verdad es el EloEloEscala de fuerza de juego: una diferencia de 200 puntos implica que el mejor gana unas tres de cada cuatro veces. Lichess usa Glicko-2, compatible en la práctica. Rukh estima el Elo de cada modelo jugando contra Stockfish limitado y publica el intervalo de confianza.. El modelo juega contra el motor de ajedrez StockfishStockfishMotor de ajedrez libre (GPL-3) y el más fuerte disponible. En Rukh no juega por el modelo: es el juez. Con UCI_LimitStrength y UCI_Elo (1320-3190) se convierte en un rival calibrado para estimar Elo, y a poca profundidad da recompensas baratas para el alineamiento. limitado a varias fuerzas conocidas, y sobre los resultados se ajusta la curva de la fórmula del Elo: la probabilidad de ganar como función de la diferencia de fuerza, que tiene forma de S (una curva logística). Donde esa curva cruza el 50 % está el Elo estimadoElo estimadoFuerza del modelo obtenida ajustando la fórmula logística del Elo a los resultados de partidas contra Stockfish limitado a varios niveles. No es un Elo de la FIDE ni de Lichess: es el número que mejor explica esos resultados, y solo significa algo acompañado de su intervalo de confianza y de la lista de rivales..

Con 160 partidas, el intervalo de confianzaIntervalo de confianzaRango dentro del que cabría la medida si se repitiera; Rukh publica el del 95 % por bootstrap (500 remuestreos) junto a cada Elo. Dos estimaciones solo se pueden declarar distintas si sus intervalos no se solapan: que los puntos estén ordenados («monótono») es barato y sale por azar; que los intervalos se separen es lo que sobrevive al ruido. Cuando se solapan, la aritmética n > 3,84 / (Δp)² dice si faltan partidas o si no hay diferencia, y el suelo de reproducibilidad de la escalera pone un límite que más partidas no bajan: M4 lo estimó en unos ±40 Elo de una sigma con dos tiradas, y M6 lo revisó con cuatro (con la máquina parada, el reloj repite al nivel del ruido de muestreo, D-137). del Elo (el margen dentro del cual está casi seguro el valor real) sale de unos ±55 a ±60 puntos, y un número sin ese margen es una anécdota. Se calcula remuestreando: se rehace la cuenta miles de veces con las mismas partidas escogidas al azar, con repetición, y se mira cuánto baila el resultado (la técnica se llama bootstrap). Además, hay ruido que el margen no cubre: el mismo modelo, medido dos veces con la misma semilla (el número con el que arranca el generador de azar, para que todo se repita igual), sacó 1498 una vez y 1558 la otra, porque Stockfish a una décima de segundo no juega siempre igual. Antes de celebrar una mejora pequeña, hay que medir cuánto se mueve el instrumento cuando no cambias nada.

Y la nota depende de cómo se pregunta. El mismo modelo de Rukh, con el mismo entrenamiento, saca 1359 de Elo o 1181 según la temperatura y el top-k con los que muestrea (capítulo 9). Con un LLM de texto pasa igual: su puntuación en un benchmark cambia con el formato del prompt, la temperatura y cuántos ejemplos lleva delante. Un resultado honesto dice siempre con qué se midió.

Un modelo entrenado es, al final, un fichero con millones o miles de millones de números. Para que alguien lo use hay que cargarlo en memoria y ejecutarlo rápido, en un centro de datos o en el dispositivo de quien lo usa. Las dos cosas chocan con el tamaño: cada parámetro guardado en coma flotante de 32 bits ocupa 4 bytes, así que un modelo de 70 000 millones de parámetros pesa unos 280 GB y no cabe en ninguna tarjeta gráfica de consumo.

Cuantizar: menos bits por número

La cuantizaciónCuantizaciónGuardar y calcular los pesos con menos bits de los que se entrenaron: fp16 (la mitad de tamaño, sin pérdida apreciable) o int8 dinámico (una cuarta parte, con algo de error). En Rukh se cuantizan solo las matrices (MatMul y Gemm) y cada fichero pasa una prueba de paridad contra PyTorch antes de subirse. A 4 bits, la receta de QLoRA en M4, cada peso es uno de 16 niveles: NF4 los coloca donde se amontonan los pesos de una red entrenada (una campana centrada en cero, con un cero exacto), cada bloque de 64 pesos guarda su escala, y esas escalas se cuantizan a su vez a 8 bits (doble cuantización). Para multiplicar, cada bloque se descuantiza al vuelo a bf16: ahorra memoria, no cálculo, y solo sirve para una base congelada; el adaptador que se entrena encima sigue en bf16. guarda cada peso con menos bits: 16 en lugar de 32 (fp16), o solo 8, un entero de −128 a 127 con una escala compartida (int8). Los modelos que la gente ejecuta en su portátil suelen ir a 4 bits. Cada peso cae al escalón más cercano de una rejilla más gruesa, y ese redondeo deja un pequeño error en cada número que el modelo calcula.

La forma de comprobar que no se ha roto nada es la paridadParidadEn cuántas posiciones la jugada elegida por un modelo exportado coincide con la del modelo original. Mide si la exportación está bien hecha, no si el modelo exportado juega igual de bien: un 95,40 % (int8 de small, M2) es un modelo que juega otra cosa una vez de cada veinte, y su Elo hay que medirlo jugando.: en cuántos casos el modelo cuantizado da la misma respuesta que el original. Rukh la midió al exportar su modelo pequeño:

Un 95,40 % de paridad quiere decir que en una de cada veinte posiciones el int8 juega otra cosa. ¿Es peor? La paridad no lo dice; hay que medirlo jugando. El curso lo hizo, y en 160 partidas el int8 no pierde un Elo que se distinga del ruido. Con los LLM de texto pasa lo mismo: que la versión cuantizada «se parezca» no dice que responda igual de bien, eso se mide en la tarea.

Un formato portátil y un motor que lo ejecute

Para ejecutar el modelo fuera del entorno donde se entrenó se exporta a un formato estándar. ONNXONNXFormato abierto para describir el grafo de una red y sus pesos, independiente del framework que la entrenó. Es lo que permite entrenar en PyTorch y ejecutar en el navegador con onnxruntime-web, sin Python ni backend. guarda la red como un grafo de operaciones que cualquier motor compatible sabe correr. Los grandes servicios usan servidores especializados que atienden a miles de usuarios a la vez, agrupando peticiones y reutilizando cálculos (la KV cache del capítulo 10).

Todo lo anterior es el esqueleto de cualquier LLM, del más pequeño al más grande. Los modelos de los chats de hoy añaden encima unas cuantas ideas que Rukh no necesita para jugar al ajedrez pero que conviene conocer. Van en bloques cortos: cada una da para un curso propio.

El prompt: todo lo que sabe en ese momento

Lo que escribes al modelo, el prompt, es lo único que tiene delante: no te recuerda de ayer ni sabe quién eres salvo que el texto lo diga. Quien monta un chat pone además, al principio de cada conversación, un prompt de sistemaPrompt de sistemaInstrucciones que quien despliega un chat pone al principio de cada conversación, antes de lo que escribe el usuario («eres un asistente de…», «responde en español»). Para el modelo son tokens como cualquier otros, marcados con el rol de sistema en la plantilla de chat; el afinado le enseña a darles prioridad. con instrucciones («responde en español, sé breve») que el usuario no ve. Y el prompt puede enseñar: si le das un par de ejemplos de una tarea, el modelo hace el siguiente sin que cambie ni uno de sus pesos. Es el llamado aprendizaje en contextoAprendizaje en contextoLo que hace un modelo cuando aprende una tarea de los ejemplos que lleva el propio prompt, sin que cambie ni uno de sus pesos: le enseñas tres traducciones y traduce la cuarta. Dura lo que dura la conversación. En Rukh la versión mínima son los tokens de Elo: el nivel se pide escribiéndolo delante, no reentrenando. (few-shot):

• gato → cat
• perro → dog
• caballo →
• horse

Funciona porque continuar el patrón es justo lo que aprendió a hacer. Como una nota que le dejas a alguien que se incorpora a mitad de turno: todo lo que necesite saber tiene que estar en la nota, y al día siguiente la nota ya no está.

Contexto largo

Rukh mira 200 tokens, lo que cabe en una partida. Los modelos de hoy leen cientos de miles o millones: un libro entero, un repositorio de código. El problema es que la atención compara cada token con todos los demás, así que su coste crece con el cuadrado de la longitud, y la KV cache ocupa más memoria que el propio modelo. Se resuelve con trucos de ingeniería (atención calculada por bloques, posiciones como RoPE que se pueden estirar, capas que solo miran una ventana cercana) y con entrenamiento específico sobre documentos largos. Que un modelo acepte un millón de tokens no quiere decir que los use todos igual de bien: lo del medio se le escapa más que el principio y el final.

Mezcla de expertos

En lugar de una sola red feed-forward por bloque, una mezcla de expertosMezcla de expertos (MoE)Variante del transformer en la que la red feed-forward de cada bloque se parte en muchos "expertos" y un pequeño enrutador elige, para cada token, solo unos pocos. El modelo tiene muchísimos parámetros pero cada token usa una fracción, así que sabe más sin costar proporcionalmente más por token. Rukh no la usa. tiene muchas y un pequeño enrutador que elige, para cada token, solo unas pocas. El modelo guarda los conocimientos de todos los expertos, pero cada token paga el cálculo de dos.

Más allá del texto

Los modelos que ven fotos o escuchan audio no tienen otro cerebro: tienen otro tokenizador. Una imagen se corta en cuadraditos de unos pocos píxeles (parches) y el audio en tramos de una fracción de segundo; cada trozo pasa por una pequeña red que lo convierte en un vector del mismo tamaño que el embedding de un token de texto. A partir de ahí el transformer lee una sola secuencia con palabras y parches mezclados, y la atención los relaciona igual que relaciona palabras entre sí. Es lo que hace a un modelo multimodalModelo multimodalModelo que lee (o escribe) algo más que texto: imágenes, audio, vídeo. La imagen se corta en parches y el audio en tramos cortos; cada trozo se convierte en un vector, igual que un token de texto, y el mismo transformer los lee todos en una sola secuencia. Rukh no lo es: su único «idioma» son las jugadas.. Como un intérprete: da igual si la frase llega hablada o escrita, una vez traducida se piensa con la misma cabeza.

Modelos que razonan

Un modelo de razonamientoModelo de razonamientoModelo entrenado para escribir un borrador de pasos intermedios (cadena de pensamiento) antes de la respuesta final, normalmente con aprendizaje por refuerzo sobre recompensas verificables: se premia la respuesta correcta y el modelo descubre que pensar por escrito ayuda. Gasta más tokens en inferencia a cambio de acertar más en problemas con solución comprobable. escribe un borrador de pasos intermedios antes de dar la respuesta, la llamada cadena de pensamiento. No se le enseña a pensar con ejemplos: se entrena con refuerzo sobre problemas que tienen solución comprobable (matemáticas, código con tests) y se premia solo la respuesta correcta. Con esa receta, la del GRPO y la recompensa verificable del capítulo 12, el modelo descubre por su cuenta que pensar por escrito, revisar y volver atrás le hace acertar más. Gasta más tokens, y por tanto más tiempo, en cada respuesta.

Por qué se inventa cosas

Un modelo genera la continuación más verosímil, no la verdadera. Casi siempre coinciden, porque lo verdadero es lo que más se repite en los textos; cuando no sabe algo, lo verosímil sigue saliendo con la misma seguridad: una cita con autor, año y página que no existe. Eso es una alucinaciónAlucinaciónRespuesta que suena segura y es falsa: una cita que no existe, un dato inventado. Sale de la tarea misma del modelo, que genera la continuación más verosímil y no la verdadera, y que no trae de serie una forma de decir «no lo sé». Se reduce dándole las fuentes (RAG), pidiéndole que cite, alineándolo para que reconozca la duda y comprobando lo que dice; no desaparece., y no es un fallo puntual sino la tarea misma funcionando donde no hay datos. De serie no hay un token de «no lo sé»: hay que enseñárselo al alinearlo, y aun así se escapa. Se reduce dándole las fuentes (el RAG de abajo), pidiéndole que cite y comprobando lo que dice. Es como el alumno que no se sabe la respuesta del examen oral y, en vez de callarse, improvisa algo que suena a temario.

Buscar antes de contestar: RAG

Un modelo solo sabe lo que había en sus datos de entrenamiento, hasta la fecha en que se cortaron, y cuando no sabe algo tiende a inventar una respuesta verosímil. La técnica RAGRAGRetrieval-Augmented Generation: antes de generar, se recuperan fragmentos relevantes (posiciones parecidas, párrafos de un libro) por similitud de embeddings y se le dan al modelo como contexto. Permite citar fuentes y actualizar conocimiento sin reentrenar. (retrieval-augmented generation) busca primero los fragmentos relevantes en una colección de documentos, comparando embeddingsEmbeddingTabla que asigna un vector aprendido a cada id del vocabulario, y por extensión ese vector. En rukh-small la tabla es de 2 030 × 512: cada jugada UCI entra en el modelo como un punto en un espacio de 512 dimensiones, aprendido a la vez que el resto de la red., y los pega en el contexto antes de la pregunta. El modelo contesta leyendo, puede citar de dónde lo sacó y el conocimiento se actualiza cambiando los documentos, sin reentrenar.

Agentes con herramientas

Un agenteAgentePrograma en el que un modelo de lenguaje decide qué herramienta llamar (motor, modelo, libro, buscador), observa el resultado y vuelve a decidir, en bucle, hasta cumplir una tarea. El entrenador de la fase 2 es un agente construido con LangGraph y trazado con LangSmith. es un modelo de lenguaje en un bucle: decide qué hacer, llama a una herramienta (un buscador, una calculadora, un motor de ajedrez, un programa), lee el resultado y vuelve a decidir, hasta que puede responder. El modelo no ejecuta nada por sí mismo: escribe una petición con un formato acordado y el programa que lo rodea la ejecuta. RAG es el caso de una sola vuelta con una sola herramienta.

Es como un becario con acceso a las herramientas de la oficina: no se sabe todo, pero sabe a quién preguntar y qué programa abrir, y cuanto mejor le describes las herramientas, mejor las usa. Para no tener que describirlas de nuevo en cada aplicación existe MCP (Model Context Protocol), un estándar para enchufar herramientas y fuentes de datos a cualquier modelo.

Si hubiera que contar un LLM en dieciséis frases, serían estas:

1. 00Un LLM predice el siguiente trozo de texto, lo añade y vuelve a empezar; todo lo demás sale de ahí.
2. 01Por dentro es una red neuronal: millones de números que multiplican y suman, ajustados a base de corregir errores.
3. 02El tokenizador corta el texto en trozos frecuentes (BPE) y cada trozo es un número.
4. 03Cada número se cambia por un vector aprendido, un embedding, en el que lo parecido queda cerca.
5. 04A los vectores se les marca la posición, porque la atención por sí sola no sabe de orden.
6. 05La atención deja que cada token recoja información de los demás, según lo que busca y lo que ofrecen.
7. 06Un transformer apila decenas de bloques iguales: atención, una red por token y un carril residual que lo une todo.
8. 07El decoder solo mira hacia atrás y sirve para escribir; el encoder mira a los dos lados y sirve para entender.
9. 08Preentrenar es adivinar el siguiente token sobre montañas de texto y corregir los pesos un poco tras cada fallo.
10. 09Al generar, los logits pasan por temperatura, filtros y softmax, y se sortea un token.
11. 10Se escribe token a token, y la KV cache evita recalcular lo que ya se había leído.
12. 11Afinar con ejemplos le enseña a seguir instrucciones; LoRA lo hace entrenando solo un parche pequeño.
13. 12Alinear lo empuja hacia lo que preferimos con comparaciones o recompensas, atado con una correa para que no haga trampas.
14. 13Se evalúa con pruebas de la tarea, sin contaminación y siempre con su margen de error.
15. 14Se sirve cuantizado, en un formato portátil, en un servidor o en tu propio navegador.
16. 15Y encima de todo eso: contextos larguísimos, expertos, razonamiento, búsqueda y herramientas.

Nada de esto es exclusivo de los gigantes. Rukh hace el recorrido entero con un modelo que se entrena en una sola tarjeta gráfica, y por eso cada paso se puede tocar, medir y romper para ver qué pasa. Si esta página te ha dado el mapa, el curso es el territorio: los mismos conceptos, con el código escrito a mano, los números medidos y los errores que enseñan de verdad.