Machine Learning on kenji.blog

【Para Principiantes】Descifrando la estructura matemática del modelo Transformer

Fri, 11 Sep 2026 22:00:00 +0900

Introducción: ¿Por qué aprender las matemáticas de Transformer?

No sería exagerado decir que “Transformer” es la arquitectura que reescribió la historia del procesamiento del lenguaje natural (NLP) moderno y de toda la IA en general. Propuesto por primera vez en 2017 por investigadores de Google en el artículo “Attention Is All You Need”, este modelo funciona actualmente como el corazón de los grandes modelos de lenguaje (LLM) que dominan el mundo, como la serie GPT de OpenAI (la tecnología base de ChatGPT), BERT de Google y Claude de Anthropic.

Sin embargo, aunque es común encontrar explicaciones cualitativas sobre cómo funciona Transformer, como “utiliza un mecanismo de Attention (atención) para comprender el contexto”, en realidad hay muy pocas explicaciones profundas dirigidas a principiantes sobre la estructura matemática que hay detrás. Para comprender verdaderamente cómo la IA procesa las “palabras” como “fórmulas matemáticas” y genera oraciones asombrosamente naturales, es indispensable descifrar su mecanismo matemático.

En este artículo, dirigido a personas con conocimientos básicos de matemáticas y programación (aquellos que comprenden conceptos de nivel de secundaria como matrices y derivadas), desentrañaremos de manera exhaustiva y fácil de entender la estructura matemática de los componentes centrales de Transformer: el “Mecanismo de Self-Attention”, el “Modelo de Consulta, Clave y Valor (Q/K/V)”, la “Normalización con la función Softmax” y el “Positional Encoding”.

Es posible que te sientas abrumado por la cantidad de fórmulas matemáticas, pero cada cálculo tiene un “significado” claro. Para cuando termines de leer este artículo, deberías poder comprender que Transformer no es simplemente una caja negra mágica, sino un cristal de matemáticas y estadísticas diseñado con gran precisión.

1. Limitaciones de los métodos tradicionales y la innovación de Transformer

Antes de la aparición de Transformer, la corriente principal en el procesamiento del lenguaje natural eran las Redes Neuronales Recurrentes (RNN) y su derivado, LSTM (Long Short-Term Memory). Las RNN están diseñadas para procesar datos de series temporales y leen el texto palabra por palabra, secuencialmente desde el principio.

Sin embargo, las RNN tenían dos debilidades fatales:

Dificultad para aprender dependencias a largo plazo: A medida que las oraciones se vuelven más largas, la información de las primeras palabras ingresadas se desvanece antes de llegar al final (problema del desvanecimiento del gradiente).
Imposibilidad de realizar cálculos en paralelo: Dado que las palabras deben procesarse en orden, es difícil realizar cálculos paralelos a gran escala utilizando GPUs, lo que hace que el entrenamiento lleve una enorme cantidad de tiempo.

Transformer abandonó por completo la estructura de las RNN y provocó un cambio de paradigma al capturar el contexto utilizando únicamente “Attention”. Esto hizo posible que, sin importar cuán larga sea la secuencia, no haya pérdida de información y se puedan paralelizar los cálculos para aprovechar al máximo el rendimiento de la GPU.

2. Arquitectura general de Transformer

Primero, demos un vistazo general a la arquitectura de Transformer. Transformer se compone principalmente de dos bloques: el “Encoder” (codificador) y el “Decoder” (decodificador). Tomando como ejemplo una tarea de traducción, el Encoder convierte el idioma de entrada (ej: inglés) en una representación vectorial matemática, y el Decoder genera el idioma de salida (ej: japonés) basándose en esa representación vectorial.

El siguiente diagrama es una simplificación de la estructura interna del bloque Encoder.

graph TD A["Tokens de Entrada"] --> B["Incrustación de Entrada"] B --> C["Codificación Posicional"] C --> D["Autoatención Multicabezal"] D --> E["Suma y Normalización de Capa"] E --> F["Red Neuronal Prealimentada"] F --> G["Suma y Normalización de Capa"] G --> H["Salida a la Siguiente Capa"] C -.->|"Conexión Residual"| E E -.->|"Conexión Residual"| G

A partir de aquí, veamos paso a paso las operaciones matemáticas que se realizan en cada componente.

3. Vectorización de palabras y codificación posicional (Positional Encoding)

Las computadoras no pueden entender el texto tal cual. El texto de entrada primero se divide en unidades llamadas “Tokens”, y cada uno se convierte en un vector de longitud fija. Esto es el Input Embedding (Incrustación de Entrada).

3.1 Las matemáticas de Input Embedding

Supongamos que el tamaño del vocabulario es $V$ y la dimensionalidad de los vectores de incrustación es $d_{model}$ (en el artículo original $d_{model} = 512$). Cada palabra $w_i$ se convierte en un vector $x_i \in \mathbb{R}^{d_{model}}$ utilizando una matriz de incrustación $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Con esto, toda la oración se representa como una matriz $X \in \mathbb{R}^{N \times d_{model}}$ ($N$ es la longitud de la oración).

3.2 La necesidad y fórmulas de Positional Encoding (Codificación Posicional)

