Retour à la bibliothèque
arXiv 2024DeepSeekNotes de lecture

DeepSeek-V2

Source ouverte, coûts réduits

Article original

DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model

Auteurs de l’article

DeepSeek-AI

Publication
Lieu de publication non encore vérifié
Premier dépôt sur arXiv
arXiv:2405.04434
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{deepseekdeepseekv22024,
  title = {{DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model}},
  author = {DeepSeek-AI},
  year = {2024},
  eprint = {2405.04434},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2405.04434v5}
}
Sur cette page

Dans la note précédente, nous parlions justement d'essayer les MoE. Moins de trois mois plus tard, voilà un autre article.

Il compte 52 pages, avec beaucoup de résultats expérimentaux et de détails techniques. Comme d'habitude, choisissons les points essentiels.

Définir le problème

Ces dernières années, l'augmentation du nombre de paramètres des grands modèles de langage s'est accompagnée de progrès remarquables, parfois décrits comme des « capacités émergentes ». Elle nourrit l'espoir d'avancer vers une intelligence artificielle générale.

Mais ce progrès consomme beaucoup de calcul : l'entraînement coûte cher, et les contraintes de calcul et de mémoire ralentissent aussi l'inférence. Elles freinent l'utilisation et le déploiement de ces modèles.

L'équipe DeepSeek propose donc DeepSeek-V2 pour s'attaquer à ces goulets d'étranglement : conserver de bonnes performances tout en réduisant les coûts d'entraînement et d'inférence.

Résoudre le problème

DeepSeek-V2 conserve la structure Transformer : chaque bloc comprend un module d'attention et un réseau feed-forward (FFN).

  • Attention : l'équipe propose la MLA, une compression conjointe de faible rang des clés et des valeurs, pour réduire le cache KV dont dépend la génération avec l'attention multi-tête classique.
  • Réseau feed-forward : elle utilise DeepSeekMoE, une architecture à mélange d'experts qui active peu de paramètres à chaque token et permet d'entraîner un grand modèle à coût maîtrisé.

Les autres choix, dont la normalisation et les fonctions d'activation, reprennent ceux de DeepSeek 67B. Voici l'architecture générale :

Figure 2 de l'article : architecture MLA et DeepSeekMoE.

Multi-head Latent Attention

Détail de la Figure 2 : les éléments mis en cache par la MLA comprennent le vecteur KV comprimé et la clé positionnelle découplée.

Dans l'attention multi-tête classique (MHA), posons :

  • dd : la dimension de la représentation ;
  • nhn_h : le nombre de têtes ;
  • dhd_h : la dimension de chaque tête ;
  • ht∈Rdh_t \in \mathbb{R}^{d} : la représentation d'entrée du token tt.

Trois matrices de projection WQW_Q, WKW_K et WVW_V, toutes de taille Rdhnh×d\mathbb{R}^{d_h n_h \times d}, produisent respectivement les requêtes, clés et valeurs :

qt=WQhtkt=WKhtvt=WVht\begin{aligned} q_t &= W_Q h_t\\[1mm] k_t &= W_K h_t\\[1mm] v_t &= W_V h_t \end{aligned}

On répartit ensuite chaque vecteur entre les nhn_h têtes :

[qt,1; qt,2; … ; qt,nh]=qt[q_{t,1};\, q_{t,2};\, \dots; \, q_{t,n_h}] = q_t [kt,1; kt,2; … ; kt,nh]=kt[k_{t,1};\, k_{t,2};\, \dots; \, k_{t,n_h}] = k_t [vt,1; vt,2; … ; vt,nh]=vt[v_{t,1};\, v_{t,2};\, \dots; \, v_{t,n_h}] = v_t

Chaque tête calcule alors son attention :

ot,i=∑j=1tSoftmaxj ⁣(qt,i⊤kj,idh)vj,io_{t,i} = \sum_{j=1}^{t} \text{Softmax}_j\!\left(\frac{q_{t,i}^\top k_{j,i}}{\sqrt{d_h}}\right) v_{j,i}

