El interior del transformer

Todo lo que puedes correr en local es un transformer, y la arquitectura cabe en una servilleta: convierte tokens en vectores, pásalos por N capas idénticas donde los tokens se miran entre sí, proyecta el vector final de vuelta a puntuaciones de vocabulario. No hace falta cálculo diferencial — productos punto y un softmax cargan todo el espectáculo. Esta página recorre el camino una vez, despacio.

La corriente residual

Imagina una cinta transportadora corriendo a través del modelo. En cada capa, los submódulos leen la cinta y añaden su contribución de vuelta sobre ella — nada reemplaza, todo se acumula:

x = embed(token_ids) + positions      # los tokens se vuelven vectores (dim ~4k)
for layer in range(N):                # N ≈ 32 para un modelo de 8B
    x = x + attention(x)              # los tokens intercambian información
    x = x + ffn(x)                    # cada token se transforma a sí mismo
logits = unembed(x[-1])               # última posición → puntuación por entrada del vocabulario
p = softmax(logits)                   # probabilidad sobre cada siguiente token

Embedding: cada ID de token indexa una tabla de vectores aprendidos. La información posicional se mezcla (embeddings rotatorios en los modelos modernos), así que «el perro muerde al hombre» difiere de «el hombre muerde al perro».
Las capas son idénticas en forma, distintas en contenido. Las capas tempranas manejan sintaxis y patrones superficiales; las más profundas portan significado, hechos y comportamiento de tarea.
Unembedding: el vector final se compara contra cada entrada del vocabulario; el softmax convierte puntuaciones en probabilidades. El muestreo elige una (muestreo).

Autoatención en cuatro tokens

El mecanismo de intercambio. El vector de cada token produce tres vectores derivados: una consulta (qué estoy buscando), una clave (qué anuncio) y un valor (qué entrego si me eligen). Oración: "The cat sat on". ¿Qué debería atraer la posición de "sat"?

token:          The     cat     sat     on
q·k scores:     1.2     4.1     3.0     0.4      (productos punto, ilustrativos)
softmax →        0.05    0.60    0.31   0.04     (los pesos suman 1.0)

output("sat") = 0.05·v(The) + 0.60·v(cat) + 0.31·v(sat) + 0.04·v(on)

"sat" atiende mayormente a "cat" — el sujeto que necesita. Cada posición corre esto simultáneamente. Una restricción lo convierte en modelo de lenguaje: el enmascaramiento causal — cada token solo puede mirar tokens anteriores, nunca posteriores, de modo que una sola pasada entrena todas las predicciones del siguiente token de la secuencia a la vez.

Ese es todo el kit matemático: puntuaciones de similitud (productos punto), normalizadas en una mezcla (softmax), sobre vectores de valor.

Como receta, una cabeza de atención en una posición:

Calcula los vectores consulta, clave y valor de cada token.
Multiplica en punto la consulta con la clave de cada token anterior; reduce escalando por √(head_dim).
Pasa las puntuaciones por softmax para obtener pesos que suman 1.
Devuelve la suma ponderada de los valores de esos tokens.
Concatena las salidas de todas las cabezas y proyecta — esa es la contribución de atención de la capa.

Multicabeza: patrones en paralelo

Una cabeza = una triple consulta/clave/valor = un tipo de relación que puede expresar (sujeto↔verbo, adjetivo↔sustantivo, correferencia). Las capas corren muchas cabezas en paralelo (p. ej. 32) sobre porciones de menor dimensión y concatenan los resultados. Más cabezas significan más tipos de relación por capa — amplitud de patrón, no profundidad de pensamiento.

Las cabezas quedan fijas en el entrenamiento; «pensar» a través de las posiciones es lo que la atención escribe de vuelta en la corriente residual.
Dim de cabeza (p. ej. 128) × cabezas (p. ej. 32) = dim oculta (4096): las cabezas son porciones paralelas de la misma cinta transportadora, no modelos separados.

