Die Entmystifizierung von DeepSeek-V3: Eine Analyse seiner revolutionären KI-Architektur

Einführung

DeepSeek-V3 stellt einen bedeutenden Fortschritt im Bereich der großen Sprachmodelle (LLMs) dar. Entwickelt von DeepSeek-AI, nutzt dieses Modell die Mixture-of-Experts (MoE) Architektur, um unvergleichliche Leistung zu bieten und gleichzeitig die Effizienz sowohl im Training als auch in der Inferenz aufrechtzuerhalten. Mit insgesamt 671 Milliarden Parametern und 37 Milliarden aktivierten pro Token ist DeepSeek-V3 darauf ausgelegt, komplexe Aufgaben mit bemerkenswerter Genauigkeit zu bewältigen.

Dieser Beitrag bietet eine detaillierte Durchsicht der Architektur von DeepSeek-V3 und erklärt seine Schlüsselkomponenten Schritt für Schritt. Jeder Abschnitt zerlegt die zugrunde liegenden Mechanismen und präsentiert die mathematischen Formulierungen, die ihre Funktionalität definieren. Die Erklärungen basieren auf dem offiziellen technischen Bericht zu DeepSeek-V3, der als primäre Informationsquelle der Autoren des Modells dient. Sie können das vollständige Papier hier einsehen: DeepSeek-V3 Technischer Bericht. Am Ende werden Sie ein klares Verständnis dafür haben, wie DeepSeek-V3 Effizienz, Skalierbarkeit und Inferenzoptimierung erreicht.

Architektur und Innovationen

DeepSeek-V3 führt mehrere Innovationen ein, die Effizienz, Skalierbarkeit und Genauigkeit verbessern. Die wichtigsten architektonischen Fortschritte umfassen:

Multi-head Latent Attention – Reduziert die Inferenzkosten und verbessert die Aufmerksamkeits-Effizienz.
DeepSeekMoE – Eine verfeinerte Mixture-of-Experts (MoE) Architektur, die die Spezialisierung der Experten und das Lastenbalancing verbessert.
Auxiliary-Loss-Free Load Balancing – Eine neuartige Expertenauswahlstrategie, die die Notwendigkeit eines Hilfsverlusts beseitigt und eine stabile und effiziente Nutzung der Experten gewährleistet.
Complementary Sequence-Wise Auxiliary Loss – Eine leichte Verlustfunktion, die lokale Ungleichgewichte innerhalb einer einzelnen Sequenz verhindert.
Node-Limited Routing – Optimiert die Verteilung der Experten über die Rechenknoten, um die Kommunikationskosten zu reduzieren.
No Token-Dropping Strategy – Gewährleistet eine stabile Token-Retention während des Trainings und der Inferenz.
Multi-Token Prediction – Verbessert die Token-Darstellungen während des Trainings und kann für spekulatives Decoding in der Inferenz verwendet werden.

Jede dieser Komponenten trägt zur state-of-the-art Leistung von DeepSeek-V3 bei und erhält gleichzeitig die rechnerische Effizienz.

DeepSeek-V3 Modellarchitektur. Quelle DeepSeek-V3 Technischer Bericht

Multi-head Latent Attention

Multi-head Latent Attention (MLA) ist ein Grundpfeiler der Architektur von DeepSeek-V3. Dieser Mechanismus ermöglicht es dem Modell, Informationen effizienter zu verarbeiten, indem es sich auf die relevantesten Teile der Eingabedaten konzentriert. MLA reduziert den Rechenaufwand und erhält gleichzeitig eine hohe Genauigkeit, was es ideal für groß angelegte Sprachmodelle macht.

Schritt-für-Schritt-Erklärung

