【万字长文】DeepSeek关键技术整理

转载需标明来源

DeepSeek技术发展沿革

总结

1. 迭代速度显著快于其他厂商。从2024年1月到2025年1月，12个月发布15个模型。
2. 全栈式的技术布局。
   1. 不同模型涉及不同的任务类型。涵盖了自然语言处理、代码生成、数学推理、多模态等领域。
   2. 技术突破涵盖了基座模型全流程。包括大模型理论研究、架构创新、训练优化、多模态整合
3. 极致成本压缩。通过自制训练框架、减少激活参数、硬件适配、新的微调方法等手段，大幅减少了大模型等成本。

重要技术点

技术点过多，本文选取关键技术点整理：

• Scaling Law
• DeepSeek MoE
• MLA
• DualPipe
• GRPO

Scaling Law

意义

deepseek提出的scaling law(DeepSeek LLM Scaling Open-Source Language Models with Longtermism, 2024)是DeepSeek系列所有语言模型最底层的指导思想。它有两点重要意义：

1. 在开始新模型设计时，scaling law指导了任务的资源分配和架构设计方向。
2. 能更准确的预测要训练的模型的性能

前置知识

scaling law最早由Open AI (Scaling Laws for Neural Language Models, 2020)提出，描述了神经网络性能随规模变化的规律。主要结论如下：

1. 模型参数量（N）、训练数据量（D）、训练的计算量（C）三者共同决定模型性能。且三者按比例缩放时，性能提升遵循幂律关系：
   $$性能\propto N^{\alpha }{D}^{\beta }{C}^{\gamma }$$
   其中$\alpha$,$\beta$,$\gamma$ 是取决于任务的常数（通常小于1）。
2. 在标准transformer模型中有：
   $$C\approx 6ND$$
3. 根据结论1和结论2：
   $C$一定时，模型性能的决策变量只有$N$和$D$ 。这意味着，通过构建一个巨大的数据集，简单的增加transformer的深度，就可以创造性能非凡的大语言模型。
4. 存在一个最优的计算分配比例：当模型参数量（N）和训练数据量（D）按比例 $N\propto D$ 增加时，性能提升最显著。

deepseek创新点

1. openai在scaling law中使用IsoFLOP(同构浮点运算数, isomorphic FLOPs)来计量模型规模（N），没有考虑注意力机制带来的计算开销。为了更精准的表示模型规模（N），deepseek提出了使用FLOPs/token来计量模型规模，用$M$表示。将$C\approx 6ND$替换为$C\approx MD$。
   

2. openai提出了最优的计算分配比例。deepseek对此进行了精细的修正。

   1. 模型尺度
      $$M_{opt}=0.1715C^{0.5243}$$
   2. 数据尺度
      $$D_{opt}=5.8316C^{0.4757}$$

3. 提出了影响transformer性能的第四个影响因素：超参。

   1. 学习率最优值$${\eta }_{opt}=0.3118C^{-0.1250}$$
   2. batchsize最优值$$B_{opt}=0.2920C^{0.3271}$$
      

DeepSeek MoE

意义

减少计算开销

1. 在训练阶段，计算成本不变时，大幅增加模型参数量
2. 在推理阶段，大幅减少推理阶段的计算开销。

前置知识

1. 混合专家模型(Mixed Expert Models, MoE)最早在1991年提出，MoE的思路是通过稀疏性降低网络的计算开销。
2. 稠密的transfromer架构中，FFN部分的参数规模和计算量最庞大，主要用于记录前置知识。
   

deepseek创新点

在一次计算时，实际上涉及很少的一部分知识参与，不必所有参数参与计算。所以MoE的核心思路在于保存全量的权重参数，但计算时只激活很少一部分神经元。

代码复现

import torch 
import torch.nn as nn 
import torch.optim as optim

