Cómo leer las matemáticas de los artículos de AI en arXiv: una guía práctica

Viacheslav Dubrov

2026-11-03 · 60 min · Ingeniería de modelos

Traducción automática

Este artículo se tradujo automáticamente a partir de la versión original en inglés.

Saber leer las matemáticas de un artículo de AI es una habilidad útil para quien necesita entender un modelo, reproducir un método o valorar un resultado experimental. Esta guía explica cómo descifrar la notación, comprobar una ecuación con números pequeños y conectarla con el resto del artículo y con la implementación. Da por hecho que sabes leer código, pero no que la notación de investigación te resulte familiar.

Una ecuación condensa varias decisiones en una sola línea: los objetos que se manipulan, sus dimensiones, qué valores se muestrean y qué se aprende o se mantiene fijo. Recuperar esos detalles es un buen primer paso. Explicar por qué funciona un método e implementarlo con fidelidad exige más trabajo.

Empieza por el recorrido de la atención: conecta una ecuación con formas de arrays, números pequeños y Python ejecutable. La referencia de notación explica las expresiones que encontrarás en otros artículos. El resto de la serie aplica el mismo método a ecuaciones de artículos concretos: ecuaciones de arquitectura como RoPE, MLA y LoRA; objetivos de entrenamiento como DPO y GRPO; y modelos generativos y métricas como el ELBO, la difusión y pass@k. Esas partes aún no han salido, así que los recorridos a los que se refiere esta parte no están enlazados. Para un tratamiento más extenso de los fundamentos, The Little Book of Generative AI Foundations, de Tianhua Chen, desarrolla el álgebra lineal y la probabilidad que hay detrás de los modelos generativos.

Atención: leer un símbolo cada vez

La atención produce un vector de salida como media ponderada de vectores valor. Obtiene los pesos comparando un vector consulta de la posición de salida con un vector clave de cada posición de entrada disponible. Las matrices $Q$, $K$ y $V$ reúnen esos vectores de consulta, clave y valor. La atención de producto escalar escalado combina estos pasos en la ecuación (1) de §3.2.1 (§ significa «sección») de Attention Is All You Need:

Las definiciones están en el texto, no en la ecuación. El párrafo anterior a la ecuación (1) dice que las consultas y las claves tienen dimensión $d_k$ y que los valores tienen dimensión $d_v$. El método calcula el producto escalar de cada consulta con todas las claves, divide cada resultado entre $\sqrt{d_k}$ y aplica una softmax «para obtener los pesos de los valores». Las consultas se «agrupan en una matriz $Q$», y las claves y los valores en $K$ y $V$. Así, cada fila de estas matrices es el vector de un token, y la softmax produce un conjunto de pesos por consulta. Las matrices aprendidas que convierten los vectores de los tokens en $Q$, $K$ y $V$ aparecen más adelante, en §3.2.2.

Formas y funciones. Una cabeza de atención realiza uno de estos cálculos con sus propios vectores de consulta, clave y valor. Anota sus formas antes de leer los operadores. Para una cabeza con $n$ consultas y $m$ claves:

Los artículos indican una forma nombrando el conjunto al que pertenece la matriz: $Q\in\mathbb R^{n\times d_k}$ significa una matriz de números reales con $n$ filas y $d_k$ columnas, es decir, un array de forma [n, dk].

Lee de dentro hacia fuera.

1. $QK^\top$ multiplica una matriz $n\times d_k$ por una matriz $d_k\times m$. El $d_k$ compartido se suma y desaparece, así que el resultado es una tabla de puntuaciones de $n\times m$. La entrada $(i,j)$ es el producto escalar de la consulta $i$ y la clave $j$: se multiplican las entradas correspondientes y después se suman los productos. Para longitudes de vector fijas, esta puntuación es mayor cuanto más se parecen sus direcciones.

2. Dividir entre $\sqrt{d_k}$ evita que las puntuaciones crezcan con el ancho del vector. La nota al pie 4 del artículo muestra por qué crecen los productos escalares sin escalar. Supón que los componentes de una consulta y de una clave son independientes entre sí (saber algunos no dice nada sobre los demás), cada uno con media 0 y varianza 1 (la distancia media al cuadrado respecto de la media). Entonces:

   $$\begin{aligned} \text{one product }q_ik_i:&\quad\text{variance }1\\ q^\top k=\textstyle\sum_{i=1}^{d_k}q_ik_i:&\quad\text{variance }d_k,\ \text{standard deviation }\sqrt{d_k}\\ q^\top k/\sqrt{d_k}:&\quad\text{standard deviation }1 \end{aligned}$$

   Las líneas usan dos reglas sobre números independientes. Primera: el producto de dos números independientes, cada uno con media 0 y varianza 1, tiene también varianza 1. Segunda: cuando se suman números independientes, sus varianzas se suman, de modo que los $d_k$ productos dan varianza $d_k$. La desviación típica es la raíz cuadrada de la varianza, $\sqrt{d_k}$. Dividir cada puntuación entre $\sqrt{d_k}$ reduce la dispersión en el mismo factor, hasta volver a 1.

   Por qué se cumplen las dos reglas

   Varianza cuando la media es 0. La varianza es la distancia media al cuadrado respecto de la media. Cuando la media es 0, esa distancia al cuadrado es simplemente el cuadrado del número, así que la varianza es la media del cuadrado. Un componente $q_i$ con media 0 y varianza 1 tiene, por tanto, un $q_i^2$ cuya media es 1.

   La media de un producto. Para números independientes, la media de un producto es el producto de las medias. Toma un número $a$ que vale 1 o 3 con la misma probabilidad, de modo que su media es 2, y un número $b$ que vale 1 o 5, también con la misma probabilidad, de modo que su media es 3. Independiente significa que $b$ toma cada uno de sus valores con la misma frecuencia sea cual sea el resultado de $a$, así que los cuatro pares son igual de probables. Cuando $a=1$, los productos son 1 y 5, que tienen media $3=1\times3$. Cuando $a=3$, son 3 y 15, con media $9=3\times3$. En ambos casos la media es $a\times3$, así que sobre los dos valores de $a$ es $(3+9)/2=6$, que es $2\times3$. Sin independencia la regla falla: si $b$ valiera 5 siempre que $a$ vale 3, y 1 siempre que $a$ vale 1, solo aparecerían los productos 1 y 15, cuya media es 8. Wikipedia enuncia la regla para cualesquiera variables aleatorias independientes, con «valor esperado» para la media: independencia y esperanza.

   Regla 1: un producto tiene varianza 1. Toma un producto $q_ik_i$. Su media es el producto de las medias, $0\times0=0$, así que su varianza es la media de $(q_ik_i)^2=q_i^2k_i^2$. Los cuadrados son independientes porque lo son $q_i$ y $k_i$, y cada uno tiene media 1, así que la varianza es $1\times1=1$. La fórmula general es la varianza de un producto de variables independientes.

   Regla 2: las varianzas de términos independientes se suman. Llama a los productos $x_i=q_ik_i$, de modo que el producto escalar es la suma $x_1+\cdots+x_{d_k}$. Los términos son independientes porque cada uno usa componentes distintos, y cada uno tiene media 0 y varianza 1. La suma también tiene media 0, así que su varianza es la media de su cuadrado. Al multiplicar la suma por sí misma sale un producto $x_ix_j$ por cada pareja de términos, una cuadrícula de $d_k\times d_k$:

   

   Las celdas de la diagonal son los cuadrados $x_i^2$, y cada una tiene media 1. Cualquier otra celda multiplica dos términos distintos e independientes, así que su media es el producto de sus medias, $0\times0=0$: sus valores positivos y negativos se cancelan. Solo quedan las $d_k$ celdas de la diagonal, así que la varianza de la suma es $d_k$ y su desviación típica es $\sqrt{d_k}$. La dispersión crece con la raíz cuadrada del ancho porque la mayor parte de la cuadrícula se cancela. Wikipedia da el enunciado general como la varianza de una suma de variables incorrelacionadas; las variables independientes siempre son incorrelacionadas, así que la regla las cubre.

   Con $d_k=64$, las puntuaciones sin escalar se dispersan típicamente en torno a $\pm8$; escaladas, en torno a $\pm1$, sea cual sea el ancho.

   Las puntuaciones muy dispersas saturan la softmax (paso 3) y sus gradientes se anulan. Si una puntuación de una fila está muy por encima de las demás, la softmax da a esa clave un peso cercano a 1 y a todas las demás un peso cercano a 0. Un pequeño cambio en cualquier puntuación apenas mueve entonces los pesos, de modo que el gradiente que llega a las consultas y las claves es casi cero y el entrenamiento casi no tiene con qué ajustarlas. El artículo lo ofrece como explicación probable de un resultado anterior: sin el escalado, la atención de producto escalar rendía peor que la atención aditiva, una forma más antigua que puntúa una consulta y una clave con una red pequeña, cuando $d_k$ es grande (Britz et al., 2017). El artículo no mide los gradientes por sí mismo.

