Desmitificando DeepSeek-V3: Desglosando Su Revolucionaria Arquitectura de IA

Introducción

DeepSeek-V3 representa un avance significativo en el campo de los grandes modelos de lenguaje (LLMs). Desarrollado por DeepSeek-AI, este modelo aprovecha la arquitectura Mixture-of-Experts (MoE) para ofrecer un rendimiento sin igual mientras mantiene la eficiencia tanto en el entrenamiento como en la inferencia. Con un total de 671 mil millones de parámetros y 37 mil millones activados por token, DeepSeek-V3 está diseñado para manejar tareas complejas con una precisión notable.

Esta publicación proporciona un recorrido detallado por la arquitectura de DeepSeek-V3, explicando sus componentes clave paso a paso. Cada sección desglosa los mecanismos subyacentes y presenta las formulaciones matemáticas que definen su funcionalidad. Las explicaciones se basan en el informe técnico oficial de DeepSeek-V3, que sirve como la fuente principal de información proporcionada por los autores del modelo. Puedes consultar el documento completo aquí: DeepSeek-V3 Technical Report. Al final, tendrás una comprensión clara de cómo DeepSeek-V3 logra eficiencia, escalabilidad y optimización de inferencia.

Arquitectura e Innovaciones

DeepSeek-V3 introduce múltiples innovaciones que mejoran la eficiencia, escalabilidad y precisión. Los avances arquitectónicos clave incluyen:

1. Multi-head Latent Attention – Reduce los costos de inferencia y mejora la eficiencia de atención.
2. DeepSeekMoE – Una arquitectura refinada de Mixture-of-Experts (MoE) que mejora la especialización de expertos y el balanceo de carga.
3. Auxiliary-Loss-Free Load Balancing – Una estrategia de selección de expertos novedosa que elimina la necesidad de pérdida auxiliar, asegurando una utilización estable y eficiente de los expertos.
4. Complementary Sequence-Wise Auxiliary Loss – Una función de pérdida ligera que previene desequilibrios locales dentro de una sola secuencia.
5. Node-Limited Routing – Optimiza la distribución de expertos a través de nodos computacionales para reducir la sobrecarga de comunicación.
6. No Token-Dropping Strategy – Asegura la retención estable de tokens durante el entrenamiento y la inferencia.
7. Multi-Token Prediction – Mejora las representaciones de tokens durante el entrenamiento y puede ser utilizada para decodificación especulativa en la inferencia.

Cada uno de estos componentes contribuye al rendimiento de vanguardia de DeepSeek-V3 mientras mantiene la eficiencia computacional.

Arquitectura del Modelo DeepSeek-V3. Fuente DeepSeek-V3 Technical Report

Multi-head Latent Attention

Multi-head Latent Attention (MLA) es una piedra angular de la arquitectura de DeepSeek-V3. Este mecanismo permite al modelo procesar información de manera más eficiente al centrarse en las partes más relevantes de los datos de entrada. MLA reduce la sobrecarga computacional mientras mantiene una alta precisión, lo que lo hace ideal para modelos de lenguaje a gran escala.

Explicación Paso a Paso

• (a) Proyección del Token de Entrada $h_t$ al Vector Latente $c_t^{kv}$

  • El token de entrada en el paso de tiempo $t$ se denota como $h_t \in \mathbb{R}^{d}$. Aquí, $h_t$ tiene la misma dimensión $d$ que el estado oculto del modelo.
  • Se proyecta en un vector latente $c_t^{kv}$ con una dimensión mucho más pequeña $d_c$ (donde $d_c \ll d_h \times n_h$): $$c_t^{kv} = W^{DQ} h_t$$
  • Aquí, $W^{DQ} \in \mathbb{R}^{d_c \times d}$ es una matriz de proyección aprendida que reduce la dimensionalidad de $h_t$.
  • El vector latente $c_t^{kv}$ almacena información comprimida utilizada para calcular las representaciones de clave y valor en el mecanismo de atención.

