{"id":243,"date":"2026-05-16T20:42:28","date_gmt":"2026-05-16T20:42:28","guid":{"rendered":"https:\/\/pulki.es\/blog\/?p=243"},"modified":"2026-05-16T20:42:28","modified_gmt":"2026-05-16T20:42:28","slug":"large-language-model-llm-from-scratch-transformers","status":"publish","type":"post","link":"https:\/\/pulki.es\/blog\/index.php\/2026\/05\/16\/large-language-model-llm-from-scratch-transformers\/","title":{"rendered":"Large Language Model (LLM) from scratch. Transformers."},"content":{"rendered":"\n

En la publicaci\u00f3n pasada entendimos la estructura general de un LLM<\/strong>. Este paso es vital, puesto que nos da una visi\u00f3n panor\u00e1mica sobre la morfolog\u00eda de estos modelos. Con esto en mente, ahora podemos estudiar la arquitectura de aquellos.<\/p>\n\n\n\n

Existen m\u00faltiples arquitecturas para dise\u00f1ar un LLM<\/strong>, no obstante, en esta entrada vamos a estudiar transformers,<\/em> puesto que es la que emplean los LLM<\/strong> m\u00e1s famosos, tales como GPT, BERT, T5, LLaMa, etc. <\/p>\n\n\n\n

Al igual que en la entrada anterior, usaremos como referencia a Jurafsky y Martin (2026)<\/a><\/strong>, como es usual. Cualquier error es mi responsabilidad.<\/p>\n\n\n\n

Atenci\u00f3n<\/h2>\n\n\n\n

En el contexto espec\u00edfico de transformers<\/strong>, el concepto de atenci\u00f3n<\/strong> fue introducido por Vaswani et al. (2017)<\/a><\/strong>. Este art\u00edculo, y concepto, son importantes por varias razones, no obstante, en este momento se me ocurren dos muy obvias: la atenci\u00f3n est\u00e1 presente en los LLMs m\u00e1s famosos, tales como GPT, BERT, etc., y adem\u00e1s, el art\u00edculo tiene m\u00e1s de 250 mil citas<\/a> (a mayo de 2026). <\/p>\n\n\n\n

En t\u00e9rminos formales, la atenci\u00f3n es un mecanismo que permite construir una nueva representaci\u00f3n contextual de un token combinando informaci\u00f3n de otros tokens de la secuencia. <\/p>\n\n\n\n

Pero, \u00bfPor qu\u00e9 necesitamos una nueva representaci\u00f3n contextual?. Primero que todo, recordemos algunos conceptos expuestos en la entrada sobre embeddings<\/a>. En esta publicaci\u00f3n, represent\u00e1bamos el significado de una palabra de forma vectorial y est\u00e1tica, es decir, los valores de los componentes del vector de la palabra no dependen del contexto en el que se encuentre. Esto es problem\u00e1tico porque muchas veces la idoneidad de la palabra es definida por el contexto. Por ejemplo:<\/p>\n\n\n\n

\n

El coche no sigui\u00f3 avanzando por el camino porque este<\/strong> estaba mojado.<\/p>\n<\/blockquote>\n\n\n\n

\n

El coche no sigui\u00f3 avanzando por el camino porque este<\/strong> estaba averiado.<\/p>\n<\/blockquote>\n\n\n\n

En este caso, en la primera oraci\u00f3n, el coche no avanz\u00f3 porque el camino estaba mojado, y en la segunda, porque el coche estaba averiado. Como podemos ver, el contexto determina el significado de la palabra \u00abeste\u00bb<\/strong>.<\/p>\n\n\n\n

Entonces, respondiendo a la pregunta, sobre si una nueva representaci\u00f3n conceptual es necesaria, si, es absolutamente necesaria, puesto que ayuda al modelo a distinguir este tipo de sutilidades.<\/p>\n\n\n\n

Ahora que sabemos por qu\u00e9 una representaci\u00f3n contextual es necesaria, estamos en condiciones de explicar el concepto de atenci\u00f3n. Formalmente, se podr\u00eda definir como el mecanismo mediante el cual el transformer<\/em> toma x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>, es decir, la representaci\u00f3n vectorial del token que est\u00e1 en la posici\u00f3n i<\/mi><\/mrow>i<\/annotation><\/semantics><\/math> de la secuencia, y produce a<\/mi>i<\/mi><\/msub><\/mrow>a_i<\/annotation><\/semantics><\/math>, una nueva representaci\u00f3n del mismo token<\/em>, pero enriquecida con informaci\u00f3n de los tokens anteriores. En un modelo causal, como GPT, esta informaci\u00f3n s\u00f3lo puede venir del propio token<\/em> y de los tokens que aparecen antes de \u00e9l, no de los tokens futuros.<\/p>\n\n\n\n

Para entender esta idea, usaremos una versi\u00f3n simplificada de lo que realmente ocurre, tal y como lo muestra Jurafsky y Martin (2026)<\/a><\/strong>. Para esto, asumiremos la siguiente estructura:<\/p>\n\n\n\n

a<\/mi>i<\/mi><\/msub>=<\/mo>\u2211<\/mo>j<\/mi>\u2264<\/mo>i<\/mi><\/mrow><\/msub>\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow><\/msub>x<\/mi>j<\/mi><\/msub><\/mrow>a_{i} = \\sum_{j\\leq i}\\alpha_{ij}x_{j}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Es decir, en la posici\u00f3n i<\/mi>i<\/annotation><\/semantics><\/math> de la secuencia, tomamos la representaci\u00f3n vectorial de los tokens anteriores (incluyendo i<\/mi>i<\/annotation><\/semantics><\/math>), y los ponderamos por \u03b1<\/mi>i<\/mi>j<\/mi><\/mrow><\/msub>\\alpha_{ij}<\/annotation><\/semantics><\/math>. Luego, para obtener este \u00faltimo, calculamos el score<\/em>, y lo pasamos por la softmax<\/em>:<\/p>\n\n\n\n

s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>=<\/mo>x<\/mi>i<\/mi><\/msub>\u22c5<\/mo>x<\/mi>j<\/mi><\/msub><\/mrow>score(x_{i},x_{j}) = x_{i} \\cdot x_{j}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow><\/msub>=<\/mo>s<\/mi>o<\/mi>f<\/mi>t<\/mi>m<\/mi>a<\/mi>x<\/mi>(<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>)<\/mo>,<\/mo>\u2200<\/mi>j<\/mi>\u2264<\/mo>i<\/mi><\/mrow>\\alpha_{ij} = softmax(score(x_{i},x_{j}) ), \\forall j\\leq i<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

\u00bfPor qu\u00e9 calculamos el producto punto<\/em>? Recordemos que este se puede interpretar como una medida de similitud entre dos vectores, entonces, si el vector de un token previo x<\/mi>j<\/mi><\/msub><\/mrow>x_j<\/annotation><\/semantics><\/math>\u200b es parecido al vector del token actual x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>, entonces probablemente contiene informaci\u00f3n \u00fatil para interpretar o representar mejor a x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>. En t\u00e9rminos pr\u00e1cticos, supongamos el siguiente ejemplo:<\/p>\n\n\n\n
\n

El gato es buena mascota. Este felino\u2026<\/p>\n<\/blockquote>\n\n\n\n

Supongamos que en esta frase estamos analizando x<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi><\/mrow><\/msub>x_{felino}<\/annotation><\/semantics><\/math>. Es de esperar, que la similitud entre x<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi><\/mrow><\/msub>x_{felino}<\/annotation><\/semantics><\/math> y x<\/mi>g<\/mi>a<\/mi>t<\/mi>o<\/mi><\/mrow><\/msub>x_{gato}<\/annotation><\/semantics><\/math>, sea mayor a la similitud entre x<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi><\/mrow><\/msub>x_{felino}<\/annotation><\/semantics><\/math>y x<\/mi>b<\/mi>u<\/mi>e<\/mi>n<\/mi>a<\/mi><\/mrow><\/msub>x_{buena}<\/annotation><\/semantics><\/math>. Lo anterior implica que \u03b1<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi>,<\/mo>g<\/mi>a<\/mi>t<\/mi>o<\/mi><\/mrow><\/msub>><\/mo>\u03b1<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi>,<\/mo>b<\/mi>u<\/mi>e<\/mi>n<\/mi>a<\/mi><\/mrow><\/msub><\/mrow>\\alpha_{felino,gato} >\\alpha_{felino,buena}<\/annotation><\/semantics><\/math>. Por tanto, el vector contextualizado del token<\/em> felino, a<\/mi>f<\/mi>e<\/mi>l<\/mi>i<\/mi>n<\/mi>o<\/mi><\/mrow><\/msub>a_{felino}<\/annotation><\/semantics><\/math>, contendr\u00e1 m\u00e1s informaci\u00f3n de gato que del token buena.<\/p>\n\n\n\n

Esta metodolog\u00eda fue desarrollada por Jurafsky y Martin (2026)<\/a><\/strong> con fines pedag\u00f3gicos, no obstante, el funcionamiento de la atenci\u00f3n es m\u00e1s compleja. Esta, tiene conceptos adicionales como attention head<\/em>, query,<\/em> key<\/em> y value<\/em>. A continuaci\u00f3n veremos cada uno, y c\u00f3mo se relacionan.<\/p>\n\n\n\n

Attention head, query y value<\/p>\n\n\n\n

Una attention head<\/strong> es un componente de atenci\u00f3n que toma las representaciones vectoriales de los tokens<\/em> y las proyecta en tres espacios distintos: queries<\/strong>, keys<\/strong> y values<\/strong>. La query<\/strong> corresponde a la representaci\u00f3n del token<\/em> actual en su rol de b\u00fasqueda; las keys<\/strong> corresponden a las representaciones de los tokens<\/em> del contexto en su rol de comparaci\u00f3n; y los values<\/strong> corresponden a la informaci\u00f3n que finalmente ser\u00e1 ponderada y sumada. De esta forma, la cabeza de atenci\u00f3n compara la query<\/em> del token<\/em> actual con las keys<\/em> de los tokens <\/em>disponibles en el contexto \u2014en un transformer causal, el propio token<\/em> y los tokens<\/em> anteriores\u2014, transforma esas comparaciones en pesos de atenci\u00f3n y usa esos pesos para combinar los values<\/em>. El resultado es una nueva representaci\u00f3n del token actual, enriquecida con informaci\u00f3n contextual. En la siguiente imagen, podemos ver con m\u00e1s claridad qu\u00e9 ocurre:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

En el ejemplo de la ilustraci\u00f3n, tenemos tres tokens de entrada que vienen en forma de embeddings: x<\/mi>1<\/mn><\/msub>x_{1}<\/annotation><\/semantics><\/math>, x<\/mi>2<\/mn><\/msub>x_{2}<\/annotation><\/semantics><\/math>y x<\/mi>3<\/mn><\/msub>x_{3}<\/annotation><\/semantics><\/math>, siendo este \u00faltimo, el token que estamos analizando. Nuestro objetivo es calcular a<\/mi>3<\/mn><\/msub>a_{3}<\/annotation><\/semantics><\/math>, es decir, una nueva representaci\u00f3n contextualizada de ese token<\/em>. Para ello, primero proyectamos cada vector de entrada en tres representaciones distintas: key<\/strong>, query<\/strong> y value<\/strong>. Estas proyecciones se obtienen mediante tres matrices aprendidas por el modelo:<\/p>\n\n\n\n

q<\/mi>i<\/mi><\/msub>=<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>Q<\/mi><\/msup><\/mrow>q_{i} = x_{i}W^{Q}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

k<\/mi>i<\/mi><\/msub>=<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>K<\/mi><\/msup><\/mrow>k_{i} = x_{i}W^{K}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

v<\/mi>i<\/mi><\/msub>=<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>V<\/mi><\/msup><\/mrow>v_{i} = x_{i}W^{V}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

donde q<\/mi>i<\/mi><\/msub>q_{i}<\/annotation><\/semantics><\/math> es la query, k<\/mi>i<\/mi><\/msub>k_{i}<\/annotation><\/semantics><\/math>es la key y v<\/mi>i<\/mi><\/msub>v_{i}<\/annotation><\/semantics><\/math>es el value correspondiente al token en la posici\u00f3n i<\/mi>i<\/annotation><\/semantics><\/math>.<\/p>\n\n\n\n

Como queremos calcular la salida de atenci\u00f3n para x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>, usamos la query de x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>, es decir, q<\/mi>3<\/mn><\/msub><\/mrow>q_3<\/annotation><\/semantics><\/math>, y la comparamos con las keys de los tokens disponibles en el contexto. Puesto que estamos en un modelo causal, x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math> puede atender a x<\/mi>1<\/mn><\/msub><\/mrow>x_1<\/annotation><\/semantics><\/math>, x<\/mi>2<\/mn><\/msub><\/mrow>x_2<\/annotation><\/semantics><\/math> y a s\u00ed mismo, pero no a tokens futuros. Por lo tanto, calculamos los siguientes scores:<\/p>\n\n\n\n

x<\/mi>3<\/mn><\/msub>contra <\/mtext>x<\/mi>1<\/mn><\/msub>:<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>3<\/mn><\/msub>,<\/mo>x<\/mi>1<\/mn><\/msub>)<\/mo>=<\/mo>q<\/mi>3<\/mn><\/msub>\u22c5<\/mo>k<\/mi>1<\/mn><\/msub><\/mrow>d<\/mi>k<\/mi><\/msub><\/msqrt><\/mfrac><\/mrow>x_{3} \\text{contra } x_{1} : score(x_{3},x_{1}) = \\frac{q_{3}\\cdot k_{1}}{\\sqrt{d_{k}}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

x<\/mi>3<\/mn><\/msub>contra <\/mtext>x<\/mi>2<\/mn><\/msub>:<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>3<\/mn><\/msub>,<\/mo>x<\/mi>2<\/mn><\/msub>)<\/mo>=<\/mo>q<\/mi>3<\/mn><\/msub>\u22c5<\/mo>k<\/mi>2<\/mn><\/msub><\/mrow>d<\/mi>k<\/mi><\/msub><\/msqrt><\/mfrac><\/mrow>x_{3} \\text{contra } x_{2} : score(x_{3},x_{2}) = \\frac{q_{3}\\cdot k_{2}}{\\sqrt{d_{k}}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

x<\/mi>3<\/mn><\/msub>contra <\/mtext>x<\/mi>1<\/mn><\/msub>:<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>3<\/mn><\/msub>,<\/mo>x<\/mi>3<\/mn><\/msub>)<\/mo>=<\/mo>q<\/mi>3<\/mn><\/msub>\u22c5<\/mo>k<\/mi>3<\/mn><\/msub><\/mrow>d<\/mi>k<\/mi><\/msub><\/msqrt><\/mfrac><\/mrow>x_{3} \\text{contra } x_{1} : score(x_{3},x_{3}) = \\frac{q_{3}\\cdot k_{3}}{\\sqrt{d_{k}}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

El producto punto q<\/mi>3<\/mn><\/msub>\u22c5<\/mo>k<\/mi>j<\/mi><\/msub><\/mrow>q_3 \\cdot k_j<\/annotation><\/semantics><\/math> mide la compatibilidad entre la query del token actual y la key de cada token del contexto. Luego, dividimos por d<\/mi>k<\/mi><\/msub><\/msqrt><\/mrow>\\sqrt{d_k}<\/annotation><\/semantics><\/math> para evitar que los scores crezcan demasiado cuando la dimensi\u00f3n de las queries y keys es alta.<\/p>\n\n\n\n

Posteriormente, pasamos estos scores por una softmax<\/em>. Esto nos permite convertir los scores en pesos de atenci\u00f3n:<\/p>\n\n\n\n

\u03b1<\/mi>31<\/mn><\/msub>,<\/mo>\u03b1<\/mi>32<\/mn><\/msub>,<\/mo>\u03b1<\/mi>33<\/mn><\/msub><\/mrow>\\alpha_{31}, \\alpha_{32}, \\alpha_{33}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Formalmente:<\/p>\n\n\n\n

\u03b1<\/mi>3<\/mn>j<\/mi><\/mrow><\/msub>=<\/mo>e<\/mi>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>3<\/mn><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo><\/mrow><\/msup>\u2211<\/mo>m<\/mi>\u2264<\/mo>3<\/mn><\/mrow><\/msub>e<\/mi>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>3<\/mn><\/msub>,<\/mo>x<\/mi>m<\/mi><\/msub>)<\/mo><\/mrow><\/msup><\/mrow><\/mfrac><\/mrow>\\alpha_{3j} = \\frac{e^{score(x_{3},x_{j})}}{\\sum_{m\\leq3}e^{score(x_{3},x_{m})}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

para j<\/mi>\u2208<\/mo>{<\/mo>1<\/mn>,<\/mo>2<\/mn>,<\/mo>3<\/mn>}<\/mo><\/mrow>j \\in \\{1,2,3\\}<\/annotation><\/semantics><\/math>. De esta forma, los pesos de atenci\u00f3n son n\u00fameros positivos que suman 1:<\/p>\n\n\n\n

\u03b1<\/mi>31<\/mn><\/msub>+<\/mo>\u03b1<\/mi>32<\/mn><\/msub>+<\/mo>\u03b1<\/mi>33<\/mn><\/msub>=<\/mo>1<\/mn><\/mrow>\\alpha_{31} + \\alpha_{32} + \\alpha_{33} =1<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Cada \u03b1<\/mi>3<\/mn>j<\/mi><\/mrow><\/msub><\/mrow>\\alpha_{3j}<\/annotation><\/semantics><\/math>\u200b indica cu\u00e1nta informaci\u00f3n del token x<\/mi>j<\/mi><\/msub><\/mrow>x_j<\/annotation><\/semantics><\/math> ser\u00e1 incorporada en la nueva representaci\u00f3n de x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>.<\/p>\n\n\n\n

Una vez obtenidos los pesos de atenci\u00f3n, podemos calcular la salida de la cabeza de atenci\u00f3n para el token x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>. Para ello, hacemos una suma ponderada de los value vectors<\/strong>:<\/p>\n\n\n\n

h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub>=<\/mo>\u03b1<\/mi>31<\/mn><\/msub>v<\/mi>1<\/mn><\/msub>+<\/mo>\u03b1<\/mi>32<\/mn><\/msub>v<\/mi>2<\/mn><\/msub>+<\/mo>\u03b1<\/mi>33<\/mn><\/msub>v<\/mi>3<\/mn><\/msub><\/mrow>head_{3} = \\alpha_{31}v_{1} + \\alpha_{32}v_{2} + \\alpha_{33}v_{3}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

El vector h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub><\/mrow>head_3<\/annotation><\/semantics><\/math>\u200b tiene dimensi\u00f3n:<\/p>\n\n\n\n

1<\/mn>\u00d7<\/mo>d<\/mi>v<\/mi><\/msub><\/mrow>1\\times d_{v}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Sin embargo, la arquitectura del transformer<\/em> necesita que la salida de la atenci\u00f3n tenga la misma dimensi\u00f3n que la representaci\u00f3n original del token, es decir:<\/p>\n\n\n\n

1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow>1\\times d_{model}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Por esta raz\u00f3n, multiplicamos h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub><\/mrow>head_3<\/annotation><\/semantics><\/math> por una matriz de salida W<\/mi>O<\/mi><\/msup><\/mrow>W^O<\/annotation><\/semantics><\/math>:<\/p>\n\n\n\n

a<\/mi>3<\/mn><\/msub>=<\/mo>h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub>W<\/mi>o<\/mi><\/msup><\/mrow>a_{3} = head_{3}W^{o} <\/annotation><\/semantics><\/math><\/p>\n\n\n\n

donde:<\/p>\n\n\n\n

W<\/mi>O<\/mi><\/msup>\u2208<\/mo>\u211d<\/mi>d<\/mi>v<\/mi><\/msub>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>W^{O} \\in \\mathbb{R}^{d_{v}\\times d_{model}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

As\u00ed, la operaci\u00f3n tiene la siguiente forma:<\/p>\n\n\n\n

[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>v<\/mi><\/msub>]<\/mo>\u22c5<\/mo>[<\/mo>d<\/mi>v<\/mi><\/msub>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>]<\/mo>=<\/mo>[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>]<\/mo><\/mrow>[1\\times d_{v}]\\cdot [d_{v}\\times d_{model}] = [1\\times d_{model}]<\/annotation><\/semantics><\/math> <\/p>\n\n\n\n

El resultado final es:<\/p>\n\n\n\n

a<\/mi>3<\/mn><\/msub>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>a_{3} \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Es decir, a<\/mi>3<\/mn><\/msub><\/mrow>a_3<\/annotation><\/semantics><\/math> es una nueva representaci\u00f3n del token x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>\u200b, enriquecida con informaci\u00f3n de x<\/mi>1<\/mn><\/msub><\/mrow>x_1<\/annotation><\/semantics><\/math>, x<\/mi>2<\/mn><\/msub><\/mrow>x_2<\/annotation><\/semantics><\/math> y del propio x<\/mi>3<\/mn><\/msub><\/mrow>x_3<\/annotation><\/semantics><\/math>\u200b. Esta representaci\u00f3n mantiene la misma dimensionalidad que la entrada, lo que permite integrarla al flujo residual del transformer<\/em> y pasarla a las siguientes capas.<\/p>\n\n\n\n

Para verlo con un ejemplo peque\u00f1o, supongamos que:<\/p>\n\n\n\n

d<\/mi>v<\/mi><\/msub>=<\/mo>3<\/mn> <\/mtext> <\/mtext> <\/mtext>y<\/mtext> <\/mtext> <\/mtext> <\/mtext>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>=<\/mo>2<\/mn><\/mrow>d_{v} = 3 \\ \\ \\ \\text{y} \\ \\ \\ d_{model}=2<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Entonces h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub><\/mrow>head_3<\/annotation><\/semantics><\/math> podr\u00eda ser un vector de tres dimensiones:<\/p>\n\n\n\n

h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi><\/msub>=<\/mo>[<\/mo>h<\/mi>1<\/mn><\/msub> <\/mtext>h<\/mi>2<\/mn><\/msub> <\/mtext>h<\/mi>3<\/mn><\/msub>]<\/mo><\/mrow>head_{i} = [h_{1} \\ h_{2} \\ h_{3}]<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

y W<\/mi>O<\/mi><\/msup>W^{O} <\/annotation><\/semantics><\/math>tendr\u00eda dimensi\u00f3n 3<\/mn>\u00d7<\/mo>2<\/mn><\/mrow>3\\times 2<\/annotation><\/semantics><\/math>:<\/p>\n\n\n\n

W<\/mi>O<\/mi><\/msup>=<\/mo>[<\/mo>w<\/mi>11<\/mn><\/msub><\/mtd>w<\/mi>12<\/mn><\/msub><\/mtd><\/mtr>w<\/mi>21<\/mn><\/msub><\/mtd>w<\/mi>22<\/mn><\/msub><\/mtd><\/mtr>w<\/mi>31<\/mn><\/msub><\/mtd>w<\/mi>32<\/mn><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mrow>W^{O} = \\begin{bmatrix} w_{11} & w_{12} \\\\ w_{21} & w_{22} \\\\ w_{31} & w_{32} \\end{bmatrix} <\/annotation><\/semantics><\/math><\/p>\n\n\n\n

La multiplicaci\u00f3n ser\u00eda:<\/p>\n\n\n\n

a<\/mi>3<\/mn><\/msub>=<\/mo>[<\/mo>h<\/mi>1<\/mn><\/msub><\/mtd>h<\/mi>2<\/mn><\/msub><\/mtd>h<\/mi>3<\/mn><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow>\u22c5<\/mo>[<\/mo>w<\/mi>11<\/mn><\/msub><\/mtd>w<\/mi>12<\/mn><\/msub><\/mtd><\/mtr>w<\/mi>21<\/mn><\/msub><\/mtd>w<\/mi>22<\/mn><\/msub><\/mtd><\/mtr>w<\/mi>31<\/mn><\/msub><\/mtd>w<\/mi>32<\/mn><\/msub><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mrow>a_{3} = \\begin{bmatrix} h_{1} & h_{2} & h_{3} \\end{bmatrix} \\cdot \\begin{bmatrix} w_{11} & w_{12} \\\\ w_{21} & w_{22} \\\\ w_{31} & w_{32} \\end{bmatrix} <\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Por lo tanto:<\/p>\n\n\n\n

a<\/mi>3<\/mn><\/msub>=<\/mo>[<\/mo>h<\/mi>1<\/mn><\/msub>w<\/mi>11<\/mn><\/msub>+<\/mo>h<\/mi>2<\/mn><\/msub>w<\/mi>21<\/mn><\/msub>+<\/mo>h<\/mi>3<\/mn><\/msub>w<\/mi>31<\/mn><\/msub><\/mrow><\/mtd>h<\/mi>1<\/mn><\/msub>w<\/mi>12<\/mn><\/msub>+<\/mo>h<\/mi>2<\/mn><\/msub>w<\/mi>22<\/mn><\/msub>+<\/mo>h<\/mi>3<\/mn><\/msub>w<\/mi>32<\/mn><\/msub><\/mrow><\/mtd><\/mtr><\/mtable>]<\/mo><\/mrow><\/mrow>a_{3} = \\begin{bmatrix} h_{1}w_{11} + h_{2}w_{21} + h_{3}w_{31} & h_{1}w_{12} + h_{2}w_{22} + h_{3}w_{32} \\end{bmatrix} <\/annotation><\/semantics><\/math><\/p>\n\n\n\n

As\u00ed, W<\/mi>O<\/mi><\/msup><\/mrow>W^O<\/annotation><\/semantics><\/math> aprende c\u00f3mo transformar y mezclar la informaci\u00f3n contenida en h<\/mi>e<\/mi>a<\/mi>d<\/mi>3<\/mn><\/msub><\/mrow>head_3<\/annotation><\/semantics><\/math> para devolverla al espacio general del modelo.<\/p>\n\n\n\n

Dicho esto, en t\u00e9rminos formales, el conjunto de ecuaciones para obtener a<\/mi>i<\/mi><\/msub>a_{i}<\/annotation><\/semantics><\/math>vendr\u00eda dado por:<\/p>\n\n\n\n

q<\/mi>i<\/mi><\/msub>=<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>Q<\/mi><\/msup> <\/mtext> <\/mtext>;<\/mo> <\/mtext> <\/mtext>k<\/mi>j<\/mi><\/msub>=<\/mo>x<\/mi>j<\/mi><\/msub>W<\/mi>K<\/mi><\/msup> <\/mtext> <\/mtext>;<\/mo> <\/mtext> <\/mtext>v<\/mi>j<\/mi><\/msub>=<\/mo>x<\/mi>j<\/mi><\/msub>W<\/mi>V<\/mi><\/msup><\/mrow>q_{i} = x_{i}W^{Q} \\ \\ ; \\ \\ k_{j} = x_{j}W^{K} \\ \\ ; \\ \\ v_{j} = x_{j}W^{V}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>=<\/mo>q<\/mi>i<\/mi><\/msub>k<\/mi>j<\/mi><\/msub><\/mrow>d<\/mi>k<\/mi><\/msub><\/msqrt><\/mfrac><\/mrow>score(x_{i},x_{j}) = \\frac{q_{i}k_{j}}{\\sqrt{d_{k}}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow><\/msub>=<\/mo>s<\/mi>o<\/mi>f<\/mi>t<\/mi>m<\/mi>a<\/mi>x<\/mi>(<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>)<\/mo> <\/mtext> <\/mtext>\u2200<\/mi>j<\/mi>\u2264<\/mo>i<\/mi><\/mrow>\\alpha_{ij} = softmax(score(x_{i},x_{j})) \\ \\ \\forall j \\leq i<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi><\/msub>=<\/mo>\u2211<\/mo>j<\/mi>\u2264<\/mo>i<\/mi><\/mrow><\/msub>\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow><\/msub>v<\/mi>j<\/mi><\/msub><\/mrow>head_{i} = \\sum_{j\\leq i} \\alpha_{ij}v_{j}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

a<\/mi>i<\/mi><\/msub>=<\/mo>h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi><\/msub>W<\/mi>o<\/mi><\/msup><\/mrow>a_{i} = head_{i}W^{o}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

M\u00faltiples attention heads<\/p>\n\n\n\n

En la secci\u00f3n anterior mostramos el funcionamiento de una sola attention head<\/strong>. Sin embargo, los transformers <\/em>no suelen usar una \u00fanica cabeza de atenci\u00f3n, sino varias trabajando en paralelo. La idea es que cada cabeza pueda aprender una forma distinta de mirar el mismo contexto. Por ejemplo, una cabeza podr\u00eda especializarse en ciertas relaciones gramaticales, otra en relaciones sem\u00e1nticas, otra en repeticiones o dependencias de largo alcance. En este sentido, multi-head attention<\/strong> permite que el modelo construya varias representaciones contextuales complementarias a partir de los mismos tokens de entrada.<\/p>\n\n\n\n

Siguiendo la notaci\u00f3n de Jurafsky y Martin (2026)<\/a><\/strong>, si tenemos A<\/mi><\/mrow>A<\/annotation><\/semantics><\/math> cabezas de atenci\u00f3n, cada cabeza c<\/mi><\/mrow>c<\/annotation><\/semantics><\/math> tiene su propio conjunto de matrices aprendidas:W<\/mi>Q<\/mi>c<\/mi><\/msub><\/msup>,<\/mo><\/mspace>W<\/mi>K<\/mi>c<\/mi><\/msub><\/msup>,<\/mo><\/mspace>W<\/mi>V<\/mi>c<\/mi><\/msub><\/msup><\/mrow>W^{Q_c}, \\quad W^{K_c}, \\quad W^{V_c}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Estas matrices proyectan los vectores de entrada en queries, keys y values espec\u00edficos para cada cabeza:<\/p>\n\n\n\n

q<\/mi>i<\/mi>c<\/mi><\/msubsup>=<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>Q<\/mi>c<\/mi><\/msub><\/msup><\/mrow>q_i^c = x_i W^{Q_c}<\/annotation><\/semantics><\/math>k<\/mi>j<\/mi>c<\/mi><\/msubsup>=<\/mo>x<\/mi>j<\/mi><\/msub>W<\/mi>K<\/mi>c<\/mi><\/msub><\/msup><\/mrow>k_j^c = x_j W^{K_c}<\/annotation><\/semantics><\/math>v<\/mi>j<\/mi>c<\/mi><\/msubsup>=<\/mo>x<\/mi>j<\/mi><\/msub>W<\/mi>V<\/mi>c<\/mi><\/msub><\/msup><\/mrow>v_j^c = x_j W^{V_c}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

para cada cabeza c<\/mi><\/mrow>c<\/annotation><\/semantics><\/math>, con 1<\/mn>\u2264<\/mo>c<\/mi>\u2264<\/mo>A<\/mi><\/mrow>1 \\leq c \\leq A<\/annotation><\/semantics><\/math>. Luego, para calcular la atenci\u00f3n del token en posici\u00f3n i<\/mi><\/mrow>i<\/annotation><\/semantics><\/math>, la cabeza c<\/mi><\/mrow>c<\/annotation><\/semantics><\/math> compara la query q<\/mi>i<\/mi>c<\/mi><\/msubsup><\/mrow>q_i^c<\/annotation><\/semantics><\/math>\u200b con las keys k<\/mi>j<\/mi>c<\/mi><\/msubsup><\/mrow>k_j^c<\/annotation><\/semantics><\/math>\u200b de los tokens disponibles en el contexto:<\/p>\n\n\n\n

s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>c<\/mi><\/msup>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>=<\/mo>q<\/mi>i<\/mi>c<\/mi><\/msubsup>\u22c5<\/mo>k<\/mi>j<\/mi>c<\/mi><\/msubsup><\/mrow>d<\/mi>k<\/mi><\/msub><\/msqrt><\/mfrac><\/mrow>score^c(x_i,x_j) = \\frac{q_i^c \\cdot k_j^c}{\\sqrt{d_k}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Estos scores se normalizan mediante una softmax, produciendo los pesos de atenci\u00f3n:<\/p>\n\n\n\n

\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow>c<\/mi><\/msubsup>=<\/mo>softmax<\/mtext>(<\/mo>s<\/mi>c<\/mi>o<\/mi>r<\/mi>e<\/mi>c<\/mi><\/msup>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>x<\/mi>j<\/mi><\/msub>)<\/mo>)<\/mo><\/mrow>\\alpha_{ij}^c = \\text{softmax}(score^c(x_i,x_j))<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

A partir de estos pesos, cada cabeza calcula su propia suma ponderada de los value vectors:<\/p>\n\n\n\n

h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi>c<\/mi><\/msubsup>=<\/mo>\u2211<\/mo>j<\/mi>\u2264<\/mo>i<\/mi><\/mrow><\/munder>\u03b1<\/mi>i<\/mi>j<\/mi><\/mrow>c<\/mi><\/msubsup>v<\/mi>j<\/mi>c<\/mi><\/msubsup><\/mrow>head_i^c = \\sum_{j \\leq i} \\alpha_{ij}^c v_j^c<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Finalmente, las salidas de todas las cabezas se concatenan y se proyectan mediante una matriz W<\/mi>O<\/mi><\/msup><\/mrow>W^O<\/annotation><\/semantics><\/math>:<\/p>\n\n\n\n

a<\/mi>i<\/mi><\/msub>=<\/mo>(<\/mo>h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi>1<\/mn><\/msubsup>\u2295<\/mo>h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi>2<\/mn><\/msubsup>\u2295<\/mo>\u22ef<\/mo>\u2295<\/mo>h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi>A<\/mi><\/msubsup>)<\/mo>W<\/mi>O<\/mi><\/msup><\/mrow>a_i = (head_i^1 \\oplus head_i^2 \\oplus \\dots \\oplus head_i^A)W^O<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

As\u00ed, la funci\u00f3n de multi-head attention puede expresarse como:<\/p>\n\n\n\n

M<\/mi>u<\/mi>l<\/mi>t<\/mi>i<\/mi>H<\/mi>e<\/mi>a<\/mi>d<\/mi>A<\/mi>t<\/mi>t<\/mi>e<\/mi>n<\/mi>t<\/mi>i<\/mi>o<\/mi>n<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>,<\/mo>[<\/mo>x<\/mi>1<\/mn><\/msub>,<\/mo>\u2026<\/mo>,<\/mo>x<\/mi>i<\/mi><\/msub>]<\/mo>)<\/mo>=<\/mo>a<\/mi>i<\/mi><\/msub><\/mrow>MultiHeadAttention(x_i, [x_1, \\dots, x_i]) = a_i<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Vale la pena destacar que la salida de cada cabeza h<\/mi>e<\/mi>a<\/mi>d<\/mi>i<\/mi>c<\/mi><\/msubsup><\/mrow>head_i^c<\/annotation><\/semantics><\/math> tiene dimensi\u00f3n:<\/p>\n\n\n\n

[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>v<\/mi><\/msub>]<\/mo><\/mrow>[1 \\times d_v]<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Por lo tanto, si tenemos A<\/mi><\/mrow>A<\/annotation><\/semantics><\/math> cabezas, la concatenaci\u00f3n de todas ellas produce un vector de dimensi\u00f3n:<\/p>\n\n\n\n

[<\/mo>1<\/mn>\u00d7<\/mo>A<\/mi>d<\/mi>v<\/mi><\/msub>]<\/mo><\/mrow>[1 \\times A d_v]<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Luego, la matriz W<\/mi>O<\/mi><\/msup><\/mrow>W^O<\/annotation><\/semantics><\/math> proyecta esta concatenaci\u00f3n de vuelta al espacio del modelo:<\/p>\n\n\n\n
W<\/mi>O<\/mi><\/msup>\u2208<\/mo>\u211d<\/mi>A<\/mi>d<\/mi>v<\/mi><\/msub>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>W^{O} \\in \\mathbb{R}^{Ad_{v}\\times d_{model}}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

De esta forma, la salida final de multi-head attention<\/em> conserva la dimensi\u00f3n esperada:<\/p>\n\n\n\n

a<\/mi>i<\/mi><\/msub>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>a_{i} \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math><\/div>\n\n\n\n

Esto es importante porque permite que la salida de la atenci\u00f3n pueda integrarse al flujo residual del transformer y pasar a las siguientes capas.<\/p>\n\n\n\n

Transformer Blocks<\/h2>\n\n\n\n

Multi-head attention<\/strong> es uno de los subcomponentes de un transformer block<\/strong>. Lo hemos explicado en un apartado especial porque es, probablemente, el componente m\u00e1s caracter\u00edstico y complejo de la arquitectura. Sin embargo, un transformer block moderno incluye tambi\u00e9n otros elementos importantes, como LayerNorm<\/strong>, conexiones residuales<\/strong> y una feedforward network<\/strong>.<\/p>\n\n\n\n

El objetivo de esta secci\u00f3n es entender c\u00f3mo interact\u00faan estos subcomponentes dentro del bloque. Para ello, resulta \u00fatil introducir la idea de residual stream<\/strong>. En un transformer moderno, la representaci\u00f3n de cada token no se reemplaza por completo cada vez que pasa por un subcomponente. M\u00e1s bien, existe un flujo principal de informaci\u00f3n \u2014el residual stream\u2014 que transporta la representaci\u00f3n del token a trav\u00e9s del bloque. Los distintos m\u00f3dulos leen desde ese flujo, calculan nueva informaci\u00f3n y luego suman su resultado de vuelta mediante conexiones residuales. En particular, la multi-head attention<\/strong> incorpora informaci\u00f3n contextual proveniente de otros tokens, mientras que la feedforward network<\/strong> transforma la representaci\u00f3n de cada token de forma independiente. Este principio se ilustra en la siguiente figura:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

Como se puede ver, cada token tiene su propio flujo vertical de informaci\u00f3n. En la figura, el token principal es x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>. Ese vector sube por el bloque, mientras algunos m\u00f3dulos leen desde \u00e9l, calculan nueva informaci\u00f3n y la suman de vuelta al flujo principal.<\/p>\n\n\n\n

En la secci\u00f3n pasada explicamos el m\u00f3dulo de multi-head attention<\/em>, sin embargo, nos falta explicar feedforward<\/em>, y layernorm<\/em>.<\/p>\n\n\n\n

Capa feedforward<\/p>\n\n\n\n

La capa feedforward<\/em> de esta arquitectura-cuyo concepto fue explicado en esta entrada<\/a>– es una red neuronal completamente conectada de dos capas, cuya capa oculta (d<\/mi>f<\/mi>f<\/mi><\/mrow><\/msub>d_{ff}<\/annotation><\/semantics><\/math>) suele tener una dimensi\u00f3n m\u00e1s grande que la del modelo (d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>d_{model}<\/annotation><\/semantics><\/math>). Conceptualmente, la red hace algo similar a esto:<\/p>\n\n\n\n

[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>]<\/mo>\u2192<\/mo>[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>f<\/mi>f<\/mi><\/mrow><\/msub>]<\/mo>\u2192<\/mo>[<\/mo>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>]<\/mo><\/mrow>[1\\times d_{model}] \\to [1\\times d_{ff}] \\to [1\\times d_{model}] <\/annotation><\/semantics><\/math><\/p>\n\n\n\n

En este caso, llevamos al vector de entrada a un espacio m\u00e1s grande (de d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>d_{model}<\/annotation><\/semantics><\/math> a d<\/mi>f<\/mi>f<\/mi><\/mrow><\/msub>d_{ff}<\/annotation><\/semantics><\/math>), porque as\u00ed la red tiene m\u00e1s \u201clugar\u201d para representar combinaciones, patrones y transformaciones no lineales. Despu\u00e9s, comprime esa informaci\u00f3n de vuelta a la dimensi\u00f3n del modelo (d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>d_{model}<\/annotation><\/semantics><\/math>). Esta compresi\u00f3n es necesaria para que sigamos trabajando con el vector en el flujo residual, de otra forma, dejar\u00edamos el vector de salida en una dimensi\u00f3n que no es la que espera el subcomponente siguiente. <\/p>\n\n\n\n

Dicho esto, en t\u00e9rminos matem\u00e1ticos, este paso se puede expresar de la siguiente forma:<\/p>\n\n\n\n

F<\/mi>F<\/mi>N<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>)<\/mo>=<\/mo>R<\/mi>e<\/mi>L<\/mi>U<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>W<\/mi>1<\/mn><\/msub>+<\/mo>b<\/mi>1<\/mn><\/msub>)<\/mo>W<\/mi>2<\/mn><\/msub>+<\/mo>b<\/mi>2<\/mn><\/msub><\/mrow>FFN(x_{i}) = ReLU(x_{i}W_{1} + b_{1} ) W_{2} + b_{2}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

donde x<\/mi>i<\/mi><\/msub>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>x_{i} \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math>, W<\/mi>1<\/mn><\/msub>\u2208<\/mo>\u211d<\/mi>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>\u00d7<\/mo>d<\/mi>f<\/mi>f<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>W_{1} \\in \\mathbb{R}^{d_{model}\\times d_{ff}}<\/annotation><\/semantics><\/math> y W<\/mi>2<\/mn><\/msub>\u2208<\/mo>\u211d<\/mi>d<\/mi>f<\/mi>f<\/mi><\/mrow><\/msub>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>W_{2} \\in \\mathbb{R}^{d_{ff}\\times d_{model}}<\/annotation><\/semantics><\/math> (Tarea: chequea que F<\/mi>F<\/mi>N<\/mi>(<\/mo>x<\/mi>i<\/mi><\/msub>)<\/mo>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>FFN(x_{i}) \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math>). <\/p>\n\n\n\n

Capa LayerNorm<\/p>\n\n\n\n

Layer norm<\/em> (de Layer Normalization) normaliza el vector de representaci\u00f3n de cada token para que sus valores no crezcan, se desplacen o se vuelvan demasiado extremos a medida que pasan por muchas capas.<\/p>\n\n\n\n

Si pensamos en x<\/mi>i<\/mi><\/msub>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>x_{i} \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math>, layer norm<\/em> toma ese vector y calcula la media y la desviaci\u00f3n est\u00e1ndar de sus propias dimensiones internas<\/strong>. Es decir, no normaliza toda la capa completa ni todos los tokens juntos, sino el vector individual de un token. En t\u00e9rminos matem\u00e1ticos, primero hace<\/p>\n\n\n\n

\u03bc<\/mi>=<\/mo>1<\/mn>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mfrac>\u2211<\/mo>r<\/mi>=<\/mo>1<\/mn><\/mrow>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/msubsup>x<\/mi>i<\/mi>r<\/mi><\/msubsup><\/mrow>\\mu = \\frac{1}{d_{model}}\\sum_{r=1}^{d_{model}}x_{i}^{r}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

\u03c3<\/mi>=<\/mo>1<\/mn>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mfrac>\u2211<\/mo>r<\/mi>=<\/mo>1<\/mn><\/mrow>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/msubsup>(<\/mo>x<\/mi>i<\/mi>r<\/mi><\/msubsup>\u2212<\/mo>\u03bc<\/mi>)<\/mo>2<\/mn><\/msup><\/mrow><\/msqrt><\/mrow>\\sigma = \\sqrt{\\frac{1}{d_{model}}\\sum_{r=1}^{d_{model}}(x_{i}^{r}-\\mu)^{2}}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Luego, normaliza:<\/p>\n\n\n\n

x<\/mi>^<\/mo><\/mover>i<\/mi><\/msub>=<\/mo>x<\/mi>i<\/mi><\/msub>\u2212<\/mo>\u03bc<\/mi><\/mrow>\u03c3<\/mi><\/mfrac><\/mrow>\\hat{x}_{i} = \\frac{x_{i}-\\mu}{\\sigma}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

y finalmente, aplica dos par\u00e1metros aprendibles (\u03b1<\/mi>\\alpha <\/annotation><\/semantics><\/math> y \u03b2<\/mi>\\beta<\/annotation><\/semantics><\/math>):<\/p>\n\n\n\n

LayerNorm<\/mtext>(<\/mo>x<\/mi>^<\/mo><\/mover>i<\/mi><\/msub>)<\/mo>=<\/mo>\u03b1<\/mi>x<\/mi>i<\/mi><\/msub>^<\/mo><\/mover>+<\/mo>\u03b2<\/mi><\/mrow>\\text{LayerNorm}(\\hat{x}_{i}) = \\alpha \\hat{x_{i}} + \\beta<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Bloque completo<\/p>\n\n\n\n

Empleando la notaci\u00f3n de Jurafsky y Martin (2026)<\/a><\/strong>, podemos expresar los c\u00e1lculos que hace un transformer block<\/em> en el siguiente conjunto de ecauciones:<\/p>\n\n\n\n

t<\/mi>i<\/mi>1<\/mn><\/msubsup>=<\/mo>LayerNorm<\/mtext>(<\/mo>x<\/mi>i<\/mi><\/msub>)<\/mo><\/mrow>t_{i}^{1} = \\text{LayerNorm}(x_{i})<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

t<\/mi>i<\/mi>2<\/mn><\/msubsup>=<\/mo>MultiheadAttention<\/mtext>(<\/mo>t<\/mi>i<\/mi>1<\/mn><\/msubsup>,<\/mo>[<\/mo>t<\/mi>1<\/mn>1<\/mn><\/msubsup>,<\/mo>.<\/mi>.<\/mi>.<\/mi>t<\/mi>N<\/mi>1<\/mn><\/msubsup>]<\/mo>)<\/mo><\/mrow>t_{i}^{2} = \\text{MultiheadAttention}(t_{i}^{1}, [t_{1}^{1},…t_{N}^{1}])<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

t<\/mi>i<\/mi>3<\/mn><\/msubsup>=<\/mo>t<\/mi>i<\/mi>2<\/mn><\/msubsup>+<\/mo>x<\/mi>i<\/mi><\/msub><\/mrow>t^{3}_{i} = t_{i}^{2} + x_{i}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

t<\/mi>i<\/mi>4<\/mn><\/msubsup>=<\/mo>LayerNorm<\/mtext>(<\/mo>t<\/mi>i<\/mi>3<\/mn><\/msubsup>)<\/mo><\/mrow>t_{i}^{4} = \\text{LayerNorm}(t_{i}^{3})<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

t<\/mi>i<\/mi>5<\/mn><\/msubsup>=<\/mo>FFN<\/mtext>(<\/mo>t<\/mi>i<\/mi>4<\/mn><\/msubsup>)<\/mo><\/mrow>t_{i}^{5} = \\text{FFN}(t_{i}^{4})<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

h<\/mi>i<\/mi><\/msub>=<\/mo>t<\/mi>i<\/mi>5<\/mn><\/msubsup>+<\/mo>t<\/mi>i<\/mi>3<\/mn><\/msubsup><\/mrow>h_{i} = t_{i}^{5} + t_{i}^{3}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n

Primero, en t<\/mi>i<\/mi>1<\/mn><\/msubsup><\/mrow>t_i^1<\/annotation><\/semantics><\/math>, se normaliza la representaci\u00f3n de entrada del token x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>. Luego, en t<\/mi>i<\/mi>2<\/mn><\/msubsup><\/mrow>t_i^2<\/annotation><\/semantics><\/math>\u200b, esa representaci\u00f3n normalizada entra al m\u00f3dulo de multi-head attention<\/strong>, que calcula una contribuci\u00f3n contextual para el token i<\/mi><\/mrow>i<\/annotation><\/semantics><\/math>, usando informaci\u00f3n del propio token y de los tokens disponibles en el contexto. Despu\u00e9s, en t<\/mi>i<\/mi>3<\/mn><\/msubsup><\/mrow>t_i^3<\/annotation><\/semantics><\/math>, la salida de attention se suma al vector original x<\/mi>i<\/mi><\/msub><\/mrow>x_i<\/annotation><\/semantics><\/math>, formando la primera conexi\u00f3n residual.<\/p>\n\n\n\n

A continuaci\u00f3n, en t<\/mi>i<\/mi>4<\/mn><\/msubsup><\/mrow>t_i^4<\/annotation><\/semantics><\/math>\u200b, se normaliza esta representaci\u00f3n actualizada t<\/mi>i<\/mi>3<\/mn><\/msubsup><\/mrow>t_i^3<\/annotation><\/semantics><\/math>\u200b. Luego, en t<\/mi>i<\/mi>5<\/mn><\/msubsup><\/mrow>t_i^5<\/annotation><\/semantics><\/math>, la representaci\u00f3n normalizada pasa por la red feedforward<\/strong>, que transforma el vector del token<\/em> de forma independiente respecto de los dem\u00e1s tokens.<\/em> Finalmente, la salida de la feedforward<\/strong> se suma nuevamente a t<\/mi>i<\/mi>3<\/mn><\/msubsup><\/mrow>t_i^3<\/annotation><\/semantics><\/math>, produciendo h<\/mi>i<\/mi><\/msub><\/mrow>h_i<\/annotation><\/semantics><\/math>, la salida final del transformer block para el token en la posici\u00f3n i<\/mi><\/mrow>i<\/annotation><\/semantics><\/math>.<\/p>\n\n\n\n

Sobre la entrada x<\/mi>i<\/mi><\/msub>x_{i}<\/annotation><\/semantics><\/math><\/h2>\n\n\n\n

Hasta este punto, hemos discutido lo que hacemos con el vector x<\/mi>i<\/mi><\/msub>\u2208<\/mo>\u211d<\/mi>1<\/mn>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>x_{i} \\in \\mathbb{R}^{1\\times d_{model}}<\/annotation><\/semantics><\/math> , no obstante, no hemos dicho mucho sobre \u00e9l. En esta secci\u00f3n veremos que no s\u00f3lo es necesario el embedding<\/em>, si no tambi\u00e9n, la posici\u00f3n de dicho vector en la secuencia.<\/p>\n\n\n\n

Supongamos que tenemos una secuencia de N<\/strong> tokens, donde N <\/strong>es el largo del contexto. El input<\/em> del transformer<\/em> se podr\u00eda escribir como X<\/mi>\u2208<\/mo>\u211d<\/mi>N<\/mi>\u00d7<\/mo>d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub><\/mrow><\/msup><\/mrow>X \\in \\mathbb{R}^{N\\times d_{model}}<\/annotation><\/semantics><\/math> , donde d<\/mi>m<\/mi>o<\/mi>d<\/mi>e<\/mi>l<\/mi><\/mrow><\/msub>d_{model}<\/annotation><\/semantics><\/math> es el largo del embedding<\/em>. Para ilustrar esta matriz, a modo de ejemplo, asumiremos que cada token<\/em> es una palabra, y que nuestro contexto viene dado por la siguiente frase (N=7):<\/p>\n\n\n\n
\n

Esto me an buelto myos enemigos malos<\/p>\n<\/blockquote>\n\n\n\n

Dicha secuencia deber\u00e1 tener 7 embeddings<\/em>, que vienen dados por:<\/p>\n\n\n\n