3. La softmax convierte cada fila de puntuaciones en pesos. Sea $z=(z_1,\ldots,z_m)$ una fila de las puntuaciones escaladas. La exponencial $e^a$, que también se escribe $\exp(a)$, usa la constante $e\approx2.718$. Entonces $\operatorname{softmax}(z)_j=e^{z_j}/\sum_{j'}e^{z_{j'}}$, donde $j'$ es solo un segundo nombre de índice, de modo que la suma recorre todas las claves de la fila. Los pesos son positivos y cada fila suma 1.

4. Multiplicar los pesos de $n\times m$ por los valores de $m\times d_v$ suma el eje de las claves y lo elimina. La fila $i$ de la salida $n\times d_v$ es una media ponderada de las filas de valores, ponderada por lo bien que cada clave coincidió con la consulta $i$.

Cuenta los cuadrados de la figura: cada producto elimina el eje que comparten sus dos cuadrículas.

Compruébalo con dos números. Toma una consulta y dos claves cuyas puntuaciones escaladas son $(0,\log3)$, elegidas para que las exponenciales sean 1 y 3, y valores $v_1=(2,0)$ y $v_2=(0,4)$. La figura lo resuelve con una operación por columna:

La atención mezcló ambos valores; no eligió el token que mejor coincidía.

Compárala con el código. La función de NumPy siguiente implementa una cabeza. k.T es la transpuesta. axis=1 es el eje de las claves, así que la fila de cada consulta se normaliza por separado. El máximo de la fila se resta antes de np.exp: sumar el mismo número a todas las puntuaciones de una fila se cancela en el cociente de la softmax, de modo que el resultado no cambia, pero las puntuaciones grandes dejan de desbordar. La máscara opcional pone las puntuaciones bloqueadas a $-\infty$, lo que hace que sus pesos sean exactamente cero. Un decodificador usa una máscara así para impedir que cada token atienda a los posteriores (§3.2.3 del artículo).

Guarda el bloque como attention_example.py y ejecuta uv run --with numpy python attention_example.py. Las comprobaciones pasan en silencio.

import numpy as np

def attention(q, k, v, allowed=None):
    """One head. q: [n, dk], k: [m, dk], v: [m, dv], allowed: bool [n, m]."""
    scores = q @ k.T / np.sqrt(q.shape[1])  # [n, m]
    if allowed is not None:
        if not allowed.any(axis=1).all():
            raise ValueError("every query needs at least one allowed key")
        scores = np.where(allowed, scores, -np.inf)
    scores = scores - scores.max(axis=1, keepdims=True)
    weights = np.exp(scores)
    weights = weights / weights.sum(axis=1, keepdims=True)  # rows sum to 1
    return weights @ v, weights  # [n, dv], [n, m]

# The two-key example from the text.
out, w = attention(
    np.array([[1.0]]),
    np.array([[0.0], [np.log(3.0)]]),
    np.array([[2.0, 0.0], [0.0, 4.0]]),
)
np.testing.assert_allclose(w, [[0.25, 0.75]])
np.testing.assert_allclose(out, [[0.5, 3.0]])

# A causal mask: query i may attend only to keys 0..i.
x = np.random.default_rng(0).normal(size=(3, 4))
out, w = attention(x, x, x, allowed=np.tril(np.ones((3, 3), dtype=bool)))
assert out.shape == (3, 4)
np.testing.assert_allclose(w.sum(axis=1), 1.0)
assert np.all(w[np.triu_indices(3, k=1)] == 0)

Una consulta cuyas claves están todas bloqueadas es un caso que la ecuación deja abierto: todos los pesos de su fila serían $0/0$. La función lanza un error en lugar de devolver NaN.

De una cabeza a varias. El Transformer base ejecuta ocho cabezas en paralelo, cada una con sus propias matrices aprendidas para producir $Q$, $K$ y $V$, y cada una con $d_k=d_v=64$. Concatena sus salidas y multiplica el resultado por otra matriz aprendida, $W^O$ (Attention Is All You Need, §3.2.2).

Una implementación también puede procesar un lote (batch): varias secuencias de entrada a la vez. Por ejemplo, la atención de producto escalar escalado de PyTorch acepta un tensor de consultas Q con forma [batch, heads, n, d_k]. Las dos primeras dimensiones seleccionan una secuencia y una cabeza; Q[b, h] es la matriz [n, d_k] de ese par. La fórmula de la atención se aplica por separado a cada par. La función de NumPy de aquí maneja solo uno de esos pares: sus operaciones .T y axis=1 suponen entradas bidimensionales.

Seis preguntas para cualquier ecuación

Qué tipo de afirmación hace una ecuación

La atención es un cálculo: dice cómo obtener una salida a partir de unas entradas. Los artículos también escriben ecuaciones que cumplen otras funciones:

Una restricción enuncia una propiedad que debe tener el resultado. Para los pesos de la atención, esa propiedad es: todo peso es no negativo y cada fila suma 1. La softmax es un cálculo que produce pesos con esa propiedad. El requisito por sí solo no te dice que uses softmax.

$=$ afirma que dos expresiones son iguales. $:=$ significa «se define como»: da nombre a una expresión. Una definición puede nombrar una métrica, una pérdida o un conjunto de valores permitidos, así que ver $:=$ no te dice qué tipo de ecuación de la tabla anterior estás leyendo.

Por ejemplo, Evaluating Large Language Models Trained on Code, el artículo que presentó el modelo de generación de código Codex, usa $:=$ para definir su estimador de pass@k (ecuación 1). Esta métrica mide la probabilidad de que al menos uno de $k$ programas generados supere las pruebas. En el informe técnico de DeepSeek-V4, la ecuación (2) combina dos afirmaciones: $\mathcal M:=\{\ldots\}$ define un conjunto de matrices permitidas, y $B_l\in\mathcal M$ exige que la matriz de mezcla $B_l$ del modelo pertenezca a ese conjunto. La definición usa $:=$; la restricción usa $\in$, que significa «pertenece a». Las secciones de pass@k y mHC trabajan esos ejemplos.