A diferencia de las RNN, Transformer no procesa las palabras en orden secuencial, sino que procesa todas las palabras de forma simultánea y paralela. Esto es una gran ventaja en términos de velocidad de cálculo, pero al mismo tiempo causa el problema de que se pierde la importante información del “orden de las palabras”. Por ejemplo, “El perro muerde al hombre” y “El hombre muerde al perro” tienen el mismo conjunto de palabras de entrada, pero significados completamente diferentes.

Para proporcionar esta información del orden de las palabras al modelo, se ideó el Positional Encoding. El Positional Encoding $PE$ para la dimensión $i$-ésima de una palabra en la posición $pos$ se calcula utilizando las siguientes funciones trigonométricas.

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Donde $pos$ es la posición de la palabra ($0, 1, 2, \dots, N-1$) e $i$ es el índice de la dimensión del vector ($0, 1, \dots, d_{model}/2 - 1$).

¿Por qué usar seno y coseno?

A simple vista parece una fórmula extremadamente compleja y extraña, pero hay una profunda razón matemática para esto. Al usar funciones trigonométricas, el modelo puede aprender fácilmente no solo la “posición absoluta”, sino también la diferencia de “posición relativa”.

Recuerda los teoremas de suma de funciones trigonométricas que se aprenden en la escuela secundaria.

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

El Positional Encoding de una posición $pos + k$, que está desplazada por un offset $k$ de una posición $pos$, se puede expresar como una combinación lineal del Positional Encoding de la posición $pos$. Es decir, utilizando una matriz $M_k$, se puede escribir de la siguiente manera:

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

De esta manera, el mecanismo de Attention puede reconocer fácilmente la distancia relativa entre las palabras (“qué tan lejos están”) a través del cálculo del producto punto. Además, al combinar múltiples ondas senoidales y cosenoidales con diferentes longitudes de onda, existe la ventaja de poder generar vectores de posición únicos sin importar cuán larga sea la oración.

La matriz de entrada final $X_{input}$ será la suma de los vectores de incrustación de las palabras y esta codificación posicional.

$$ X_{input} = X + PE $$

4. Las matemáticas profundas de Self-Attention (Mecanismo de Autoatención)

Por fin, nos adentramos en el componente más importante de Transformer: Self-Attention. El propósito de Self-Attention es “calcular el grado de relación entre todas las palabras dentro de una oración y actualizar el vector de cada palabra a una representación más rica que tenga en cuenta el contexto”.

Aquí se utiliza la analogía de un “sistema de búsqueda”.

Query (Q): Consulta (Término de búsqueda). “¿Qué información estoy buscando ahora?”
Key (K): Clave (Encabezado). “¿Qué información poseo?”
Value (V): Valor (Entidad). “¿Qué información proporciono realmente?”

4.1 Generación de las matrices $Q, K, V$