La matrice de sortie WO∈Rd×dhnhW_O \in \mathbb{R}^{d \times d_h n_h} réunit enfin les résultats :

ut=WO[ot,1; ot,2; … ; ot,nh]u_t = W_O [o_{t,1};\, o_{t,2};\, \dots; \, o_{t,n_h}]

Jusqu'ici, rien de surprenant : c'est le calcul de la MHA.

Le problème arrive à l'inférence. Pour éviter de recalculer les étapes précédentes, il faut conserver les clés et les valeurs : 2nhdh2 n_h d_h éléments par token et par couche. À dimensions fixées, la mémoire du cache croît linéairement avec la longueur de la séquence conservée, jusqu'à devenir un sérieux goulet d'étranglement.

La MLA réduit ce cache grâce à une compression de faible rang.

  1. Compression conjointe des clés et valeurs : pour chaque token, on calcule d'abord une représentation latente plus courte :

    cKV,t=WDKVhtc_{KV,t} = W_{DKV} h_t

    Ici cKV,t∈Rdcc_{KV,t} \in \mathbb{R}^{d_c}, avec dc≪dhnhd_c \ll d_h n_h, et WDKV∈Rdc×dW_{DKV} \in \mathbb{R}^{d_c \times d} est la projection descendante.

  2. Reconstruction par projection ascendante : les clés et les valeurs peuvent être reconstruites depuis ce vecteur :

    kC,t=WUKcKV,tk_C,t = W_{UK} c_{KV,t} vC,t=WUVcKV,tv_C,t = W_{UV} c_{KV,t}

    Les matrices WUKW_{UK} et WUVW_{UV} ont chacune la taille Rdhnh×dc\mathbb{R}^{d_h n_h \times d_c}.

Avant l'ajout de l'encodage positionnel, il suffit de conserver cKV,tc_{KV,t}, soit dcd_c éléments par token et par couche. Après l'introduction du RoPE découplé ci-dessous, il faut aussi conserver la clé de position partagée kR,tk_{R,t} : le total devient dc+dhRd_c+d_h^R éléments.

La projection WUKW_{UK} peut être absorbée dans WQW_Q, et WUVW_{UV} dans WOW_O ; il n'est donc pas nécessaire de reconstruire explicitement toutes les clés et valeurs pendant le calcul d'attention.

Pour économiser aussi la mémoire des activations pendant l'entraînement, l'équipe comprime de manière analogue les requêtes :

cQ,t=WDQhtc_{Q,t} = W_{DQ} h_t qC,t=WUQcQ,tq_C,t = W_{UQ} c_{Q,t}