Cómo encontrar la ecuación nueva, sus definiciones y su código

La sección de métodos de un artículo describe cómo funciona su modelo o su algoritmo de entrenamiento. El encabezado puede ser «Method», «Architecture» o algo más específico. Los autores suelen explicar primero un método existente y después mostrar qué han cambiado. Para identificar la contribución que se reivindica, empieza por el resumen de novedades de la introducción. Por ejemplo, DeepSeekMath, §1.1 presenta Group Relative Policy Optimization (GRPO), su método para entrenar modelos a partir de respuestas puntuadas. Los números de sección y de ecuación de aquí se refieren al artículo enlazado.

Después compara el método propuesto con el método anterior que modifica. Dos artículos lo ilustran:

• Un cambio de arquitectura. DeepSeek-V2 describe la atención multicabezal estándar en §2.1.1 e introduce la atención latente multicabezal (MLA) en §2.1.2. La atención estándar guarda las claves y los valores de todos los tokens anteriores. MLA guarda un vector comprimido a partir del cual se pueden reconstruir. Comparar esas ecuaciones revela qué guarda el modelo de forma distinta; el recorrido de MLA deriva el ahorro de memoria.
• Un cambio de entrenamiento. DeepSeekMath, §4.1.1 imprime el objetivo de Proximal Policy Optimization (PPO) como ecuación (1) y el de GRPO como ecuación (3). Ambos usan una ventaja (advantage): un número que indica si una respuesta fue mejor o peor de lo esperado. PPO la estima con una segunda red aprendida, el modelo de valor, que predice la recompensa que falta por obtener a partir de una respuesta parcial. GRPO, en cambio, compara la recompensa de la respuesta con las recompensas de otras respuestas a la misma pregunta. El recorrido de GRPO compara estos términos con la notación de respuesta completa de DeepSeek-R1.

Busca las definiciones alrededor de la ecuación. Revisa el párrafo anterior, cualquier frase «donde …» posterior, las notas al pie y los apéndices. En Attention Is All You Need, el párrafo anterior a la ecuación (1) define las dimensiones y la nota al pie 4 explica el factor de escala. DeepSeek-V3 define la mayoría de sus símbolos de enrutamiento justo después de la ecuación (15), y el sesgo $b_i$ justo antes de la ecuación (16). DeepSeek-V2 desarrolla MLA a lo largo de las ecuaciones (9)–(19) y después reúne el cálculo en el Apéndice C.

Revisa el algoritmo y el código. Una caja de algoritmo es un listado numerado de pseudocódigo que da el orden de las operaciones. El Algoritmo 1 de DeepSeekMath muestra cuándo generar respuestas y cuándo actualizar el modelo. El Algoritmo 1 de Denoising Diffusion Probabilistic Models (DDPM) especifica cómo muestrear la imagen de entrenamiento, el nivel de ruido y el ruido. Las implementaciones resuelven más detalles: por defecto, np.std divide la suma de las desviaciones al cuadrado entre $n$, mientras que torch.std divide entre $n-1$. El ejemplo de GRPO muestra cómo esa elección cambia los valores de la ventaja calculados a partir de las mismas recompensas.

Las versiones de arXiv pueden cambiar secciones de lugar y repetir ecuaciones con números nuevos, así que cita la versión. En DeepSeek-R1 v1, el objetivo de GRPO está en §2.2.1, ecuaciones (1)–(3). En la v2, publicada en enero de 2026, está en §2.1, y las mismas ecuaciones reaparecen como (11)–(13) en el Suplemento A.3. Un enlace sin versión abre la más reciente, así que todos los enlaces a arXiv de esta serie incluyen la versión con la que se comprobaron.

Cómo comprobar tu lectura con un LLM

Un modelo de chat puede redactar la tabla de símbolos, el índice de cada suma y una comprobación con números pequeños, si le das las definiciones y le pides que señale lo que falta. El texto copiado de un PDF aplana subíndices, superíndices y fracciones en una sola línea; los enlaces «HTML (experimental)» y «TeX Source» de la página de resumen de arXiv dan texto limpio para pegar. Pega la ecuación y los párrafos que la rodean con un prompt como este:

Below is equation (N) from <paper title, arXiv ID and version>, followed by
the paragraphs that define its symbols.

1. Make a table with one row per symbol: shape or type, meaning, and whether
   it is input data, a trained weight, a frozen model, a fixed setting or a
   random sample. Quote the sentence that defines it.
2. List every symbol the pasted text does not define. Do not guess them.
3. For every sum, mean, softmax, min or expectation, name the index or the
   distribution it runs over.
4. Work through the equation with the smallest numbers that use every term.
5. Say which kind of statement it is: a computation, definition, objective,
   update rule, constraint, bound, estimator or empirical fit.

Sin el paso 2, nada impide que el modelo rellene una definición ausente con el significado habitual de la letra, como leer $\sigma$ en DPO como una desviación típica en lugar de como la sigmoide. Las citas del paso 1 hacen que la tabla sea comprobable: busca cada una en el PDF y trata una fila cuya cita no encuentres como una conjetura.

El mismo procedimiento como skills de agente. paper-math-skills empaqueta esta sección y la referencia de notación de más abajo como dos skills escritas para Claude Code; otros agentes que cargan archivos SKILL.md también pueden usarlas. read-paper-math obtiene la versión fijada de arXiv, cita la frase que define cada símbolo, lee la ecuación de dentro hacia fuera y ejecuta una comprobación con números pequeños. check-paper-math revisa una lectura así contra el artículo: busca cada cita, repite los números y señala las afirmaciones más fuertes o más débiles que las del artículo. paper-math-readings contiene las lecturas de las skills para las Partes 2–4, una para cada una de las 15 secciones con una línea Source:.

Referencia de notación

Si una letra griega no te resulta familiar, abre la referencia de letras griegas de este artículo (Apéndice A) para ver su nombre y sus significados habituales. Para practicar más con las matemáticas, Stanford CS229 ofrece repasos de probabilidad y de álgebra lineal con ejercicios; los preliminares de Dive into Deep Learning explican los fundamentos con código.

Subíndices, marcas y signos de relación

Las letras son nombres de variables locales: cada artículo define las suyas. Los subíndices suelen ser índices. $x_i$ puede ser la coordenada $i$ de un vector o el ejemplo $i$ de un dataset, y $h_t$ es el vector del modelo para el token $t$, llamado su estado oculto (hidden state).

Los superíndices en los artículos de modelos suelen ser etiquetas. En $h_t^{(\ell)}$, el superíndice entre paréntesis suele ser un número de capa, no una potencia; en $\operatorname{FFN}^{(s)}_i$ y $\operatorname{FFN}^{(r)}_i$ de DeepSeek-V3 marca los expertos compartidos y los enrutados, es decir, los que usan todos los tokens y los que elige un enrutador (véase el ejemplo de enrutamiento de MoE). En DeepSeek-V2, $W^{DKV}$ y $k_t^C$ llevan etiquetas, no exponentes; el ejemplo de MLA define esas etiquetas. $W^\top$ es una transpuesta y $x^2$ es un cuadrado.