(a) Projektion des Eingabetokens $h_t$ auf den latenten Vektor $c_t^{kv}$
- Das Eingabetoken zum Zeitpunkt $t$ wird als $h_t \in \mathbb{R}^{d}$ bezeichnet. Hier hat $h_t$ die gleiche Dimension $d$ wie der verborgene Zustand des Modells.
- Es wird in einen latenten Vektor $c_t^{kv}$ mit einer viel kleineren Dimension $d_c$ (wobei $d_c \ll d_h \times n_h$ ) projiziert: $c_t^{kv} = W^{DQ} h_t$
- Hier ist $W^{DQ} \in \mathbb{R}^{d_c \times d}$ eine gelernt Projektionsmatrix, die die Dimensionalität von $h_t$ reduziert.
- Der latente Vektor $c_t^{kv}$ speichert komprimierte Informationen, die zur Berechnung der Schlüssel- und Wert-Darstellungen im Aufmerksamkeitsmechanismus verwendet werden.
(b) Berechnung des Schlüsselvektors durch Hochskalierung vom latenten Vektor
- Der Schlüsselvektor wird berechnet, indem er von der latenten Vektordimension $d_c$ auf die volle Aufmerksamkeitsdimension $d_h \times n_h$ hochskaliert wird: $k_t^c = W^{U_k} c_t^{kv}$
- Hier ist $W^{U_k} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ eine gelernt Projektionsmatrix, die $c_t^{kv}$ in die vollständige Schlüsselrepräsentation $k_t^c$ erweitert.
- Dies stellt sicher, dass $k_t^c$ die gleiche Dimensionalität wie die Schlüssel in der Multi-Head Attention (MHA) hat.
(c) Projektion und RoPE-Kodierung des Eingabetokens
- Das Eingabetoken $h_t$ wird zuerst von der Dimension $d$ auf $d_h^R$ unter Verwendung einer gelernten Projektionsmatrix projiziert: $k_t^r = W^{QR} h_t$
- Hier ist $W^{QR} \in \mathbb{R}^{d_h^R \times d}$ eine gelernt Projektionsmatrix mit der Größe $d_h^R \times d$ .
- Der projizierte Vektor $k_t^r$ wird dann unter Verwendung von Rotary Positional Embeddings (RoPE) an der Token-Position $t$ kodiert: $k_t^{rope} = \text{RoPE}(k_t^r)$
- Der RoPE-kodierte Schlüssel $k_t^{rope}$ wird konkatenisiert mit den Schlüsselvektoren jedes Kopfes, um sicherzustellen, dass der gleiche positionskodierte Schlüssel über alle Köpfe hinweg geteilt wird.
- Nach der Konkatenation erhalten wir den endgültigen pro-Kopf Schlüsselvektor $k_t^i$ für jeden Aufmerksamkeitskopf $i$ mit der Dimensionalität: $k_t^i \in \mathbb{R}^{\left(d_h + d_h^R\right)}$
(d) Berechnung des Wertvektors durch Hochskalierung vom latenten Vektor
- Der Wertvektor wird berechnet, indem er vom latenten Vektor $c_t^{kv}$ mit der Dimension $d_c$ auf die volle Aufmerksamkeitsdimension $d_h \times n_h$ hochskaliert wird: $v_t = W^{UV} c_t^{kv}$
- Hier ist $W^{UV} \in \mathbb{R}^{(d_h \times n_h) \times d_c}$ eine gelernt Projektionsmatrix.
- Dies stellt sicher, dass $v_t$ die gleiche Dimensionalität wie die Werte in der Multi-Head Attention (MHA) hat.
(e) Berechnung des Abfragevektors mit niedrigrangiger Kompression
- Die Aufmerksamkeitsabfrage wird unter Verwendung einer niedrigrangigen Kompression berechnet, indem $h_t$ zuerst in einen latenten Raum mit der Dimension $d_c'$ (wobei $d_c' \ll d_h \times n_h$ ) herunterprojiziert wird: $c_t^q = W^{DQ} h_t$
- Hier ist $W^{DQ} \in \mathbb{R}^{d_c' \times d}$ eine gelernt Herunterprojektionsmatrix, und der latente Vektor $c_t^q$ hat die Dimension: $c_t^q \in \mathbb{R}^{d_c'}$
- Die Abfrage wird dann mit einer gelernten Hochprojektionsmatrix wieder hochskaliert: $q_t^c = W^{UQ} c_t^q$
- Hier ist $W^{UQ} \in \mathbb{R}^{(d_h \times n_h) \times d_c'}$ eine gelernt Hochprojektionsmatrix, die spezifisch für Abfragen ist und sich von der für Schlüssel und Werte verwendeten unterscheidet.
- RoPE-Kodierung wird auf den projizierten Abfragevektor an der Token-Position $t$ angewendet: $q_t^{R} = \text{RoPE}(W^{QR} c_t^q)$
- Hier ist $W^{QR} \in \mathbb{R}^{(d_h^R \times n_h) \times d_c'}$ eine gelernt Projektionsmatrix mit der Größe $(d_h^R \times n_h) \times d_c'$ .
- Schließlich wird die RoPE-kodierte Abfrage mit dem hochskalierten Abfragevektor konkatenisiert, um den endgültigen pro-Kopf Abfragevektor zu bilden: $q_{t,i} = [q_{t,i}^{c}; q_{t,i}^{R}]$
- Die resultierende Dimensionalität jedes pro-Kopf Abfragevektors ist: $q_{t,i} \in \mathbb{R}^{\left(d_h + d_h^R\right)}$
(f) Berechnung der Aufmerksamkeitsausgabe
- Die endgültige Aufmerksamkeitsausgabe wird unter Verwendung der Abfragen, Schlüssel und Werte berechnet: $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}$
- Hier gilt für jeden Kopf $i$ $i$ :
  - Die Abfrage $q_{t,i} \in \mathbb{R}^{d_h + d_h^R}$ .
  - Der Schlüssel $k_{j,i} \in \mathbb{R}^{d_h + d_h^R}$ .
  - Der Wert $v_{j,i}^{c} \in \mathbb{R}^{d_h}$ .
  - Die Ausgabe $o_{t,i} \in \mathbb{R}^{d_h}$ .
- Die Ähnlichkeit zwischen Abfrage und Schlüssel wird durch den Faktor $\sqrt{d_h + d_h^R}$ (die Dimension von $q_{t,i}$ und $k_{j,i}$ ) skaliert, bevor die Softmax angewendet wird.
- Die Ausgaben aller $n_h$ Köpfe werden in einen einzigen Spaltenvektor zusammengeführt: $\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d_h \times n_h}$ der $d_h \times n_h$ Einträge hat.
- Der endgültige verborgene Ausgabestatus wird berechnet als: $u_t = W^O \,\bigl[\, o_{t,1},\, o_{t,2},\, \dots,\, o_{t,n_h} \,\bigr] \in \mathbb{R}^{d}$
- Hier ist $W^O \in \mathbb{R}^{d \times (d_h \cdot n_h)}$ die gelernte Ausgabepunktionsmatrix.
- Die endgültige Ausgabe $u_t$ ist ein Spaltenvektor mit $d$ Einträgen, d.h. $u_t \in \mathbb{R}^{d}$ .