# 1. 定义专家模型。2 * mlp + relu + softmax
class Expert(nn.Module): 
 def __init__(self, input_dim, hidden_dim, output_dim): 
        super(Expert, self).__init__() 
        self.layer1 = nn.Linear(input_dim, hidden_dim) 
        self.layer2 = nn.Linear(hidden_dim, output_dim) 

 def forward(self, x): 
        x = torch.relu(self.layer1(x)) 
 return torch.softmax(self.layer2(x), dim=1)

# 2. 门控函数 
# 3 * linear + dropout + relu/leakyrelu + softmax
class Gating(nn.Module): 
 def __init__(self, input_dim, 
                 num_experts, dropout_rate=0.1): 
        super(Gating, self).__init__() 

 # Layers 
        self.layer1 = nn.Linear(input_dim, 128) 
        self.dropout1 = nn.Dropout(dropout_rate) 

        self.layer2 = nn.Linear(128, 256) 
        self.leaky_relu1 = nn.LeakyReLU() 
        self.dropout2 = nn.Dropout(dropout_rate) 

        self.layer3 = nn.Linear(256, 128) 
        self.leaky_relu2 = nn.LeakyReLU() 
        self.dropout3 = nn.Dropout(dropout_rate) 

        self.layer4 = nn.Linear(128, num_experts) 

 def forward(self, x): 
        x = torch.relu(self.layer1(x)) 
        x = self.dropout1(x) 

        x = self.layer2(x) 
        x = self.leaky_relu1(x) 
        x = self.dropout2(x) 

        x = self.layer3(x) 
        x = self.leaky_relu2(x) 
        x = self.dropout3(x) 

 return torch.softmax(self.layer4(x), dim=1)

# MoE模块
class MoE(nn.Module): 
 def __init__(self, trained_experts): 
        super(MoE, self).__init__() 
        self.experts = nn.ModuleList(trained_experts) 
        num_experts = len(trained_experts) 
 # 假设每个专家输入维度相同
        input_dim = trained_experts[0].layer1.in_features 
        self.gating = Gating(input_dim, num_experts) 

 def forward(self, x): 
 # 获取门控权重
        weights = self.gating(x) 

 # 计算专家输出
        outputs = torch.stack( 
            [expert(x) for expert in self.experts], dim=2) 

 # 调整weights形状，以适应专家网络的输出
        weights = weights.unsqueeze(1).expand_as(outputs) 

 return torch.sum(outputs * weights, dim=2)

相关文献

MoE 架构 https://blog.csdn.net/v_JULY_v/article/details/145406756

MLA

意义

减少显存（或内存）开销
传统的自注意力机制中，KV缓存与序列长度成线性关系，导致长文本场景下的硬件资源焦虑。MLA能大幅减少KV缓存。

前置知识

1. 传统的MHA(多头注意力机制, Multi-Head Attention)中，缓存是怎么产生：
   先看单个head的计算：
   step 1: 计算Q、K、V$$Q=X{W}_Q,K=X{W}_K,V=X{W}_V$$
   step 2: 计算注意力分数$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{Q{K}^T}{\sqrt{d_k}}\right)V$$
   多头注意力就是单头注意力的拼接。每个头是不同的子空间，可以让模型专注不同方面的信息：
   

transformer是自回归的：模型每生成一个字，就要把之前的所有输入和输出都输入。

这导致越后面的预测，序列长度越长。$K$和$V$越大，计算量也就越大。
但实际前面运算得到的$K$和$V$可以存起来重复利用，大幅减少了注意力机制的运算开销。
这样缓存的KV参数量为$2n_h{d}_{n}l$，其中$n_h$为head的数量，$d_h$为K和V的维度，$l$为block的块数。

deepseek创新点

业界优化KV Cache的主要方法：

1. 共享KV：多个Head共享使用1组KV，将原来每个Head一个KV，变成1组Head一个KV，来压缩KV的存储。代表方法：GQA，MQA等
2. 窗口KV：针对长序列控制一个计算KV的窗口，KV cache只保存窗口内的结果（窗口长度远小于序列长度），超出窗口的KV会被丢弃，通过这种方法能减少KV的存储，当然也会损失一定的长文推理效果。代表方法：Longformer等
3. 量化压缩：基于量化的方法，通过更低的Bit位来保存KV，将单KV结果进一步压缩，代表方法：INT8等
4. 计算优化：通过优化计算过程，减少访存换入换出的次数，让更多计算在片上存储SRAM进行，以提升推理性能，代表方法：flashAttention等

