Démystifier DeepSeek-V3 : Décomposer son architecture IA révolutionnaire

Introduction

DeepSeek-V3 représente un bond en avant significatif dans le domaine des grands modèles de langage (LLMs). Développé par DeepSeek-AI, ce modèle exploite l'architecture Mixture-of-Experts (MoE) pour offrir des performances sans précédent tout en maintenant l'efficacité tant dans l'entraînement que dans l'inférence. Avec un total de 671 milliards de paramètres et 37 milliards activés par token, DeepSeek-V3 est conçu pour gérer des tâches complexes avec une précision remarquable.

Cet article fournit une explication détaillée de l'architecture de DeepSeek-V3, expliquant ses composants clés étape par étape. Chaque section décompose les mécanismes sous-jacents et présente les formulations mathématiques qui définissent leur fonctionnalité. Les explications sont basées sur le rapport technique officiel de DeepSeek-V3, qui sert de source principale d'information fournie par les auteurs du modèle. Vous pouvez consulter l'article complet ici : DeepSeek-V3 Technical Report. À la fin, vous aurez une compréhension claire de la manière dont DeepSeek-V3 atteint l'efficacité, la scalabilité et l'optimisation de l'inférence.

Architecture et Innovations

DeepSeek-V3 introduit plusieurs innovations qui améliorent l'efficacité, la scalabilité et la précision. Les avancées architecturales clés incluent :

1. Multi-head Latent Attention – Réduit les coûts d'inférence et améliore l'efficacité de l'attention.
2. DeepSeekMoE – Une architecture Mixture-of-Experts (MoE) affinée qui améliore la spécialisation des experts et l'équilibrage de charge.
3. Load Balancing sans perte auxiliaire – Une nouvelle stratégie de sélection d'experts qui élimine le besoin de perte auxiliaire, garantissant une utilisation stable et efficace des experts.
4. Perte auxiliaire complémentaire par séquence – Une fonction de perte légère qui empêche les déséquilibres locaux au sein d'une seule séquence.
5. Routage limité par nœud – Optimise la distribution des experts à travers les nœuds de calcul pour réduire les frais de communication.
6. Stratégie sans perte de token – Garantit la rétention stable des tokens pendant l'entraînement et l'inférence.
7. Prédiction multi-token – Améliore les représentations des tokens pendant l'entraînement et peut être utilisée pour le décodage spéculatif lors de l'inférence.

Chacun de ces composants contribue à la performance de pointe de DeepSeek-V3 tout en maintenant l'efficacité computationnelle.

Architecture du modèle DeepSeek-V3. Source DeepSeek-V3 Technical Report

Multi-head Latent Attention

Multi-head Latent Attention (MLA) est une pierre angulaire de l'architecture de DeepSeek-V3. Ce mécanisme permet au modèle de traiter l'information plus efficacement en se concentrant sur les parties les plus pertinentes des données d'entrée. MLA réduit la surcharge computationnelle tout en maintenant une haute précision, ce qui le rend idéal pour les modèles de langage à grande échelle.

Explication étape par étape

• (a) Projection du token d'entrée $h_t$ vers le vecteur latent $c_t^{kv}$

  • Le token d'entrée au moment $t$ est noté $h_t \in \mathbb{R}^{d}$. Ici, $h_t$ a la même dimension $d$ que l'état caché du modèle.
  • Il est projeté dans un vecteur latent $c_t^{kv}$ avec une dimension beaucoup plus petite $d_c$ (où $d_c \ll d_h \times n_h$) : $$c_t^{kv} = W^{DQ} h_t$$
  • Ici, $W^{DQ} \in \mathbb{R}^{d_c \times d}$ est une matrice de projection apprise qui réduit la dimensionnalité de $h_t$.
  • Le vecteur latent $c_t^{kv}$ stocke des informations compressées utilisées pour calculer les représentations de clé et de valeur dans le mécanisme d'attention.

• (b) Calcul du vecteur clé par agrandissement à partir du vecteur latent

  • Le vecteur clé est calculé par agrandissement de la dimension du vecteur latent $d_c$ à la dimension d'attention complète $d_h \times n_h$ : $$k_t^c = W^{U_k} c_t^{kv}$$
  • Ici, $W^{U_k} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ est une matrice de projection apprise qui étend $c_t^{kv}$ dans la représentation clé complète $k_t^c$.
  • Cela garantit que $k_t^c$ a la même dimensionnalité que les clés dans Multi-Head Attention (MHA).

