Anatomía de un transformer: el cerebro detrás de la IA generativa

Hasta ahora hemos recorrido el camino de transformar texto en números: tokenización → IDs → embeddings (vectores con significado). Pero esos vectores, por sí solos, no generan texto. Necesitan un procesador, una máquina que los lea, los interprete en contexto, y decida qué token viene después. Esa máquina es el transformer.

El transformer tiene fama de intimidante — y es cierto que los modelos de producción tienen cientos de miles de millones de parámetros. Pero el diseño central, la arquitectura, cabe en una servilleta. Son pocas piezas, y la más importante (el bloque de atención) se repite una y otra vez. Entender estas piezas es entender el 90% de lo que hace que la IA generativa funcione.

La estructura general: un pipeline de principio a fin

Un transformer es, en esencia, un pipeline de procesamiento: entran vectores (los embeddings de los tokens) y sale una predicción (una distribución de probabilidad sobre el vocabulario). El recorrido completo:

1. Tokenizar y embeber — convertir texto en IDs y luego en vectores (la posición entra después, dentro de la atención).
2. Pasar por una pila de bloques — donde ocurre el verdadero “cerebro”: cada bloque refina las representaciones.
3. Normalizar y proyectar — una normalización final y una cabeza de salida que asigna puntajes a cada token del vocabulario.
4. Convertir en probabilidades — aplicar softmax para que los puntajes sumen 1 y se puedan muestrear.

Lo más importante: desde los embeddings hasta la salida, la forma del tensor nunca cambia. Cada token viaja por el modelo como un vector de tamaño fijo (el ancho del modelo). El transformer es un transformador de representaciones: recibe una secuencia de vectores y produce otra secuencia de vectores de la misma longitud y dimensionalidad, pero cada vez más ricos en contexto.

El viaje completo, con un ejemplo — tomemos la frase “el gato se sentó en el tapete”. Tras tokenizar, tenemos 6 tokens:

Fíjate en algo crucial: la forma no cambia en los bloques. El transformer no comprime ni expande la secuencia; la transforma manteniendo la estructura. Cada bloque es una “capa de refinamiento” que mejora las representaciones.

No hay maquinaria especializada por dominio — el mismo diseño sirve para texto, código, imágenes (con adaptadores), y más. Los laboratorios de punta añaden mejoras (atención más eficiente, mixture of experts), pero la arquitectura central sigue siendo la misma. Lo que separa a los líderes de la competencia no está tanto en el plano arquitectónico, sino en los datos, el cómputo, y el refinamiento posterior al entrenamiento.

Dentro de un bloque: el corazón del transformer

Cada bloque tiene dos subcapas principales:

• Atención causal multi-cabeza — donde los tokens “se hablan” entre sí, intercambiando información.
• MLP (Multi-Layer Perceptron) — donde cada token “piensa” individualmente sobre lo que ha escuchado.

Y dos elementos estructurales que envuelven estas subcapas: conexiones residuales (permiten que la información fluya directamente a través del bloque) y normalización pre-norm (estabiliza el entrenamiento).

El bloque se ejecuta en este orden (variante moderna pre-norm):

1. x = x + Atencion(Norma(x))     # los tokens se hablan entre sí
2. x = x + MLP(Norma(x))          # cada token reflexiona individualmente

Las conexiones residuales (las sumas) son autopistas que permiten que la información de capas anteriores llegue intacta a capas posteriores. Sin ellas, entrenar redes profundas sería casi imposible.

Atención causal multi-cabeza: el mecanismo que lo cambió todo

La atención es el ingrediente estrella — el mecanismo que permite que cada token mire a otros tokens y decida cuánto peso darles. La intuición: no todas las palabras en una oración son igualmente importantes para entender una palabra dada.

Analogía: imagina que estás leyendo una frase y te encuentras con la palabra “ella”. Para entender a quién se refiere, necesitas mirar hacia atrás y encontrar el sustantivo femenino más reciente. La atención hace exactamente eso: cada token puede “preguntar” a los demás por información relevante, y recibir respuestas ponderadas.

¿Cómo funciona técnicamente? Cada token genera tres vectores a partir de su embedding:

• Query (Q): “¿Qué estoy buscando?” — la pregunta que hace el token.
• Key (K): “¿Qué ofrezco?” — la etiqueta que el token ofrece a los demás.
• Value (V): “¿Qué información aporto?” — el contenido que comparte si es seleccionado.

El proceso: cada token calcula su puntaje de atención hacia todos los demás (incluyéndose a sí mismo) mediante el producto punto de su query con la key de cada uno — produciendo una matriz de puntajes de tamaño (T × T), donde T es la longitud de la secuencia. Se aplica softmax a esos puntajes (fila por fila) para convertirlos en probabilidades que suman 1. Esa distribución pondera los values de los demás tokens — el resultado es una suma ponderada: cada token recibe una mezcla de información de los demás, ponderada por relevancia.