La représentation comprimée cQ,t∈Rdc′c_{Q,t} \in \mathbb{R}^{d'_c} vérifie dc′≪dhnhd'_c \ll d_h n_h.

Encodage positionnel rotatif découplé

Le Rotary Position Embedding (RoPE) ajoute la position aux clés et aux requêtes. Si on l'applique directement à la clé comprimée kC,tk_C,t, la matrice de remontée WUKW_{UK} se trouve liée à la position. L'absorption précédente devient alors impossible, et les clés des tokens du préfixe doivent être recalculées pendant l'inférence.

L'équipe découple donc le RoPE. Des requêtes supplémentaires qR,t,i∈RdhRq_{R,t,i} \in \mathbb{R}^{d^R_h} et une clé partagée kR,t∈RdhRk_{R,t} \in \mathbb{R}^{d^R_h} portent séparément l'information de position :

[qR,t,1; qR,t,2; … ; qR,t,nh]=qR,t=RoPE(WQRcQ,t)[q_{R,t,1};\, q_{R,t,2};\, \dots; \, q_{R,t,n_h}] = q_{R,t} = \text{RoPE}(W_{QR} c_{Q,t}) kR,t=RoPE(WKRht)k_{R,t} = \text{RoPE}(W_{KR} h_t)

WQR∈RdhRnh×dc′W_{QR} \in \mathbb{R}^{d^R_h n_h \times d'_c} et WKR∈RdhR×dW_{KR} \in \mathbb{R}^{d^R_h \times d} produisent ces nouvelles composantes.

Chaque tête réunit ensuite contenu et position :

qt,i=[qC,t,i; qR,t,i]q_{t,i} = [q_{C,t,i};\, q_{R,t,i}] kt,i=[kC,t,i; kR,t]k_{t,i} = [k_{C,t,i};\, k_{R,t}]

Le calcul d'attention devient :

ot,i=∑j=1tSoftmaxj ⁣(qt,i⊤kj,idh+dhR)vC,j,io_{t,i} = \sum_{j=1}^{t} \text{Softmax}_j\!\left(\frac{q_{t,i}^\top k_{j,i}}{\sqrt{d_h + d^R_h}}\right) v_{C,j,i}

Puis WOW_O réunit les sorties des têtes :

ut=WO[ot,1; ot,2; … ; ot,nh]u_t = W_O [o_{t,1};\, o_{t,2};\, \dots; \, o_{t,n_h}]

Le RoPE est ainsi séparé du contenu comprimé : il conserve les avantages de l'encodage positionnel sans empêcher l'absorption des matrices. Les clés de contenu du préfixe n'ont plus à être reconstruites, mais la clé positionnelle supplémentaire doit toujours être mise en cache.

DeepSeekMoE

Détail de la Figure 2 : experts partagés et experts routés de DeepSeekMoE.

DeepSeekMoE subdivise les FFN en deux familles d'experts :

  • Experts partagés (Shared Experts) : ils sont toujours utilisés pour chaque token.
  • Experts routés (Routed Experts) : une partie seulement est choisie pour chaque token.

Pour le token tt, l'entrée du FFN est utu_t et la sortie ht′h'_t vaut :

ht′=ut+∑i=1NsFFNi(s)(ut)+∑i=1Nrgi,t FFNi(r)(ut)h'_t = u_t + \sum_{i=1}^{N_s} \text{FFN}^{(s)}_i(u_t) + \sum_{i=1}^{N_r} g_{i,t} \,\text{FFN}^{(r)}_i(u_t)

NsN_s est le nombre d'experts partagés, NrN_r celui des experts routés, et FFNi(s)\text{FFN}^{(s)}_i et FFNi(r)\text{FFN}^{(r)}_i désignent leurs transformations respectives.

Le poids gi,tg_{i,t} dépend d'un routage :

gi,t={si,t,if si,t∈Topk({sj,t∣1≤j≤Nr},Kr),0,otherwise,g_{i,t} = \begin{cases} s_{i,t}, & \text{if } s_{i,t} \in \text{Topk}(\{ s_{j,t} \mid 1 \le j \le N_r\}, K_r),\\[1mm] 0, & \text{otherwise}, \end{cases}

KrK_r est le nombre d'experts routés activés. Le score d'affinité du token pour l'expert ii est :

si,t=Softmaxi(ut⊤ei)s_{i,t} = \text{Softmax}_i\bigl(u_t^\top e_i\bigr)

Le vecteur eie_i représente l'expert ii dans le routeur. L'article l'appelle un « centroïde » ; il s'agit d'un paramètre appris, et non du centre calculé a posteriori sur un jeu de données.

Lorsque les experts se trouvent sur plusieurs appareils, le routage peut multiplier les communications. Pour en contenir le coût, DeepSeekMoE emploie un routage limité par appareil :

  1. Pour chaque token, choisir MM appareils qui contiennent des experts aux scores d'affinité élevés.
  2. Ne choisir ensuite les experts Top-K qu'à l'intérieur de ces MM appareils.

Quand M≥3M \ge 3, les résultats observés restent proches de ceux du Top-K sans restriction. Cette règle sert à limiter les appareils sollicités ; le tableau ne chiffre pas à lui seul l'économie de communication.

Le compromis recherché est clair : préserver un routage utile sans faire communiquer inutilement tous les appareils d'un grand système distribué.

Pertes auxiliaires d'équilibrage

Un MoE risque de surcharger quelques experts tandis que d'autres restent inactifs. DeepSeekMoE utilise donc trois pertes auxiliaires pour répartir la charge.

  1. Équilibrage entre experts

    LExpBal=α1∑i=1Nrfi PiL_{ExpBal} = \alpha_1 \sum_{i=1}^{N_r} f_i\, P_i

    Avec :

    fi=NrKr T∑t=1T1(Token t choisit Expert i)f_i = \frac{N_r}{K_r\,T} \sum_{t=1}^{T} 1(\text{Token } t \text{ choisit Expert } i) Pi=1T∑t=1Tsi,tP_i = \frac{1}{T} \sum_{t=1}^{T} s_{i,t}

    TT est le nombre de tokens de la séquence, 1(⋅)1(\cdot) la fonction indicatrice et α1\alpha_1 le poids de cette perte. L'objectif est d'équilibrer la fréquence d'activation des experts et leur affinité moyenne.


  1. Équilibrage entre appareils

    Les experts routés sont répartis en DD groupes ; les experts de EiE_i résident sur le même appareil :

    LDevBal=α2∑i=1Dfi′ Pi′L_{DevBal} = \alpha_2 \sum_{i=1}^{D} f'_i\, P'_i fi′=1∣Ei∣∑j∈Eifjf'_i = \frac{1}{|E_i|} \sum_{j \in E_i} f_j Pi′=∑j∈EiPjP'_i = \sum_{j \in E_i} P_j

    Le coefficient α2\alpha_2 pondère cette perte, qui vise à éviter qu'un appareil concentre trop de calcul.


  1. Équilibrage des communications

    Même avec le routage limité, certains appareils pourraient recevoir bien plus de tokens que d'autres :

    LCommBal=α3∑i=1Dfi′′ Pi′′L_{CommBal} = \alpha_3 \sum_{i=1}^{D} f''_i\, P''_i fi′′=DM T∑t=1T1(Token t est envoyeˊ aˋ l’appareil i)f''_i = \frac{D}{M\,T} \sum_{t=1}^{T} 1(\text{Token } t \text{ est envoyé à l'appareil } i) Pi′′=∑j∈EiPjP''_i = \sum_{j \in E_i} P_j

    α3\alpha_3 règle le poids de cette troisième perte. Elle encourage une répartition plus régulière du trafic entre appareils.


L'équipe ajoute aussi une stratégie de rejet de tokens par appareil pour éviter de gaspiller du calcul lorsque la charge est déséquilibrée :

  1. Attribuer à chaque appareil un budget de calcul moyen, avec un facteur de capacité égal à 1,0.
  2. Y éliminer les tokens dont les scores d'affinité sont les plus faibles jusqu'à respecter ce budget.
  3. Protéger tous les tokens d'environ 10 % des séquences d'entraînement contre ce rejet.

Ces séquences protégées conservent une voie sans rejet. L'entraînement rapporté emploie le rejet de tokens pour accélérer le calcul ; l'évaluation, elle, n'en rejette aucun.

Stratégie d'entraînement

L'article reprend le traitement des données de DeepSeek 67B, puis le modifie sur trois points :

  • Davantage de données : un nettoyage amélioré récupère de nombreuses données supprimées par erreur auparavant.
  • Une meilleure qualité : l'équipe ajoute des données de qualité, notamment en chinois. Dans le corpus obtenu, le nombre de tokens chinois dépasse celui des tokens anglais d'environ 12 %. Elle améliore également le filtrage pour écarter des contenus peu utiles tout en conservant les données intéressantes.
  • Le filtrage de contenus controversés : cette mesure vise à réduire les biais liés à certaines cultures régionales.

Le tokenizer utilise, comme DeepSeek 67B, un encodage BBPE (byte-level byte-pair encoding) avec un vocabulaire de 100 000 unités. Le corpus de préentraînement final compte 8,1 billions de tokens (8,1 × 10¹²).

Voici les principaux paramètres du modèle :

  • 60 couches Transformer ;
  • une dimension cachée de 5120 ;
  • un écart-type de 0,006 pour l'initialisation aléatoire des paramètres entraînables ;
  • pour MLA : 128 têtes d'attention (nhn_h), 128 dimensions par tête (dhd_h), 512 dimensions latentes pour la compression KV (dcd_c), 1536 pour la compression des requêtes (dc′d'_c) et 64 dimensions par tête pour les requêtes et clés découplées (dhRd_h^R).

À l'exception de la première couche, chaque couche FFN est remplacée par une couche MoE. Chacune contient deux experts partagés et 160 experts routés, d'une dimension intermédiaire de 1536. Chaque token active six experts routés. Des couches RMS Norm et des facteurs d'échelle supplémentaires aident à stabiliser l'entraînement malgré la compression de faible rang et la division fine des experts.

Le modèle compte ainsi 236 milliards de paramètres au total, dont 21 milliards sont activés par token.

L'entraînement suit les réglages suivants :

  • Optimiseur AdamW : β1=0.9\beta_1=0.9, β2=0.95\beta_2=0.95 et décroissance des poids de 0,1.
  • Taux d'apprentissage : augmentation linéaire pendant les 2000 premières étapes, puis multiplication par 0,316 vers 60 % et 90 % des tokens parcourus ; maximum de 2,4 × 10⁻⁴.
  • Norme du gradient limitée à 1,0.
  • Taille de batch augmentée progressivement de 2304 à 9216 séquences, puis maintenue à 9216.
  • Longueur maximale de 4K tokens, pour un entraînement sur 8,1 billions de tokens.
  • Parallélisme de pipeline entre appareils ; experts routés répartis également sur huit appareils (D=8D=8).
  • Routage limité à trois appareils au plus par token (M=3M=3).
  • Poids des pertes auxiliaires : α1=0.003\alpha_1=0.003, α2=0.05\alpha_2=0.05 et α3=0.02\alpha_3=0.02.
  • Rejet de tokens pendant l'entraînement pour accélérer le calcul, sans rejet lors de l'évaluation.

Après ce préentraînement, YaRN étend la fenêtre de contexte par défaut de 4K à 128K. L'extension porte en particulier sur la clé partagée découplée ktRk_t^R, qui transporte RoPE. Les réglages sont une échelle s=40s=40, α=1\alpha=1, β=32\beta=32 et une longueur maximale cible de 160K.

Pour cette attention particulière, le facteur d'échelle de longueur devient :

t=0.0707ln⁡s+1\sqrt{t} = 0.0707 \ln s + 1

Il vise à limiter la perplexité. Pendant cette extension, l'équipe poursuit l'entraînement sur 1000 étapes avec des séquences de 32K tokens et un batch de 576 séquences. Les séquences d'entraînement ne font donc que 32K, tandis que le test « Needle In A Haystack » (NIAH) rapporte de bons résultats pour les longueurs évaluées jusqu'à 128K. Ce test ne couvre pas tous les usages de longs documents.

Alignement du modèle

L'équipe ajuste ensuite le modèle par apprentissage par renforcement afin d'améliorer la qualité des réponses et leur adéquation aux préférences humaines. Elle emploie Group Relative Policy Optimization (GRPO) : les scores d'un groupe servent à estimer la référence, ce qui évite d'entraîner un modèle critic de la même taille que la politique.

L'alignement comporte deux étapes :

  • Étape 1 — raisonnement. Un modèle de récompense RMreasoningR_{\text{Mreasoning}} évalue notamment les tâches de programmation et de mathématiques :

    ri=RMreasoning(oi)r_i = R_{\text{Mreasoning}}(o_i)

    Il fournit un signal pour améliorer la résolution de ces tâches.

  • Étape 2 — préférences humaines. Un cadre à plusieurs récompenses combine l'utilité (RMhelpfulR_{\text{Mhelpful}}), la sécurité (RMsafetyR_{\text{Msafety}}) et des règles explicites (RMruleR_{\text{Mrule}}). Pour une réponse oio_i :

    ri=c1⋅RMhelpful(oi)+c2⋅RMsafety(oi)+c3⋅RMrule(oi)r_i = c_1 \cdot R_{\text{Mhelpful}}(o_i) + c_2 \cdot R_{\text{Msafety}}(o_i) + c_3 \cdot R_{\text{Mrule}}(o_i)

    c1c_1, c2c_2 et c3c_3 sont les coefficients correspondants.

Pour obtenir les signaux de préférence, l'équipe s'appuie sur les retours de compilateurs en programmation et sur les réponses de référence en mathématiques. Les modèles de récompense partent de DeepSeek-V2 Chat (SFT) et sont entraînés au moyen de pertes ponctuelles ou par paires.

Discussion

La place manque pour passer tous les résultats en revue. Regardons AlignBench ; les autres expériences figurent dans l'article original.

Tableau 5 de l'article : résultats AlignBench en chinois, évalués par GPT-4-0613.

Le tableau classe les modèles selon leur score global sur AlignBench. GPT-4-0613 sert de juge pour ces tâches ouvertes en chinois : le classement dépend donc de cette grille d'évaluation et des versions de modèles testées.

DeepSeek-V2 Chat (RL) obtient 7,91 au total, contre 7,74 pour la version SFT. Les deux dépassent les autres modèles ouverts du tableau, dont Qwen1.5 72B Chat à 7,19. Entre SFT et RL, la moyenne en raisonnement chinois passe de 7,30 à 7,45, celle en langue de 8,17 à 8,36 ; en revanche, le raisonnement logique passe de 7,26 à 7,14.

Pour la compréhension du chinois, RL atteint 8,28 : au-dessus de GPT-4-1106-Preview (7,33), mais en dessous d'ERNIEBot-4.0-202404 (8,53). Sa moyenne en raisonnement, 7,45, reste aussi sous ERNIEBot (7,61) et GPT-4-1106-Preview (7,73).

AlignBench ne mesure ici que les tâches en chinois. Dans le tableau 4, consacré séparément à la conversation en anglais, RL dépasse SFT sur MT-Bench (8,97 contre 8,62) et sur le taux de victoire d'AlpacaEval 2.0 corrigé de la longueur (38,9 contre 30,0). Chaque tableau montre ainsi ses propres gains et compromis ; les résultats anglais ne se déduisent pas du classement chinois.

Conclusion

Figure 1 de l'article : capacités, coût d'entraînement, cache KV et débit de génération.

DeepSeek-V2 est un grand modèle de langage à architecture MoE qui prend en charge un contexte allant jusqu'à 128K tokens.

Il repose sur deux idées principales :

  • Multi-head Latent Attention : la compression conjointe de faible rang des clés et des valeurs réduit fortement le cache KV nécessaire à l'inférence.
  • DeepSeekMoE : des experts plus fins et des experts partagés rendent possible un entraînement moins coûteux pour cette capacité.

Face à DeepSeek LLM 67B, dans la configuration d'entraînement et de déploiement de l'article, DeepSeek-V2 rapporte un coût d'entraînement réduit de 42,5 %, un cache KV réduit de 93,3 % et un débit de génération multiplié par 5,76.

Le modèle rassemble 236 milliards de paramètres, mais n'en active que 21 milliards par token. Il présentait donc, parmi les modèles MoE ouverts comparés lors de la publication, un rapport coût-performances favorable. Le gain de débit dépend de la configuration de déploiement étudiée.