Large Language Model (LLM) from scratch. Transformers.

En la publicación pasada entendimos la estructura general de un LLM. Este paso es vital, puesto que nos da una visión panorámica sobre la morfología de estos modelos. Con esto en mente, ahora podemos estudiar la arquitectura de aquellos.

Existen múltiples arquitecturas para diseñar un LLM, no obstante, en esta entrada vamos a estudiar transformers, puesto que es la que emplean los LLM más famosos, tales como GPT, BERT, T5, LLaMa, etc.

Al igual que en la entrada anterior, usaremos como referencia a Jurafsky y Martin (2026), como es usual. Cualquier error es mi responsabilidad.

Atención

En el contexto específico de transformers, el concepto de atención fue introducido por Vaswani et al. (2017). Este artículo, y concepto, son importantes por varias razones, no obstante, en este momento se me ocurren dos muy obvias: la atención está presente en los LLMs más famosos, tales como GPT, BERT, etc., y además, el artículo tiene más de 250 mil citas (a mayo de 2026).

En términos formales, la atención es un mecanismo que permite construir una nueva representación contextual de un token combinando información de otros tokens de la secuencia.

Pero, ¿Por qué necesitamos una nueva representación contextual?. Primero que todo, recordemos algunos conceptos expuestos en la entrada sobre embeddings. En esta publicación, representábamos el significado de una palabra de forma vectorial y estática, es decir, los valores de los componentes del vector de la palabra no dependen del contexto en el que se encuentre. Esto es problemático porque muchas veces la idoneidad de la palabra es definida por el contexto. Por ejemplo:

El coche no siguió avanzando por el camino porque este estaba mojado.

El coche no siguió avanzando por el camino porque este estaba averiado.

En este caso, en la primera oración, el coche no avanzó 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 «este».

Entonces, respondiendo a la pregunta, sobre si una nueva representación conceptual es necesaria, si, es absolutamente necesaria, puesto que ayuda al modelo a distinguir este tipo de sutilidades.

Ahora que sabemos por qué una representación contextual es necesaria, estamos en condiciones de explicar el concepto de atención. Formalmente, se podría definir como el mecanismo mediante el cual el transformer toma $x_i$, es decir, la representación vectorial del token que está en la posición $i$ de la secuencia, y produce $a_i$, una nueva representación del mismo token, pero enriquecida con información de los tokens anteriores. En un modelo causal, como GPT, esta información sólo puede venir del propio token y de los tokens que aparecen antes de él, no de los tokens futuros.

Para entender esta idea, usaremos una versión simplificada de lo que realmente ocurre, tal y como lo muestra Jurafsky y Martin (2026). Para esto, asumiremos la siguiente estructura:

$a_{i} = \sum_{j\leq i}\alpha_{ij}x_{j}$

Es decir, en la posición $i$ de la secuencia, tomamos la representación vectorial de los tokens anteriores (incluyendo $i$), y los ponderamos por $\alpha_{ij}$. Luego, para obtener este último, calculamos el score, y lo pasamos por la softmax:

$score(x_{i},x_{j}) = x_{i} \cdot x_{j}$

$\alpha_{ij} = softmax(score(x_{i},x_{j}) ), \forall j\leq i$

¿Por qué calculamos el producto punto? Recordemos que este se puede interpretar como una medida de similitud entre dos vectores, entonces, si el vector de un token previo $x_j$​ es parecido al vector del token actual $x_i$, entonces probablemente contiene información útil para interpretar o representar mejor a $x_i$. En términos prácticos, supongamos el siguiente ejemplo:

El gato es buena mascota. Este felino…

Supongamos que en esta frase estamos analizando $x_{felino}$. Es de esperar, que la similitud entre $x_{felino}$ y $x_{gato}$, sea mayor a la similitud entre $x_{felino}$y $x_{buena}$. Lo anterior implica que $\alpha_{felino,gato} >\alpha_{felino,buena}$. Por tanto, el vector contextualizado del token felino, $a_{felino}$, contendrá más información de gato que del token buena.