$x_{1:T}$ significa las posiciones de 1 a $T$, incluida $T$, a diferencia de un slice de Python; los artículos suelen contar desde 1. $x_{<t}$ significa todas las posiciones anteriores a $t$. $X_{t,:}$ selecciona la fila $t$, como en el slicing de NumPy.

Las marcas sobre una letra suelen cambiar su significado de una de estas maneras:

Algunos símbolos que no son letras griegas también tienen varios usos:

Cinco signos indican cómo se relacionan dos lados. $:=$, a veces $\triangleq$, define un nombre nuevo. $\approx$ marca una aproximación, como el promedio muestreado de Esperanzas y de dónde salen las muestras. $\propto$ significa «proporcional a», con una constante de normalización omitida: $p_i\propto e^{z_i}$ se convierte en una distribución solo después de dividir entre $\sum_j e^{z_j}$. $\ll$ significa «mucho menor que», como en $d_c\ll d_hn_h$ de DeepSeek-V2: el ancho comprimido es mucho menor que el ancho total de todas las cabezas. $\leftarrow$ es una asignación, como en una regla de actualización.

Sumas, recuentos, intervalos y logaritmos

La $\sum$ grande suma términos y $\prod$ los multiplica. El índice bajo cada operador empieza aquí en 1 y llega hasta el límite superior $N$:

El índice pertenece al operador, igual que una variable de bucle pertenece a su bucle. En $y_i=\sum_{j=1}^{d}W_{ij}x_j$, la suma recorre $j$, mientras que $i$ identifica una entrada de la salida. El resultado es un vector con una entrada por cada $i$: el producto matriz-vector $Wx$ escrito explícitamente. Los índices del lado izquierdo te dicen la forma de la salida.

El factor que precede a una suma decide qué recibe el mismo peso. Un lote con una respuesta de 2 tokens y otra de 8 tokens, donde $\ell_{it}$ es la pérdida del token $t$ de la respuesta $i$ (en GRPO, $\ell$ es un término que se maximiza), puede promediarse de dos maneras:

En la primera, cada respuesta recibe peso $\tfrac12$, repartido entre sus tokens:

En la segunda, cada token tiene peso $1/10$. GRPO muestrea $G$ respuestas $o_1,\ldots,o_G$ a cada pregunta, y $\vert o_i\vert$ es el número de tokens de la respuesta $i$. Los dos promedios se leen entonces así, para el GRPO de DeepSeekMath y para DAPO, una variante posterior de GRPO:

Con $G=2$, estos son $L_{\text{answers}}$ y $L_{\text{tokens}}$ de arriba. DAPO pasó al promedio por token (§3.3) porque el promedio por respuesta daba demasiado poco peso a los tokens de las respuestas largas: el modelo aprendía muy poco de las respuestas largas buenas y no penalizaba lo bastante las respuestas largas, repetitivas y malas.

Una suma también puede contar. Los artículos lo hacen con un indicador: un uno en negrita seguido de una condición, $\mathbf 1[C]$, que vale 1 cuando la condición $C$ es verdadera y 0 cuando es falsa. Algunos artículos ponen la condición entre paréntesis o imprimen un uno de trazo doble; el significado es el mismo. Sumar indicadores cuenta, por tanto, cuántas veces se cumple la condición. La exactitud (accuracy) es el ejemplo habitual. Si $\hat y_i$ es la clase predicha e $y_i$ la clase correcta del ejemplo $i$, entonces $\sum_i\mathbf 1[\hat y_i=y_i]$ es el número de predicciones correctas. Las predicciones (gato, perro, perro) frente a las etiquetas correctas (gato, gato, perro) dan los indicadores 1, 0 y 1, así que el recuento es 2 y la exactitud 2/3. En una capa de mezcla de expertos (MoE), un enrutador envía cada token a unas pocas de muchas subredes feed-forward, llamadas expertos. En la pérdida de equilibrio de DeepSeek-V3 (ecuación 18), el indicador vale 1 cuando la puntuación de un experto para un token está entre las $K_r$ más altas para ese token, donde $K_r$ es a cuántos expertos se enruta cada token. Su suma sobre los tokens de una secuencia cuenta cuántas veces ocurrió. La puntuación de aquí omite el sesgo que añade el enrutamiento, de modo que el recuento puede diferir de los expertos que el enrutador elige realmente (enrutamiento de MoE).

El coeficiente binomial $\binom nk$, que se lee «$n$ sobre $k$», cuenta las formas de elegir $k$ elementos distintos de $n$ sin tener en cuenta el orden. Para enteros $0\leq k\leq n$, es igual a $n!/(k!\,(n-k)!)$. El signo de exclamación significa factorial: $n!=1\times2\times\cdots\times n$, con $0!=1$. Por ejemplo, $\binom52=5!/(2!\,3!)=10$: cinco elementos tienen diez parejas distintas. DeepSeekMoE usa coeficientes binomiales para contar combinaciones de expertos, y el estimador de pass@k los usa para contar conjuntos de muestras.

Los intervalos usan corchetes para los extremos incluidos: $[a,b]$ incluye ambos, $(a,b)$ ninguno. En Gated DeltaNet, $\alpha_t\in(0,1)$ significa estrictamente entre 0 y 1. En otros contextos, $(a,b)$ es una pareja.

El logaritmo natural invierte la exponenciación: $\log(e^a)=a$. Los logaritmos convierten productos en sumas y cocientes en diferencias: $\log(ab)=\log a+\log b$ y $\log(a/b)=\log a-\log b$, pero $\log(a+b)$ no se separa. Por eso los artículos trabajan con log-probabilidades. El logaritmo de un producto de probabilidades de tokens es una suma, y el logaritmo de un cociente de las probabilidades de dos modelos es una diferencia, la forma que usan los objetivos de DPO y GRPO. Los artículos de ML se refieren al logaritmo natural salvo que digan otra cosa; los resultados están en nats, y los logaritmos en base 2 dan bits. Para una probabilidad $p\leq1$, $-\log p\geq0$, y crece sin límite cuando $p$ se acerca a 0, de modo que una predicción errónea hecha con seguridad resulta cara.

Log-sum-exp significa: exponenciar cada puntuación $z_i$, sumar los resultados y después tomar el logaritmo. Calcular $\log\sum_i e^{z_i}$ directamente puede desbordar cuando una puntuación es grande. En su lugar, busca la puntuación mayor y llámala $m$. La notación $m=\max_i z_i$ significa «compara todas las entradas $z_i$ y toma la mayor»; en NumPy, m = z.max().

Resta $m$ de todas las puntuaciones antes de exponenciar y súmalo de nuevo después de tomar el logaritmo:

Para $z=(1000,1001)$, la puntuación mayor es $m=1001$. Las puntuaciones desplazadas son $(-1,0)$, así que el cálculo pasa a ser $1001+\log(e^{-1}+1)\approx1001.313$. Ninguna exponencial es mayor que 1. El código de la atención usa la misma resta antes de la softmax; allí el factor común se cancela en la división, así que no hay que volver a sumar nada.

Probabilidad condicional y probabilidad de un texto

$p_\theta(y\mid x)$ es la probabilidad que el modelo con parámetros $\theta$ asigna a la salida $y$ dada la entrada $x$. El subíndice nombra los parámetros; algunos artículos escriben $p(y\mid x;\theta)$, donde el punto y coma también marca parámetros y no una condición. Con un punto en lugar de la salida, $p_\theta(\cdot\mid x)$ es la distribución completa sobre las salidas y no un solo número. Los artículos de RL escriben el mismo objeto como $\pi_\theta(o\mid q)$, la probabilidad de que el modelo escriba la respuesta $o$ a la pregunta $q$, y llaman al modelo una política (policy).