• (c) Projection et encodage RoPE du token d'entrée

  • Le token d'entrée $h_t$ est d'abord projeté de la dimension $d$ à $d_h^R$ en utilisant une matrice de projection apprise : $$k_t^r = W^{QR} h_t$$
  • Ici, $W^{QR} \in \mathbb{R}^{d_h^R \times d}$ est une matrice de projection apprise de taille $d_h^R \times d$.
  • Le vecteur projeté $k_t^r$ est ensuite encodé en utilisant des Encodages Positifs Rotatifs (RoPE) à la position du token $t$ : $$k_t^{rope} = \text{RoPE}(k_t^r)$$
  • La clé encodée RoPE $k_t^{rope}$ est concaténée aux vecteurs clés de chaque tête, garantissant que la même clé encodée positionnellement est partagée entre toutes les têtes.
  • Après concaténation, nous obtenons le vecteur clé par tête final $k_t^i$ pour chaque tête d'attention $i$ avec une dimensionnalité : $$k_t^i \in \mathbb{R}^{\left(d_h + d_h^R\right)}$$

• (d) Calcul du vecteur valeur par agrandissement à partir du vecteur latent

  • Le vecteur valeur est calculé par agrandissement à partir du vecteur latent $c_t^{kv}$ avec dimension $d_c$ à la dimension d'attention complète $d_h \times n_h$ : $$v_t = W^{UV} c_t^{kv}$$
  • Ici, $W^{UV} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ est une matrice de projection apprise.
  • Cela garantit que $v_t$ a la même dimensionnalité que les valeurs dans Multi-Head Attention (MHA).