DeepSeekMoE

DeepSeekMoE ist eine spezialisierte Mixture of Experts (MoE) Architektur, die in DeepSeek-V3 für Feed-Forward-Netzwerke (FFNs) verwendet wird. Im Vergleich zu traditionellen MoE-Architekturen wie GShard führt DeepSeekMoE eine feinere Expertenzuweisung ein, bei der einige Experten als gemeinsame fungieren.

Schritt-für-Schritt-Erklärung

(a) FFN-Berechnung für jedes Token
- Lassen Sie den FFN-Eingang des $t$ -ten Tokens $u_t \in \mathbb{R}^{d}$ sein, wobei $d$ die verborgene Dimension ist.
- Die Ausgabe wird berechnet als: $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)$
- Hier:
  - $N_s$ und $N_r$ bezeichnen die Anzahl der gemeinsamen und gerouteten Experten.
  - $\text{FFN}_i^{(s)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ repräsentiert den $i$ -ten gemeinsamen Experten.
  - $\text{FFN}_i^{(r)}(\cdot): \mathbb{R}^{d} \to \mathbb{R}^{d}$ repräsentiert den $i$ -ten gerouteten Experten.
  - $g_{i,t}$ ist der Gate-Wert für den $i$ -ten Experten.
  - Sowohl $u_t$ als auch $h'_t$ haben die gleiche verborgene Dimension $d$ .
(b) Normalisierung des Gate-Wertes
- Die Gate-Werte $g_{i,t}$ werden über die aktivierten Experten normalisiert: $g_{i,t} = \frac{g'_{i,t}}{\sum_{j=1}^{N_r} g'_{j,t}}$
- wobei $g'_{i,t}$ der ursprüngliche Gate-Score ist.
(c) Top-K Expertenauswahl
- Jedes Token wird den Top $K_r$ Experten mit den höchsten Affinitätscores zugewiesen: $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{sonst} \end{cases}$
- Der Affinitätswert $s_{i,t}$ bestimmt die Routing-Wahrscheinlichkeit.
(d) Berechnung der Token-zu-Experten-Affinität
- Der Token-zu-Experten-Affinitätswert wird gegeben durch: $s_{i,t} = \text{Sigmoid}(u_t^\top e_i)$ Die Sigmoid-Funktion ist eine mathematische Funktion, die definiert ist als $\sigma(x) = \frac{1}{1 + e^{-x}}$ , die jede reelle Zahl in einen Bereich zwischen 0 und 1 abbildet, häufig verwendet für Wahrscheinlichkeitsabschätzungen und Aktivierungen in neuronalen Netzen.
- Der Schwerpunkt wird berechnet als: $e_i = \frac{1}{|B_i|} \sum_{t \in B_i} u_t$
- Hier:
  - $e_i$ ist der Schwerpunktvektor des $i$ -ten gerouteten Experten.
  - $B_i$ ist die Menge der Tokens, die in einem bestimmten Batch an den Experten $i$ geroutet werden.
  - $|B_i|$ ist die Anzahl der Tokens, die dem Experten $i$ zugewiesen sind.
  - Der Schwerpunkt $e_i$ wird während des Trainings gelernt, um Experten für verschiedene Arten von Tokens zu spezialisieren.
  - Während der Inferenz bleibt $e_i$ fest und wird nur für Routing-Entscheidungen verwendet.

Auxiliary-Loss-Free Load Balancing

Für Mixture of Experts (MoE) Modelle kann eine unausgeglichene Expertenlast zu Routing-Kollaps führen, was die rechnerische Effizienz in Experten-parallelen Architekturen verringert. Konventionelle Lösungen verwenden Hilfsverluste, um die Tokenverteilung auszugleichen, aber große Hilfsverluste können die Modellleistung beeinträchtigen. Um diese Kompromisse zu vermeiden, führt DeepSeek-V3 eine hilfsverlustfreie Lastenausgleichsstrategie ein, die dynamisch einen Bias-Term $b_i$ für jeden Experten anpasst. Dieser Bias wird zu den Affinitätswerten $s_{i,t}$ hinzugefügt, um die Expertenauswahl zu bestimmen.

Schritt-für-Schritt-Erklärung

(a) Expertenauswahl mit Bias-Anpassung
- Jeder Experte hat einen Bias-Term $b_i$ , der zu dem ursprünglichen Affinitätswert $s_{i,t}$ vor dem Routing hinzugefügt wird: $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{sonst} \end{cases}$
- Hier:
  - $s_{i,t}$ ist der ursprüngliche Token-zu-Experten-Affinitätswert.
  - $b_i$ $b_{i}$ ist ein Bias-Term, der dem Experten $i$ $i$ zugewiesen ist.
    - $b_i$ wird während des Trainings gelernt, um die Nutzung der Experten auszugleichen.
    - Während der Inferenz bleibt $b_i$ fest und wird nur für Routing-Entscheidungen verwendet.
  - Die Top- $K_r$ Funktion wählt die $K_r$ Experten mit den höchsten angepassten Werten aus.
(b) Bias-Term wird nur für Routing verwendet
- Der Bias-Term beeinflusst nicht die FFN-Berechnung.
- Er wird nur verwendet, um die Wahrscheinlichkeiten der Expertenauswahl anzupassen.
(c) Dynamische Bias-Aktualisierung zur Lastenausgleichung
- Am Ende jedes Trainingsschrittes wird der Bias-Term $b_i$ $b_{i}$ basierend auf der Expertenlast aktualisiert:
  - Wenn der Experte $i$ überlastet ist, wird $b_i$ um einen Faktor von $\gamma$ verringert.
  - Wenn der Experte $i$ unterlastet ist, wird $b_i$ um einen Faktor von $\gamma$ erhöht.
- Hier:
  - $\gamma$ ist ein Hyperparameter für die Bias-Aktualisierungsrate, der steuert, wie schnell $b_i$ angepasst wird.

Complementary Sequence-Wise Auxiliary Loss

Obwohl DeepSeek-V3 hauptsächlich auf eine hilfsverlustfreie Strategie für den Lastenausgleich setzt, führt es einen komplementären sequenzweisen Ausgleichsverlust ein, um extreme Ungleichgewichte innerhalb einer einzelnen Sequenz zu verhindern. Dies stellt sicher, dass die Nutzung der Experten über die Tokens in einer Sequenz hinweg ausgeglichen bleibt.

Der sequenzweise Ausgleichsverlust wird definiert als:

\mathcal{L}_{\text{Bal}} = \alpha \sum_{i=1}^{N_r} f_i P_i

wobei $\alpha$ ein Hyperparameter für den Ausgleich ist, der in DeepSeek-V3 einen extrem kleinen Wert zugewiesen bekommt.

Schritt-für-Schritt-Erklärung

(a) Berechnung des Expertenlastanteils $f_i$
- Der Anteil der Tokens, die dem Experten $i$ innerhalb einer Sequenz zugewiesen sind, wird berechnet als: $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)$
- Hier:
  - $N_r$ ist die Anzahl der gerouteten Experten.
  - $K_r$ ist die Anzahl der aktivierten Experten pro Token.
  - $T$ ist die Sequenzlänge, die die Anzahl der Tokens darstellt.
  - $\mathbb{1}(\cdot)$ ist die Indikatorfunktion, die 1 zurückgibt, wenn der Experte $i$ zu den Top- $K_r$ ausgewählten Experten für das Token $t$ gehört.