deepseek创新点

多头潜在注意力(Multiple Latent Attention, MLA)使用了低秩分解的思路减少KV缓存的参数量，从而减少显存开销。

多头潜在注意力(Multiple Latent Attention, MLA)使用了低秩分解的思路减少KV缓存的参数量，从而减少显存开销。
完整的更新公式如下：
$$\begin{array}{rl}\left[q_t^C;q_t^{NR}\right]& amp;=h_t{W}^{DQ}{W}^{UQR}\\ \left[q_{t,1}^C;q_{t,2}^C;...;q_{t,n_h}^C\right]=q_t^C& amp;=slice[h_t{W}^{DQ}{W}^{UQR},:d_h{n}_h]\\ \left[q_{t,1}^R;q_{t,2}^R;...;q_{t,n_h}^R\right]=q_t^R& amp;=RoPE(q_t^{NR})W^{DKVR}\\ q_{t,i}& amp;=[q_{t,i}^C;q_{t,i}^R]\\ \left[c_t^{KV};k_t^{NR}\right]& amp;=h_t{W}^{DKVR}\\ k_t^R& amp;=RoPE(k_t^{NR})\\ \left[k_t^C;v_t^C\right]& amp;=c_t^{KV}{W}^{UKV}\\ \left[k_{t,1}^C;k_{t,2}^C;...;k_{t,n_h}^C\right]=k_t^C& amp;=c_t^{KV}slice[W^{UKV},:d_n{n}_h]\\ k_{t,i}& amp;=[k_{t,i}^C;k_t^R]\\ \left[v_{t,1}^C;v_{t,2}^C;...;v_{t,n_h}^C\right]=v_t^C& amp;=c_t^{KV}slice[W^{UKV},d_h{n}_h:]\\ o_{t,i}& amp;=\sum _{j=1}^{t}Softmax(\frac{q_{t,i}{k}_{j,i}^T}{\sqrt{d_h+d_h^R}})v_{j,i}^C\\ & amp;=\sum _{j=1}^{t}Softmax(\frac{(slice[h_t{W}^{DQ}{W}^{UQR},:d_h{n}_h]{(slice[W^{UKV},:d_n{n}_h])}^T{(c_j^{KV})}^T+RoPE(slice[h_t{W}^{DQ}{W}^{UQR},d_h{n}_h:])k_j^R))}{\sqrt{d_h+d_h^R}})c_j^{KV}slice[W^{UKV},d_h{n}_h:]\end{array}\text{\hspace{1em}(i)(ii)(iii)(iv)(v)(vi)(vii)(viii)(ix)(x)}$$

代码实现

https://github.com/ThomasVonWu/Interview-Note/blob/main/%E5%A4%A7%E6%A8%A1%E5%9E%8B/%E5%A4%A7%E6%A8%A1%E5%9E%8B%E6%8E%A8%E7%90%86%E5%8A%A0%E9%80%9F/DeepSeek_MLA.py

相关文献

MHA机制 https://zhuanlan.zhihu.com/p/109983672
MLA机制 https://zhuanlan.zhihu.com/p/23062701108
MHA、MQA、GQA演变 https://blog.csdn.net/v_JULY_v/article/details/134228287

DualPipe

意义

DualPipe是一种并行计算策略。通过显著减少气泡（GPU空闲时间）提升大规模分布式训练效率。也是deepseek节约成本的关键。

前置知识

1. 多层感知机的反向传播和参数更新（略过）
2. PP(流水线并行, Pipeline Parallel)
   将模型和数据都拆分为多个chunk，每个device分别训练。每个数据chunk是一个micro-batch。