• (e) Calcul du vecteur de requête avec compression à faible rang

  • La requête d'attention est calculée en utilisant une compression à faible rang, d'abord en projetant $h_t$ dans un espace latent avec dimension $d_c'$ (où $d_c' \ll d_h \times n_h$) : $$c_t^q = W^{DQ} h_t$$
  • Ici, $W^{DQ} \in \mathbb{R}^{d_c' \times d}$ est une matrice de projection apprise de réduction, et le vecteur latent $c_t^q$ a la dimension : $$c_t^q \in \mathbb{R}^{d_c'}$$
  • La requête est ensuite agrandie de nouveau à l'espace d'attention complet en utilisant une matrice de projection apprise : $$q_t^c = W^{UQ} c_t^q$$
  • Ici, $W^{UQ} \in \mathbb{R}^{(d_h \times n_h) \times d_c'}$ est une matrice de projection apprise spécifique aux requêtes, distincte de celles utilisées pour les clés et les valeurs.
  • L'encodage RoPE est appliqué au vecteur de requête projeté à la position du token $t$ : $$q_t^{R} = \text{RoPE}(W^{QR} c_t^q)$$
  • Ici, $W^{QR} \in \mathbb{R}^{(d_h^R \times n_h) \times d_c'}$ est une matrice de projection apprise de taille $(d_h^R \times n_h) \times d_c'$.
  • Enfin, la requête encodée RoPE est concaténée avec le vecteur de requête agrandi, formant le vecteur de requête par tête final : $$q_{t,i} = [q_{t,i}^{c}; q_{t,i}^{R}]$$
  • La dimension résultante de chaque vecteur de requête par tête est : $$q_{t,i} \in \mathbb{R}^{\left(d_h + d_h^R\right)}$$

• (f) Calcul de la sortie d'attention

  • La sortie d'attention finale est calculée en utilisant les requêtes, les clés et les valeurs : $$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}$$
  • Ici, pour chaque tête $i$ :
    • La requête $q_{t,i} \in \mathbb{R}^{d_h + d_h^R}$.
    • La clé $k_{j,i} \in \mathbb{R}^{d_h + d_h^R}$.
    • La valeur $v_{j,i}^{c} \in \mathbb{R}^{d_h}$.
    • La sortie $o_{t,i} \in \mathbb{R}^{d_h}$.
  • La similarité requête-clé est mise à l'échelle par le facteur $\sqrt{d_h + d_h^R}$ (la dimension de $q_{t,i}$ et $k_{j,i}$) avant d'appliquer le softmax.
  • Les sorties de toutes les têtes $n_h$ sont concaténées en un seul vecteur colonne : $$\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d_h \times n_h}$$ qui a $d_h \times n_h$ entrées.
  • L'état caché de sortie final est calculé comme : $$u_t = W^O \,\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d}$$
  • Ici, $W^O \in \mathbb{R}^{d \times (d_h \cdot n_h)}$ est la matrice de projection de sortie apprise.
  • La sortie finale $u_t$ est un vecteur à une colonne avec $d$ entrées, c'est-à-dire, $u_t \in \mathbb{R}^{d}$.

DeepSeekMoE

DeepSeekMoE est une architecture Mixture of Experts (MoE) spécialisée utilisée dans DeepSeek-V3 pour les réseaux de neurones à propagation avant (FFNs). Comparé aux architectures MoE traditionnelles comme GShard, DeepSeekMoE introduit une allocation d'experts plus fine, où certains experts fonctionnent comme des experts partagés.

Explication étape par étape

• (a) Calcul FFN pour chaque token

  • Soit l'entrée FFN du $t$-ième token $u_t \in \mathbb{R}^{d}$, où $d$ est la dimension cachée.
  • La sortie est calculée comme : $$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)$$
  • Ici :
    • $N_s$ et $N_r$ désignent le nombre d'experts partagés et routés, respectivement.
    • $\text{FFN}_i^{(s)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ représente le $i$-ème expert partagé.
    • $\text{FFN}_i^{(r)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ représente le $i$-ème expert routé.
    • $g_{i,t}$ est la valeur de gating pour le $i$-ème expert.
    • Les deux $u_t$ et $h'_t$ ont la même dimension cachée $d$.

• (b) Normalisation de la valeur de gating

  • Les valeurs de gating $g_{i,t}$ sont normalisées à travers les experts activés : $$g_{i,t} = \frac{g'_{i,t}}{\sum_{j=1}^{N_r} g'_{j,t}}$$
  • où $g'_{i,t}$ est le score de gating initial.

• (c) Sélection des experts Top-K

  • Chaque token est assigné aux $K_r$ experts avec les scores d'affinité les plus élevés : $$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{sinon} \end{cases}$$
  • Le score d'affinité $s_{i,t}$ détermine la probabilité de routage.

• (d) Calcul de l'affinité token-expert

  • Le score d'affinité token-expert est donné par : $$s_{i,t} = \text{Sigmoid}(u_t^\top e_i)$$ La fonction sigmoïde est une fonction mathématique définie comme $\sigma(x) = \frac{1}{1 + e^{-x}}$, qui mappe tout nombre réel à une plage entre 0 et 1, couramment utilisée pour l'estimation de probabilité et l'activation dans les réseaux de neurones.
  • Le centroïde est calculé comme : $$e_i = \frac{1}{|B_i|} \sum_{t \in B_i} u_t$$
  • Ici :
    • $e_i$ est le vecteur centroïde du $i$-ème expert routé.
    • $B_i$ est l'ensemble des tokens routés vers l'expert $i$ dans un lot donné.
    • $|B_i|$ est le nombre de tokens assignés à l'expert $i$.
    • Le centroïde $e_i$ est appris pendant l'entraînement pour spécialiser les experts pour différents types de tokens.
    • Pendant l'inférence, $e_i$ reste fixe et est utilisé uniquement pour les décisions de routage.

Load Balancing sans perte auxiliaire

Pour les modèles Mixture of Experts (MoE), une charge d'expert déséquilibrée peut conduire à un effondrement de routage, réduisant l'efficacité computationnelle dans les architectures parallèles d'experts. Les solutions conventionnelles utilisent des pertes auxiliaires pour équilibrer la distribution des tokens, mais de grandes pertes auxiliaires peuvent dégrader la performance du modèle. Pour éviter ces compromis, DeepSeek-V3 introduit une stratégie d'équilibrage de charge sans perte auxiliaire qui ajuste dynamiquement un terme de biais $b_i$ pour chaque expert. Ce biais est ajouté aux scores d'affinité $s_{i,t}$ pour déterminer la sélection des experts.

Explication étape par étape

• (a) Sélection des experts avec ajustement de biais

  • Chaque expert a un terme de biais $b_i$, qui est ajouté au score d'affinité original $s_{i,t}$ avant le routage : $$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{sinon} \end{cases}$$
  • Ici :
    • $s_{i,t}$ est le score d'affinité token-expert original.
    • $b_i$ est un terme de biais assigné à l'expert $i$.
      • $b_i$ est appris pendant l'entraînement pour équilibrer l'utilisation des experts.
      • Pendant l'inférence, $b_i$ reste fixe et est uniquement utilisé pour les décisions de routage.
    • La fonction Top-$K_r$ sélectionne les $K_r$ experts avec les scores ajustés les plus élevés.

• (b) Le terme de biais est uniquement utilisé pour le routage

  • Le terme de biais n'affecte pas le calcul FFN.
  • Il est uniquement utilisé pour ajuster les probabilités de sélection des experts.

• (c) Mise à jour dynamique du biais pour équilibrer la charge

  • À la fin de chaque étape d'entraînement, le terme de biais $b_i$ est mis à jour en fonction de la charge des experts :
    • Si l'expert $i$ est surchargé, $b_i$ est diminué par un facteur de $\gamma$.
    • Si l'expert $i$ est sous-chargé, $b_i$ est augmenté par un facteur de $\gamma$.
  • Ici :
    • $\gamma$ est un hyperparamètre de vitesse de mise à jour du biais qui contrôle la rapidité d'ajustement de $b_i$.

Perte auxiliaire complémentaire par séquence

Bien que DeepSeek-V3 s'appuie principalement sur une stratégie sans perte auxiliaire pour l'équilibrage de charge, il introduit une perte d'équilibre par séquence complémentaire pour prévenir les déséquilibres extrêmes au sein d'une seule séquence. Cela garantit que l'utilisation des experts reste équilibrée à travers les tokens dans une séquence.

La perte d'équilibre par séquence est définie comme :

où $\alpha$ est un hyperparamètre de facteur d'équilibre, assigné une valeur extrêmement petite dans DeepSeek-V3.

Explication étape par étape

• (a) Calcul de la fraction de charge des experts $f_i$

  • La fraction de tokens assignés à l'expert $i$ au sein d'une séquence est calculée comme : $$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)$$
  • Ici :
    • $N_r$ est le nombre d'experts routés.
    • $K_r$ est le nombre d'experts activés par token.
    • $T$ est la longueur de la séquence, représentant le nombre de tokens.
    • $\mathbb{1}(\cdot)$ est la fonction indicatrice, retournant 1 si l'expert $i$ est parmi les experts sélectionnés dans le top-$K_r$ pour le token $t$.

• (b) Probabilité d'expert normalisée $s'_{i,t}$

  • La valeur de gating token-expert normalisée est calculée comme : $$s'_{i,t} = \frac{s_{i,t}}{\sum_{j=1}^{N_r} s_{j,t}}$$
  • Ici :
    • $s_{i,t}$ est la valeur de gating token-expert originale.
    • Le dénominateur garantit que les valeurs de gating s'additionnent à 1 à travers tous les experts routés.

• (c) Calcul de l'utilisation moyenne des experts $P_i$

  • La probabilité moyenne que l'expert $i$ soit sélectionné à travers la séquence est : $$P_i = \frac{1}{T} \sum_{t=1}^{T} s'_{i,t}$$
  • Cela représente la valeur de gating normalisée moyenne pour l'expert $i$ sur tous les tokens de la séquence.

• (d) Comment la perte d'équilibre par séquence est utilisée

  • $\mathcal{L}_{\text{Bal}}$ pénalise les déséquilibres dans l'utilisation des experts au sein d'une séquence.
  • Elle est appliquée uniquement pendant l'entraînement et non utilisée lors de l'inférence.
  • Elle ajuste doucement le routage pour prévenir la surcharge à court terme des experts.
  • L'hyperparamètre $\alpha$ garantit une interférence minimale avec la perte principale.

Routage limité par nœud

DeepSeek-V3 utilise le Routage Limité par Nœud pendant l'entraînement pour réduire les coûts de communication dans les modèles MoE. Chaque token est routé vers au maximum $M$ nœuds, sélectionnés en fonction de la somme des scores d'affinité les plus élevés $\frac{K_r}{M}$ parmi les experts sur chaque nœud. Cette contrainte garantit un équilibrage de charge efficace tout en maintenant un recouvrement computationnel-communication presque complet, optimisant l'efficacité de l'entraînement.

Stratégie sans perte de token

En raison de son équilibrage de charge efficace, DeepSeek-V3 ne perd aucun token pendant l'entraînement ou l'inférence. Le modèle maintient une utilisation stable des experts, et les stratégies de déploiement spécifiques à l'inférence garantissent un routage équilibré des tokens.

Prédiction multi-token

DeepSeek-V3 introduit la Prédiction Multi-Token (MTP), un objectif d'entraînement qui étend la portée de la prédiction à plusieurs tokens futurs par position. Cette approche améliore l'efficacité de l'entraînement tout en améliorant les représentations des tokens pour une meilleure prédiction des tokens futurs.

Implémentation de la Prédiction Multi-Token (MTP) de DeepSeek-V3. Source DeepSeek-V3 Technical Report

Explication étape par étape

• (a) Modules MTP

  • MTP est implémenté en utilisant $D$ modules séquentiels, chacun prédisant un token supplémentaire.
  • Chaque module MTP $(k)$-ième se compose de :
    • Une tête de sortie partagée $\text{OutHead}(\cdot)$.
    • Un bloc Transformer $\text{TRM}_k(\cdot)$.
    • Une matrice de projection $M_k \in \mathbb{R}^{d \times 2d}$.
  • À la profondeur de prédiction $k$, la représentation du token $t_i$ est calculée en combinant la représentation de profondeur précédente $h_i^{k-1}$ du $(i)$-ème token avec l'embedding du $(i+k)$-ième token : $$h_i^{k'} = M_k \left[ \text{RMSNorm}(h_i^{k-1}); \text{RMSNorm}(\text{Emb}(t_{i+k})) \right]$$
  • Ici :
    • $M_k$ est une matrice de projection apprise.
    • $h_i^{k-1}$ est la représentation cachée de la profondeur précédente.
    • $\text{Emb}(t_{i+k})$ est l'embedding du token futur à la position $(i+k)$.
    • RMSNorm est utilisé pour la normalisation, stabilisant les activations sans soustraction de la moyenne.
  • La représentation transformée est traitée à travers un bloc Transformer : $$h_{1:T-k}^k = \text{TRM}_k(h_{1:T-k}^{k'})$$ où $T$ représente la longueur de la séquence d'entrée, et $i:j$ désigne l'opération de découpage (inclusif des deux limites gauche et droite).
  • Enfin, en prenant $h_i^{k}$ comme entrée, la tête de sortie partagée calcule la distribution de probabilité pour le token de prédiction supplémentaire $k$-ième : $$p^k_{i+k+1} = \text{OutHead}(h_i^{k})$$ où $p^k_{i+k+1} \in \mathbb{R}^{V}$, avec $V$ étant la taille du vocabulaire. La tête de sortie $\text{OutHead}(\cdot)$ mappe linéairement la représentation aux logits et applique ensuite la fonction Softmax$(\cdot)$ pour calculer les probabilités de prédiction du token supplémentaire $k$-ième.

• (b) Objectif d'entraînement MTP

  • Pour chaque profondeur de prédiction, une perte d'entropie croisée $\mathcal{L}^{k}_{\text{MTP}}$ est calculée : $$\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],$$
  • où $T$ désigne la longueur de la séquence d'entrée, $t_i$ représente le token de vérité de terrain à la position $i$, et $p^k_i[t_i]$ est la probabilité prédite de $t_i$ donnée par le module MTP $k$-ième.
  • Les pertes MTP sont moyennées à travers toutes les profondeurs et mises à l'échelle par un facteur de pondération $\lambda$ pour obtenir la perte MTP globale $\mathcal{L}_{\text{MTP}}$, qui sert d'objectif d'entraînement supplémentaire : $$\mathcal{L}_{\text{MTP}} = \frac{\lambda}{D} \sum_{k=1}^{D} \mathcal{L}^{k}_{\text{MTP}}.$$

• (c) MTP en inférence

  • MTP est utilisé pendant l'entraînement pour améliorer les représentations des tokens.
  • Lors de l'inférence, les modules MTP sont désactivés, et seul le modèle principal est utilisé pour la prédiction des tokens.
  • MTP peut également être réutilisé pour la spéculation de tokens, améliorant l'efficacité du décodage.

Points clés à retenir

• Attention efficace avec MLA : Réduit l'utilisation de la mémoire en utilisant des projections dans l'espace latent pour réduire les dimensions des clés et des valeurs, avec des économies computationnelles potentielles en opérant sur des représentations plus petites.
• Routage d'expert stable avec DeepSeekMoE : Met en œuvre un équilibrage de charge sans perte auxiliaire, prévenant l'effondrement du routage et garantissant une spécialisation efficace des experts. Utilise un mécanisme de sélection ajusté par biais pour maintenir une distribution équilibrée token-expert, améliorant la stabilité du modèle sans introduire de surcharge computationnelle supplémentaire.
• Pas de perte de token : Maintient une rétention stable des tokens pendant l'entraînement et l'inférence, évitant la dégradation du traitement des séquences.
• La prédiction multi-token améliore l'entraînement : Améliore les représentations des tokens et l'efficacité de l'apprentissage en étendant l'objectif de prédiction au-delà du prochain token.

DeepSeek-V3 représente un bond majeur tant en efficacité d'entraînement qu'en scalabilité d'inférence, établissant une nouvelle norme pour les modèles de langage de prochaine génération.

Source(s)

• DeepSeek-V3 Technical Report

Vous avez apprécié cet article? Vous l'avez trouvée instructive ? N'hésitez pas à laisser un commentaire ci-dessous pour partager vos réflexions ou poser des questions. Un compte GitHub est requis pour participer à la discussion.

Si vous avez trouvé l'analyse mathématique des architectures LLM précieuse et que vous souhaitez voir plus d'articles explorant leurs rouages en profondeur, faites-le nous savoir.