• (b) Cálculo del Vector Clave Aumentando desde el Vector Latente

  • El vector clave se calcula aumentando desde la dimensión del vector latente $d_c$ a la dimensión completa de atención $d_h \times n_h$: $$k_t^c = W^{U_k} c_t^{kv}$$
  • Aquí, $W^{U_k} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ es una matriz de proyección aprendida que expande $c_t^{kv}$ en la representación clave completa $k_t^c$.
  • Esto asegura que $k_t^c$ tenga la misma dimensionalidad que las claves en Multi-Head Attention (MHA).

• (c) Proyección y Codificación RoPE del Token de Entrada

  • El token de entrada $h_t$ se proyecta primero de la dimensión $d$ a $d_h^R$ utilizando una matriz de proyección aprendida: $$k_t^r = W^{QR} h_t$$
  • Aquí, $W^{QR} \in \mathbb{R}^{d_h^R \times d}$ es una matriz de proyección aprendida con tamaño $d_h^R \times d$.
  • El vector proyectado $k_t^r$ se codifica luego utilizando Rotary Positional Embeddings (RoPE) en la posición del token $t$: $$k_t^{rope} = \text{RoPE}(k_t^r)$$
  • La clave codificada por RoPE $k_t^{rope}$ se concatena a los vectores clave de cada cabeza, asegurando que la misma clave codificada posicionalmente se comparta entre todas las cabezas.
  • Después de la concatenación, obtenemos el vector clave por cabeza final $k_t^i$ para cada cabeza de atención $i$ con dimensionalidad: $$k_t^i \in \mathbb{R}^{\left(d_h + d_h^R\right)}$$

• (d) Cálculo del Vector de Valor Aumentando desde el Vector Latente

  • El vector de valor se calcula aumentando desde el vector latente $c_t^{kv}$ con dimensión $d_c$ a la dimensión completa de atención $d_h \times n_h$: $$v_t = W^{UV} c_t^{kv}$$
  • Aquí, $W^{UV} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ es una matriz de proyección aprendida.
  • Esto asegura que $v_t$ tenga la misma dimensionalidad que los valores en Multi-Head Attention (MHA).

• (e) Cálculo del Vector de Consulta con Compresión de Bajo Rango

  • La consulta de atención se calcula utilizando una compresión de bajo rango, primero proyectando hacia abajo $h_t$ en un espacio latente con dimensión $d_c'$ (donde $d_c' \ll d_h \times n_h$): $$c_t^q = W^{DQ} h_t$$
  • Aquí, $W^{DQ} \in \mathbb{R}^{d_c' \times d}$ es una matriz de proyección aprendida de proyección hacia abajo, y el vector latente $c_t^q$ tiene dimensión: $$c_t^q \in \mathbb{R}^{d_c'}$$
  • La consulta se aumenta de nuevo al espacio completo de atención utilizando una matriz de proyección aprendida: $$q_t^c = W^{UQ} c_t^q$$
  • Aquí, $W^{UQ} \in \mathbb{R}^{(d_h \times n_h) \times d_c'}$ es una matriz de proyección aprendida específica para consultas, separada de las utilizadas para claves y valores.
  • La codificación RoPE se aplica al vector de consulta proyectado en la posición del token $t$: $$q_t^{R} = \text{RoPE}(W^{QR} c_t^q)$$
  • Aquí, $W^{QR} \in \mathbb{R}^{(d_h^R \times n_h) \times d_c'}$ es una matriz de proyección aprendida con tamaño $(d_h^R \times n_h) \times d_c'$.
  • Finalmente, la consulta codificada por RoPE se concatena con el vector de consulta aumentado, formando el vector de consulta por cabeza final: $$q_{t,i} = [q_{t,i}^{c}; q_{t,i}^{R}]$$
  • La dimensionalidad resultante de cada vector de consulta por cabeza es: $$q_{t,i} \in \mathbb{R}^{\left(d_h + d_h^R\right)}$$

• (f) Cálculo de la Salida de Atención

  • La salida final de atención se calcula utilizando las consultas, claves y valores: $$o_{t,i} = \sum_{j=1}^{t} \operatorname{Softmax}\!\left( \frac{q_{t,i}^T k_{j,i}}{\sqrt{d_h + d_h^R}} \right) v_{j,i}^{c}$$
  • Aquí, para cada cabeza $i$:
    • La consulta $q_{t,i} \in \mathbb{R}^{d_h + d_h^R}$.
    • La clave $k_{j,i} \in \mathbb{R}^{d_h + d_h^R}$.
    • El valor $v_{j,i}^{c} \in \mathbb{R}^{d_h}$.
    • La salida $o_{t,i} \in \mathbb{R}^{d_h}$.
  • La similitud consulta-clave se escala por el factor $\sqrt{d_h + d_h^R}$ (la dimensión de $q_{t,i}$ y $k_{j,i}$) antes de aplicar el softmax.
  • Las salidas de todas las $n_h$ cabezas se concatenan en un solo vector columna: $$\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d_h \times n_h}$$ que tiene $d_h \times n_h$ entradas.
  • El estado oculto de salida final se calcula como: $$u_t = W^O \,\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d}$$
  • Aquí, $W^O \in \mathbb{R}^{d \times (d_h \cdot n_h)}$ es la matriz de proyección de salida aprendida.
  • La salida final $u_t$ es un vector de una columna con $d$ entradas, es decir, $u_t \in \mathbb{R}^{d}$.