3. PP的气泡
   PP的空闲时间占比$\frac{k-1}{k+m-1}$($k$为节点数量，$m$为micro batch数量)。

4. 1F1B：打乱model chunks的顺序，尽可能让一个节点的forward与另一个节点的backward并行。
   
5. ZB-H1和ZB-H2
   F里面每有一个矩阵乘法，B里面就有两个矩阵乘法。因此1B=2F。所以1F1B中的气泡来自于F在等B结束。ZB-H1将B进一步拆分为B和W。一个model chunk的B要等前面的B算完，但W无需等待前面的层算完，因此ZB-H1可以将W提前来填补F的等待时间。ZB-H2是在ZB-H1的基础上将optimizer step进一步提前，消除了更多的气泡。
   
   

deepseek创新点

DualPipe是在ZB-H2点基础上针对MoE模型进行了适配。

前向传播

1. multi-head attention的计算；
2. all-to-all dispatch，信息分发到各个节点；为的是计算moe做准备（总是需要把token分发到M个机器上）
3. model parallel MOE，模型并行MOE，也就是deepseekMOE；FFN的计算；
4. all-to-all combine，M个机器的MOE计算完成之后，需要合并一下各自的信息。
   
   F的步骤：

B的步骤就是F的步骤翻过来：

dualpipe的整体逻辑：让整个集群中保存两个model的副本，用DP的方把两个micro-batch分别发给两个model。一个batch的计算和另外一个batch的通信并行。
Forward和Backward是交叉进行的。

下图是论文中给出的一个8节点20micro-batches的流程图。

官方代码实现

https://github.com/deepseek-ai/DualPipe

相关文献

https://zhuanlan.zhihu.com/p/22681871459

GRPO

意义

赋予推理模型思维链的能力。比如V3与R1，同为671B的模型，未微调的V3为基座模型。经过（包括了GRPO）微调的R1则成为了推理模型。

前置知识

1. RLHF
   RLHF是利用强化学习完成模型对齐（微调）的一种技术。一般分为两种技术路线：
   1. 以 PPO为代表的 On Policy 路线 - 时间成本高、效果上限高
   2. 以DPO为代表的 Off Policy 路线 - 时间成本低、效果上限低
      两者的区分标准为在于训练时是否要进行文本生成。GRPO属于On Policy路线。
2. PPO
   具体公式可以略过，只需要了解PPO的特点即可：
   • Actor：用于生成句子的模型。也是我们最后想要的模型。
   • Critic：指导Actor的教练模型。需要与Actor一同训练。
   • Reward Model：用于给出最终分数的模型。不训练，只生成。
   • Reference Model：用于保持的最终结果不会偏离的模型。不训练，只生成。
     同时训练两个模型，推理四个模型，所以PPO非常耗费资源。

deepseek创新点

deepseek提出的GRPO(分组相对策略优化, Group Relative Policy Optimization)大幅降低了微调的成本。下图是PPO和GRPO的对比，其中的Policy Model是Actor，Value Model是Critic。GRPO相比PPO减少了一个Critic。

GRPO原理

GRPO的流程（简化版）：

• 将G个query抛给Policy Model推理，每个query生成出t个不同的回答（实际这里我们要的不是回答，而是回答中每个token的概率分布）。
• 将所有回答交给Reward Model计算rewards。再根据rewards计算advantage。每个回答对应的advantage是个标量，代表这个回答有多么符合我们的预期。
• Policy Model与Reference Model的KL散度用来表征Policy Model的训练偏移量。为了不让Policy Model过分的偏移原有的模型，我们将advantage与KL散度相减作为GRPO的loss。
• 根据GRPO的loss更新Policy Model的参数。

代码复现

https://github.com/huggingface/open-r1/blob/main/src/open_r1/grpo.py

相关文献

https://zhuanlan.zhihu.com/p/21046265072
https://www.bilibili.com/video/BV15zNyeXEVP/?share_source=copy_web&vd_source=9eb6d7fad45f9fa869cd9abb34fa68ca