Esta metodología fue desarrollada por Jurafsky y Martin (2026) con fines pedagógicos, no obstante, el funcionamiento de la atención es más compleja. Esta, tiene conceptos adicionales como attention head, query, key y value. A continuación veremos cada uno, y cómo se relacionan.

Attention head, query y value

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

En el ejemplo de la ilustración, tenemos tres tokens de entrada que vienen en forma de embeddings: $x_{1}$, $x_{2}$y $x_{3}$, siendo este último, el token que estamos analizando. Nuestro objetivo es calcular $a_{3}$, es decir, una nueva representación contextualizada de ese token. Para ello, primero proyectamos cada vector de entrada en tres representaciones distintas: key, query y value. Estas proyecciones se obtienen mediante tres matrices aprendidas por el modelo:

$q_{i} = x_{i}W^{Q}$

$k_{i} = x_{i}W^{K}$

$v_{i} = x_{i}W^{V}$

donde $q_{i}$ es la query, $k_{i}$es la key y $v_{i}$es el value correspondiente al token en la posición $i$.

Como queremos calcular la salida de atención para $x_3$, usamos la query de $x_3$, es decir, $q_3$, y la comparamos con las keys de los tokens disponibles en el contexto. Puesto que estamos en un modelo causal, $x_3$ puede atender a $x_1$, $x_2$ y a sí mismo, pero no a tokens futuros. Por lo tanto, calculamos los siguientes scores:

$x_{3} \text{contra } x_{1} : score(x_{3},x_{1}) = \frac{q_{3}\cdot k_{1}}{\sqrt{d_{k}}}$

$x_{3} \text{contra } x_{2} : score(x_{3},x_{2}) = \frac{q_{3}\cdot k_{2}}{\sqrt{d_{k}}}$

$x_{3} \text{contra } x_{1} : score(x_{3},x_{3}) = \frac{q_{3}\cdot k_{3}}{\sqrt{d_{k}}}$

El producto punto $q_3 \cdot k_j$ mide la compatibilidad entre la query del token actual y la key de cada token del contexto. Luego, dividimos por $\sqrt{d_k}$ para evitar que los scores crezcan demasiado cuando la dimensión de las queries y keys es alta.

Posteriormente, pasamos estos scores por una softmax. Esto nos permite convertir los scores en pesos de atención:

$\alpha_{31}, \alpha_{32}, \alpha_{33}$

Formalmente:

$\alpha_{3j} = \frac{e^{score(x_{3},x_{j})}}{\sum_{m\leq3}e^{score(x_{3},x_{m})}}$

para $j \in \{1,2,3\}$. De esta forma, los pesos de atención son números positivos que suman 1:

$\alpha_{31} + \alpha_{32} + \alpha_{33} =1$

Cada $\alpha_{3j}$​ indica cuánta información del token $x_j$ será incorporada en la nueva representación de $x_3$.

Una vez obtenidos los pesos de atención, podemos calcular la salida de la cabeza de atención para el token $x_3$. Para ello, hacemos una suma ponderada de los value vectors:

$head_{3} = \alpha_{31}v_{1} + \alpha_{32}v_{2} + \alpha_{33}v_{3}$

El vector $head_3$​ tiene dimensión:

$1\times d_{v}$

Sin embargo, la arquitectura del transformer necesita que la salida de la atención tenga la misma dimensión que la representación original del token, es decir:

$1\times d_{model}$

Por esta razón, multiplicamos $head_3$ por una matriz de salida $W^O$:

$a_{3} = head_{3}W^{o}$

donde:

$W^{O} \in \mathbb{R}^{d_{v}\times d_{model}}$

Así, la operación tiene la siguiente forma:

$[1\times d_{v}]\cdot [d_{v}\times d_{model}] = [1\times d_{model}]$

El resultado final es:

$a_{3} \in \mathbb{R}^{1\times d_{model}}$

Es decir, $a_3$ es una nueva representación del token $x_3$​, enriquecida con información de $x_1$, $x_2$ y del propio $x_3$​. Esta representación mantiene la misma dimensionalidad que la entrada, lo que permite integrarla al flujo residual del transformer y pasarla a las siguientes capas.