La FFN: donde viven los parámetros

La segunda mitad de cada capa es una red de dos matrices aplicada a cada token de forma independiente: expandir el vector (~4×), no linealidad, proyectar de vuelta. En un modelo denso típico, aproximadamente dos tercios de todos los parámetros viven aquí, no en la atención. La intuición útil: memoria clave-valor — la primera matriz guarda patrones que detectar, la segunda qué añadir a la cinta cuando un patrón se dispara. Mucho de lo que la gente llama «los hechos del modelo» está almacenado en los pesos de la FFN (véase parámetros).

Componente	Proporción de parámetros (denso típico 7–9B)
Atención (Q, K, V, O)	~10–15%
FFN	~60–70%
Embedding + cabeza de salida	~10–25% (crece con el tamaño de vocabulario)

Cuenta los parámetros tú mismo

Las tarjetas de modelo publican cinco números; multiplícalos y llegas al recuento de parámetros. Para un modelo abierto real clase 8B (32 capas, dim oculta 4096, 32 cabezas con 8 cabezas KV, ancho FFN 14336, vocab ~128k):

atención/capa:  q: 4096×4096 + k,v: 2×(4096×1024) + o: 4096×4096
                ≈ 42M por capa × 32 capas              ≈ 1.3B
FFN/capa:       3 × (4096×14336), gated ≈ 176M × 32    ≈ 5.6B
embeddings:     2 × (128k × 4096), entrada + salida    ≈ 1.1B
total                                                    ≈ 8.0B

La aritmética coincide con el «8B» de la tarjeta del modelo casi exactamente. Dos lecciones caen por su peso: la FFN domina el recuento de parámetros (y por tanto el presupuesto de memoria), y un vocabulario grande cuesta alrededor de mil millones de parámetros antes de que corra la primera capa — parte de por qué los modelos multilingües de vocabulario grande pesan más de lo que sus hermanos densos sugieren.

GQA: la corrección del coste de la atención

Durante la generación, cada token nuevo debe leer las claves y valores de todos los tokens previos — almacenados en la caché KV. La atención multicabeza original almacena una K y una V por cabeza por token. La atención agrupada por consultas (GQA) comparte un puñado de cabezas KV entre muchas cabezas de consulta (p. ej. 32 cabezas de consulta, 8 cabezas KV), encogiendo la caché 4× a un coste de calidad negligible. La atención multi-consulta (MQA) comparte una única cabeza KV. En la práctica, todos los modelos abiertos modernos usan GQA; esos ahorros son gran parte de por qué el contexto largo es utilizable siquiera (caché KV).

Longitud de contexto = amplitud de atención

La atención deja que cada token vea todos los tokens anteriores, así que el cómputo de prefill crece cuadráticamente con la longitud del prompt y la caché crece linealmente con cada token generado. Un modelo de «contexto 128k» llega ahí con trucos posicionales y extensión entrenada, y la calidad cerca del extremo lejano de la ventana suele ser más débil que cerca del inicio. Llena ventanas largas solo cuando debas.

Pruébalo tú mismo: pon un dato al inicio de la ventana, llena el medio con relleno, pregunta por él. La mayoría de los modelos pasan cerca del principio y del final de la ventana y caen en el medio — el patrón bien conocido de «perderse en el medio». Trata el contexto anunciado como capacidad, no como garantía de calidad.

Por qué esto es suficiente

De esta estructura sola puedes derivar los hechos prácticos: necesidad de memoria = pesos + caché KV (cálculo de VRAM); velocidad de decodificación = qué tan rápido puedes releer los pesos (prefill vs decodificación); la capacidad sigue al recuento de parámetros (parámetros); el coste del contexto = amplitud de atención. La arquitectura es simple — los miles de millones de pesos entrenados dentro de ella son la parte que nadie podría escribir a mano.

Relacionados: qué es un LLM · caché KV · prefill vs decodificación · parámetros