Atención causal: en los modelos generativos (GPT, Llama, etc.), los tokens solo pueden mirar hacia atrás — posiciones anteriores o a sí mismos, nunca el futuro. Se implementa con una máscara: en la matriz de puntajes, se pone -infinito en las celdas de posiciones futuras, así el softmax les da probabilidad cero. Esto es lo que permite entrenar el modelo prediciendo el siguiente token en paralelo: en una sola pasada, cada posición predice basándose solo en el pasado.

Múltiples cabezas: en lugar de una sola atención, el modelo tiene varias cabezas en paralelo (8, 12, 96…). Cada cabeza aprende sus propias proyecciones Q, K, V, y puede enfocarse en distintos tipos de relaciones — una cabeza podría aprender dependencias sintácticas, otra semánticas, otra de largo alcance. Los resultados de todas las cabezas se concatenan y se proyectan de vuelta al ancho original.

La fórmula de atención, con máscara:

Donde QKᵀ es el producto de queries y keys (la matriz de puntajes), √d_k escala los puntajes para evitar gradientes muy pequeños en el softmax, M es la máscara causal (0 donde se permite mirar, -∞ donde no), y V son los valores que se ponderan.

En la práctica, esta operación corre como un kernel fusionado (scaled dot-product attention), que calcula todo sin materializar la enorme matriz QKᵀ en memoria — dramáticamente más rápido.

# Proyectar X en Q, K, V (una sola proyección produce las tres)
q, k, v = mx.split(self.c_attn(x), 3, axis=-1)   # (B, T, 3*C)

# Reorganizar para cabezas múltiples: (B, n_head, T, head_dim)
B, T, C = x.shape
hd = C // self.n_head
q = q.reshape(B, T, self.n_head, hd).transpose(0, 2, 1, 3)
k = k.reshape(B, T, self.n_head, hd).transpose(0, 2, 1, 3)
v = v.reshape(B, T, self.n_head, hd).transpose(0, 2, 1, 3)

# Aplicar RoPE (posiciones rotativas)
q = self.rope(q)
k = self.rope(k)

# Atención con máscara causal
y = mx.fast.scaled_dot_product_attention(
    q, k, v, scale=1.0 / math.sqrt(hd), mask="causal"
)

# Reorganizar de vuelta
y = y.transpose(0, 2, 1, 3).reshape(B, T, C)

El MLP: cuando cada token piensa por sí mismo

Si la atención es el momento de la conversación (donde los tokens se intercambian información), el MLP es el momento de la reflexión individual — procesa esa información de forma local, sin comunicación con otros tokens.

Analogía: imagina una reunión de equipo. Primero, todos hablan y comparten información (atención). Luego, cada persona se retira a su escritorio, procesa lo escuchado, y toma notas (MLP). Finalmente, vuelven a la reunión con nuevas ideas (el siguiente bloque).

El MLP es una red de dos capas con una no linealidad en medio. Sin la no linealidad, apilar capas lineales sería equivalente a una sola capa — no ganarías capacidad. La no linealidad es lo que permite al MLP aprender funciones complejas.

Estructura moderna (SwiGLU): en lugar del clásico “expandir a 4x, aplicar GELU, comprimir”, los modelos modernos usan SwiGLU. La receta: expandir (proyectar el vector a un espacio más grande, ~2.67× el ancho original), y comprimir (proyectar de vuelta al ancho original, con una compuerta que decide qué información pasa — esa compuerta es la entrada pasada por SiLU, multiplicada por la rama principal). Esto da tres matrices lineales (up, gate, down) en vez de dos, pero mejora el rendimiento.

def __call__(self, x):
    # Primero, atención con normalización y residual
    x = x + self.attn(self.ln_1(x))

    # Luego, MLP con normalización y residual
    h = self.ln_2(x)
    # SwiGLU: gate (con SiLU) * up, luego down
    x = x + self.down(nn.silu(self.gate(h)) * self.up(h))
    return x

El MLP se lleva aproximadamente dos tercios de los parámetros de un bloque (la atención ocupa el tercio restante) — por eso, cuando los modelos escalan, crecen principalmente añadiendo más MLP. Regla mnemotécnica: la atención mueve información entre posiciones; el MLP transforma información dentro de cada posición.

La carretera residual y la normalización: el pegamento que lo une todo

Conexiones residuales: cada subcapa (atención y MLP) no reemplaza el vector de entrada — añade su salida al vector original: salida = entrada + subcapa(entrada). Esto crea una autopista de información que va directamente desde la entrada hasta la salida del bloque, sin pasar por la subcapa. En redes profundas, esto es esencial porque permite que el gradiente fluya sin atenuarse durante el entrenamiento. Antes de que las conexiones residuales se popularizaran (2015-2016), entrenar redes de más de un par de docenas de capas era casi imposible.

Normalización (pre-norm): re-escala los vectores para que tengan una magnitud consistente, evitando que los números “se vayan a la deriva” en capas profundas. Los modelos modernos usan RMSNorm: normaliza por la raíz cuadrada de la media de los cuadrados (sin restar la media) — más ligero computacionalmente. La variante pre-norm (normalizar antes de la subcapa, no después) se popularizó con GPT-2 y es la que usan todos los modelos modernos — facilita mucho la optimización porque las conexiones residuales quedan “limpias”.