Para verlo con un ejemplo pequeño, supongamos que:

$d_{v} = 3 \ \ \ \text{y} \ \ \ d_{model}=2$

Entonces $head_3$ podría ser un vector de tres dimensiones:

$head_{i} = [h_{1} \ h_{2} \ h_{3}]$

y $W^{O}$tendría dimensión $3\times 2$:

$W^{O} = \begin{bmatrix} w_{11} & w_{12} \\ w_{21} & w_{22} \\ w_{31} & w_{32} \end{bmatrix}$

La multiplicación sería:

$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}$

Por lo tanto:

$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}$

Así, $W^O$ aprende cómo transformar y mezclar la información contenida en $head_3$ para devolverla al espacio general del modelo.

Dicho esto, en términos formales, el conjunto de ecuaciones para obtener $a_{i}$vendría dado por:

$q_{i} = x_{i}W^{Q} \ \ ; \ \ k_{j} = x_{j}W^{K} \ \ ; \ \ v_{j} = x_{j}W^{V}$

$score(x_{i},x_{j}) = \frac{q_{i}k_{j}}{\sqrt{d_{k}}}$

$\alpha_{ij} = softmax(score(x_{i},x_{j})) \ \ \forall j \leq i$

$head_{i} = \sum_{j\leq i} \alpha_{ij}v_{j}$

$a_{i} = head_{i}W^{o}$

Múltiples attention heads

En la sección anterior mostramos el funcionamiento de una sola attention head. Sin embargo, los transformers no suelen usar una única cabeza de atención, 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ía especializarse en ciertas relaciones gramaticales, otra en relaciones semánticas, otra en repeticiones o dependencias de largo alcance. En este sentido, multi-head attention permite que el modelo construya varias representaciones contextuales complementarias a partir de los mismos tokens de entrada.

Siguiendo la notación de Jurafsky y Martin (2026), si tenemos $A$ cabezas de atención, cada cabeza $c$ tiene su propio conjunto de matrices aprendidas:$$W^{Q_c}, \quad W^{K_c}, \quad W^{V_c}$$

Estas matrices proyectan los vectores de entrada en queries, keys y values específicos para cada cabeza:

$$q_i^c = x_i W^{Q_c}$$$$k_j^c = x_j W^{K_c}$$$$v_j^c = x_j W^{V_c}$$

para cada cabeza $c$, con $1 \leq c \leq A$. Luego, para calcular la atención del token en posición $i$, la cabeza $c$ compara la query $q_i^c$​ con las keys $k_j^c$​ de los tokens disponibles en el contexto:

$$score^c(x_i,x_j) = \frac{q_i^c \cdot k_j^c}{\sqrt{d_k}}$$

Estos scores se normalizan mediante una softmax, produciendo los pesos de atención:

$$\alpha_{ij}^c = \text{softmax}(score^c(x_i,x_j))$$

A partir de estos pesos, cada cabeza calcula su propia suma ponderada de los value vectors:

$$head_i^c = \sum_{j \leq i} \alpha_{ij}^c v_j^c$$

Finalmente, las salidas de todas las cabezas se concatenan y se proyectan mediante una matriz $W^O$:

$$a_i = (head_i^1 \oplus head_i^2 \oplus \dots \oplus head_i^A)W^O$$

Así, la función de multi-head attention puede expresarse como:

$$MultiHeadAttention(x_i, [x_1, \dots, x_i]) = a_i$$

Vale la pena destacar que la salida de cada cabeza $head_i^c$ tiene dimensión:

$$[1 \times d_v]$$

Por lo tanto, si tenemos $A$ cabezas, la concatenación de todas ellas produce un vector de dimensión:

$$[1 \times A d_v]$$

Luego, la matriz $W^O$ proyecta esta concatenación de vuelta al espacio del modelo:

De esta forma, la salida final de multi-head attention conserva la dimensión esperada:

Esto es importante porque permite que la salida de la atención pueda integrarse al flujo residual del transformer y pasar a las siguientes capas.

Transformer Blocks

