Cómo funcionan los Transformers, desde los cuellos de botella de las RNN hasta la atención, los agentes y las ventanas de contexto
Un recorrido paso a paso por el transformador: por qué se estancaron las RNN, cómo funcionan los tokens y las embeddings, la atención, QKV, las cabezas, las posiciones, la estructura de bloques, la escala y los agentes.
Cualquiera que solo utilice herramientas de IA puede arreglárselas sin entender qué hay detrás de ellas. Pero aquellos que quieren desarrollar, depurar o mejorar esos sistemas no pueden hacerlo. Cada modelo de lenguaje grande en uso actual se basa en una arquitectura presentada en un artículo de 2017 de unas quince páginas titulado “Attention Is All You Need”. Pocos artículos de investigación de la última década han cambiado tanto la dirección de la inteligencia artificial. Las ideas en su base no son tan complejas como parecen, y la lógica matemática resulta comprensible si se explica en el orden adecuado. Después de eso, esas mismas ideas aparecen por todas partes: en la forma en que los agentes planifican, en el motivo por el cual funciona el aprendizaje in-contexto, en la razón por la que un modelo puede pasar de un tema a otro durante una conversación, y en el porqué las ventanas de contexto más largas son tan importantes.
La ruta que se describe a continuación comienza con el antiguo enfoque secuencial y las razones por las que fracasó, pasa por cómo el texto se convierte en números, luego por la atención y la estructura completa del bloque, y finaliza explicando cómo el diseño evolucionó hasta dar lugar a los modelos de lenguaje y agentes actuales.
Por qué leer el texto una palabra a la vez chocó contra un muro
Antes de los transformadores, el lenguaje se procesaba principalmente mediante redes neuronales recurrentes, generalmente abreviadas como RNN. La idea es sencilla: la red recorre una secuencia palabra por palabra y lleva consigo un estado oculto que representa un resumen continuo de todo lo visto hasta ese momento.
Una imagen aproximada: alguien lee una novela pero solo puede guardar una nota adhesiva, y debe ir página por página, sin saltar hacia adelante ni retroceder. Después de cada oración, la nota se reescribe con lo que parezca importante, pero es muy pequeña. Para la página 300, casi nada queda de lo que había en la página 1. Tampoco es posible entregar el capítulo dos a un amigo para que lo lea al mismo tiempo, ya que primero hay que terminar las notas del capítulo uno.
Ese orden estricto genera dos problemas de escalamiento separados.
El primero es el gradiente que desaparece. El entrenamiento ajusta los pesos mediante retropropagación, la cual determina cuánto contribuyó cada parámetro al error. En una RNN que lee una secuencia larga, esa señal debe viajar hacia atrás a través de cada paso temporal. Para cuando llega a los pasos más tempranos, a menudo se ha reducido casi a cero, por lo que la red en realidad no puede aprender de lo que hicieron esas primeras palabras.
El segundo es el cuello de botella secuencial. El resultado en la posición n no puede calcularse antes de que se complete la posición n-1, ya que cada paso consume el estado oculto anterior. Las GPU modernas están diseñadas para realizar una enorme cantidad de operaciones al mismo tiempo, y las RNN casi no les ofrecen nada para hacer en paralelo. Un documento de 1,000 palabras requiere 1,000 pasos seguidos, con el hardware en su mayor parte inactivo entre ellos.
El diagrama a continuación contrasta las dos formas de manejar los tokens: uno por uno con un estado oculto que se desvanece en un lado, y cada par conectado al mismo tiempo en el otro:
╔══════════════════════════════════════════════════════════════════════════════╗
║ RNN vs TRANSFORMER: HOW TOKENS ARE PROCESSED ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ RNN ── Sequential (slow, forgets early context) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ║
║ │ │ │ │ │ │ ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ RNN │──▶│ RNN │─▶│ RNN │▶│ RNN │▶│ RNN │▶│ RNN │ ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ h₁ ──▶ h₂ ──▶ h₃ ──▶ h₄ ──▶ h₅ ──▶ h₆ ║
║ ║
║ Step 1 Step 2 Step 3 Step 4 Step 5 Step 6 (must wait!) ║
║ ⚠ "The" signal is diluted through 5 hops by the time we reach "mat" ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌─────────────────────────────────────────────────────────────────────┐ ║
║ │ TRANSFORMER ── Parallel (fast, every token sees all others) │ ║
║ └─────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ "The" "cat" "sat" "on" "the" "mat" ◀── ALL AT ONCE ║
║ │╲╲ │╲ ╲╲ │╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ │ ╲╲ │ ╲ ╲╲ │ ╲╲ ╲ │ ╲╲ │ ╲╲ │ ║
║ ├───╫──┼───╫───┼───╫───┼────╫──┼────╫───┤ ← every token ║
║ │ ╱╱ │ ╱ ╱╱ │ ╱╱ ╱ │ ╱╱ │ ╱╱ │ attends to ║
║ │╱╱ │╱ ╱╱ │╱╱ ╱ │ ╱╱ │ ╱╱ │ every token ║
║ ▼ ▼ ▼ ▼ ▼ ▼ ║
║ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ║
║ │ out │ │ out │ │ out │ │ out │ │ out │ │ out │ ← all computed ║
║ │ 1 │ │ 2 │ │ 3 │ │ 4 │ │ 5 │ │ 6 │ simultaneously ║
║ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ ║
║ ✓ "The" has DIRECT connection to "mat" — no information decay ║
║ ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ LEGEND: ──▶ sequential dependency ╲╱╱ all-pairs attention ║
║ h₁ hidden state ⚠ information bottleneck ║
╚══════════════════════════════════════════════════════════════════════════════╝
Las puertas ayudaron, pero no cambiaron la naturaleza del problema
Las redes de memoria a largo y corto plazo, introducidas por Hochreiter y Schmidhuber en 1997, incorporaron puertas que permitían un control explícito sobre qué conservar, qué descartar y qué emitir en cada paso. Funcionaron bien. A lo largo de la década de 2010, se utilizaron en la mayoría de las aplicaciones prácticas de procesamiento del lenguaje natural, incluyendo las primeras traducciones automáticas, el análisis de sentimientos y la generación de texto.
Siguieron siendo secuenciales. Las dependencias a muy largo alcance seguían siendo difíciles de manejar, y el hardware paralelo aún no podía utilizarse en su totalidad. Las LSTM no fracasaron porque modelaran mal el lenguaje, sino porque no podían escalar: añadir más recursos computacionales generaba beneficios cada vez menores, y para superar ese límite se necesitaba un estilo de cálculo completamente diferente.
De texto a números
Las redes neuronales procesan números y el lenguaje está formado por palabras, por lo que es necesario realizar una conversión antes de que la atención entre en juego. Esto implica dos pasos: tokenización e incrustación.
Tokenización
La tokenización convierte una cadena en una secuencia de identificadores enteros extraídos de un vocabulario fijo. Lo primero que hay que entender es que los tokens no son palabras. Los tokenizadores modernos dividen el texto en fragmentos subpalabras, generalmente mediante Byte-Pair Encoding o WordPiece, y los resultados se ven así:
"Hello world" → ["Hello", " world"] → [15496, 995]
"unbelievable" → ["un", "believ", "able"] → [256, 9391, 540]
"ChatGPT" → ["Chat", "G", "PT"] → [14126, 38, 2969]
"antidisestablishmentarianism" → ["ant", "idis", "est", "ablish", "ment", "ari", "an", "ism"]
Las palabras frecuentes reciben su propio token, mientras que las palabras raras o compuestas se dividen en partes más pequeñas. Esto permite una buena cobertura con un vocabulario de tamaño manejable, ya que no es necesario tener una entrada para cada palabra posible. Los tamaños de vocabulario van desde unos 30,000 en BERT y 50,257 en GPT-2 hasta más de 100,000 en los modelos más recientes.
Una conversión útil para el inglés: un token equivale a aproximadamente tres cuartos de una palabra, o una palabra equivale a unos 1.3 tokens. Por lo tanto, una novela de 100,000 palabras tiene aproximadamente 133,000 tokens, lo cual es importante cuando existen límites en la ventana de contexto.
Embeddings
Una matriz de incrustación con una fila por entrada del vocabulario y d_model columnas asigna a cada ID de token un vector denso. Consultar un token consiste simplemente en seleccionar su fila. El ID de token 995, que representa “world”, apunta a la fila 995 y devuelve valores de d_model, como por ejemplo 0.24, -0.83, 0.17 y así sucesivamente hasta 0.91.
Esa matrices se aprenden durante el entrenamiento, y surge una propiedad útil: los tokens con significados relacionados terminan teniendo vectores que están geográficamente cercanos.
Cosine similarity in embedding space:
similarity("cat", "lion") ≈ 0.89 ← very similar
similarity("cat", "moon") ≈ 0.12 ← not similar
similarity("king", "queen") ≈ 0.91 ← very similar
Una advertencia sobre el famoso ejemplo de que rey menos hombre más mujer igual a reina. Esa aritmética proviene de Word2Vec en 2013 y no de los embeddings de transformadores. Los transformadores aprenden sus embeddings junto con todos los demás parámetros, por lo que la aritmética vectorial pura es menos fiable. Lo que sí se mantiene es el principio de que las palabras con significados relacionados ocupan regiones adyacentes en ese espacio.
Una anchura en todas partes
Una dimensión fija, d_model, aparece en todas partes de un transformador: en los embeddings, en las salidas de atención y en las entradas y salidas de las capas feed-forward. Esto se hace intencionadamente. Cada componente lee y escribe en un flujo de vectores de ancho fijo, llamado flujo residual, que fluye a través de cada capa. Dado que todos los componentes trabajan con un vector del mismo tamaño y suman sus resultados en él, las partes se combinan de manera ordenada. También es la razón por la cual la información posicional puede añadirse simplemente a un embedding de token: ambos tienen la misma forma, y su suma se introduce directamente en el flujo.
Por lo tanto, la entrada al primer bloque es la incrustación del token más un vector de posición. Dado que ambos se encuentran en el mismo espacio, su suma no requiere parámetros adicionales, y la información de posición se integra en los mismos vectores que transmiten el significado. Los modelos de estilo BERT que procesan dos oraciones juntas, como en las respuestas a preguntas con una pregunta y un pasaje, añaden una incrustación de segmento que indica a qué oración pertenece cada token: 0 para la primera y 1 para la segunda. Los modelos de estilo GPT la omiten.
Atención: aprender dónde mirar
Alrededor de 2014 y 2015, los investigadores que trabajaban en la traducción automática detectaron una deficiencia incluso en los sistemas LSTM. El modelo comprimía todo lo que sabía sobre la oración de entrada en un vector de tamaño fijo antes de comenzar a generar la salida, lo cual representaba otro cuello de botella. La pregunta obvia era si el modelo podía echar un vistazo a toda la entrada en cada paso de la generación. La respuesta a esa pregunta fue el mecanismo de atención, que cambió la forma en que se modelan las secuencias.
Dos situaciones cotidianas hacen que esta idea sea intuitiva.
En una fiesta ruidosa con diez conversaciones simultáneas, el cerebro no otorga la misma importancia a cada sonido al seguir a un amigo. Potencia la voz y la dirección de ese amigo y atenúa el resto, sin apagarlo por completo. La ponderación es continua, no se trata de un interruptor de encendido/apagado.
Al recibir una foto de clase y tener que encontrar al profesor, una persona no escanea cada píxel de manera igual. La búsqueda se dirige directamente a las características que sugieren la presencia de un adulto, como la altura en comparación con los demás y las proporciones faciales. Lo que se busca determina hacia dónde van los ojos.
La atención computacional convierte estas intuiciones en cuatro pasos: tener algo que buscar, que es la consulta; contar con un conjunto de candidatos que podrían ser relevantes; asignar a cada candidato una puntuación de relevancia continua; y combinar la información, ponderada según esas puntuaciones.
Un concepto erróneo que vale la pena aclarar desde el principio: la atención no significa que el modelo se enfoque únicamente en una cosa e ignore todo lo demás. El resultado es un promedio ponderado al que contribuye cada elemento, algunos de ellos mucho más que otros. Se trata de una consideración graduada y no de un enfoque binario.
La forma original, añadida posteriormente
En su forma inicial, la atención era un complemento para los modelos RNN y LSTM. En cada paso de decodificación, el modelo realizaba lo siguiente:
- examinaba todos los estados ocultos del codificador;
- calculaba una puntuación de relevancia entre el estado actual del decodificador y cada estado del codificador;
- convertía esas puntuaciones en pesos mediante softmax;
- tomaba la suma ponderada de los estados del codificador como el contexto de atención.
Softmax merece una breve explicación. Convierte un vector de números reales arbitrarios en una distribución de probabilidades. Cada puntuación se convierte en e elevado a esa puntuación, dividido entre la suma de e elevado a cada una de las puntuaciones. Todos los resultados son positivos y suman 1; además, como la función exponencial amplifica la diferencia entre puntuaciones altas y bajas, el elemento con la puntuación más alta obtiene la mayor parte del peso.
Esto representó una gran mejora, ya que el modelo podía acceder ahora a cualquier parte de la entrada en cada paso. Luego, los autores de “Attention Is All You Need” plantearon algo aún más audaz: ¿qué pasaría si se eliminara la estructura recurrente y la atención no fuera algo adicional, sino todo el modelo?
Autoatención y el trío de consulta, clave y valor
La idea central del artículo de 2017 es la autoatención. En lugar de pasar la atención de una secuencia a otra, cada token en una misma secuencia presta atención a todos los demás tokens de esa misma secuencia. Así es como un transformador construye el contexto, y para comprenderlo se necesitan tres vectores presentes en cada cálculo de atención: la consulta, la clave y el valor.
Un motor de búsqueda de videos
Al escribir “cómo hacer pan de masa madre” en un sitio de videos, no se compara el texto con cada frame de cada video. Cada video cuenta con etiquetas de metadatos que funcionan como claves: título, etiquetas, palabras clave de descripción. El sitio compara la consulta con esas etiquetas para obtener puntuaciones de relevancia, y se muestran los videos con las puntuaciones más altas para poder recuperar su contenido real, es decir, los valores correspondientes.
Existe un matiz importante en este proceso. El resultado no es un único video, sino una mezcla ponderada de todos los videos al mismo tiempo, siendo cada uno reproducido a un volumen proporcional a su nivel de relevancia. El video más relevante predomina, con contribuciones más suaves de los demás superpuestas debajo. La relación de correspondencia es la siguiente:
| YouTube Concept | Attention Concept | Question it Answers |
|----------------|------------------|---------------------|
| Search query | **Query (Q)** | "What am I looking for?" |
| Video metadata/tags | **Key (K)** | "What do I contain?" |
| Actual video content | **Value (V)** | "What should I contribute?" |
¿Por qué tres vectores separados?
¿Por qué no comparar los embeddings directamente? Tomemos la oración “El gato se sentó en la alfombra porque estaba cansado”. Para determinar a qué se refiere “él”, la palabra debe prestar atención al “gato”. Sin embargo, en el espacio de embeddings en bruto, un pronombre y un sustantivo no son especialmente similares. Al dividirlos en consultas y claves, el modelo puede aprender que la consulta de un pronombre debe coincidir con las claves de los sustantivos a los que podría referirse, incluso cuando el pronombre y el sustantivo no se parecen en absoluto en sus embeddings base. Las proyecciones aprendidas crean un espacio de relevancia que es distinto del espacio de similitud de los embeddings en bruto. La relevancia y la similitud son cosas diferentes, y el diseño QKV permite al modelo codificar ambas.
Atención por producto escalar escalado en cuatro pasos
El primer paso es la proyección. La representación de cada token se multiplica por tres matrices aprendidas, W_Q, W_K y W_V, lo que genera una consulta, una clave y un valor para dicho token.
El segundo paso mide la compatibilidad. La pregunta es hasta qué punto el token a coincide con el token b, y la respuesta es el producto escalar entre la consulta de a y la clave de b. Un valor alto indica que el token a debe prestar mucha atención al token b. Los productos escalares aumentan con el tamaño del vector y con la dimensión de la clave d_k, no solo con su dirección; por eso el paso siguiente los reescala.
El tercer paso realiza la escalamiento y normalización. Cuando d_k es grande, los productos escalares brutos se vuelven elevados y empujan a la función softmax hacia regiones donde los gradientes son muy pequeños. Dividir entre la raíz cuadrada de d_k antes de aplicar softmax evita esto, y de ahí proviene el nombre del método: atención por producto escalado. El resultado es un conjunto de pesos alpha_ab.
La cuarta etapa es la agregación. El resultado para el token a es la suma, sobre cada token b, de alpha_ab multiplicado por el vector de valores de b.
Todos los tokens pueden manejarse juntos como matrices, en una sola línea compacta: Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. El diagrama lo ilustra para la frase de tres palabras “the cat sat”:
╔══════════════════════════════════════════════════════════════════════════════╗
║ SCALED DOT-PRODUCT ATTENTION ── "the cat sat" ║
╚══════════════════════════════════════════════════════════════════════════════╝
STEP 1: Input embeddings - ALL tokens are stacked into one matrix X
┌─────────────────────────────────────────┐
│ "the"→x₁ "cat"→x₂ "sat"→x₃ │ X ∈ ℝⁿˣᵈ
└──────────────────┬──────────────────────┘
│ the SAME X feeds all three projections
STEP 2: Three separate linear projections (each applied to every token)
┌─────────────┴─────────────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ W_Q │ │ W_K │ │ W_V │ ← learned weight matrices
└────┬────┘ └────┬────┘ └────┬────┘
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│ Q rows │ │ K rows │ │ V rows │
│ q₁ │ │ k₁ │ │ v₁ │
│ q₂ │ │ k₂ │ │ v₂ │
│ q₃ │ │ k₃ │ │ v₃ │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
STEP 3: score = QKᵀ, scale by 1/√dₖ, then softmax row-wise
│ │ │
└──────┬──────┘ │
▼ │
┌─────────────────────┐ │
│ softmax(QKᵀ / √dₖ) │ │
│ the cat sat │ │
│ the[.72 .20 .08] │ │ each row
│ cat[.12 .71 .17] │ │ sums to 1.0
│ sat[.09 .28 .63] │ │
└──────────┬──────────┘ │
│ │
STEP 4: multiply weights by Values V (weighted sum)
└──────────┬─────────┘
▼
┌─────────────────┐
│ output for "cat"│ 0.12·v₁ + 0.71·v₂ + 0.17·v₃
└────────┬────────┘ ← rich context-aware vector
│
OUTPUT: contextualized token representations
┌──────────┐ ┌──────────┐ ┌──────────┐
│"the" │ │"cat" │ │"sat" │
│knows it │ │knows it │ │knows │
│precedes │ │sat, and │ │who was │
│"cat" │ │where │ │sitting │
└──────────┘ └──────────┘ └──────────┘
Un caso práctico: el banco de palabras
Tomemos la frase “Ella fue al banco a depositar dinero”. Mientras que el transformador codifica “bank”, la autoatención permite que esa palabra examine todas las demás palabras al mismo tiempo. Se asigna un peso elevado a “deposit” y “money”, lo que introduce el significado financiero en la representación de “bank”. El contexto resuelve la ambigüedad.
╔══════════════════════════════════════════════════════════════════════════════╗
║ SELF-ATTENTION RESOLVES AMBIGUITY: What does "bank" mean? ║
╚══════════════════════════════════════════════════════════════════════════════╝
Sentence: "I went to the bank to deposit money"
t₁ t₂ t₃ t₄ t₅ t₆ t₇ t₈
ATTENTION WEIGHTS for token "bank" (t₅) attending to all other tokens:
Token │ Weight │ Visualization
──────────┼────────┼───────────────────────────────────────────
"I" │ 0.03 │ ░
"went" │ 0.04 │ ░
"to" │ 0.02 │
"the" │ 0.03 │ ░
"bank" │ 0.08 │ ░░
"to" │ 0.05 │ ░
"deposit" │ 0.38 │ ████████████████████████░░░░░░░░ ← strong!
"money" │ 0.37 │ ████████████████████████░░░░░░░ ← strong!
FULL ATTENTION HEATMAP (rows = query token, columns = key token):
Higher weight → more ░/▒/▓/█
Q\K │ I went to the bank to deposit money
──────────┼──────────────────────────────────────────────
I │ ▓ ░ ░ ░ ░ ░ ░ ░
went │ ░ ▓ ░ ░ ░ ░ ░ ░
bank │ ░ ░ ░ ░ ▒ ░ █ █ ← "bank"→"deposit","money"
deposit │ ░ ░ ░ ░ █ ░ ▓ ▒ ← "deposit"→"bank"
money │ ░ ░ ░ ░ █ ░ ▒ ▓ ← "money"→"bank"
BEFORE attention: "bank" = ambiguous (river bank? financial bank?)
AFTER attention: "bank" ≈ 0.38·v(deposit) + 0.37·v(money) + ...
→ "bank" representation is now strongly financial ✓
The model learned this WITHOUT any explicit disambiguation rules.
Las ponderaciones en esa ilustración se han creado con fines de claridad y no provienen de un modelo real. Los patrones reales suelen ser más desordenados, y la investigación sobre cómo se relacionan las ponderaciones de atención con lo que el modelo “piensa” aún está en curso. La ventaja práctica es distinta a la que se muestra en la imagen: la autoatención para todos los tokens consiste en una multiplicación de matrices, es decir, una sola operación en la GPU. Lo que a una RNN le cuesta n pasos secuenciales, a un transformador le cuesta una operación paralela, y esa es la razón por la cual los transformadores son escalables.
Varias cabezas, varias perspectivas
Una cabeza procesa un solo tipo de relevancia a la vez, ¿entonces qué ocurre cuando varios tipos de relación son importantes al mismo tiempo? Observe la frase “El músico que actuó en el festival ganó el premio”. Comprenderla implica seguir varias dependencias al mismo tiempo: “ganó” con “músico” como sujeto y verbo, “músico” con “actuó” a través de la oración subordinada, “actuó” con “festival” como lugar, y “premio” con “ganó” como verbo y objeto.
Una sola cabeza tendría que incluir todo eso en un único conjunto de pesos. En cambio, la atención multi-cabeza ejecuta la función de atención h veces en paralelo, cada vez con sus propias proyecciones aprendidas para consultas, claves y valores. Las h salidas se concatenan y pasan por otra matriz aprendida, W_O, que las mapea de vuelta a la dimensión del modelo. Cada cabeza funciona en un subespacio más pequeño, con d_k igual a d_model dividido entre h, por lo que el costo total de todas las cabezas es aproximadamente el de una sola cabeza de ancho completo.
Imagínese un manuscrito enviado a un comité editorial. Un corrector gramatical verifica la sintaxis, un corrector de estilo sigue el flujo narrativo, un verificador de hechos busca consistencia semántica y un corrector estructural observa la organización a largo plazo. Todos leen al mismo tiempo e independientemente, y sus notas se combinan en una sola reseña. La atención multi-cabeza funciona de la misma manera.
╔══════════════════════════════════════════════════════════════════════════════╗
║ MULTI-HEAD ATTENTION (3 heads shown) ║
╚══════════════════════════════════════════════════════════════════════════════╝
Input Embedding x ∈ ℝᵈ_model
┌────────────────────────────┐
│ [ x₁ x₂ x₃ ... xₙ ] │
└──────────┬─────────────────┘
│
┌────────────────────┼────────────────────┐
│ │ │
▼ ▼ ▼
╔══════════════╗ ╔══════════════╗ ╔══════════════╗
║ HEAD 1 ║ ║ HEAD 2 ║ ║ HEAD 3 ║
║ "Syntax" ║ ║ "Semantics" ║ ║ "Position" ║
║ ║ ║ ║ ║ ║
║ W_Q¹ W_K¹ ║ ║ W_Q² W_K² ║ ║ W_Q³ W_K³ ║
║ W_V¹ ║ ║ W_V² ║ ║ W_V³ ║
║ ║ ║ ║ ║ ║
║ ┌──────────┐ ║ ║ ┌──────────┐ ║ ║ ┌──────────┐ ║
║ │ Scaled │ ║ ║ │ Scaled │ ║ ║ │ Scaled │ ║
║ │ Dot- │ ║ ║ │ Dot- │ ║ ║ │ Dot- │ ║
║ │ Product │ ║ ║ │ Product │ ║ ║ │ Product │ ║
║ │Attention │ ║ ║ │Attention │ ║ ║ │Attention │ ║
║ └────┬─────┘ ║ ║ └────┬─────┘ ║ ║ └────┬─────┘ ║
║ │ ║ ║ │ ║ ║ │ ║
║ learns: ║ ║ learns: ║ ║ learns: ║
║ subject-verb ║ ║ word meaning ║ ║ nearby-word ║
║ agreement ║ ║ similarity ║ ║ relationships║
╚══════╤═══════╝ ╚══════╤═══════╝ ╚══════╤═══════╝
│ head₁ ∈ ℝⁿˣ⁽ᵈ/ʰ⁾ │ head₂ │ head₃
└───────────────────┼───────────────────┘
▼
┌──────────────────────────────┐
│ CONCATENATE all heads │
│ [head₁ ║ head₂ ║ head₃] │ ∈ ℝⁿˣᵈ_model
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Final linear projection W_O │ blends info from all heads
└──────────────┬───────────────┘
▼
┌──────────────────────────────┐
│ Multi-Head Attention Output │ ∈ ℝⁿˣᵈ_model (same shape as input)
└──────────────────────────────┘
Qué hacen las cabezas en realidad
Los análisis de los modelos entrenados han revelado cabezas especializadas. Algunas se encargan de la sintaxis, como la concordancia sujeto-verbo y los modificadores asociados a los sustantivos. Otras operan a largas distancias, relacionando pronombres con sus antecedentes. Hay también cabezas locales que se centran en palabras adyacentes y patrones bigramaticos. Algunas miden la distancia relativa entre los tokens, mientras que otras identifican los roles temáticos, es decir, quién hizo qué a quién. Nadie programa esto; el entrenamiento recompensa las predicciones precisas, y la red descubre que dividir el trabajo entre cabezas especializadas funciona.
Una limitación de ese enfoque: estas categorías provienen principalmente de trabajos sobre interpretabilidad en modelos más pequeños. En los modelos grandes, muchas cabezas no pueden ser analizadas con claridad, y los experimentos demuestran que tales modelos suelen seguir funcionando bien incluso después de eliminar muchas cabezas, con poca pérdida en rendimiento. La arquitectura permite la especialización, pero no garantiza divisiones claras y fáciles de comprender para los humanos.
Asignar una dirección a las palabras
La autoatención relaciona cada par de tokens, pero al hacerlo trata la secuencia como un conjunto sin orden. La puntuación entre cualquier token a y el token b depende únicamente del contenido, no de cuál viene primero ni de cuán separados estén. El lenguaje es altamente dependiente del orden. “El perro muerde al hombre” y “El hombre muerde al perro” contienen las mismas palabras pero significan cosas opuestas, y “no feliz” dice algo muy diferente de “feliz no”. Dado que un transformador procesa todas las posiciones en paralelo, por defecto nada en él codifica el orden, por lo que este debe ser introducido explícitamente. Esa es la función de la codificación posicional.
Imagínese agregar metadatos a cada edificio de una ciudad. Cada uno necesita una dirección que indique su ubicación exacta, exprese su posición relativa (el edificio 402 está cerca del 404) y funcione sin necesidad de conocer previamente el plano completo de la ciudad. Las coordenadas GPS lo logran de manera eficaz. La codificación posicional es la versión lingüística: una coordenada matemática añadida a la representación de cada palabra.
Ondas seno y coseno
El transformador original utilizaba funciones sinusoidales, con una frecuencia por cada par de dimensiones de incrustación. Para la posición pos y el índice de dimensión k, los senos y cosenos de pos divididos entre una potencia de 10000 y escalados por k llenan el vector. Las ondas lentas de baja frecuencia marcan posiciones aproximadas, mientras que las rápidas de alta frecuencia indican posiciones precisas; juntas, le dan a cada posición una huella digital única.
╔══════════════════════════════════════════════════════════════════════════╗
║ SINUSOIDAL POSITIONAL ENCODING ║
╚══════════════════════════════════════════════════════════════════════════╝
GRID: exact values for a tiny d_model=8 - positions 0-4, dims 0-7
(frequency denominators are 1, 10, 100, 1000 for dim-pairs 0,1,2,3)
dim→ d=0 d=1 d=2 d=3 d=4 d=5 d=6 d=7
sin cos sin cos sin cos sin cos
pos↓ ──────────────────────────────────────────────────────
pos=0 │ 0.000 1.000 0.000 1.000 0.000 1.000 0.000 1.000 │
pos=1 │ 0.841 0.540 0.100 0.995 0.010 1.000 0.001 1.000 │
pos=2 │ 0.909 -0.416 0.199 0.980 0.020 1.000 0.002 1.000 │
pos=3 │ 0.141 -0.990 0.296 0.955 0.030 1.000 0.003 1.000 │
pos=4 │ -0.757 -0.654 0.389 0.921 0.040 0.999 0.004 1.000 │
↑ fast-changing ↑ medium-changing ↑ very slow
(high frequency) (mid frequency) (low freq)
unique per position gradual shift global structure
WAVE PATTERNS (each row = one dimension across positions):
dim 0 (sin): █ ▇ ▄ ▁ ▂ ▅ ▇ █ ▇ ▄ ▁ ← fast oscillation
dim 2 (sin): █ █ ▇ ▇ ▆ ▅ ▄ ▃ ▂ ▁ ▁ ← medium oscillation
dim 4 (sin): █ █ █ █ █ █ ▇ ▇ ▇ ▇ ▆ ← slow oscillation
dim 6 (sin): █ █ █ █ █ █ █ █ █ █ █ ← very slow oscillation
HOW IT'S USED: Added to the token embedding elementwise
┌─────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│ Token Embedding│ │ Positional Enc. │ │ Final Input x_t │
│ "cat" │ │ position = 2 │ │ │
│ [0.2, 0.8, │ │ [0.9,-0.4, │ │ [1.1, 0.4, │
│ 0.1, 0.5, │ + │ 0.2, 1.0, │ = │ 0.3, 1.5, │
│ 0.9, 0.3] │ │ 0.0, 1.0] │ │ 0.9, 1.3] │
│ (meaning) │ │ (where in seq) │ │ (meaning+position)│
└─────────────────┘ └─────────────────┘ └──────────────────┘
WHY SINUSOIDS?
✓ Each position gets a unique encoding across all dimensions
✓ Distance between nearby positions is consistent and learnable
✓ Can represent any position mathematically (unlike learned embeddings)
✓ Model can attend to relative positions via linear combinations
Las dimensiones más bajas oscilan rápidamente y capturan la posición a nivel detallado, mientras que las dimensiones más altas cambian lentamente y capturan el orden global. El vector se agrega simplemente a la incrustación del token.
Ondas fijas, tablas aprendidas y rotación
El esquema sinusoidal posee una propiedad matemática útil: la codificación en la posición pos+k es una función lineal de la codificación en pos. Por lo tanto, los desplazamientos relativos se representan de manera consistente, lo que facilita el aprendizaje de las relaciones posicionales.
Los embeddings de posición aprendidos, que consisten en una tabla separada con una entrada por posición como lo utiliza BERT, son más simples pero no pueden extrapolar a posiciones posteriores a las vistas durante el entrenamiento, mientras que las sinusoides pueden representar en principio cualquier posición. Aun así, las sinusoides no resuelven por completo la generalización en contextos largos. Los modelos siguen teniendo dificultades con secuencias mucho más extensas que sus datos de entrenamiento, ya que los patrones de atención también deben generalizarse a distancias no vistas.
Modelos como Llama utilizan Embeddings de Posición Rotativa, o RoPE. Antes de calcular los productos escalar, las consultas y las claves se rotan en un ángulo proporcional a sus posiciones. En el producto de una consulta en una posición y una clave en otra, la rotación relativa codifica directamente el desfase. Hacer de la posición relativa una entrada explícita para la puntuación de atención, en lugar de algo implícito y aprendido a través de las matrices de proyección, ayuda con contextos largos.
La arquitectura completa
Ahora se pueden ensamblar las piezas. El diagrama muestra la forma moderna con Pre-LayerNorm de toda la estructura:
╔═══════════════════════════════════════════════════════════════════════════════════════╗
║ THE COMPLETE TRANSFORMER ARCHITECTURE (Pre-LayerNorm, modern) ║
╠═══════════════════════════════════════════╦═══════════════════════════════════════════╣
║ ENCODER (×N layers) ║ DECODER (×N layers) ║
╠═══════════════════════════════════════════╬═══════════════════════════════════════════╣
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ Linear → Softmax → P(next token) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ ⊕ Add (residual) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ ║ ┌───────────────────────────────────────┐ ║
║ ║ │ FFN( LayerNorm(x) ) │ ║
║ ║ └───────────────────────────────────────┘ ║
║ ║ ▲ ║
║ Encoder output → K, V (to decoder) ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ ⊕ Add (residual) │ ║
║ ┌───────────────────────────────────────┐ ║ └───────────────────────────────────────┘ ║
║ │ ⊕ Add (residual) │ ║ ▲ ║
║ └───────────────────────────────────────┘ ║ ┌───────────────────────────────────────┐ ║
║ ▲ ║ │ Cross-Attention │ ║
║ ┌───────────────────────────────────────┐ ║ │ Q ← decoder │ ║
║ │ FFN( LayerNorm(x) ) │ ║ │ K, V ← encoder output │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ ⊕ Add (residual) │ ║ │ ⊕ Add (residual) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Multi-Head Self-Attention │ ║ │ Masked Multi-Head Self-Attention │ ║
║ │ ( on LayerNorm(x), bidirectional ) │ ║ │ ( on LayerNorm(x), causal ) │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Input Embedding + Positional Enc. │ ║ │ Output Embedding + Positional Enc. │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
║ ▲ ║ ▲ ║
║ ┌───────────────────────────────────────┐ ║ ┌───────────────────────────────────────┐ ║
║ │ Source: "The cat sat on the mat" │ ║ │ Target (shifted): <BOS> "Le" "chat"… │ ║
║ └───────────────────────────────────────┘ ║ └───────────────────────────────────────┘ ║
╠═══════════════════════════════════════════╩═══════════════════════════════════════════╣
║ Data flows UPWARD (▲). Each sub-layer is a residual branch over a ║
║ LayerNorm-ed input: h = x + SubLayer( LayerNorm(x) ) ║
║ The encoder's output (K, V) flows into the decoder's Cross-Attention. ║
╚═══════════════════════════════════════════════════════════════════════════════════════╝
Un transformador tiene dos partes principales: un codificador y un decodificador. En el artículo original, cada uno contaba con 6 capas, 8 cabezas de atención y un d_model de 512.
El codificador: comprensión en contexto
El codificador lee la secuencia de entrada y genera una representación contextualizada de cada token, capturando no solo el significado de una palabra por separado sino también su significado en esa oración específica. Utiliza atención autoreferencial bidireccional, de modo que cada token puede considerar a todos los demás tokens tanto del lado izquierdo como del derecho. Así se resuelve la ambigüedad de “bank” mencionada anteriormente: el modelo ve al mismo tiempo “deposit” y “money”.
Se ejecutan seis capas de codificador en secuencia, cada una perfeccionando la representación. Las capas iniciales se centran en aspectos sintácticos como el orden de las palabras y la categoría gramatical. Las capas intermedias manejan estructuras gramaticales más complejas. Las capas posteriores capturan significados de alto nivel como los tipos de entidades, la estructura de los eventos y la pragmática. Esta estructura en capas es una de las razones por las que el transfer learning funciona tan bien: el ajuste fino modifica principalmente las capas posteriores, mientras que los patrones lingüísticos generales de las capas iniciales siguen siendo útiles en diferentes tareas.
El decodificador: generación con memoria
El decodificador emite tokens de salida uno por uno, de forma autoregresiva. Cada nuevo token depende de todo lo generado hasta el momento, además de toda la entrada codificada. Cuenta con tres subcapas.
La primera es la autoatención enmascarada, también conocida como atención causal. El decodificador solo puede considerar los tokens que ya ha generado, lo cual se garantiza mediante una máscara causal. Las puntuaciones por encima de la diagonal se establecen en menos infinito antes de aplicar softmax, lo que hace que los tokens futuros sean invisibles. De este modo, el entrenamiento coincide con la inferencia, ya que el modelo debe predecir cada token únicamente a partir del contexto pasado.
╔══════════════════════════════════════════════════════════════════════════╗
║ DECODER SELF-ATTENTION: Causal (Autoregressive) Masking ║
║ "Each token can only attend to itself and tokens before it" ║
╚══════════════════════════════════════════════════════════════════════════╝
Tokens: [The] [cat] [sat] [on] [mat]
t₁ t₂ t₃ t₄ t₅
ATTENTION SCORE MATRIX (row = query, col = key)
KEY → t₁ t₂ t₃ t₄ t₅
QUERY ↓ "The" "cat" "sat" "on" "mat"
──────────────────────────────────────
t₁ "The" │ ✓ ✗ ✗ ✗ ✗
t₂ "cat" │ ✓ ✓ ✗ ✗ ✗
t₃ "sat" │ ✓ ✓ ✓ ✗ ✗
t₄ "on" │ ✓ ✓ ✓ ✓ ✗
t₅ "mat" │ ✓ ✓ ✓ ✓ ✓
✓ = ALLOWED (score kept, participates in softmax)
✗ = MASKED (score → −∞, becomes 0 after softmax)
When generating t₃ "sat":
Raw scores: [ 2.1 3.4 1.8 -∞ -∞ ]
After softmax: [ 0.18 0.68 0.14 0 0 ]
↑
future tokens are invisible
WHY IS MASKING NECESSARY?
┌──────────────────────────────────────────────────────────┐
│ TRAINING: We feed the whole target sequence at once │
│ (teacher-forcing). Without masking, t₃ could "cheat" │
│ by looking at t₄ and t₅ - the answers it should │
│ be predicting. │
│ │
│ INFERENCE: We generate one token at a time anyway, │
│ so future tokens literally don't exist yet. Masking │
│ makes training match inference behavior exactly. │
└──────────────────────────────────────────────────────────┘
El segundo es la atención cruzada, el puente entre el codificador y el decodificador. Las consultas provienen del decodificador, representando el estado actual de la generación, mientras que las claves y los valores provienen del codificador, representando lo que dijo la entrada. Así funciona la traducción. Cuando el decodificador está generando la palabra francesa “chat”, consulta la representación del codificador de toda la oración en inglés, y la atención cruzada dirige un peso elevado hacia “cat”.
El tercero es la red feed-forward, cuyo papel es idéntico al de la que se encuentra en el codificador y que se explica más abajo.
Tres familias construidas a partir de las mismas partes
La combinación codificador-decodificador es solo una forma de utilizar estos componentes, y diferentes tareas requieren arreglos distintos:
| Model | Architecture | Training Objective | Best For |
|-------|-------------|-------------------|----------|
| **BERT** | Encoder-only | Masked Language Modeling | Understanding: classification, NER, QA |
| **GPT** | Decoder-only | Next token prediction | Generation: writing, coding, conversation |
| **T5** | Encoder-Decoder | Text-to-text seq-to-seq | Transformation: translation, summarization |
╔══════════════════════════════════════════════════════════════════════════════════════╗
║ BERT vs GPT vs T5: Architecture Families ║
╠══════════════════╦═══════════════════════════╦═════════════════════════════════════╣
║ BERT ║ GPT ║ T5 ║
║ Encoder-Only ║ Decoder-Only ║ Encoder + Decoder ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ ATTENTION: ║ ATTENTION: ║ ATTENTION: ║
║ t₁ ● ● ● ● ║ t₁ ● ║ Encoder: ● ● ● ● (bidir) ║
║ t₂ ● ● ● ● ║ t₂ ● ● ║ ● ● ● ● ║
║ t₃ ● ● ● ● ║ t₃ ● ● ● ║ Decoder: causal + ║
║ t₄ ● ● ● ● ║ t₄ ● ● ● ● ║ cross-attn to encoder ║
║ (bidirectional) ║ (causal/left-only) ║ ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ BEST FOR: ║ BEST FOR: ║ BEST FOR: ║
║ ✓ Classification ║ ✓ Text generation ║ ✓ Translation ║
║ ✓ NER / tagging ║ ✓ Completion ║ ✓ Summarization ║
║ ✓ Sentence embeds ║ ✓ Chat / dialogue ║ ✓ Question answering ║
║ ✓ Reading comp. ║ ✓ Code generation ║ ✓ Any seq-to-seq task ║
╠══════════════════╬═══════════════════════════╬═════════════════════════════════════╣
║ EXAMPLES: ║ EXAMPLES: ║ EXAMPLES: ║
║ BERT, RoBERTa ║ GPT-4o, Claude 4, ║ T5, BART, ║
║ DeBERTa ║ Llama 4, Gemini 2.5 ║ mT5, FLAN-T5 ║
╚══════════════════╩═══════════════════════════╩═════════════════════════════════════╝
BERT lee en ambas direcciones y es adecuado para tareas de comprensión. GPT genera de izquierda a derecha bajo enmascaramiento causal. T5 mantiene toda la arquitectura para transformaciones estructuradas de secuencia a secuencia. La elección entre ellos se basa en adaptar la arquitectura a la tarea y no en determinar cuál es mejor. En resumen, el codificador crea representaciones contextuales bidireccionales, el decodificador genera de forma autoregresiva con enmascaramiento causal y atención cruzada, y diferentes subconjuntos de la estructura se ajustan para la comprensión, generación y transformación.
Los componentes auxiliares
La atención y la capa feed-forward reciben la mayor parte de la atención, pero tres otras partes evitan que los transformadores profundos colapsen durante el entrenamiento: las redes feed-forward propiamente dichas, la normalización por capas y las conexiones residuales.
Redes feed-forward: tiempo de procesamiento por token
Después de cada capa de atención en cada bloque, hay una red feed-forward por posición. El vector de cada token pasa por la misma red MLP de dos capas, aplicada por separado a cada posición: se multiplica por W1, se agrega un sesgo, se aplica una función no lineal GeLU, luego se multiplica por W2 y se agrega otro sesgo. W1 mapea desde d_model a cuatro veces d_model, y W2 vuelve a mapear hacia allí. En los tamaños originales, esto significa de 512 a 2048 y luego a 512, lo que permite a la red almacenar y transformar información que la atención por sí sola no puede capturar.
La expresión clave es “por posición”, ya que la capa trata cada token de forma independiente. La atención es el mecanismo de comunicación, mediante el cual los tokens se hablan entre sí, mientras que la red feed-forward es el mecanismo de cálculo, donde cada token procesa lo que ha recopilado.
Geva y sus colegas (2021) descubrieron que estas capas se comportan de manera similar a las memorias clave-valor, y se pueden identificar neuronas individuales que se activan ante ciertos conceptos semánticos. Cuando un modelo de lenguaje “sabe” que París es la capital de Francia, esa asociación reside principalmente en los pesos de propagación directa. Esto explica dos cosas: el ajuste fino puede actualizar el conocimiento factual porque modifica esos pesos, y la generación reforzada por recuperación funciona porque coloca el hecho dentro de la ventana de contexto, donde la atención puede acceder a él directamente.
Conexiones residuales
Los gradientes que viajan hacia atrás a través de una red profunda se reducen a lo largo de muchas capas. Una conexión residual, también llamada conexión de salto, resuelve este problema de manera eficaz: la salida de una subcapa es el resultado de dicha subcapa más su propia entrada. De este modo, la capa solo necesita aprender el cambio, es decir, el residual, y no toda la función de mapeo. Esto crea una vía por la cual los gradientes pueden regresar directamente, evitando cualquier capa, y es por eso que los transformadores modernos pueden tener 96 o más capas sin que el entrenamiento falle.
Normalización de capas: mantener bajo control las escalas
La normalización por capas estandariza el vector de activación de cada token a una media cero y una varianza unitaria, y luego aplica una escala aprendida gamma y un desplazamiento beta. Las estadísticas provienen de las características d_model de un token: la media es el promedio simple de sus valores, y la varianza es la distancia al cuadrado promedio desde esa media. Una pequeña constante epsilon, típicamente 10 elevado a menos 5, se introduce dentro de la raíz cuadrada para evitar divisiones por cero. A diferencia de la normalización por lotes, el cálculo se realiza por token y no a lo largo del lote, lo cual es adecuado para secuencias de longitud variable.
El patrón de bloques moderno
El artículo original aplicó LayerNorm después de la adición residual, lo que se conoce como Post-LN. Casi todos los modelos modernos, desde GPT-2 y GPT-3 hasta Llama y prácticamente todo lo entrenado desde alrededor de 2020, utilizan Pre-LayerNorm y normalizan los datos antes de cada subcapa. Pre-LN permite un entrenamiento más estable y no requiere un proceso de calentamiento de la tasa de aprendizaje.
Cada bloque agrega luego un ramo de atención y un ramo feed-forward sobre las entradas ya normalizadas. El primer estado intermedio es la entrada más la atención aplicada a dicha entrada normalizada, mientras que el segundo estado es ese resultado sumado a la red feed-forward aplicada a su propia versión normalizada. Al examinar el código de cualquier transformador moderno, se observa que LayerNorm se aplica antes de la etapa de atención y también antes de la etapa feed-forward. Repitiendo ese bloque N veces, donde N puede ser 6, 12, 24, 96 o más según el tamaño del modelo, se obtiene el transformador completo.
El mecanismo de atención es la idea ingeniosa. Estas partes auxiliares son la ingeniería que hace posible que esa idea funcione. Las capas feed-forward proporcionan cálculos por token que almacenan asociaciones factuales, los caminos residuales ofrecen una ruta a los gradientes a través de la profundidad, y Pre-LN mantiene estables las activaciones. Juntos, hacen factible el uso de docenas de bloques.
El camino de una oración
Un proceso completo se lleva a cabo de la siguiente manera: tokenización, incrustación, adición de codificación de posición, codificación, decodificación de un token a la vez, y luego proyección al vocabulario. El siguiente diagrama muestra cómo se traduce “Hello world”:
╔══════════════════════════════════════════════════════════════════════════╗
║ END-TO-END DATA FLOW: "Hello world" → Translation ║
╚══════════════════════════════════════════════════════════════════════════╝
STAGE 1: Tokenization
┌─────────────────────────────────────────────────────────────────┐
│ Raw text: "Hello world" │
│ ↓ Tokenizer (BPE / WordPiece) │
│ Token IDs: [ 7592, 2088 ] ← integers into vocabulary │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 2: Embedding Lookup e_t = E[t] ∈ ℝ^512
┌─────────────────────────────────────────────────────────────────┐
│ 7592 → [0.21, -0.54, 0.88, ...] "Hello" │
│ 2088 → [0.67, 0.12,-0.34, ...] "world" │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 3: Add Positional Encoding x_t = e_t + PE(t)
┌─────────────────────────────────────────────────────────────────┐
│ embedding + PE = input vector carrying BOTH meaning AND order │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 4: Encoder Stack (× N layers)
┌─────────────────────────────────────────────────────────────────┐
│ ╔═══════════════════════════════════╗ │
│ ║ Each Encoder Layer: ║ × 6 │
│ ║ h₁ = x + Attn(LayerNorm(x)) ║ │
│ ║ h₂ = h₁ + FFN(LayerNorm(h₁)) ║ │
│ ╚═══════════════════════════════════╝ │
│ After 6 layers: rich contextual reps - "Hello" knows context │
└──────────────────────┬──────────────────────────────────────────┘
↓ (K, V flow into decoder cross-attention)
STAGE 5: Decoder Stack (generates tokens autoregressively)
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: <BOS> → Decoder → predict "Hola" │
│ Step 2: <BOS> "Hola" → Decoder → predict "mundo" │
│ Step 3: <BOS> "Hola mundo" → Decoder → predict <EOS> │
│ │
│ Each step: ① Masked self-attention on generated tokens │
│ ② Cross-attention: Q←decoder, K,V←encoder │
│ ③ LayerNorm → FFN → residual │
└──────────────────────┬──────────────────────────────────────────┘
↓
STAGE 6: Output Projection & Softmax
┌─────────────────────────────────────────────────────────────────┐
│ hidden state → W_vocab → logits over 50k vocab items │
│ → softmax → probability distribution │
│ → sample or argmax → next token │
└──────────────────────┬──────────────────────────────────────────┘
↓
"Hola mundo" ✓
Cómo un artículo de traducción se convirtió en un modelo de lenguaje
Eso abarca la arquitectura completa, pero ¿cómo pasó de un diseño para la traducción automática a sistemas que escriben ensayos y código y resuelven problemas complejos? La respuesta breve es la escala.
La línea de tiempo a continuación va desde el transformer de 2017 hasta los modelos más avanzados recientes:
YEAR MODEL PARAMS KEY DEVELOPMENT
────────────────────────────────────────────────────────────────────────────────
2017 Transformer 65M "Attention Is All You Need" published
2018 GPT-1 117M First successful generative pre-training
2019 GPT-2 1.5B Improved fluency; staged release
2020 GPT-3 175B Few-shot in-context learning emerges
2022 ChatGPT 175B+ InstructGPT + RLHF = aligned conversational AI
2023 GPT-4 undisclosed Multimodal input + stronger reasoning
2024 GPT-4o undisclosed Natively multimodal, faster & cheaper (May)
2024 o1 undisclosed "Reasoning" model: thinks before answering (Sep)
2025 o3 / o4-mini undisclosed Stronger reasoning, tool use, long-horizon
2025 Claude 4 undisclosed Anthropic: Opus 4 / Sonnet 4 (May)
2025 Gemini 2.5 undisclosed Google: 1M-token context, multimodal
2025 Llama 4 undisclosed Meta: open weights, up to 10M-token context
2026 GPT-5 series undisclosed OpenAI flagship (GPT-5.4 / 5.5); 272K-1M ctx
2026 Gemini 3.x undisclosed Google: frontier reasoning; 1M context
2026 Claude 5 family undisclosed Anthropic: Opus 4.8, Sonnet 5, Fable 5
2026 Grok 4.x undisclosed xAI frontier line (Grok 4.5, Jul 2026)
(Every one is the same core transformer from 2017 — scaled and refined, not replaced)
La arquitectura básica apenas cambió entre GPT-1 y los modelos de vanguardia actuales. Lo que sí cambió fue lo siguiente:
- La escala, es decir, más parámetros, más datos y más capacidad de cálculo.
- La alineación, mediante el aprendizaje por refuerzo basado en retroalimentación humana para que los modelos sean útiles y seguros.
- El ajuste por instrucciones, que entrena a los modelos para seguir indicaciones en lugar de simplemente continuar el texto.
- El entrenamiento para el razonamiento, que aplica aprendizaje por refuerzo a gran escala a problemas verificables. Es el elemento clave detrás de los modelos de razonamiento, como la serie o de OpenAI y los modos de pensamiento extendido ahora comunes en Claude, Gemini y otros, que invierten recursos adicionales en pensar antes de responder.
Habilidades que parecen activarse
Ocurrió algo inesperado a medida que los modelos crecían. Ciertas capacidades no mejoraban de forma gradual, sino que parecían mejorar de repente en tamaños específicos. La aritmética de múltiples pasos era prácticamente inexistente con menos de unos 10 mil millones de parámetros, pero se volvía fiable al llegar a cerca de 100 mil millones. El razonamiento por cadena de pensamiento estaba prácticamente ausente a menos que el modelo fuera lo suficientemente grande y se le solicitara específicamente. La generación de código mejoró drásticamente a partir de la escala de GPT-3. Nada de esto estaba programado; surgió por sí mismo.
Se debate cuán pronunciados son realmente esos saltos. Un análisis de 2023 ampliamente citado por Schaeffer y sus colegas, titulado “¿Son las capacidades emergentes de los modelos de lenguaje grandes una ilusión?”, demostró que algunos cambios aparentes de nivel se deben en parte a la métrica utilizada. Evaluar una tarea como todo o nada, como lo hace la precisión de coincidencia exacta, puede transformar avances constantes y graduales en algo que parece un salto repentino, mientras que una métrica continua muestra el progreso sostenido subyacente. El punto práctico sigue siendo válido, ya que los modelos grandes pueden hacer cosas que los pequeños no pueden, pero las cifras de umbral específicas deben considerarse como ilustraciones aproximadas y no como leyes físicas estrictas.
El objetivo de entrenamiento de todos los modelos de estilo GPT es la misma tarea sencilla de predecir el siguiente token. El razonamiento, la generación de código, la comprensión multilingüe y la escritura creativa nunca se entrenan de forma explícita. Surgen a medida que el modelo mejora en la predicción del siguiente token, siempre y cuando haya suficiente escala: un corpus grande, de alta calidad y diverso, además de un modelo lo suficientemente grande como para contener los patrones necesarios. Por eso los investigadores califican este objetivo de engañosamente simple. El objetivo es sencillo, pero lo que el modelo debe aprender para desempeñarse bien en él no lo es.
La ventana de contexto como memoria de trabajo
La memoria de trabajo, en el caso de un modelo, es la ventana de contexto: la mayor cantidad de tokens que puede procesar durante una sola pasada forward. El crecimiento ha sido drástico. GPT-2 en 2019 manejaba 1,024 tokens y GPT-3 en 2020 manejaba 2,048. GPT-4o en 2024 alcanzó los 128,000. Para mediados de 2026, este límite había avanzado aún más: la serie GPT-5 de OpenAI ofrece 272,000 tokens como estándar y aproximadamente un millón a través de la API; Claude de Anthropic y Gemini 3 de Google ofrecen más de un millón, mientras que Llama 4 Scout de Meta promete hasta 10 millones de tokens, lo que equivale a unas 15,000 páginas. Estas cifras siguen aumentando con cada generación.
Una ventana más grande es importante porque permite analizar un archivo de código completo y no solo fragmentos, mantener una conversación coherente a lo largo de muchas interacciones, resumir documentos enteros y realizar razonamientos en múltiples pasos teniendo en cuenta numerosos resultados intermedios.
Hay un problema. Calcular la matriz de atención completa, que relaciona cada token con todos los demás, requiere O(n al cuadrado) de tiempo y memoria durante el entrenamiento. Doblar la longitud del contexto hace que ambos valores aumenten cuatro veces. En la inferencia, el caché KV reduce los cálculos por paso, pero la memoria sigue creciendo linealmente con la longitud del contexto. Este cuello de botella en el entrenamiento cuadrático es un área de investigación activa. La atención dispersa, la atención con ventana deslizante utilizada en Mistral y otros diseños eficientes, Flash Attention (atención exacta con bajo consumo de memoria) y las aproximaciones lineales intentan reducir este costo.
Qué se encuentra sobre la base
La atención, QKV, las múltiples cabezas, la codificación posicional y la estructura encoder-decoder constituyen la infraestructura, y el motivo para aprenderlas es todo lo que se construye sobre ellas.
La IA generativa consiste en la predicción repetida del siguiente token
Cada aplicación generativa es, en esencia, el mismo bucle que se ejecuta una y otra vez:
Prompt: "Write a poem about autumn"
↓
Model predicts most likely next token: "The"
↓
Prompt + "The" → predicts: "leaves"
↓
Prompt + "The leaves" → predicts: "fall"
↓
... continues until <end-of-sequence> token predicted
Verlo de esa manera elimina el misterio de varios comportamientos:
- Alucinación. El modelo predice tokens probables y no obtiene datos de una base de datos. Si existe un token plausible pero incorrecto, este puede ser generado.
- Por qué el contexto es tan importante. En cada paso de generación se tiene en cuenta toda la ventana de contexto, por lo que todo lo incluido en el prompt determina qué pesos de atención se calculan y, por ende, qué resultado se obtiene.
Aprendizaje in-contexto: la atención realizando recuperación de información
Una de las capacidades más destacadas de los transformadores grandes es el aprendizaje in-contexto, que permite adaptarse a una nueva tarea a partir de ejemplos incluidos en la instrucción sin necesidad de ajustes adicionales. El mecanismo se ajusta a lo explicado anteriormente: los ejemplos de pocos casos ocupan ciertas posiciones dentro de la ventana. Cuando el modelo procesa el caso de prueba, la consulta correspondiente a ese token se compara mediante producto escalar con las claves de cada token anterior, incluidas las parejas de ejemplos. Dado que los ejemplos comparten un patrón estructural con el caso de prueba, sus claves coinciden bien y sus valores reciben pesos elevados. La atención es, literalmente, el mecanismo de recuperación, y por eso la estructura de una instrucción, a través de su efecto en los patrones de atención, modifica la salida.
Agentes: un transformador como motor de razonamiento
Los agentes de IA son sistemas que descomponen tareas por sí mismos, utilizan herramientas, iteran con base en los comentarios recibidos y persiguen objetivos a través de numerosos pasos. En 2023 eran una curiosidad para la investigación. Ahora, productos como Claude Code, GitHub Copilot, Cursor y Devin son utilizados diariamente por los desarrolladores. Cada agente serio cuenta con un modelo transformer en su núcleo.
╔══════════════════════════════════════════════════════════════════════════════╗
║ THE CONTEXT WINDOW AS AGENT WORKING MEMORY ║
╚══════════════════════════════════════════════════════════════════════════════╝
TIME ──────────────────────────────────────────────────────────────────────▶
┌──────────────┬──────────────┬────────────────┬────────────┬──────────────┐
│ SYSTEM │ USER │ AGENT │ TOOL │ AGENT │
│ PROMPT │ MESSAGE │ THOUGHT │ RESULT │ RESPONSE │
│ │ │ (reasoning) │ │ │
│ "You are a │ "What is │ <think> │ {"temp": │ "The current │
│ weather │ the weather │ I need to │ 22, │ temperature │
│ assistant │ in Paris │ call the │ "unit": │ in Paris │
│ ..." │ today?" │ weather API │ "C", │ is 22°C and │
│ │ │ for Paris... │ "cond": │ cloudy." │
│ │ │ </think> │ "cloudy"} │ │
│ ~200 tokens │ ~15 tokens │ ~80 tokens │ ~40 tokens │ ~25 tokens │
└──────────────┴──────────────┴────────────────┴────────────┴──────────────┘
▲ ▲ ▲ ▲ ▲
└───────────────┴───────────────┴───────────────┴─────────────┘
│
At each generation step:
Full self-attention runs over the
ENTIRE context simultaneously.
Cost: O(n²) in total context length.
WHAT THIS MEANS FOR AGENTS:
✓ Tool results are just tokens - the model attends to them like any text
✓ Reasoning traces are visible - chain-of-thought shapes next generation
✓ Long task history - "memory" without any separate mechanism
⚠ Context fills up - very long loops need summarization/offload
⚠ O(n²) attention cost - longer context = quadratically more compute
KEY INSIGHT: There is no "working memory" separate from the context.
The context window IS the agent's entire cognitive state.
Para un agente, la ventana es un buffer plano y ordenado de tokens, y en cada paso de generación se considera todo su contenido, lo que mantiene al alcance todo lo que ha ocurrido hasta el límite establecido. La ventana constituye la memoria de trabajo del agente, la atención es su mecanismo de razonamiento y el bucle de token siguiente es su ciclo de acción. La IA agente no necesitaba una nueva arquitectura; lo que se requirió fue darse cuenta de que el modelo transformer, a una escala lo suficientemente grande, ya podía soportar la capacidad de actuar de forma autónoma.
En la práctica, los agentes creados en 2026 rara vez se basan únicamente en la ventana de procesamiento. Para poder llevar a cabo tareas prolongadas, incorporan memoria externa: archivos de trabajo temporal, una capa de recuperación o una base de conocimientos que mantienen actualizada. Esto no contradice lo mencionado anteriormente, ya que la memoria externa afecta al modelo solo al ser leída nuevamente dentro de la ventana. Amplía el búfer sin reemplazarlo, y la atención del modelo sobre ese contexto sigue siendo el único lugar donde tiene lugar el razonamiento.
Hacia dónde se dirige la investigación
El rendimiento de los modelos Transformer sigue leyes de potencia predecibles en cuanto a parámetros, datos de entrenamiento y recursos computacionales, lo que proporciona a los investigadores una hoja de ruta. La frontera de la investigación avanza por varias vías:
- Arquitecturas eficientes que reducen el costo cuadrático de la atención, mediante Flash Attention, atención dispersa y atención lineal.
Todos estos se basan en la infraestructura de los transformadores, por lo que conocerla facilita la comprensión de estas direcciones de desarrollo.
La tabla a continuación presenta cada componente en una sola vista, indicando el problema que resuelve, cómo funciona y sus principales características:
| Component | Problem it Solves | Core Mechanism | Key Properties |
|-----------|------------------|----------------|----------------|
| **Tokenization** | Text is not natively numeric | Subword BPE/WordPiece splitting | Vocabulary ≈ 30k–100k; subwords handle rare terms |
| **Embeddings** | Discrete IDs have no geometry | $\mathbf{e}_t = E[t] \in \mathbb{R}^{d_{\text{model}}}$ | Semantic similarity → geometric proximity |
| **Positional Encoding** | Parallel attention loses token order | sin/cos at different frequencies (or RoPE) | Multi-scale; encodes absolute and relative position |
| **Self-Attention** | Long-range deps, sequential bottleneck | $\text{softmax}(QK^\top/\sqrt{d_k})V$ | $O(n^2)$ but parallel; dynamic contextual reps |
| **Query/Key/Value** | Separating "what I seek" from "what I offer" | Three separate learned linear projections | Relevance ≠ similarity; flexible dependency modeling |
| **Multi-Head Attention** | Single head captures only one relationship type | $h$ parallel heads, concatenated + $W^O$ | Simultaneously captures syntactic, semantic, positional |
| **Encoder** | Understanding input in full bidirectional context | Full self-attention, no masking | Bidirectional; rich contextualized representations |
| **Decoder** | Generating output autoregressively | Causal self-attention + cross-attention | Predicts one token at a time; teacher-forcing in training |
| **Cross-Attention** | Connecting generation to input understanding | Q from decoder, K/V from encoder | Enables encoder→decoder communication |
| **Feed-Forward Network** | Per-token computation + factual storage | $\text{GeLU}(\mathbf{x}W_1)\,W_2$ per token | Position-wise; stores factual associations in weights |
| **Residual Connections** | Vanishing gradients in deep networks | $\mathbf{h} = \text{SubLayer}(\mathbf{x}) + \mathbf{x}$ | Creates gradient highway; enables 100+ layer models |
| **Pre-LayerNorm** | Unstable activations in deep networks | Normalize before each sublayer | Stable training; standard in all modern transformers |
Qué se ha tratado y qué hacer a continuación
Las piezas encajan de la siguiente manera. La atención paralela funciona mejor que el procesamiento paso a paso y captura las dependencias a distancia de forma más eficaz, por lo que los transformadores reemplazaron a los modelos secuenciales. Los datos fluyen desde el texto hasta los tokens, luego a las representaciones embeddings, seguidas del codificado posicional, la atención y las capas feed-forward, para luego repetir el proceso. La autoatención es la operación central, donde cada token presta atención a todos los demás a través de proyecciones aprendidas Q, K y V, como en Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V. Varias cabezas capturan patrones diversos, el codificado posicional restablece el orden, y el diseño codificador-decodificador permite tanto la comprensión como la generación. Las capas feed-forward almacenan conocimiento, los enlaces residuales permiten mayor profundidad y Pre-LayerNorm mantiene estable el entrenamiento. La predicción del siguiente token a gran escala genera capacidades emergentes, la ventana de contexto funciona como la memoria de trabajo de un agente, y la arquitectura fr
Un artículo de traducción de 2017 es la base de los sistemas más avanzados de hoy en día.
Para profundizar, un plan por etapas funciona bien.
Primeras dos semanas: las matemáticas. Estudia la serie de Andrej Karpathy “Neural Networks: Zero to Hero” en YouTube, especialmente el video en el que se construye GPT desde cero. Luego escribe una capa de autoatención simple en NumPy. Los conceptos se comprenden mejor cuando se calculan a mano.
Semanas tres y cuatro: los artículos científicos. Lee “Attention Is All You Need” (Vaswani et al., 2017), que ahora es accesible, junto con el artículo de BERT (Devlin et al., 2018), el artículo de GPT-3 “Language Models are Few-Shot Learners” (Brown et al., 2020) y “Scaling Laws for Neural Language Models” (Kaplan et al., 2020).
Segundo mes: práctica con bibliotecas y APIs. La biblioteca Hugging Face transformers permite utilizar estos modelos desde Python con poca configuración. Ajuste finamente a BERT o a un modelo de pesos abiertos pequeño como una variante de Llama o Qwen para una tarea de clasificación. Luego, acceda a un modelo de vanguardia, ya sea Claude Sonnet 5 o uno de los modelos GPT-5, a través de los SDKs en Python de Anthropic u OpenAI. Hacer ambas cosas conecta la teoría con la práctica, ya que los mismos principios de transformadores son visibles tanto en modelos de pesos abiertos como en modelos de API de vanguardia.
Tercer mes: profundización en un área. Elija uno de los frameworks de agentes (LangChain, LlamaIndex) o practique directamente con Claude Code o Cursor para observar el comportamiento de los agentes en una herramienta de producción real), transformadores eficientes (Flash Attention, atención dispersa y lineal) o el ajuste finamente de LLMs con LoRA y PEFT. Aquí, la profundidad es más importante que la amplitud.
En curso: manténgase al día con la investigación. Las secciones cs.CL y cs.LG de arXiv, el blog de Hugging Face, la página de investigación de Anthropic y el AI Alignment Forum son fuentes útiles. El campo avanza rápidamente, pero los recursos mencionados anteriormente ayudan a comprender los nuevos artículos.
El artículo sobre transformers tiene unas quince páginas, y la arquitectura que describe es lo suficientemente clara como para implementarla en una tarde. Lo que este trabajo desató, y lo que la escalabilidad y los refinamientos siguen generando, ha cambiado la forma en que las personas ven lo que pueden hacer las máquinas.