(b) Normalisierter Expertenwahrscheinlichkeitswert $s'_{i,t}$
- Der normalisierte Token-zu-Experten-Gate-Wert wird berechnet als: $s'_{i,t} = \frac{s_{i,t}}{\sum_{j=1}^{N_r} s_{j,t}}$
- Hier:
  - $s_{i,t}$ ist der ursprüngliche Token-zu-Experten-Gate-Wert.
  - Der Nenner stellt sicher, dass die Gate-Werte über alle gerouteten Experten hinweg auf 1 summiert werden.
(c) Berechnung der durchschnittlichen Expertennutzung $P_i$
- Die durchschnittliche Wahrscheinlichkeit, dass der Experte $i$ über die Sequenz hinweg ausgewählt wird, ist: $P_i = \frac{1}{T} \sum_{t=1}^{T} s'_{i,t}$
- Dies stellt den durchschnittlichen normalisierten Gate-Wert für den Experten $i$ über alle Tokens in der Sequenz dar.
(d) Wie der sequenzweise Ausgleichsverlust verwendet wird
- $\mathcal{L}_{\text{Bal}}$ bestraft Ungleichgewichte in der Nutzung der Experten innerhalb einer Sequenz.
- Er wird nur während des Trainings angewendet und nicht in der Inferenz.
- Er passt das Routing sanft an, um kurzfristige Überlastungen der Experten zu verhindern.
- Der Hyperparameter $\alpha$ sorgt für minimale Störung des Hauptverlusts.