Intercambiar el evento y la condición da un número distinto. Supón 100 respuestas del modelo: 60 son correctas, 50 son JSON válido y 40 son ambas cosas. Entonces

Sea $A$ «la respuesta es correcta» y $B$ «la respuesta es JSON válido». La probabilidad condicional restringe el recuento a las respuestas que cumplen la condición: $P(A\mid B)=P(A\cap B)/P(B)$, siempre que $P(B)>0$. El símbolo $\cap$ significa «ocurren ambos eventos». Aquí la fracción es $0.4/0.5=0.8$, lo mismo que 40 respuestas correctas entre 50 con JSON válido.

Dos eventos son independientes cuando saber que uno ha ocurrido no cambia la probabilidad del otro. Eso exige que $P(A\cap B)=P(A)P(B)$. En esta muestra, $P(\text{both})=0.4$, mientras que $P(\text{correct})P(\text{valid JSON})=0.6\times0.5=0.3$, así que las proporciones observadas no cumplen la independencia.

El teorema de Bayes, también llamado regla de Bayes, relaciona las dos direcciones del condicionamiento: $P(A\mid B)=P(B\mid A)P(A)/P(B)$. Permite calcular la probabilidad de $A$ dado $B$ a partir de la probabilidad de $B$ dado $A$ y de las probabilidades de los dos eventos. El ejemplo del ELBO lo usa para hallar la probabilidad de un código oculto dada una imagen observada.

Un modelo de lenguaje puntúa una secuencia token a token. Por la regla de la cadena de la probabilidad,

Cada factor se condiciona a todos los tokens anteriores, así que la fórmula no supone que los tokens sean independientes. Si tres tokens tienen probabilidades condicionales 0.5, 0.2 y 0.1:

La pérdida de entrenamiento habitual es el negativo de esta suma, dividido entre la longitud:

Durante el entrenamiento, los tokens anteriores $y_{<t}$ vienen del dataset. Durante la generación, son las elecciones previas del propio modelo.

Esperanzas y de dónde salen las muestras

Una esperanza es un promedio ponderado por probabilidades:

Lee $\mathbb E_{x\sim p}[f(x)]$ como «la media de $f(x)$ cuando $x$ se extrae de $p$». La notación $\sum_x$ suma sobre todos los valores discretos posibles de $x$. Sin subíndice, $\mathbb E[X]$ promedia una variable aleatoria $X$ sobre su propia distribución: si $X$ vale 1 con probabilidad 0.75 y 3 con probabilidad 0.25, entonces $\mathbb E[X]=1\times0.75+3\times0.25=1.5$.

Cuando una variable tiene una densidad $p(x)$, es decir, probabilidad por unidad de $x$, el promedio ponderado es una integral, $\int f(x)p(x)\,dx$. El $dx$ identifica $x$ como la variable que se integra; sin límites escritos aquí, la integral cubre todo su rango. El ejemplo de la densidad explica la probabilidad por unidad y muestra una integral como el área bajo una curva.

El código de entrenamiento no puede sumar sobre todas las entradas posibles, así que muestrea y promedia: $\mathbb E_{x\sim p}[f(x)]\approx\frac1N\sum_{i=1}^{N}f(x_i)$, con cada $x_i$ extraído de forma independiente de $p$, lo que los artículos escriben como $x_i\overset{\text{iid}}{\sim}p$. Los artículos lo llaman una estimación de Monte Carlo, y en el código es loss.mean() sobre un lote. La media del lote estima la esperanza solo si el lote se extrae de la distribución del subíndice de $\mathbb E$, así que el subíndice te dice cómo se producen los datos de entrenamiento:

• DPO promedia sobre ejemplos guardados $(x,y_w,y_l)\sim\mathcal D$: un prompt, una respuesta preferida y una respuesta rechazada. Las respuestas se recopilan y se etiquetan antes de esta fase de entrenamiento; pueden proceder de generaciones anteriores de un modelo. En cada paso de entrenamiento, el modelo calcula las probabilidades de esas respuestas ya dadas y actualiza sus pesos. No muestrea respuestas nuevas para ese paso.
• GRPO en DeepSeek-R1: generar respuestas y después comparar sus recompensas. El entrenamiento toma una pregunta del dataset, genera varias respuestas y las puntúa con una función de recompensa, como comprobar un resultado matemático o ejecutar pruebas unitarias. La actualización favorece las respuestas que puntuaron por encima de la media del grupo. La notación $q\sim P(Q)$ significa «muestrea una pregunta $q$ de la distribución de preguntas». La notación $\{o_i\}\sim\pi_{\theta_{old}}(O\mid q)$ significa «muestrea respuestas $o_i$ a esa pregunta de la copia del modelo llamada $\pi_{\theta_{old}}$». El subíndice old marca la copia que generó estas respuestas; esa copia permanece fija mientras el lote se usa para las actualizaciones. El recorrido de GRPO explica la comparación de recompensas y las actualizaciones.
• Destilación on-policy en MiniLLM y DeepSeek-V4: generar texto y después aprender de las probabilidades del maestro. El modelo que se entrena es el estudiante. Genera texto; un maestro congelado aporta las probabilidades del siguiente token para los mismos prefijos, y el entrenamiento ajusta las probabilidades del estudiante hacia las del maestro. Estas probabilidades dan la señal de entrenamiento, en lugar de la puntuación de recompensa de una respuesta que usa GRPO. MiniLLM escribe el texto muestreado del estudiante como $y\sim q_\theta$: $y$ es el texto y $q_\theta$ nombra al modelo estudiante. DeepSeek-V4 llama a su estudiante $\pi_\theta$ y usa varios maestros especialistas. El procedimiento de muestreo real de MiniLLM también mezcla tokens extraídos del maestro. El recorrido de la destilación explica los objetivos y esa distinción del muestreo.

El orden te dice qué optimiza el entrenamiento. Supón que un modelo asigna probabilidades 0.9 y 0.1 a las salidas correctas de dos ejemplos de entrenamiento con el mismo peso. Promediar sus log-probabilidades significa tomar primero cada logaritmo y después promediar: np.log(probs).mean(). Tomar el logaritmo de su promedio significa np.log(probs.mean()). Si $X$ es la probabilidad asignada a la salida correcta de un ejemplo elegido al azar:

Al cambiar el signo de estas puntuaciones se obtienen pérdidas de 1.20 y 0.69. Un segundo modelo que asigna 0.5 a cada salida correcta obtiene 0.69 con cualquiera de los dos cálculos. Así, promediar las probabilidades antes de tomar el logaritmo trata a los dos modelos como igual de buenos, mientras que la log-probabilidad negativa media habitual penaliza más al primer modelo por su baja probabilidad en la segunda salida correcta. Al traducir una pérdida a código, conserva el orden del logaritmo y del promedio.

La desigualdad de Jensen enuncia la relación general para $X$ positiva: $\mathbb E[\log X]\leq\log\mathbb E[X]$. También ayuda a construir objetivos de entrenamiento alternativos. Cuando la probabilidad de los datos de un modelo exige un promedio costoso sobre variables ocultas, un promedio de términos logarítmicos puede dar una cota inferior más fácil de estimar. El recorrido del ELBO explica ese problema de entrenamiento; ELBO significa evidence lower bound (cota inferior de la evidencia). La sección 2.4 de The Little Book of Generative AI Foundations, de Tianhua Chen, deriva la cota con la desigualdad de Jensen.