Multi-head attention es uno de los subcomponentes de un transformer block. Lo hemos explicado en un apartado especial porque es, probablemente, el componente más característico y complejo de la arquitectura. Sin embargo, un transformer block moderno incluye también otros elementos importantes, como LayerNorm, conexiones residuales y una feedforward network.

El objetivo de esta sección es entender cómo interactúan estos subcomponentes dentro del bloque. Para ello, resulta útil introducir la idea de residual stream. En un transformer moderno, la representación de cada token no se reemplaza por completo cada vez que pasa por un subcomponente. Más bien, existe un flujo principal de información —el residual stream— que transporta la representación del token a través del bloque. Los distintos módulos leen desde ese flujo, calculan nueva información y luego suman su resultado de vuelta mediante conexiones residuales. En particular, la multi-head attention incorpora información contextual proveniente de otros tokens, mientras que la feedforward network transforma la representación de cada token de forma independiente. Este principio se ilustra en la siguiente figura:

Como se puede ver, cada token tiene su propio flujo vertical de información. En la figura, el token principal es $x_i$. Ese vector sube por el bloque, mientras algunos módulos leen desde él, calculan nueva información y la suman de vuelta al flujo principal.

En la sección pasada explicamos el módulo de multi-head attention, sin embargo, nos falta explicar feedforward, y layernorm.

Capa feedforward

La capa feedforward de esta arquitectura-cuyo concepto fue explicado en esta entrada– es una red neuronal completamente conectada de dos capas, cuya capa oculta ($d_{ff}$) suele tener una dimensión más grande que la del modelo ($d_{model}$). Conceptualmente, la red hace algo similar a esto:

$[1\times d_{model}] \to [1\times d_{ff}] \to [1\times d_{model}]$

En este caso, llevamos al vector de entrada a un espacio más grande (de $d_{model}$ a $d_{ff}$), porque así la red tiene más “lugar” para representar combinaciones, patrones y transformaciones no lineales. Después, comprime esa información de vuelta a la dimensión del modelo ($d_{model}$). Esta compresión es necesaria para que sigamos trabajando con el vector en el flujo residual, de otra forma, dejaríamos el vector de salida en una dimensión que no es la que espera el subcomponente siguiente.

Dicho esto, en términos matemáticos, este paso se puede expresar de la siguiente forma:

$FFN(x_{i}) = ReLU(x_{i}W_{1} + b_{1} ) W_{2} + b_{2}$

donde $x_{i} \in \mathbb{R}^{1\times d_{model}}$, $W_{1} \in \mathbb{R}^{d_{model}\times d_{ff}}$ y $W_{2} \in \mathbb{R}^{d_{ff}\times d_{model}}$ (Tarea: chequea que $FFN(x_{i}) \in \mathbb{R}^{1\times d_{model}}$).

Capa LayerNorm

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

Si pensamos en $x_{i} \in \mathbb{R}^{1\times d_{model}}$, layer norm toma ese vector y calcula la media y la desviación estándar de sus propias dimensiones internas. Es decir, no normaliza toda la capa completa ni todos los tokens juntos, sino el vector individual de un token. En términos matemáticos, primero hace

$\mu = \frac{1}{d_{model}}\sum_{r=1}^{d_{model}}x_{i}^{r}$

$\sigma = \sqrt{\frac{1}{d_{model}}\sum_{r=1}^{d_{model}}(x_{i}^{r}-\mu)^{2}}$

Luego, normaliza:

$\hat{x}_{i} = \frac{x_{i}-\mu}{\sigma}$

y finalmente, aplica dos parámetros aprendibles ($\alpha$ y $\beta$):

$\text{LayerNorm}(\hat{x}_{i}) = \alpha \hat{x_{i}} + \beta$

Bloque completo

Empleando la notación de Jurafsky y Martin (2026), podemos expresar los cálculos que hace un transformer block en el siguiente conjunto de ecauciones:

$t_{i}^{1} = \text{LayerNorm}(x_{i})$

$t_{i}^{2} = \text{MultiheadAttention}(t_{i}^{1}, [t_{1}^{1},…t_{N}^{1}])$