DeepSeekMoE

DeepSeekMoE es una arquitectura especializada de Mixture of Experts (MoE) utilizada en DeepSeek-V3 para Redes de Alimentación (FFNs). En comparación con arquitecturas MoE tradicionales como GShard, DeepSeekMoE introduce una asignación de expertos más detallada, donde algunos expertos funcionan como compartidos.

Explicación Paso a Paso

• (a) Cálculo de FFN para Cada Token

  • Sea la entrada de FFN del token $t$-ésimo $u_t \in \mathbb{R}^{d}$, donde $d$ es la dimensión oculta.
  • La salida se calcula como: $$h'_t \in \mathbb{R}^{d} = u_t + \sum_{i=1}^{N_s} \text{FFN}_i^{(s)}(u_t) + \sum_{i=1}^{N_r} g_{i,t} \text{FFN}_i^{(r)}(u_t)$$
  • Aquí:
    • $N_s$ y $N_r$ denotan el número de expertos compartidos y enrutados, respectivamente.
    • $\text{FFN}_i^{(s)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ representa el $i$-ésimo experto compartido.
    • $\text{FFN}_i^{(r)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ representa el $i$-ésimo experto enrutado.
    • $g_{i,t}$ es el valor de enrutamiento para el $i$-ésimo experto.
    • Tanto $u_t$ como $h'_t$ tienen la misma dimensión oculta $d$.

• (b) Normalización del Valor de Enrutamiento

  • Los valores de enrutamiento $g_{i,t}$ se normalizan entre los expertos activados: $$g_{i,t} = \frac{g'_{i,t}}{\sum_{j=1}^{N_r} g'_{j,t}}$$
  • donde $g'_{i,t}$ es la puntuación de enrutamiento inicial.

• (c) Selección de los Mejores K Expertos

  • A cada token se le asigna los $K_r$ expertos con las puntuaciones de afinidad más altas: $$g'_{i,t} = \begin{cases} s_{i,t}, & s_{i,t} \in \text{Topk}(\{s_{j,t} \mid 1 \leq j \leq N_r\}, K_r) \\ 0, & \text{de lo contrario} \end{cases}$$
  • La puntuación de afinidad $s_{i,t}$ determina la probabilidad de enrutamiento.

• (d) Cálculo de Afinidad Token-a-Experto

  • La puntuación de afinidad token-a-experto se da por: $$s_{i,t} = \text{Sigmoid}(u_t^\top e_i)$$ La función sigmoide es una función matemática definida como $\sigma(x) = \frac{1}{1 + e^{-x}}$, que mapea cualquier número real a un rango entre 0 y 1, comúnmente utilizada para estimación de probabilidades y activación en redes neuronales.
  • El centroide se calcula como: $$e_i = \frac{1}{|B_i|} \sum_{t \in B_i} u_t$$
  • Aquí:
    • $e_i$ es el vector centroide del $i$-ésimo experto enrutado.
    • $B_i$ es el conjunto de tokens enrutados al experto $i$ en un lote dado.
    • $|B_i|$ es el número de tokens asignados al experto $i$.
    • El centroide $e_i$ se aprende durante el entrenamiento para especializar expertos para diferentes tipos de tokens.
    • Durante la inferencia, $e_i$ permanece fijo y se utiliza solo para decisiones de enrutamiento.

Auxiliary-Loss-Free Load Balancing

Para modelos Mixture of Experts (MoE), una carga de expertos desequilibrada puede llevar a colapsos de enrutamiento, reduciendo la eficiencia computacional en arquitecturas paralelas de expertos. Las soluciones convencionales utilizan pérdidas auxiliares para equilibrar la distribución de tokens, pero grandes pérdidas auxiliares pueden degradar el rendimiento del modelo. Para evitar estos compromisos, DeepSeek-V3 introduce una estrategia de balanceo de carga sin pérdida auxiliar que ajusta dinámicamente un término de sesgo $b_i$ para cada experto. Este sesgo se añade a las puntuaciones de afinidad $s_{i,t}$ para determinar la selección de expertos.

Explicación Paso a Paso

• (a) Selección de Expertos con Ajuste de Sesgo

  • Cada experto tiene un término de sesgo $b_i$, que se añade a la puntuación de afinidad original $s_{i,t}$ antes del enrutamiento: $$g'_{i,t} = \begin{cases} s_{i,t}, & s_{i,t} + b_i \in \text{Topk}(\{s_{j,t} + b_j \mid 1 \leq j \leq N_r\}, K_r) \\ 0, & \text{de lo contrario} \end{cases}$$
  • Aquí:
    • $s_{i,t}$ es la puntuación de afinidad token-a-experto original.
    • $b_i$ es un término de sesgo asignado al experto $i$.
      • $b_i$ se aprende durante el entrenamiento para equilibrar la utilización de expertos.
      • Durante la inferencia, $b_i$ permanece fijo y se utiliza solo para decisiones de enrutamiento.
    • La función Top-$K_r$ selecciona los $K_r$ expertos con las puntuaciones ajustadas más altas.

• (b) El Término de Sesgo se Utiliza Solo para Enrutamiento

  • El término de sesgo no afecta el cálculo de FFN.
  • Se utiliza solo para ajustar las probabilidades de selección de expertos.

• (c) Actualización Dinámica del Sesgo para Equilibrar la Carga

  • Al final de cada paso de entrenamiento, el término de sesgo $b_i$ se actualiza en función de la carga del experto:
    • Si el experto $i$ está sobrecargado, $b_i$ se disminuye por un factor de $\gamma$.
    • Si el experto $i$ está subcargado, $b_i$ se aumenta por un factor de $\gamma$.
  • Aquí:
    • $\gamma$ es un hiperparámetro de velocidad de actualización del sesgo que controla qué tan rápido se ajusta $b_i$.

Complementary Sequence-Wise Auxiliary Loss

Aunque DeepSeek-V3 se basa principalmente en una estrategia sin pérdida auxiliar para el balanceo de carga, introduce una pérdida de balance complementaria por secuencia para prevenir desequilibrios extremos dentro de una sola secuencia. Esto asegura que la utilización de expertos permanezca equilibrada entre los tokens en una secuencia.

La pérdida de balance por secuencia se define como:

donde $\alpha$ es un hiperparámetro de factor de balance, asignado un valor extremadamente pequeño en DeepSeek-V3.

Explicación Paso a Paso

• (a) Cálculo de la Fracción de Carga del Experto $f_i$

  • La fracción de tokens asignados al experto $i$ dentro de una secuencia se calcula como: $$f_i = \frac{N_r}{K_r T} \sum_{t=1}^{T} \mathbb{1} \left( s_{i,t} \in \text{Topk}(\{s_{j,t} \mid 1 \leq j \leq N_r\}, K_r) \right)$$
  • Aquí:
    • $N_r$ es el número de expertos enrutados.
    • $K_r$ es el número de expertos activados por token.
    • $T$ es la longitud de la secuencia, representando el número de tokens.
    • $\mathbb{1}(\cdot)$ es la función indicadora, que devuelve 1 si el experto $i$ está entre los expertos seleccionados en el top-$K_r$ para el token $t$.

• (b) Probabilidad Normalizada del Experto $s'_{i,t}$

  • El valor de enrutamiento token-a-experto normalizado se calcula como: $$s'_{i,t} = \frac{s_{i,t}}{\sum_{j=1}^{N_r} s_{j,t}}$$
  • Aquí:
    • $s_{i,t}$ es el valor de enrutamiento token-a-experto original.
    • El denominador asegura que los valores de enrutamiento sumen 1 entre todos los expertos enrutados.

• (c) Cálculo de la Utilización Media del Experto $P_i$

  • La probabilidad media de que el experto $i$ sea seleccionado a lo largo de la secuencia es: $$P_i = \frac{1}{T} \sum_{t=1}^{T} s'_{i,t}$$
  • Esto representa el valor de enrutamiento normalizado promedio para el experto $i$ sobre todos los tokens en la secuencia.

• (d) Cómo se Utiliza la Pérdida de Balance por Secuencia

  • $\mathcal{L}_{\text{Bal}}$ penaliza los desequilibrios en el uso de expertos dentro de una secuencia.
  • Se aplica solo durante el entrenamiento y no se utiliza en la inferencia.
  • Ajusta suavemente el enrutamiento para prevenir la sobrecarga a corto plazo de expertos.
  • El hiperparámetro $\alpha$ asegura una interferencia mínima con la pérdida principal.

Node-Limited Routing

DeepSeek-V3 emplea Enrutamiento Limitado por Nodo durante el entrenamiento para reducir los costos de comunicación en modelos MoE. Cada token se enrutará a como máximo $M$ nodos, seleccionados en función de la suma de las puntuaciones de afinidad más altas $\frac{K_r}{M}$ entre los expertos en cada nodo. Esta restricción asegura un balanceo de carga eficiente mientras mantiene una casi superposición completa de computación-comunicación, optimizando la eficiencia del entrenamiento.

No Token-Dropping Strategy

Debido a su efectivo balanceo de carga, DeepSeek-V3 no descarta ningún token durante el entrenamiento o la inferencia. El modelo mantiene una utilización estable de expertos, y las estrategias de implementación específicas para la inferencia aseguran un enrutamiento equilibrado de tokens.

Multi-Token Prediction

DeepSeek-V3 introduce Predicción de Múltiples Tokens (MTP), un objetivo de entrenamiento que extiende el alcance de predicción a múltiples tokens futuros por posición. Este enfoque mejora la eficiencia del entrenamiento mientras mejora las representaciones de tokens para mejorar la predicción de tokens futuros.

Implementación de Predicción de Múltiples Tokens (MTP) de DeepSeek-V3. Fuente DeepSeek-V3 Technical Report

Explicación Paso a Paso

• (a) Módulos MTP

  • MTP se implementa utilizando $D$ módulos secuenciales, cada uno prediciendo un token adicional.
  • Cada módulo MTP $(k)$-ésimo consiste en:
    • Una cabeza de salida compartida $\text{OutHead}(\cdot)$.
    • Un bloque Transformer $\text{TRM}_k(\cdot)$.
    • Una matriz de proyección $M_k \in \mathbb{R}^{d \times 2d}$.
  • En la profundidad de predicción $k$, la representación del token $t_i$ se calcula combinando la representación de la profundidad anterior $h_i^{k-1}$ del token $(i)$-ésimo con la incrustación del token $(i+k)$-ésimo: $$h_i^{k'} = M_k \left[ \text{RMSNorm}(h_i^{k-1}); \text{RMSNorm}(\text{Emb}(t_{i+k})) \right]$$
  • Aquí:
    • $M_k$ es una matriz de proyección aprendida.
    • $h_i^{k-1}$ es la representación oculta de la profundidad anterior.
    • $\text{Emb}(t_{i+k})$ es la incrustación del token futuro en la posición $(i+k)$.
    • RMSNorm se utiliza para la normalización, estabilizando las activaciones sin sustracción de la media.
  • La representación transformada se procesa a través de un bloque Transformer: $$h_{1:T-k}^k = \text{TRM}_k(h_{1:T-k}^{k'})$$ donde $T$ representa la longitud de la secuencia de entrada, y $i:j$ denota la operación de corte (inclusiva de ambos límites izquierdo y derecho).
  • Finalmente, tomando $h_i^{k}$ como entrada, la cabeza de salida compartida calcula la distribución de probabilidad para el token adicional $k$-ésimo: $$p^k_{i+k+1} = \text{OutHead}(h_i^{k})$$ donde $p^k_{i+k+1} \in \mathbb{R}^{V}$, siendo $V$ el tamaño del vocabulario. La cabeza de salida $\text{OutHead}(\cdot)$ mapea linealmente la representación a logits y posteriormente aplica la función Softmax$(\cdot)$ para calcular las probabilidades de predicción del token adicional $k$-ésimo.

• (b) Objetivo de Entrenamiento MTP

  • Para cada profundidad de predicción, se calcula una pérdida de entropía cruzada $\mathcal{L}^{k}_{\text{MTP}}$: $$\mathcal{L}^{k}_{\text{MTP}} = \text{CrossEntropy}(P^k_{2+k:T+1}, t_{2+k:T+1}) = - \frac{1}{T} \sum_{i=2+k}^{T+1} \log p^k_i[t_i],$$
  • donde $T$ denota la longitud de la secuencia de entrada, $t_i$ representa el token de verdad en la posición $i$-ésima, y $p^k_i[t_i]$ es la probabilidad predicha de $t_i$ dada por el módulo MTP $k$-ésimo.
  • Las pérdidas MTP se promedian a través de todas las profundidades y se escalan por un factor de ponderación $\lambda$ para obtener la pérdida MTP general $\mathcal{L}_{\text{MTP}}$, que sirve como un objetivo de entrenamiento adicional: $$\mathcal{L}_{\text{MTP}} = \frac{\lambda}{D} \sum_{k=1}^{D} \mathcal{L}^{k}_{\text{MTP}}.$$

• (c) MTP en Inferencia

  • MTP se utiliza durante el entrenamiento para mejorar las representaciones de tokens.
  • Durante la inferencia, los módulos MTP se desactivan, y solo se utiliza el modelo principal para la predicción de tokens.
  • MTP también puede ser reutilizado para especulación de tokens, mejorando la eficiencia de decodificación.

Conclusiones Clave

• Atención Eficiente con MLA: Reduce el uso de memoria al utilizar proyecciones en el espacio latente para reducir las dimensiones de clave y valor, con posibles ahorros computacionales al operar en representaciones más pequeñas.
• Enrutamiento Estable de Expertos con DeepSeekMoE: Implementa un balanceo de carga sin pérdida auxiliar, previniendo el colapso de enrutamiento y asegurando una especialización eficiente de expertos. Utiliza un mecanismo de selección ajustado por sesgo para mantener una distribución uniforme de token-a-experto, mejorando la estabilidad del modelo sin introducir sobrecarga computacional adicional.
• Sin Pérdida de Tokens: Mantiene una retención estable de tokens durante el entrenamiento y la inferencia, evitando la degradación en el procesamiento de secuencias.
• La Predicción de Múltiples Tokens Mejora el Entrenamiento: Mejora las representaciones de tokens y la eficiencia de aprendizaje al extender el objetivo de predicción más allá del siguiente token.

DeepSeek-V3 representa un gran avance tanto en la eficiencia del entrenamiento como en la escalabilidad de la inferencia, estableciendo un nuevo estándar para los modelos de lenguaje de próxima generación.

Fuente(s)

• DeepSeek-V3 Technical Report

¿Te gustó este post? ¿Lo encontraste interesante? No dudes en dejar un comentario a continuación para compartir tus pensamientos o hacer preguntas. Se requiere una cuenta de GitHub para unirse a la discusión.

Si encontraste valioso el análisis matemático de las arquitecturas LLM y te gustaría ver más publicaciones explorando sus mecanismos internos en profundidad, háznoslo saber.