Densidades, varianza y barras de error

$p(x)$ tiene dos significados habituales. Para resultados discretos, como tokens o clases, da la probabilidad del resultado $x$: un número de 0 a 1, de modo que las probabilidades suman 1 sobre todos los resultados.

Para entender el otro significado, supón que $X$ se elige de forma uniforme entre 0 y 0.5. Los intervalos de igual longitud tienen probabilidades iguales. El intervalo de 0.1 a 0.2 ocupa una quinta parte de todo el rango, así que

Dentro de este rango, la probabilidad es la anchura del intervalo multiplicada por 2. Ese multiplicador es la densidad de probabilidad: $p(x)=2$ para $0\leq x\leq0.5$, y cero fuera. La densidad describe la probabilidad por unidad de la variable, no la probabilidad de un valor exacto.

Probabilidad cero para un punto no significa que no se muestree nada. Estrecha un intervalo en torno a 0.15: su probabilidad es el doble de su anchura, así que se acerca a cero cuando la anchura se acerca a cero. El punto exacto único tiene, por tanto, probabilidad cero. Aun así, una extracción produce algún valor en $[0,0.5]$, y ese intervalo completo tiene probabilidad 1. Si registras el resultado redondeado a dos decimales, un valor registrado de 0.15 representa el intervalo de 0.145 a 0.155, cuya probabilidad es $2\times0.01=0.02$.

Para una densidad no uniforme, el multiplicador varía con $x$. La integral suma las contribuciones a lo largo del intervalo:

Geométricamente, es el área bajo la curva de densidad entre $a$ y $b$; el área sobre todo el rango es 1. En el ejemplo uniforme, el área es simplemente la altura 2 por la anchura 0.5. Una densidad puede, por tanto, superar 1, y su logaritmo puede ser positivo, como lo es aquí $\log2\approx0.69$. Una probabilidad nunca supera 1.

La distribución gaussiana que se usa para el ruido en DDPM tiene una densidad de este tipo. No toda distribución continua tiene una densidad ordinaria: la distribución de Cantor es un contraejemplo matemático, ajeno a los modelos de los que hablamos aquí. Almacenar valores reales tampoco implica una distribución continua: una variable restringida a 0.0 y 1.0 sigue teniendo dos resultados discretos.

Los artículos suelen usar la misma letra para probabilidades y densidades. Comprueba cómo define el artículo la distribución de la variable y sobre qué variable se suma o se integra. Una integral sobre una variable oculta $z$, como el código latente del ELBO de la Parte 4, no te dice si una $x$ observada es discreta o continua. Algunos artículos escriben $P$ mayúscula para las probabilidades y $p$ minúscula para las densidades, pero muchos usan $p$ para ambas.

Para describir cuánto se dispersa una distribución alrededor de su media, los artículos usan la varianza: la diferencia media al cuadrado respecto de la media, $\operatorname{Var}(X)=\mathbb E[(X-\mu)^2]$, donde $\mu=\mathbb E[X]$. La desviación típica es su raíz cuadrada, así que tiene las mismas unidades que $X$.

Estas cantidades también aparecen en los nombres de las distribuciones. La distribución gaussiana, también llamada distribución normal, se escribe $\mathcal N(\mu,\sigma^2)$: $\mu$ es su media y $\sigma^2$ su varianza. Para un vector, $\mathcal N(\mu,\Sigma)$ usa una matriz de covarianza $\Sigma$: la entrada $(i,j)$ mide cómo varían juntas las coordenadas $i$ y $j$, y la diagonal contiene sus varianzas. $\mathcal N(0,I)$ describe un vector de números normales estándar independientes, cada uno con media 0 y varianza 1; $I$ es la matriz identidad.

Las tablas de benchmarks suelen dar una puntuación media junto con una medida de variación. La dispersión de las ejecuciones individuales no es lo mismo que la incertidumbre de su media: para $N$ ejecuciones independientes con desviación típica $\sigma$, el error típico de la media es $\sigma/\sqrt N$.

Antes de comparar dos entradas como $82.3\pm0.4$ y $81.5\pm0.4$, averigua en el pie de la tabla si 0.4 es una desviación típica entre ejecuciones, un error típico o la semianchura de un intervalo de confianza. Para comparar las medias, calcula un intervalo para su diferencia. Un procedimiento de intervalo de confianza del 95 % produce rangos que contienen la diferencia verdadera en el 95 % de los experimentos repetidos, bajo sus supuestos.

Para este ejemplo, supón cuatro ejecuciones independientes por modelo, puntuaciones de las ejecuciones aproximadamente normales y varianzas poblacionales iguales. Si las ejecuciones están emparejadas, como dos modelos evaluados en las mismas tareas muestreadas de forma independiente, analiza en su lugar las diferencias dentro de cada pareja. La guía de dos muestras del NIST explica estos casos.

Para medias independientes, la varianza de su diferencia es la suma de sus varianzas. Una variable normal estándar cae entre $-1.96$ y $1.96$ con probabilidad aproximada de 0.95, lo que aporta el multiplicador de una aproximación normal para un intervalo del 95 %. Si 0.4 es la desviación típica entre cuatro ejecuciones, ese primer cálculo da:

Ese multiplicador 1.96 trata la dispersión estimada como si fuera conocida. Con solo cuatro ejecuciones por modelo, usa la distribución t de Student para tener en cuenta la incertidumbre de la dispersión. Bajo los supuestos anteriores, sus grados de libertad son $4+4-2=6$ (ocho ejecuciones menos dos medias estimadas). scipy.stats.t.ppf(0.975, 6) da aproximadamente 2.447 en lugar de 1.96; 0.975 deja un 2.5 % fuera en cada extremo de un intervalo del 95 %. Si el supuesto de varianzas iguales no es adecuado, usa un intervalo de Welch, cuyos grados de libertad se calculan de otra manera.

Considera ahora la otra lectura del pie de tabla: 0.4 ya es el error típico de cada media, estimado a partir de esas cuatro ejecuciones. No se divide nada entre $\sqrt4$, y el error típico de la diferencia es de unos 0.566. El multiplicador t sigue siendo necesario. Las dos lecturas dan:

La figura compara la aproximación normal inicial con los dos intervalos t:

Cuando 0.4 es la desviación típica, el intervalo t excluye el cero: bajo estos supuestos, los resultados respaldan una diferencia positiva. Cuando 0.4 es el error típico estimado, el intervalo contiene el cero, así que los resultados no establecen qué modelo tiene la puntuación media más alta.

Entropía cruzada y divergencia KL

Durante el entrenamiento, un modelo necesita una pérdida numérica que mida lo bien que concuerdan sus probabilidades predichas con el objetivo de entrenamiento. El algoritmo de entrenamiento cambia los parámetros del modelo para reducir esa pérdida. La entropía cruzada aporta una pérdida así para ejemplos etiquetados o para las probabilidades de un modelo maestro. La divergencia de Kullback–Leibler (KL) mide la discrepancia entre dos distribuciones. Los artículos la usan para entrenar a un estudiante que imite a un maestro o para penalizar los cambios respecto de un modelo de referencia fijo.