$t^{3}_{i} = t_{i}^{2} + x_{i}$

$t_{i}^{4} = \text{LayerNorm}(t_{i}^{3})$

$t_{i}^{5} = \text{FFN}(t_{i}^{4})$

$h_{i} = t_{i}^{5} + t_{i}^{3}$

Primero, en $t_i^1$, se normaliza la representación de entrada del token $x_i$. Luego, en $t_i^2$​, esa representación normalizada entra al módulo de multi-head attention, que calcula una contribución contextual para el token $i$, usando información del propio token y de los tokens disponibles en el contexto. Después, en $t_i^3$, la salida de attention se suma al vector original $x_i$, formando la primera conexión residual.

A continuación, en $t_i^4$​, se normaliza esta representación actualizada $t_i^3$​. Luego, en $t_i^5$, la representación normalizada pasa por la red feedforward, que transforma el vector del token de forma independiente respecto de los demás tokens. Finalmente, la salida de la feedforward se suma nuevamente a $t_i^3$, produciendo $h_i$, la salida final del transformer block para el token en la posición $i$.

Sobre la entrada $x_{i}$

Hasta este punto, hemos discutido lo que hacemos con el vector $x_{i} \in \mathbb{R}^{1\times d_{model}}$ , no obstante, no hemos dicho mucho sobre él. En esta sección veremos que no sólo es necesario el embedding, si no también, la posición de dicho vector en la secuencia.

Supongamos que tenemos una secuencia de N tokens, donde N es el largo del contexto. El input del transformer se podría escribir como $X \in \mathbb{R}^{N\times d_{model}}$ , donde $d_{model}$ es el largo del embedding. Para ilustrar esta matriz, a modo de ejemplo, asumiremos que cada token es una palabra, y que nuestro contexto viene dado por la siguiente frase (N=7):

Esto me an buelto myos enemigos malos

Dicha secuencia deberá tener 7 embeddings, que vienen dados por:

• Esto = [$x_{1}^{1},…,x_{d_{model}}^{1}$]
• me = [$x_{1}^{2},…,x_{d_{model}}^{2}$]
• an = [$x_{1}^{3},…,x_{d_{model}}^{3}$]
• …
• malos = [$x_{1}^{7},…,x_{d_{model}}^{7}$]

Por lo que la matriz X vendría dada por:

$X = \begin{bmatrix} x_{1}^{1} & … & x_{d_{model}}^{1} \\ … & … & … \\ x_{1}^{7} & … & x_{d_{model}}^{7} \end{bmatrix}$

En este punto, es importante entender que los embeddings obtenidos no registran ningún tipo de posición en el texto -en esta entrada podrás entender por qué-. No obstante, como podrás intuir después de leer el apartado de atención, la posición importa. En la siguiente imagen ilustramos por qué importa:

En este caso, podemos ver que el significado de la oración cambia levemente al intercambiar el orden de las palabras. Entonces, para que el transformer enriquezca los vectores según el contexto de forma correcta, es necesario que reciba el token bajo análisis, más los tokens que lo preceden en el orden original en que aparecieron en la secuencia.

Para llevar a cabo esta tarea, el modelo usa positional embeddings. Estos embeddings son vectores asociados a las posiciones de la secuencia. Por ejemplo, si tenemos una secuencia de N tokens, tendríamos N vectores:

• $P_{1} \in \mathbb{R}^{1\times d_{model}}$
• $P_{2} \in \mathbb{R}^{1\times d_{model}}$
• …
• $P_{N} \in \mathbb{R}^{1\times d_{model}}$

Luego, para construir la representación final de la entrada del token en la posición $i$, llevamos a cabo la siguiente suma:

$x_{i} = E[token_{i}] + P_{i}$

donde $E \in \mathbb{R}^{|V|\times d_{model}}$, es el vector de embeddings, y $|V|$ es el tamaño del vocabulario.