Node-Limited Routing

DeepSeek-V3 verwendet während des Trainings Node-Limited Routing, um die Kommunikationskosten in MoE-Modellen zu reduzieren. Jedes Token wird an höchstens $M$ Knoten geroutet, die basierend auf der Summe der höchsten $\frac{K_r}{M}$ Affinitätswerte unter den Experten auf jedem Knoten ausgewählt werden. Diese Einschränkung gewährleistet ein effizientes Lastenbalancing, während nahezu eine vollständige Berechnung-Kommunikationsüberlappung aufrechterhalten wird, was die Trainingseffizienz optimiert.

No Token-Dropping

Aufgrund seines effektiven Lastenbalancings lässt DeepSeek-V3 keine Tokens während des Trainings oder der Inferenz fallen. Das Modell erhält eine stabile Nutzung der Experten, und spezifische Bereitstellungsstrategien für die Inferenz gewährleisten ein ausgewogenes Token-Routing.

Multi-Token Prediction

DeepSeek-V3 führt Multi-Token Prediction (MTP) ein, ein Trainingsziel, das den Vorhersagebereich auf mehrere zukünftige Tokens pro Position erweitert. Dieser Ansatz verbessert die Trainingseffizienz und verbessert die Token-Darstellungen für eine bessere Vorhersage zukünftiger Tokens.