Aquí los resultados son discretos, como tokens o clases. Escribe la distribución objetivo como $p$ y la distribución predicha por el modelo sobre los mismos resultados como $q$. Empieza con un resultado observado $i$: cuando el modelo le dio probabilidad $q_i$, su pérdida es $-\log q_i$. Vale 0 cuando $q_i=1$, unos 0.69 cuando $q_i=0.5$, unos 2.3 cuando $q_i=0.1$ e infinito cuando $q_i=0$.

La entropía cruzada promedia esa pérdida sobre los resultados extraídos del objetivo:

Con una etiqueta one-hot $p$, que vale 1 en la clase correcta $y$ y 0 en el resto, solo cuenta la clase correcta, y $H(p,q)=-\log q_y$: la pérdida de clasificación ordinaria. nn.CrossEntropyLoss de PyTorch la calcula a partir de las puntuaciones brutas del modelo, llamadas logits, y aplica internamente la log-softmax; su entrada no es el vector de probabilidades $q$. Con la distribución suave de un modelo maestro como $p$, cada clase cuenta en proporción a la probabilidad del maestro. La destilación clásica entrena así a un modelo pequeño con las probabilidades de uno grande. Para el objetivo $p=(0.9,0.1)$, dos modelos tienen estas entropías cruzadas $H(p,q)$:

El segundo modelo coincide con el objetivo, y ningún modelo puede hacerlo mejor. Ese mínimo, 0.325 aquí, es $H(p)=-\sum_ip_i\log p_i$, la entropía de $p$. Es 0 solo para un objetivo one-hot: cuando el propio objetivo es incierto, queda cierta pérdida que ningún modelo puede eliminar.

La divergencia KL resta ese mínimo y conserva solo la pérdida causada por que $q$ difiera de $p$. Se escribe con una barra doble $\Vert$, que solo separa los dos argumentos; no es la barra de probabilidad condicional $\mid$ de Probabilidad condicional y probabilidad de un texto ni las barras de longitud $\Vert x\Vert$ de la referencia de vectores. Los artículos la usan en lugar de una coma para marcar que el orden importa: el promedio recorre los resultados extraídos del primer argumento.

Para el primer modelo de arriba, $0.693-0.325\approx0.37$. La KL es 0 cuando las dos distribuciones coinciden y positiva en caso contrario.

El orden cambia qué discrepancias se penalizan. Un término con $p_i>0$ y $q_i=0$ es infinito, así que $D_{\mathrm{KL}}(p\Vert q)$ penaliza a $q$ por asignar probabilidad cero a algo que $p$ puede producir. Los resultados con $p_i=0$ no suman nada (por convenio $0\log0=0$), así que no aportan penalización directa aunque $q_i>0$. Invertir los argumentos da $D_{\mathrm{KL}}(q\Vert p)$, que es infinita siempre que $q_i>0$ y $p_i=0$. Los resultados con $q_i=0$ ahora no suman nada, aunque $p_i>0$. Con $p$ como objetivo, $D_{\mathrm{KL}}(p\Vert q)$ se llama KL directa (forward) y $D_{\mathrm{KL}}(q\Vert p)$ KL inversa (reverse).

Para $p=(0.5,0.5)$ y $q=(1,0)$, la KL directa es infinita, porque $q$ pasa por alto un resultado que $p$ produce, mientras que la KL inversa es solo $1\times\log(1/0.5)+0=\log2$: el resultado que $q$ omite no suma nada. Para $p=(0.9,0.1)$ y $q=(0.5,0.5)$, la KL directa es el 0.37 hallado arriba, calculado aquí término a término, y la KL inversa es distinta:

Esta asimetría es la razón por la que la KL se llama divergencia y no distancia.

Como $H(p,q)=H(p)+D_{\mathrm{KL}}(p\Vert q)$, y la entropía $H(p)$ de un maestro fijo no depende del estudiante, la entropía cruzada frente a un maestro fijo da al estudiante los mismos gradientes que $D_{\mathrm{KL}}(p\Vert q)$. Cambiar un parámetro del estudiante cambia ambas pérdidas en la misma cantidad, así que sus derivadas usadas en el entrenamiento son iguales; Gradientes y optimización explica ese cálculo. Esto permite que el código de clasificación y de destilación clásica use la entropía cruzada. El intercambio funciona solo con el maestro en primer lugar. Con el estudiante en primer lugar, $D_{\mathrm{KL}}(q\Vert p)=H(q,p)-H(q)$, y la propia entropía del estudiante $H(q)$ cambia a medida que entrena, así que ya no dan los mismos gradientes.

Vectores y matrices

Las ecuaciones de arquitectura describen cálculos sobre arrays de números. La forma (shape) de un array te dice cómo están dispuestos sus números, qué operaciones son válidas y qué producen. Un vector es una lista ordenada de números. Una matriz dispone números en filas y columnas. En el código de ML, tensor es el término general para estos arrays numéricos, incluidos los que tienen más de dos ejes. Un eje es una dimensión a lo largo de la cual se indexa el array: una matriz tiene un eje de filas y un eje de columnas.

El estado oculto (hidden state) de un token es un vector de números calculado dentro del modelo para representar ese token. Supón que procesamos a la vez un lote de $B$ secuencias, cada una con $T$ posiciones de token, y que cada estado oculto contiene $d$ números. El array de estados ocultos tiene forma [B, T, d], que los artículos también escriben como $B\times T\times d$. Sus tres ejes seleccionan la secuencia, la posición del token y el número dentro del vector de ese token. Por ejemplo, [2, 3, 4] contiene dos secuencias, tres vectores de token por secuencia y cuatro números por vector: 24 números en total. Aquí $d$ es el ancho del vector. La forma enumera los tres tamaños; multiplicarlos da el número de entradas.

Los artículos suelen escribir las formas como pertenencia a un conjunto: $a\in\mathbb R^d$ significa que $a$ es un vector de $d$ números reales, y $A\in\mathbb R^{m\times n}$ significa que $A$ es una matriz con $m$ filas y $n$ columnas. Las letras en negrita a veces marcan vectores o tensores, pero la definición del artículo determina la forma.

En la tabla siguiente, $a$ y $b$ son vectores columna: sus números están dispuestos en vertical. El superíndice $\top$ significa transpuesta: intercambiar filas y columnas. Así, $a^\top$ es una fila con los mismos números que la columna $a$. Las $A$ y $B$ mayúsculas de aquí nombran matrices; $B$ ya no significa el tamaño del lote.

Para una comparación concreta, toma $a=\begin{pmatrix}1\\2\end{pmatrix}$ y $b=\begin{pmatrix}3\\4\end{pmatrix}$. Mover la transpuesta cambia tanto el cálculo como el resultado:

El producto escalar da una sola puntuación, como en la comparación consulta–clave de la atención. El producto externo conserva un valor distinto para cada pareja de entradas; la actualización de Gated DeltaNet lo usa para construir una actualización matricial a partir de dos vectores.

Un producto de matrices puede reagruparse, $(AB)C=A(BC)$, pero no reordenarse; la derivación de MLA usa el reagrupamiento para evitar reconstruir las claves. NumPy escribe la multiplicación de matrices como @ y el producto elemento a elemento como *. Los artículos no heredan las reglas de broadcasting de NumPy: sumar un vector a una matriz exige un eje indicado. Los artículos tampoco coinciden en si un vector es una fila o una columna: la atención apila los tokens como las filas de $Q$, mientras que MLA, Gated DeltaNet y LoRA escriben $Wh$ con vectores columna, y nn.Linear de PyTorch calcula x @ W.T sobre filas.