¿Cómo se aprende el modelo $P_{i}$? Al inicio del entrenamiento, los vectores $P_1,\dots,P_N$​ suelen estar inicializados con valores aleatorios. Durante el entrenamiento, el modelo intenta predecir correctamente los siguientes tokens. Si la información de posición ayuda a reducir el error, los gradientes van ajustando esos vectores posicionales. Con muchas frases, el modelo aprende patrones como: qué suele pasar al comienzo de una oración, qué roles suelen tener ciertas posiciones, cómo afecta el orden a la interpretación, etc.

The Language Modeling Head

Hasta este punto ya sabemos lo que hace la capa del transformer. En términos coloquiales, en dicha capa entra un bloque completo de tokens como una matriz, y el transformer procesa todas las posiciones en paralelo. Gracias a la máscara causal, cada posición sólo puede usar información de los tokens anteriores y de sí misma. En términos matemáticos, una capa de transformer mapea una ventana completa de vectores de entrada (x) en vectores de salida contextualizados (h), es decir,

La siguiente ilustración resume parte de lo que hemos explicado si entrase la secuencia «A diestro dexan a Sant Esteuan, mas cae aluen.»

Con estos vectores ya enriquecidos, estamos en condiciones de predecir la siguiente palabra (como lo hicimos en esta entrada). Este proceso es la función principal de un language modeling head. La siguiente imagen explica esta función en detalle:

La figura muestra el flujo final de un transformer usado como modelo de lenguaje. Primero, una secuencia de tokens de entrada $w_1, w_2, \dots, w_N$​ atraviesa el último bloque transformer, produciendo una representación contextualizada para cada posición: $h_1^L, h_2^L, \dots, h_N^L$​. Durante la generación, normalmente nos interesa el último vector contextualizado, $h_N^L$​, porque contiene información del contexto disponible hasta el token $N$.

Luego, el vector $h_N^L$ entra en la language modeling head. En esta etapa, se proyecta desde el espacio interno del modelo hacia el espacio del vocabulario mediante una capa de unembedding, usualmente representada como $U = E^T$, donde $U \in \mathbb{R}^{d \times |V|}$. Matemáticamente, esta operación se expresa como $u = h_N^L U$, con $u \in \mathbb{R}^{1 \times |V|}$. El vector resultante $u$ contiene los logits, es decir, un puntaje no normalizado para cada token posible del vocabulario. Finalmente, una función softmax transforma esos logits en una distribución de probabilidad $y \in \mathbb{R}^{1 \times |V|}$. Cada componente de $y$ indica la probabilidad que el modelo asigna a un posible siguiente token.

Fase de entrenamiento

En el entrenamiento de un transformer causal, el modelo aprende a predecir el siguiente token en cada posición de una secuencia, es decir,

Para ello, produce una distribución de probabilidad sobre el vocabulario y se compara esa distribución con el token correcto. La pérdida usada es la cross-entropy loss, que penaliza al modelo cuando asigna baja probabilidad al token real siguiente (si has seguido esta serie de publicaciones, esto te resultaría familiar, en caso contrario, visita esta entrada). Luego, mediante gradient descent, los pesos del modelo se ajustan para reducir esa pérdida promedio.

Es importante precisar que, durante el entrenamiento, el modelo no procesa todo el corpus completo de una sola vez. En la práctica, se define una ventana de contexto —por ejemplo, de algunos miles de tokens— y el corpus se organiza en segmentos o chunks que caben dentro de esa ventana. Si un documento es más corto que la ventana, pueden empaquetarse varios documentos en un mismo chunk, normalmente separados por un token especial. Cada chunk se procesa como una secuencia de entrenamiento: el modelo recibe sus tokens y aprende a predecir el siguiente token en cada posición, respetando la máscara causal. De esta manera, puede entrenarse sobre corpus muy grandes, pero siempre mediante fragmentos de tamaño limitado por su ventana de contexto.

Notas finales, y próxima entrada…

En esta entrada vimos el concepto de transformers con mayor profundidad. Esta idea ha sido fundamental en la construcción de los LLM’s más famosos, por tanto, su lectura es obligatoria.

En la próxima publicación veremos prácticas asociadas al post-entrenamiento, tales como instuction tuning y alignment. Stay tuned!

José Miguel Muñoz Urra – jmunozu@pulki.es