DeepSeek-V3 Multi-Token Prediction (MTP) Implementierung. Quelle DeepSeek-V3 Technischer Bericht

Schritt-für-Schritt-Erklärung

(a) MTP-Module
- MTP wird unter Verwendung von $D$ sequentiellen Modulen implementiert, die jeweils ein zusätzliches Token vorhersagen.
- Jedes $(k)$ $(k)$ -te MTP-Modul besteht aus:
  - Einem gemeinsamen Ausgabekopf $\text{OutHead}(\cdot)$ .
  - Einem Transformer-Block $\text{TRM}_k(\cdot)$ .
  - Einer Projektionsmatrix $M_k \in \mathbb{R}^{d \times 2d}$ .
- Bei der Vorhersagetiefe $k$ wird die Darstellung des Tokens $t_i$ berechnet, indem die vorherige Tiefenrepräsentation $h_i^{k-1}$ des $(i)$ -ten Tokens mit der Einbettung des $(i+k)$ -ten Tokens kombiniert wird: $h_i^{k'} = M_k \left[ \text{RMSNorm}(h_i^{k-1}); \text{RMSNorm}(\text{Emb}(t_{i+k})) \right]$
- Hier:
  - $M_k$ ist eine gelernt Projektionsmatrix.
  - $h_i^{k-1}$ ist die verborgene Darstellung der vorherigen Tiefe.
  - $\text{Emb}(t_{i+k})$ ist die Einbettung des zukünftigen Tokens an der Position $(i+k)$ .
  - RMSNorm wird zur Normalisierung verwendet, um die Aktivierungen ohne Mittelwertsubtraktion zu stabilisieren.
- Die transformierte Darstellung wird durch einen Transformer-Block verarbeitet: $h_{1:T-k}^k = \text{TRM}_k(h_{1:T-k}^{k'})$ wobei $T$ die Eingabesequenzlänge darstellt und $i:j$ die Slicing-Operation (einschließlich beider Grenzen) bezeichnet.
- Schließlich berechnet der gemeinsame Ausgabekopf die Wahrscheinlichkeitsverteilung für das $k$ -te zusätzliche Vorhersagetoken: $p^k_{i+k+1} = \text{OutHead}(h_i^{k})$ wobei $p^k_{i+k+1} \in \mathbb{R}^{V}$ ist, wobei $V$ die Größe des Wortschatzes ist. Der Ausgabekopf $\text{OutHead}(\cdot)$ ordnet die Darstellung linear den Logits zu und wendet anschließend die Softmax $(\cdot)$ -Funktion an, um die Vorhersagewahrscheinlichkeiten des $k$ -ten zusätzlichen Tokens zu berechnen.
(b) MTP-Trainingsziel
- Für jede Vorhersagetiefe wird ein Kreuzentropieverlust $\mathcal{L}^{k}_{\text{MTP}}$ berechnet: $\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],$
- wobei $T$ die Eingabesequenzlänge darstellt, $t_i$ das Ground-Truth-Token an der $i$ -ten Position repräsentiert und $p^k_i[t_i]$ die vorhergesagte Wahrscheinlichkeit von $t_i$ ist, die vom $k$ -ten MTP-Modul gegeben wird.
- Die MTP-Verluste werden über alle Tiefen gemittelt und mit einem Gewichtungsfaktor $\lambda$ skaliert, um den Gesamt-MTP-Verlust $\mathcal{L}_{\text{MTP}}$ zu erhalten, der als zusätzliches Trainingsziel dient: $\mathcal{L}_{\text{MTP}} = \frac{\lambda}{D} \sum_{k=1}^{D} \mathcal{L}^{k}_{\text{MTP}}.$
(c) MTP in der Inferenz
- MTP wird während des Trainings verwendet, um die Token-Darstellungen zu verbessern.
- Während der Inferenz sind MTP-Module deaktiviert, und nur das Hauptmodell wird für die Token-Vorhersage verwendet.
- MTP kann auch für Token-Spekulation umfunktioniert werden, um die Decodierungseffizienz zu verbessern.

Wichtige Erkenntnisse

Effiziente Aufmerksamkeit mit MLA: Reduziert den Speicherbedarf, indem latente Raumprojektionen verwendet werden, um Schlüssel- und Wertdimensionen zu verkleinern, mit potenziellen Rechenersparnissen durch die Arbeit mit kleineren Darstellungen.
Stabiles Expertenrouting mit DeepSeekMoE: Implementiert hilfsverlustfreies Lastenbalancing, um Routing-Kollaps zu verhindern und eine effiziente Spezialisierung der Experten zu gewährleisten. Verwendet einen bias-adjustierten Auswahlmechanismus, um eine gleichmäßige Token-zu-Experten-Verteilung aufrechtzuerhalten und die Stabilität des Modells zu verbessern, ohne zusätzliche Rechenlast einzuführen.
Kein Token-Dropping: Gewährleistet eine stabile Token-Retention während des Trainings und der Inferenz, um eine Verschlechterung der Sequenzverarbeitung zu vermeiden.
Multi-Token Prediction verbessert das Training: Verbessert die Token-Darstellungen und die Lerneffizienz, indem das Vorhersageziel über das nächste Token hinaus erweitert wird.

DeepSeek-V3 stellt einen großen Fortschritt sowohl in der Trainingseffizienz als auch in der Inferenzskalierbarkeit dar und setzt einen neuen Standard für Sprachmodelle der nächsten Generation.

Quelle(n)

DeepSeek-V3 Technischer Bericht

Hat Ihnen dieser Beitrag gefallen? Fanden Sie sie aufschlussreich? Hinterlassen Sie gerne einen Kommentar unten, um Ihre Gedanken zu teilen oder Fragen zu stellen. Ein GitHub-Konto ist erforderlich, um an der Diskussion teilzunehmen.

Wenn Sie die mathematische Analyse von LLM-Architekturen wertvoll fanden und mehr Beiträge sehen möchten, die ihre inneren Abläufe im Detail erkunden, lassen Sie es uns wissen.