Una ecuación de arquitectura también puede describir el tamaño de un vector, restringir qué matrices están permitidas o reordenar un producto:

Gradientes y optimización

El entrenamiento usa derivadas para decidir cómo cambiar los parámetros del modelo. Sea $\mathcal L$ una pérdida escalar y $\theta$ el vector de todos los parámetros; $\theta_i$ es una entrada de ese vector.

La derivada parcial $\partial\mathcal L/\partial\theta_i$ es un solo número, evaluado en los valores actuales de los parámetros. Mide la tasa de cambio de la pérdida cuando cambia solo $\theta_i$ y los demás parámetros se mantienen fijos. Léela como «la derivada parcial de la pérdida respecto del parámetro $\theta_i$».

El gradiente $\nabla_\theta\mathcal L$ reúne esos números de todos los parámetros en un único vector. Su entrada $i$-ésima es $\partial\mathcal L/\partial\theta_i$. El símbolo $\nabla$ se llama nabla; aquí significa «toma el gradiente». Con un solo parámetro, el gradiente tiene una entrada igual a la derivada ordinaria.

Por ejemplo, toma $\mathcal L(\theta_1,\theta_2)=\theta_1^2+3\theta_2^2$. En $\theta_1=2$ y $\theta_2=1$:

La primera derivada parcial, 4, significa que aumentar $\theta_1$ en 0.01 eleva la pérdida aproximadamente 0.04 mientras $\theta_2$ permanece fijo. El gradiente contiene esta información para ambos parámetros. El descenso de gradiente resta la derivada de cada parámetro, multiplicada por una tasa de aprendizaje (learning rate) positiva $\eta$ que controla el tamaño del paso:

Con $\eta=0.1$, el ejemplo pasa de $(2,1)$ a $(1.6,0.4)$, y la pérdida baja de 7 a 3.04. Para una pérdida derivable con gradiente no nulo, un paso suficientemente pequeño reduce la pérdida. Un gradiente cero no da ninguna actualización.

El subíndice de $\nabla$ indica qué varía. $\nabla_\theta\log p_\theta(x)$ varía los parámetros; $\nabla_x\log p_\theta(x)$ varía la entrada, y los artículos de difusión lo llaman la puntuación (score), que no tiene nada que ver con la puntuación de un benchmark.

Un jacobiano registra las derivadas de varias salidas. Una capa de una red neuronal puede producir muchos números, como los componentes del estado oculto de un token. Para describir cómo responde cada salida a cada entrada, se reúnen las derivadas parciales en una matriz llamada jacobiano. Para $y=f(x)$ con $n$ números de entrada y $m$ números de salida, su forma es $m\times n$: las filas corresponden a las salidas, las columnas a las entradas, y la entrada $J_{ij}=\partial y_i/\partial x_j$ mide cómo cambia la salida $i$ cuando cambia la entrada $j$.

Por ejemplo, sea una función que toma dos números y devuelve $y_1=x_1+2x_2$ e $y_2=3x_1-x_2$. Su jacobiano es

La segunda columna dice que aumentar $x_2$ en 0.1 manteniendo fijo $x_1$ aumenta $y_1$ en 0.2 y disminuye $y_2$ en 0.1. Este ejemplo es lineal, así que su jacobiano es constante. Para una función no lineal, las entradas pueden depender de la entrada actual y describen cambios pequeños de forma local. Con una sola salida escalar, el jacobiano tiene una fila: las mismas derivadas que el gradiente, transpuestas según nuestro convenio de vectores columna. Deep Learning, §4.3, da las definiciones generales.

La retropropagación (backpropagation) usa estas derivadas para calcular el gradiente de la pérdida a través de capas sucesivas. El ejemplo de cambio de variables del Apéndice B de este artículo usa otra propiedad: el valor absoluto del determinante de un jacobiano cuadrado da el factor local de escala del volumen, que hace falta para ajustar una densidad de probabilidad.

En el entrenamiento, las derivadas describen cambios locales; un objetivo de optimización establece qué deben minimizar o maximizar las actualizaciones. Los artículos distinguen el mejor valor de un objetivo de los parámetros que lo alcanzan: $\min_\theta f(\theta)$ es el menor valor de $f$, mientras que $\operatorname*{arg\,min}_\theta f(\theta)$ da los valores de los parámetros que lo alcanzan. Para $f(\theta)=(\theta-3)^2$, el mínimo es 0 y el argmin es 3. Un argmin especifica el resultado deseado, pero deja abierto el algoritmo de actualización.

Por ejemplo, MiniLLM escribe su objetivo como $\theta=\operatorname*{arg\,min}_\theta D_{\mathrm{KL}}(q_\theta\Vert p)$ (ecuación 1), donde $q_\theta$ es el modelo estudiante y $p$ el maestro del que aprende. La sección 2.2 deriva después un gradiente y lo modifica para que el entrenamiento sea más estable; la ecuación (7) es el gradiente que se usa para las actualizaciones. El ejemplo de destilación on-policy explica esos cambios. Leer solo el argmin los pasaría por alto.

Un stop-gradient, $\operatorname{sg}(x)$, pasa $x$ hacia delante sin cambios pero bloquea los gradientes a través de él, como .detach() en PyTorch. Dos expresiones con el mismo valor hacia delante pueden entrenar de forma distinta si una de ellas está separada del grafo. En el ejemplo de GRPO, Hugging Face TRL trata como fija la log-probabilidad del modelo antiguo. En el atajo de destilación que comenta DeepSeek-V4, un log-cociente maestro–estudiante separado del grafo aporta un peso fijo a la actualización.

Conjuntos y restricciones

Una restricción establece qué valores están permitidos. Los artículos suelen expresar las restricciones mediante conjuntos: colecciones de miembros distintos, escritas entre llaves, como $\{1,2,3\}$. El orden no importa, así que $\{3,1,2\}$ nombra el mismo conjunto. Las entradas repetidas cuentan solo una vez. En cambio, los paréntesis de un vector como $(1,2,3)$ describen una lista ordenada: $(3,1,2)$ es un vector distinto.

Una vez que un artículo define un conjunto, puede comprobar la pertenencia, combinar conjuntos, contar sus miembros o enunciar una condición sobre ellos. Toma $A=\{1,2,3\}$ y $B=\{3,4\}$:

La notación de formas de Vectores y matrices también nombra conjuntos: $\mathbb R^d$ es el conjunto de todos los vectores de $d$ números reales, y $\mathbb R^{n\times d}$ el conjunto de todas las matrices reales con $n$ filas y $d$ columnas. Así, $Q\in\mathbb R^{n\times d_k}$ especifica qué forma debe tener $Q$.

La notación de construcción de conjuntos describe un conjunto mediante una condición: $\{x\in S\mid\text{condition}\}$ se lee «los miembros de $S$ que cumplen la condición», como la comprensión de conjuntos de Python {x for x in S if condition(x)}. La barra significa «tal que», no probabilidad condicional; algunos artículos usan dos puntos en su lugar. Ejemplos de esta serie son las matrices permitidas de mHC, los expertos seleccionados de MoE y los tokens seleccionados de la atención dispersa.

DAPO, un método de entrenamiento que filtra grupos de respuestas generadas, conserva una pregunta solo cuando algunas respuestas son correctas y otras erróneas. Para $G$ respuestas muestreadas $o_1,\ldots,o_G$ y la respuesta de referencia $a$, escribe el conjunto de los índices de las respuestas correctas como