Para una matriz de entrada $X \in \mathbb{R}^{N \times d_{model}}$ (ignoraremos el tamaño del lote aquí para simplificar), multiplicamos por las matrices de pesos aprendibles $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$ para calcular la consulta $Q$, la clave $K$ y el valor $V$. (Normalmente $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Aquí, $Q, K, V$ son todas matrices de $\mathbb{R}^{N \times d_k}$.

4.2 Cálculo del Attention Score (Producto Punto)

Para medir qué tan relacionada está la Query de cada palabra con la Key de todas las demás palabras, calculamos el producto punto de los vectores. Expresado en operaciones de matrices, queda de la siguiente manera:

$$ \text{Scores} = Q K^T $$

Cada elemento $s_{ij}$ de la matriz resultante $\text{Scores} \in \mathbb{R}^{N \times N}$ obtenida por este cálculo representa el producto punto entre la Query de la palabra $i$ y la Key de la palabra $j$, es decir, la “fuerza de la relación”.

4.3 Escalamiento (Scale)

Hay un problema con el cálculo de la puntuación mediante el producto punto. Cuando la dimensionalidad $d_k$ de los vectores se vuelve grande, el valor del producto punto puede volverse extremadamente grande o pequeño.

Demostremos esto matemáticamente. Supongamos que cada elemento de la consulta $q \sim \mathcal{N}(0, 1)$ y cada elemento de la clave $k \sim \mathcal{N}(0, 1)$ siguen distribuciones normales estándar independientes. Encontremos la media y la varianza del producto punto $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Media: Dado que $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, la media de la suma también es $0$. Varianza: La varianza de $q_i k_i$ es, debido a la independencia, $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Por lo tanto, la varianza de todo el producto punto será igual a la dimensionalidad $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Si la varianza se vuelve grande, al aplicar la función Softmax más adelante, el gradiente para todo valor que no sea el máximo se volverá extremadamente pequeño (lo que se conoce como “desvanecimiento del gradiente”), lo que impedirá que el aprendizaje avance. Para evitar esto, dividimos (escalamos) las puntuaciones por $\sqrt{d_k}$ para mantener la varianza siempre en $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Probabilización mediante la función Softmax

Para convertir las puntuaciones obtenidas en una distribución de probabilidad (pesos) cuya suma sea $1$, aplicamos la función Softmax fila por fila.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

La matriz $A \in \mathbb{R}^{N \times N}$ se denomina matriz de Attention Weight (Pesos de Atención). Al observar cada fila $i$ de esta matriz, podemos ver expresado como un valor de 0 a 1 “a qué otras palabras $j$ y en qué medida se debe prestar atención (Attention) para comprender la palabra $i$”.

4.5 Suma ponderada de Value

Finalmente, utilizamos la matriz de Attention Weight $A$ obtenida para calcular la suma ponderada de la matriz Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

La matriz $Z \in \mathbb{R}^{N \times d_v}$ obtenida mediante esta operación es un conjunto de “representaciones vectoriales de palabras actualizadas teniendo en cuenta el contexto”. Esta es la totalidad del Scaled Dot-Product Attention definido en el artículo.

5. Multi-Head Attention (Atención Multicabezal)

Con un solo cálculo de Attention (cabezal único), existe la posibilidad de que solo se capture el contexto desde un único punto de vista (por ejemplo, la “relación gramatical”). Por lo tanto, para capturar simultáneamente diversas relaciones semánticas y sintácticas del lenguaje (como “sujeto y predicado”, “pronombre y su referente”, etc.), se introdujo el Multi-Head Attention.

Realizamos la generación anterior de $Q, K, V$ y el cálculo de Attention en paralelo $h$ veces (número de cabezales, $h=8$ en el artículo original).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Aquí, $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ son matrices de pesos aprendibles dedicadas para el cabezal $i$-ésimo.

Los resultados emitidos desde cada cabezal $\text{head}_i \in \mathbb{R}^{N \times d_v}$ se concatenan horizontalmente (Concatenate).

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Normalmente se configura para que $h \cdot d_v = d_{model}$, de modo que la dimensionalidad después de la concatenación vuelva a ser $d_{model}$ como en la entrada. Finalmente, multiplicamos esta matriz por una matriz de pesos $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ para obtener la salida final.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Entrada X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Cabezal 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Cabezal 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Cabezal h"] H1 & H2 & HN --> C["Concatenar"] C --> WO["Multiplicar por WO"] WO --> OUT["Salida Multicabezal"]

6. Feed-Forward Neural Network (FFN)

La salida de Multi-Head Attention se introduce a continuación en una Position-wise Feed-Forward Network (FFN). Esta es una red neuronal totalmente conectada de dos capas que se aplica “independientemente para cada posición (palabra)” en la secuencia.

Expresado matemáticamente, se ve de la siguiente manera:

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Aquí, $\max(0, z)$ representa la función de activación ReLU (Rectified Linear Unit) (en los modelos recientes se usan a menudo GELU o SwiGLU).

El papel de esta red es sumamente importante. Mientras que el mecanismo de Attention aprende “las relaciones entre palabras (relaciones espaciales/secuenciales)”, la FFN se encarga de “la transformación no lineal de características de cada vector de palabra en sí”. Normalmente, la dimensionalidad se expande significativamente en la primera capa mediante los pesos $W_1$ (por ejemplo, de $d_{model}=512$ a $d_{ff}=2048$, expandiéndose 4 veces), se realizan cálculos complejos en el espacio de características y, luego, en la segunda capa se vuelve a la dimensión original utilizando los pesos $W_2$. Esta “expansión y reducción de dimensiones” aumenta dramáticamente el poder de representación del modelo.

7. Conexiones Residuales (Residual Connection) y Normalización de Capas (Layer Normalization)

En el aprendizaje profundo, al hacer que las redes sean más profundas, los gradientes tienden a desvanecerse o explotar durante el entrenamiento, lo que provoca que el aprendizaje falle. Para prevenir esto, alrededor de cada subcapa (Attention y FFN) de Transformer, se han colocado una Conexión Residual (Residual Connection) y una Normalización de Capas (Layer Normalization).

Matemáticamente, la salida de la subcapa se procesa de la siguiente manera:

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Conexión Residual ($x + \text{Sublayer}(x)$)

La entrada $x$ se suma directamente a la salida de la subcapa. Esto permite que el gradiente viaje directamente a las capas más superficiales a través del atajo durante la retropropagación, estabilizando así el aprendizaje incluso si se añaden más capas.

7.2 Las matemáticas de Layer Normalization

La Layer Normalization es una técnica que calcula la media y la varianza a lo largo de la dimensión de las características y normaliza los datos. En una entrada con tamaño de lote $B$, longitud de secuencia $N$ y dimensionalidad $d_{model}$, la normalización se realiza para un único vector de palabra $x \in \mathbb{R}^{d_{model}}$.

Se calculan la media $\mu$ y la varianza $\sigma^2$:

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

Y se obtiene la salida normalizada $\hat{x}$:

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

(Donde $\epsilon$ es una constante minúscula para evitar la división por cero. $\gamma$ y $\beta$ son parámetros de escala y desplazamiento aprendibles).

La razón por la que se adoptó la normalización a lo largo de las capas (Layer Normalization) en lugar de la normalización a lo largo de los lotes (Batch Normalization) es que las estadísticas entre lotes tienden a volverse inestables al procesar datos de secuencia de longitudes variables, como las oraciones. Con Layer Normalization, Transformer puede realizar un aprendizaje estable de forma independiente del tamaño del lote.

8. Estructuras específicas del Decoder: Masked Attention y Cross-Attention

La estructura que hemos explicado hasta ahora es la del Encoder. En el bloque del Decoder que genera las oraciones, la estructura es un poco diferente.

8.1 Masked Multi-Head Attention

El papel del Decoder es “predecir la siguiente palabra a partir de las palabras pasadas”. Por lo tanto, si “mira las palabras futuras” durante el entrenamiento, sería hacer trampa. La operación matemática para prevenir esto es el Masking (Enmascaramiento).

A la matriz de puntuaciones $Q K^T$, le sumamos una matriz de máscara $M$ que establece un valor extremadamente pequeño cercano a $-\infty$ en la parte triangular superior (correspondiente a la información futura).

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

Al calcular la función Softmax, dado que $\exp(-\infty) = 0$, el Attention Weight para las palabras futuras se vuelve completamente $0$. Esto permite una generación autorregresiva manteniendo la causalidad (Causality).

8.2 Encoder-Decoder Cross-Attention

La segunda subcapa del Decoder es el Cross-Attention, que hace referencia a la salida del Encoder. Aquí, $Q$ se genera a partir de la capa anterior del Decoder, mientras que $K$ y $V$ se generan a partir de la salida de la capa final del Encoder.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

Con este cálculo, en tareas como la traducción, el modelo puede aprender “a qué parte de la oración original extranjera está fuertemente relacionada la palabra que se está traduciendo ahora”.

9. Complejidad computacional y las matemáticas de la optimización moderna

Aunque Transformer es un modelo maravilloso, también tiene “debilidades” debidas a su estructura matemática. Preste atención a la complejidad computacional del Self-Attention. En el cálculo de la matriz de puntuación $Q K^T$, multiplicamos una matriz de $(N \times d_k)$ por una matriz de $(d_k \times N)$, por lo que la complejidad es $O(N^2 \cdot d_{model})$.

Es decir, el costo computacional y el uso de memoria aumentan de manera cuadrática con respecto a la longitud de la secuencia $N$. Cuando las oraciones son cortas esto no es un problema, pero si intentas ingresar a un LLM un contexto extremadamente largo, como el de un libro entero, $N$ alcanza las decenas o cientos de miles, y el cálculo tradicional de Attention agotará inmediatamente la memoria de la GPU.

Para romper esta maldición de $O(N^2)$, en los últimos años se han propuesto varias optimizaciones desde perspectivas matemáticas y de hardware. El ejemplo más representativo es FlashAttention. FlashAttention es un algoritmo que divide el cálculo de Attention en mosaicos (Tiling) para minimizar la transferencia de datos (accesos a memoria) entre la jerarquía de memoria de la GPU (SRAM y HBM). A pesar de arrojar matemáticamente el mismo resultado exacto que el Attention estándar (Exact Attention), ha logrado una aceleración y reducción de memoria dramáticas gracias a la optimización a nivel de hardware, haciendo posible la realización de modelos de contexto largo como GPT-4.

Además, se están investigando activamente otras aproximaciones de la complejidad computacional como $O(N \log N)$ y $O(N)$, tales como Sparse Attention y Linear Attention.

10. Imagen de implementación (Pseudocódigo al estilo PyTorch)

Si trasladamos la estructura matemática explicada hasta aquí a un código de programación real (Python / PyTorch), veremos que se puede escribir de una forma asombrosamente simple. Aquí mostramos el pseudocódigo del núcleo de Self-Attention.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # formas de q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Cálculo de puntuación mediante producto punto: Q * K^T
 # Se calculan los productos de las matrices transponiendo las dos últimas dimensiones
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Escalamiento
 scores = scores / math.sqrt(d_k)

 # 3. Enmascaramiento (En el caso de Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Probabilización mediante Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Multiplicación por la matriz Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Podemos ver que el $Q K^T / \sqrt{d_k}$ expresado matemáticamente, se implementa de manera intuitiva como torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). Es un aspecto sumamente interesante del aprendizaje profundo que la teoría matemática pueda materializarse en unas pocas líneas de código con la ayuda de bibliotecas de optimización avanzadas.

Conclusión: La forma de la “Inteligencia” vista desde las fórmulas matemáticas

En este artículo, hemos desentrañado la estructura matemática profunda del modelo Transformer.

El Embedding que asigna palabras a un espacio vectorial multidimensional, el Positional Encoding que expresa la información de posición como la composición de ondas trigonométricas, y el mecanismo de Self-Attention, un cálculo de producto punto de matrices nacido de una analogía con la recuperación de información. Cada uno de estos componentes no es más que una acumulación de matemáticas fundamentales como el álgebra lineal, el cálculo diferencial e integral, y la probabilidad y estadística.

Sin embargo, cuando estas simples operaciones matriciales se apilan en numerosas capas y aprenden patrones de gigantescos conjuntos de datos a través de miles de millones o billones de parámetros, surge una “forma de inteligencia” que parece comprender nuestras “palabras”, realizar deducciones lógicas y, a veces, generar ideas creativas.

Como sugiere el provocador título “Attention Is All You Need”, la belleza de esta arquitectura, que descarta los complejos procesamientos recurrentes o convolucionales y se especializa en el puro cálculo de “Atención” (grado de relación), reside precisamente en su simplicidad matemática.

En el futuro, podrían surgir nuevas arquitecturas que superen a Transformer (como los State Space Models, por ejemplo, Mamba), pero el marco matemático de “comprensión del contexto mediante Attention” forjado por Transformer quedará grabado para siempre en la historia de la IA.

Si en el futuro tienes la oportunidad de usar LLMs como ChatGPT o Claude, imagina los billones de multiplicaciones de matrices de $Q K^T$ por segundo y las funciones Softmax calculando probabilidades en segundo plano. Esto aumentará tu resolución sobre la tecnología y hará que el mundo de la IA te parezca aún más fascinante.

Referencias

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Este artículo fue escrito como una guía para aquellos que aprenden los fundamentos matemáticos del procesamiento de lenguaje natural y la inteligencia artificial. ¡Si tienes alguna pregunta o discusión, por favor háznoslo saber en la sección de comentarios!

Explicación del mecanismo de la tecnología de cuantización (GGUF) de llama.cpp

Fri, 11 Sep 2026 00:00:00 +0900

1. Introducción: ¿Por qué los LLM necesitan cuantización?

El reciente avance de los modelos de lenguaje grande (LLM: Large Language Models) ha sido notable, pero detrás de escena han surgido problemas graves como el “agotamiento de recursos de cómputo” y el “cuello de botella del ancho de banda de memoria”. Por ejemplo, si se carga en memoria un modelo de 70B (70 mil millones) de parámetros como Llama 3 utilizando el estándar de coma flotante de 16 bits (FP16), solo los parámetros consumirán unos 140 GB de VRAM/RAM. Si a esto le sumamos el contexto durante la inferencia (caché KV), el modelo no podrá funcionar sin agrupar en un clúster múltiples GPU de gama alta para centros de datos (como NVIDIA A100 de 80 GB o H100 de 80 GB).

Como salvador para ejecutar LLMs en dispositivos edge (como MacBooks o PCs de gaming comunes) y para desarrolladores individuales, apareció llama.cpp y su tecnología principal, la cuantización (Quantization). En particular, el formato de archivo GGUF (GPT-Generated Unified Format) y el avanzado algoritmo de cuantización por bloques llamado k-quants son métodos innovadores que comprimen el tamaño del modelo a una fracción de su original, minimizando al máximo la degradación en la precisión (Perplejidad) del mismo.

En este artículo, explicaremos exhaustivamente desde los fundamentos matemáticos de la cuantización en llama.cpp, la diferencia con el formato GGML, la estructura detallada del formato GGUF, hasta los mecanismos internos de k-quants.

2. Fundamentos matemáticos de la cuantización (Quantization)

En el contexto de los LLM, la cuantización se refiere a la operación de mapear valores continuos (o números de coma flotante de alta precisión) a valores discretos representados con menos bits (INT8, INT4, INT3, etc.).

2.1. Fórmulas básicas de la cuantización lineal

El enfoque más simple es la cuantización lineal (cuantización Min-Max). Sea $W$ el tensor de pesos original de alta precisión y $W_q$ el tensor de enteros cuantizado.

$$ W_q = \text{round}\left( \frac{W}{S} \right) + Z $$

Donde:

$S$ es el Factor de escala (Scale Factor), que determina el tamaño del paso de cuantización (resolución).
$Z$ es el Punto cero (Zero-point), un valor de sesgo (bias) para desplazar a qué valor entero cuantizado corresponde el número real $0.0$.
$\text{round}(\cdot)$ es la función de redondeo al entero más cercano.

Mediante la descuantización (Dequantization), se restaura el peso real aproximado $\tilde{W}$ durante la inferencia.

$$ \tilde{W} = S \times (W_q - Z) $$

2.2. Cuantización simétrica vs Cuantización asimétrica

Dependiendo del tratamiento del punto cero $Z$, se divide principalmente en dos métodos:

Cuantización asimétrica (Asymmetric Quantization) Mapea utilizando el valor mínimo $W_{\min}$ y el valor máximo $W_{\max}$ de los datos.
$$ S = \frac{W_{\max} - W_{\min}}{2^b - 1}, \quad Z = \text{round}\left(-\frac{W_{\min}}{S}\right) $$
Donde $b$ es el número de bits de cuantización (ej: $2^4-1 = 15$ para 4 bits). Debido a que es necesario almacenar $Z$, la sobrecarga de cálculo y de memoria aumenta ligeramente.
Cuantización simétrica (Symmetric Quantization) Mapea los valores alrededor del cero utilizando el valor máximo absoluto de los datos ($Z=0$).
$$ S = \frac{\max(|W_{\max}|, |W_{\min}|)}{2^{b-1} - 1}, \quad Z = 0 $$
Las versiones iniciales de la cuantización de llama.cpp (por ejemplo, el formato heredado Q4_0) adoptaron la cuantización simétrica. La falta del término $Z$ tiene la gran ventaja de acelerar significativamente el cálculo del producto escalar con instrucciones SIMD.

3. Evolución de GGML a GGUF y estructura de archivos

Al hablar de llama.cpp, es imprescindible mencionar la biblioteca de operaciones con tensores escrita en C++, GGML, y el formato de archivo derivado de ella, GGUF.

3.1. Problemas de GGML

Las versiones iniciales de llama.cpp usaban el formato ggml (y variantes como ggjt). Sin embargo, estos presentaban los siguientes problemas:

Falta de extensibilidad: Los números mágicos y los hiperparámetros estaban codificados rígidamente (hardcoded) en un orden y longitud fijos. Cada vez que se agregaba una nueva arquitectura de modelo (ej: Llama, Falcon, Mixtral, etc.) o un nuevo tokenizador, se producían cambios destructivos (breaking changes).
Pérdida de retrocompatibilidad: El formato se actualizaba con tanta frecuencia que los archivos de modelos antiguos no se podían leer en las versiones recientes de llama.cpp de forma recurrente.

3.2. Nacimiento del formato GGUF

Introducido en agosto de 2023, GGUF es un formato altamente versátil diseñado para resolver estos problemas. Su característica más importante es la adopción de una estructura de metadatos basada en clave-valor (Key-Value).

El siguiente diagrama Mermaid abstrae la estructura de un archivo GGUF.

graph TD A["Archivo GGUF"] --> B["Cabecera (Magia, Versión)"] A --> C["Metadatos (Pares Clave-Valor)"] A --> D["Info del Tensor (Nombre, Forma, Desplazamiento)"] A --> E["Datos del Tensor (Carga útil binaria)"] C --> C1["general.architecture: llama"] C --> C2["llama.context_length: 4096"] C --> C3["tokenizer.ggml.tokens: [...]"] E --> E1["Pesos de la Capa 0"] E --> E2["Pesos de la Capa 1"] E --> E3["..."]

Principales ventajas de GGUF:

Flexibilidad: Todos los hiperparámetros del modelo, la configuración de RoPE (Rotary Positional Embedding), los datos del vocabulario del tokenizador, etc., se almacenan como pares Clave-Valor con nombre. Las claves desconocidas se ignoran, lo que facilita agregar nuevas funciones.
Independencia del Endianness: GGUF adopta Little Endian de forma predeterminada, pero incluye un indicador explícito, por lo que es portátil de manera segura incluso entre arquitecturas diferentes.
Optimización para mmap (mapeo de memoria): Los datos de los tensores están alineados (padded) en límites específicos de la memoria, permitiendo mapearlos directamente desde el disco al espacio de memoria mediante la llamada al sistema mmap() del SO. Esto reduce el tiempo de inicialización de carga del modelo prácticamente a cero.

4. Las profundidades de k-quants: Cuantización avanzada por bloques

El verdadero potencial del formato GGUF radica en el mecanismo llamado k-quants (K-quantization), que se encarga de la compresión de los pesos del modelo.

En general, los pesos de una red neuronal tienen una forma cercana a una distribución normal cuando se observan a nivel de capa completa, pero localmente existen valores atípicos (Outliers). Si se cuantizan los pesos de toda una capa con un único factor de escala $S$ uniforme, los valores atípicos arrastrarán la escala y la información de los pesos más pequeños se perderá por completo.

Para evitar esto, llama.cpp realiza una cuantización por bloques (Block-wise Quantization). Consiste en dividir el tensor de pesos en bloques pequeños (por ejemplo, 32 o 256 elementos) y asignar a cada bloque su propio factor de escala (y punto cero).

4.1. Límites de la cuantización heredada (Q4_0, Q4_1)

El inicial Q4_0 agrupaba 32 pesos FP16 en un solo bloque y compartía 1 factor de escala FP16.

Tamaño del bloque: 32
Memoria: 1 escala (16 bits) + 32 pesos de 4 bits (128 bits) = 144 bits
Bits efectivos por peso (bpw: bits per weight): $144 / 32 = 4.5$ bpw

Aunque esto es bastante bueno, los límites entre la precisión y la tasa de compresión se hicieron evidentes. Así es como surgieron los k-quants, que tienen una estructura jerárquica mucho más compleja y sofisticada.

4.2. Estructura jerárquica de superbloques y subbloques (Ejemplo de Q4_K_M)

k-quants tiene una estructura jerárquica compuesta por “Superbloques (Super-blocks)” grandes y pequeños “Subbloques (Sub-blocks)” contenidos en su interior. Mediante esto, también cuantiza los propios metadatos (como los valores de escala), reduciendo los bpw al mínimo mientras mantiene la precisión.

Veamos la estructura de la configuración más popular, Q4_K_M. En Q4_K_M, se utiliza un superbloque de 256 elementos.

graph TD A["Superbloque (256 pesos)"] --> B["Metadatos de escala (FP16/INT8)"] A --> C["Subbloque 0 (32 pesos, 4-bit)"] A --> D["Subbloque 1 (32 pesos, 4-bit)"] A --> E["..."] A --> F["Subbloque 7 (32 pesos, 4-bit)"] B --> B1["Super-escala (FP16)"] B --> B2["Sub-escalas (8 x 6-bit)"] B --> B3["Sub-mínimos (8 x 6-bit)"]

La estructura real en C++ (GGML) se define conceptualmente de la siguiente manera:

1
2
3
4
5
6
7
8


// Estructura conceptual de block_q4_K en llama.cpp
#define QK_K 256

struct block_q4_K {
 uint8_t d[2]; // Súper-escala de todo el superbloque (FP16 x 2, etc.)
 uint8_t scales[12]; // Datos empaquetados de escalas de 6-bit y mínimos de 6-bit (puntos cero) para 8 subbloques (32 elementos cada uno)
 uint8_t qs[QK_K/2]; // Datos de pesos cuantizados a 4-bit (256 elementos / 2 = 128 bytes)
};

Proceso matemático de descuantización (Dequantization):

El valor real aproximado $\tilde{W}_{i, j}$ del elemento $j$ ($0 \le j < 32$) dentro del subbloque $i$ ($0 \le i < 8$) se calcula de la siguiente manera:

$$ \tilde{W}_{i, j} = S_{\text{super}} \times s_i \times (w_{i, j} - m_i) $$

$S_{\text{super}}$: Escala de punto flotante de todo el superbloque
$s_i$: Escala cuantizada a 6-bit para el subbloque $i$
$m_i$: Valor mínimo cuantizado a 6-bit (punto cero) para el subbloque $i$
$w_{i, j}$: Peso cuantizado a 4-bit ($0 \dots 15$)

Gracias a esta estructura jerárquica, se mantiene la adaptabilidad a los valores atípicos, a la vez que se reduce drásticamente la cantidad de memoria ocupada por los propios factores de escala. En conjunto, Q4_K_M logra un aproximado de 4.8 bpw.

4.3. Diversas opciones de k-quants

llama.cpp ofrece múltiples variaciones según el objetivo. Los sufijos después de la “K” (S, M, L) indican el tamaño.

Formato	BPW (Bits por Peso)	Descripción y características
Q2_K	2.5～3.3	Compresión extrema. La precisión se degrada considerablemente, pero es útil en entornos con muy poca VRAM.
Q3_K_M	3.3	Estándar para la cuantización de 3 bits. Se degrada más que Q4, pero a menudo se mantiene dentro de márgenes aceptables.
Q4_K_M	4.8	El punto óptimo recomendado (sweet spot). Equilibra la reducción a la mitad del tamaño del modelo manteniendo una buena precisión.
Q5_K_M	5.5	Cuando se requiere mayor precisión. Una posición intermedia entre Q4 y FP16.
Q6_K	6.6	Mantiene una Perplejidad casi equivalente a FP16, pero el tamaño del archivo es mayor.
Q8_0	8.5	Equivalente a INT8. Principalmente usado para tensores intermedios durante la inferencia o utilizado solo en la última capa.

※ El BPW real se promedia sobre el modelo completo, ya que internamente se realiza una cuantización mixta (Mixed Quantization) dependiendo del tensor del modelo (por ejemplo, proyecciones Q/K/V de Attention frente a los pesos FFN). Se aplican optimizaciones internas, como cuantizar los tensores importantes en Q6 y el resto en Q4.

5. Optimización del rendimiento en la inferencia: Arquitecturas SIMD y CUDA

El solo hecho de cargar un modelo GGUF en memoria no hace que la inferencia sea rápida. La mayor parte de la inferencia de un LLM es una “multiplicación de matriz-vector (Matrix-Vector Multiplication, abreviado GEMV, o Matriz-Matriz, GEMM)”. La clave reside en cómo acelerar la operación de suma de productos (dot product) entre los pesos cuantizados y las activaciones (datos de entrada) retenidas en FP16 (o FP32).

5.1. Aprovechamiento de instrucciones SIMD en entornos de CPU

La sorprendente velocidad que presume llama.cpp en la inferencia por CPU se debe a su optimización SIMD (Single Instruction, Multiple Data) a nivel de ensamblador. Por ejemplo, en procesadores Intel/AMD, aprovecha al máximo los conjuntos de instrucciones AVX2 o AVX-512, y en Apple Silicon, las instrucciones ARM NEON.

Durante la inferencia, no se convierte (Dequantize) intencionalmente $W_q$ de vuelta a FP32 para luego realizar la multiplicación. El lado de las activaciones también se cuantiza dinámicamente por bloques (Dynamic Quantization, generalmente hacia INT8), y se calcula el producto en bloque mediante aritmética de enteros INT8 $\times$ INT4 utilizando instrucciones SIMD especiales para el producto escalar (ej. vdpaddd o _mm256_madd_epi16). Al devolver el acumulador final a FP32 y multiplicarlo por el factor de escala, se logra un rendimiento asombroso.

5.2. Descarga (Offload) en entornos de GPU (cuBLAS / CUDA)

Recientemente, llama.cpp no solo soporta CPUs, sino que cuenta con un poderoso soporte para GPUs de NVIDIA (CUBLAS / CUDA). Es posible descargar (offload) partes o todas las capas del archivo GGUF a la VRAM (mediante la opción --n-gpu-layers).

sequenceDiagram participant User as Usuario participant CPU_RAM as CPU & RAM (mmap) participant VRAM as GPU VRAM participant Compute as Tensor Cores User->>CPU_RAM: Cargar GGUF (mmap) CPU_RAM->>VRAM: Descargar (Offload) capas (ej. 30/32 capas) Note over CPU_RAM, VRAM: Los datos permanecen cuantizados en VRAM User->>Compute: Paso hacia adelante (Tokens de entrada) Compute->>VRAM: Obtener pesos cuantizados Compute->>Compute: Descuantizar a FP16 sobre la marcha en SRAM Compute->>Compute: Multiplicación de matrices (cuBLAS / Kernels personalizados) Compute->>User: Logits de salida

Cuando se realizan cálculos en la GPU, el ancho de banda de la memoria de video (Memory Bandwidth) se convierte en el mayor cuello de botella. Dado que los pesos están comprimidos con k-quants, la transferencia de datos desde la VRAM a las unidades de cálculo de la GPU (SM: Streaming Multiprocessor o Tensor Cores) se reduce a un tercio o a un cuarto. En el instante exacto en que los pesos llegan a la unidad de cómputo, se descuantizan (expanden) a FP16 sobre la marcha, y utilizando los Tensor Cores, se ejecutan las multiplicaciones de matrices a velocidad ultra alta. En otras palabras, la cuantización se realiza no para “reducir la cantidad de cálculos”, sino para “reducir la cantidad de transferencia de memoria”.

6. Ejemplos concretos del balance (trade-off) entre uso de memoria y rendimiento

Tomemos como ejemplo el modelo Llama 3 de 8B para ver los requisitos técnicos según el nivel de cuantización de GGUF. (Las cifras son una estimación orientativa).

Modelo/Cuantización	Tamaño del archivo	VRAM/RAM necesaria	Velocidad de inferencia (est.)	Degradación de Perplejidad
Llama-3-8B (FP16)	Aprox. 16 GB	18 GB o más	Referencia	Ninguna (Base)
Llama-3-8B (Q8_0)	Aprox. 8.5 GB	10 GB o más	Rápida	Casi nula
Llama-3-8B (Q6_K)	Aprox. 6.6 GB	8 GB o más	Muy rápida	Mínima
Llama-3-8B (Q4_K_M)	Aprox. 4.9 GB	6.5 GB o más	La más rápida / Óptima	Aceptable / Minúscula
Llama-3-8B (Q3_K_M)	Aprox. 3.9 GB	5.5 GB o más	La más rápida	Algo notable
Llama-3-8B (Q2_K)	Aprox. 3.0 GB	4.5 GB o más	Rápida	Degradación evidente

Punto de atención (El impacto de la caché KV): Durante la inferencia de un LLM, a medida que la longitud del contexto (número de tokens en el prompt) aumenta, el consumo de memoria se incrementa de manera explosiva no solo por los pesos del modelo, sino también por la Caché KV, que guarda el estado histórico de Attention. Por ejemplo, si el contexto tiene 8192 tokens, la caché KV por sí sola consumirá varios gigabytes. Por tanto, en la operación real, es necesario asegurar un margen (Headroom) de Tamaño del archivo del modelo + Aprox. 1.5GB ~ 3GB. La razón por la que se recomienda Q4_K_M es porque, incluso reservando este espacio para la caché KV, representa el equilibrio ideal para funcionar con seguridad en una GPU común de 8 GB de VRAM (como una RTX 3060 / 4060).

En las versiones recientes de llama.cpp, se ha añadido también la función de cuantizar la propia Caché KV a Q8_0 o Q4_0, de manera que se investiga incesantemente para poder extender aún más la longitud de los contextos.

7. Conclusión

En este artículo, hemos profundizado en la estructura interna del formato GGUF y la tecnología de cuantización k-quants, que conforman el núcleo de llama.cpp.

La flexibilidad de GGUF: Su estructura de metadatos tipo clave-valor ha construido un sólido ecosistema capaz de seguir el rápido ritmo evolutivo de los LLM (con la aparición de nuevas arquitecturas de modelos) sin sufrir cambios destructivos.
Compresión extrema mediante k-quants: A través de la gestión jerárquica de los factores de escala en superbloques y subbloques, se ha logrado una asombrosa compresión promedio de 4.8 bits por peso (en Q4_K_M), conservando al mismo tiempo la información de los valores atípicos.
Resolución del cuello de botella en el ancho de banda de memoria: Mediante el uso de sofisticadas implementaciones de kernels en SIMD y CUDA, y al realizar la descuantización al vuelo mientras se calcula, se reduce la cantidad de transferencia hacia/desde la VRAM, lo que mejora drásticamente la velocidad de inferencia.

Se podría decir, sin exagerar, que el poder tecnológico detrás de llama.cpp, que está impulsando la democratización de la IA, va mucho más allá de ser una simple herramienta y representa una de las cumbres de la ingeniería de software moderna. Al comprender los algoritmos de cuantización y los mecanismos del formato GGUF, podrá seleccionar el modelo ideal y ajustar el rendimiento (performance tuning) de forma más precisa para su propio entorno.

Enlaces de referencia

(Fin)