Lo que hace un bloque, en cuatro pasos: normalizar, atender, sumar a la autopista; normalizar, correr el MLP, sumar de nuevo. No hay bloque final especial — el modelo obtiene su poder de la repetición.

De vuelta a las palabras: la cabeza de salida

Después de pasar por todos los bloques, el vector en la última posición es la representación final que el modelo tiene de la secuencia hasta ese punto. La cabeza de salida es una proyección lineal: multiplica ese vector por una matriz de tamaño (vocabulario × dim), produciendo un puntaje por cada token del vocabulario. Softmax convierte esos puntajes en probabilidades que suman 1.

Weight tying (compartir pesos): en muchos modelos, la matriz de la cabeza de salida es la misma que la tabla de embeddings de entrada (transpuesta) — el embedding de un token y su puntaje de salida usan los mismos vectores. Tres ventajas: ahorra parámetros (la tabla de embeddings no se duplica), mejora generalización (geometría compartida entre entrada y salida), y estabilidad (no hay que aprender dos representaciones separadas). Es una decisión de diseño común en la línea GPT y muchos otros modelos modernos.

Dimensionando el modelo: los hiperparámetros clave

Un transformer se define por cinco hiperparámetros principales:

Ejemplo concreto: un modelo con 16 bloques, ancho 768, 32 cabezas, contexto 2.1M, y vocabulario 10,000 (el mismo tamaño de vocabulario que usamos en el ejemplo de conteo manual de este capítulo) tiene aproximadamente 120.9 millones de parámetros. Distribución típica: Embeddings (~6%), Atención (~31%), MLP (~62%).

hidden = 64 * ((int(8 * n_embd / 3) + 63) // 64)   # ancho del MLP (SwiGLU), redondeado a 64
per_block = 4 * n_embd * n_embd + 3 * n_embd * hidden
emb = vocab_size * n_embd
total = emb + n_layer * per_block

En modelos pequeños, los embeddings pueden ser una fracción significativa (hasta un tercio, como en nuestro ejemplo de 120.9M). En modelos grandes, el término de los bloques (12d² × capas) domina completamente, porque d² crece rápido. Por eso, los modelos gigantes están hechos, abrumadoramente, de bloques transformer repetidos.

De dónde viene este diseño: una breve historia

El transformer se presentó en el paper “Attention Is All You Need” (Vaswani et al., 2017), originalmente diseñado para traducción automática (de ahí el encoder-decoder original). Pero fue la variante solo-decodificador (causal) la que cambió el juego:

• 2018 — GPT-1 (Radford et al.): primer transformer generativo pre-entrenado a gran escala.
• 2019 — GPT-2: 12 capas, ancho 768, contexto 1,024 → 124 millones de parámetros. Introdujo la variante pre-norm y popularizó el weight tying.
• 2020 — GPT-3: 96 capas, ancho 12,288, 96 cabezas → 175 mil millones de parámetros. La arquitectura apenas cambió; solo escalaron.

Desde entonces, la arquitectura central se ha mantenido, con mejoras incrementales: RoPE reemplaza las posiciones absolutas, SwiGLU reemplaza a GELU en el MLP, y mixture of experts (MoE) reemplaza algunos MLP densos por múltiples expertos con un enrutador — dando dos métricas de tamaño: parámetros totales vs. parámetros activos (un modelo reciente tiene 975B parámetros totales pero activa solo 41B por token).

Un dato que vale la pena remarcar: en el salto de GPT-2 a GPT-3, la arquitectura apenas cambió — la mayor diferencia fue el volumen de datos y el número de parámetros. Esto subraya una lección importante: la arquitectura importa, pero los datos y el cómputo son igual de cruciales.

Resumen del capítulo

El transformer es un procesador de secuencias que:

• Tokeniza y embebe, convirtiendo texto en vectores.
• Apila bloques, cada uno con atención causal multi-cabeza (los tokens intercambian información mirando solo hacia atrás) y MLP con SwiGLU (cada token procesa individualmente lo recibido), envueltos en conexiones residuales y normalización pre-norm que permiten entrenar redes profundas.
• Proyecta y aplica softmax para obtener una distribución de probabilidad sobre el vocabulario.

El modelo no tiene memoria externa ni estado persistente: cada predicción se basa únicamente en la secuencia de tokens actual. Todo el “conocimiento” del modelo vive en los parámetros — pesos de atención y MLP, y la tabla de embeddings — que se aprenden durante el entrenamiento.

En el próximo capítulo veremos cómo se entrena realmente un modelo: los datos de entrenamiento, la función de pérdida, y el descenso de gradiente a escala masiva. Entender la arquitectura es solo la mitad; la otra mitad es cómo convertir montañas de texto en parámetros útiles.

Si en algún momento te sientes abrumado por la complejidad, vuelve a esta idea central: un bloque transformer son solo dos subcapas (atención y MLP) unidas por sumas residuales y normalización. El poder no viene de una pieza mágica, sino de la repetición y la escala. Es como un taller de artesanía: cada obrero (bloque) hace un pequeño refinamiento, y tras muchos obreros y muchas iteraciones, la pieza queda perfecta. El transformer no es magia, es ingeniería.