PaperReading:Deepseek series
paperreading
本文字数：5.9k 字 | 阅读时长 ≈ 23 min
原创 paperreading

PaperReading:Deepseek series

paperreading
本文字数：5.9k 字 | 阅读时长 ≈ 23 min

原创 paperreading

Deepseek v1

1. 模型结构

Deepseek LLM 第一版本。

目前，ChatGPT、Claude、Bard 等封闭模型引领了 LLM 的潮流，但同时也激发了开源 LLM 的快速发展，如 LLaMA 系列。LLaMA系列凭借高效架构和优越性能，成为开源社区的重要基准。然而，开源社区在固定规模（7B、13B、34B、70B）模型上投入较多，却相对忽视了LLM的扩展规律（Scaling Laws）研究。

重点对于模型训练和 scaling law 的研究。针对 7B 与 67B 规模的 LLM，探索了批量大小、学习率的扩展趋势，并分析了数据与模型扩展的最优策略。研究表明，不同数据集会影响扩展规律，因此在不同数据上推广扩展规律需谨慎。

在实践中，构建了全新的开源大模型，预训练数据涵盖2万亿 tokens（主要为中文与英文）。模型架构沿用LLaMA，但调整了学习率策略，以支持持续训练。微调阶段，收集了 100万+ 实例进行 SFT，并采用直接偏好优化（DPO）提升对话质量。

模型各项参数对比

参数 7B 模型 67B 模型
层数（nlayers） 30 层 95 层
总参数量 7B（70 亿） 67B（670 亿）
隐藏层维度（dmodel） 4096 8192
序列长度（Sequence Length） 2304 4608
上下文长度（Context Length） 4096 4096
训练 Token 量 2.0T 2.0T
学习率 4.2e-4 3.2e-4
主要优化点 采用标准 Transformer 结构，适用于计算资源有限的环境 通过增加层数（depth）扩展模型，而非增加 FFN 宽度，提高性能
归一化方法 Pre-Norm 结构，采用 RMSNorm Pre-Norm 结构，采用 RMSNorm
激活函数 SwiGLU SwiGLU
前馈网络（FFN） 8/3 dmodel 8/3 dmodel
位置编码 旋转位置编码（RoPE） 旋转位置编码（RoPE）
注意力机制 标准 MHA Grouped-Query Attention（GQA）
查询头数（nheads） 32 64
键/值头数（nkv_heads） 32 8
主要优化点 采用标准 MHA，不使用 GQA，计算完整性较高 采用 GQA，减少 KV 计算量，提高推理速度，减少 KV Cache 存储需求

什么是 Transformer 的“深度”和“宽度”？

  1. Transformer 的“深度”指的是模型中堆叠的 Transformer 层（Layer）的数量。
  2. “宽度”主要有两个维度：
    • 隐藏层维度（$d_{model}$）：每个 token 被表示成的向量长度，也就是每层的特征维度。比如 $d_{model} = 4096$ 表示每个 token 是用一个 4096 维的向量表示的。
    • 前馈网络中间层维度（FFN 中间宽度）：每层 Transformer 中 FFN（前馈神经网络）模块的隐藏层维度，通常是 4*$d_{model}$ 或更大。

2. 训练策略

AdamW 优化器: 配置如下β₁ = 0.9，β₂ = 0.95，权重衰减（Weight Decay）= 0.1，初始权重使用标准差为 0.006 的正态分布初始化

学习率调度器: Multi-Step Scheduler，相比常见的 Cosine 调度器，DeepSeek 使用了 多阶段学习率调度（multi-step）：Warmup 前 2000 步提升至最大学习率，训练 80% token 后下降为 31.6%，训练 90% token 后降为 10%，保持到训练结束，这种调度方式便于继续训练（continual training），相比 cosine 更灵活。

梯度裁剪: 为了避免梯度爆炸，设置裁剪阈值为：Gradient Clipping = 1.0

随着模型规模变大，Batch Size 增加，学习率相应略微降低。

模型规模 Batch Size 学习率
DeepSeek 7B 2304 4.2e-4
DeepSeek 67B 4608 3.2e-4

DeepSeek 采用了 AdamW + Multi-Step LR + Gradient Clipping 的组合，兼顾了训练稳定性、性能提升和后期可持续训练需求，是大模型训练中的一个高质量参考方案。

3. Scaling Laws

Scaling Law（扩展规律）是指：在固定计算预算下，模型性能如何随着参数量（模型规模）和训练数据量的变化而变化。简单来说，就是在给定资源下，“是加大模型还是多喂数据更有效”？

  1. 超参数扩展规律（Hyperparameter Scaling）

通过拟合得出经验公式（Compute Budget = C）：

$$
\text{Batch Size}{\text{opt}} = 0.292 \cdot C^{0.3271} \\
\text{Learning Rate}{\text{opt}} = 0.3118 \cdot C^{-0.125}
$$

这为训练更大模型时的参数设置提供了数学指导。

  1. 模型规模与数据量的最优分配

$$
M_{\text{opt}} = 0.1715 \cdot C^{0.5243} \
D_{\text{opt}} = 5.8316 \cdot C^{0.4757}
$$

也就是说，在计算量提升时，更多资源应投入在模型扩展上，而不是单纯扩充数据量。

  1. 不同数据质量下的扩展策略变化

这个结论也可以用于反向评估数据质量：如果你在一个数据集上训练时发现更倾向扩大模型，可能说明它质量不错。

验证与预测

Deepseek v2

核心是 Multi-head Latent Attention (MLA) 和 DeepSeekMoE

1. 模型结构

与 v1 版本相比，v2 版本在模型结构上进行了优化，采用了 MoE 结构，并引入了 sparse 稀疏激活技术。

要理解什么是 MoE 模型，首先需要了解什么是 Dense 模型。“Dense 模型”指的是：每一个 token 在每一层都会激活模型中所有的参数进行计算，常见的 GPT-3、LLaMA、ChatGPT 等模型大多属于 dense 模型。

比如一个 Dense 模型总参数量是 70B，那每个 token 的前向计算也用掉这 70B 参数——每层都不落下，每个专家都要参与。

DeepSeek-V2 是 MoE（Mixture-of-Experts）稀疏激活模型，总参数量是 236B，但每次只用其中的一小部分（21B）来进行计算。

Dense vs. MoE 模型对比总结：

Dense 模型（如 DeepSeek 67B） MoE 模型（如 DeepSeek-V2）
总参数量 67B（= 每 token 实际使用） 236B（每 token 实际只用 21B）
每 token 计算量 高（全部参数参与） 低（只激活部分专家）
推理速度 慢，吞吐小 快，吞吐大（提升 5.76x）
KV 缓存 大 小（减少 93.3%）
训练成本 高 低（节省 42.5%）
性能 高 同样甚至更高性能

DeepSeek-V2 的构建过程可分为预训练、监督微调和强化学习三大阶段。首先，模型基于一个规模高达 8.1 万亿 token 的高质量多源语料库进行预训练。与前代模型 DeepSeek 67B 相比，该语料在中文数据的覆盖上显著增强，同时整体数据质量也得到大幅提升。在完成基础预训练后，模型进一步引入了 150 万条多领域对话数据，包括数学、编程、写作、推理与安全等内容，开展监督微调（Supervised Fine-Tuning），形成对话能力较强的 DeepSeek-V2 Chat (SFT) 版本。最后，为了更好地贴合人类偏好，模型采用 GRPO（Group Relative Policy Optimization）强化学习算法进行优化，产出最终版本 DeepSeek-V2 Chat (RL)，在多个任务和场景中展现出优异的对齐能力与交互表现。

科研使用：为进一步推动 MLA 与 DeepSeekMoE 架构的研究与应用，团队还同步开源了轻量级版本模型 —— DeepSeek-V2-Lite。该模型在设计上同样集成了 MLA 与 DeepSeekMoE 两大核心技术，具备优秀的推理效率和训练性价比。V2-Lite 的总参数规模为 15.7B，但每次仅激活 2.4B 参数进行计算，极大降低了资源门槛，适合更广泛的开源社区用户在研究探索和实际部署中使用。

2. 核心模块设计

2.1 Multi-Head Latent Attention

📌 背景问题：传统 MHA 的 KV 缓存很大

在推理时，传统 MHA 要对每一层、每个 token 保留：
• K_t：Key 向量
• V_t：Value 向量

每个 token 要缓存 K_t 和 V_t，维度是 nₕ × dₕ，再乘以层数 l，非常大。

⸻

✅ MLA 的解决方案：低秩联合压缩（Low-Rank Key-Value Joint Compression）

MLA 的核心思想是：

不再分别生成 Key 和 Value，而是先将输入压缩成一个 低维 latent 表示，再从这个 latent 表示中恢复出 Key 和 Value。

🔧 具体步骤如下：

⸻

🧮 Step 1：将输入投影成一个压缩向量（latent vector）

c_{KV_t} = W_{D_{KV}} · h_t

•	h_t 是当前 token 的隐藏状态（维度 d）
•	W_{D_{KV}} 是一个降维矩阵（维度 d_c × d）
•	得到一个 压缩向量 c_{KV_t}，它的维度是 d_c，远小于原始 nₕ × dₕ

⸻

🧮 Step 2：再分别用上采样矩阵恢复 Key 和 Value

k^C_t = W_{U_K} · c_{KV_t}
v^C_t = W_{U_V} · c_{KV_t}

•	W_{U_K} 是用来恢复 Key 的上采样矩阵（维度 nₕ × dₕ × d_c）
•	W_{U_V} 是用来恢复 Value 的上采样矩阵（同理）

注意：这个压缩和恢复操作只在 训练时计算一次，而在 推理时只缓存 c_{KV_t} 这个 latent 向量即可，无需显式存下 K/V。

⸻

🚀 优势是什么？

对比项 传统 MHA MLA（Ours）
缓存内容 每 token 缓存 Key + Value（2 × nₕ × dₕ） 每 token 只缓存一个 latent 向量（d_c）
计算量 正常 更省计算（因为共享路径）
推理内存 非常大 极大缩小（减少 93.3%）
性能 高 更高（没有牺牲性能）

⸻

📌 总结一句话：

MLA 利用 低秩联合压缩 的方式，把 Key 和 Value 压缩成一个小的 latent 向量，大大减小了 KV 缓存，同时保持甚至提升了性能，是 DeepSeek-V2 提速提效的核心技术之一。

⸻

  1. 输入：隐藏状态 $h_t$
    维度为 d，即 Transformer 层的输出。
  2. Step 1：降维
    使用投影矩阵 $W_{D_{KV}}$ 将 $h_t$ 压缩为低维 latent 表示 $c_{KV_t}$。
    输出维度为 $d_c$，大大低于原始的 Key/Value 维度。
  3. Step 2：分别恢复 Key 和 Value
    用 $W_{U_K}$ 将 $c_{KV_t}$ 映射为 Key $k^C_t$。
    用 $W_{U_V}$ 将 $c_{KV_t}$ 映射为 Value $v^C_t$。
    两者维度为 n_h × d_h，用于标准 attention 计算。

伪代码如下

# h_t: hidden state of current token, shape (d,)
# W_D_KV: down-projection matrix, shape (d_c, d)
# W_U_K, W_U_V: up-projection matrices, shape (n_h * d_h, d_c)

# Step 1: Compress
c_KV_t = W_D_KV @ h_t  # shape: (d_c,)

# Step 2: Recover Key and Value
k_C_t = W_U_K @ c_KV_t  # shape: (n_h * d_h,)
v_C_t = W_U_V @ c_KV_t  # shape: (n_h * d_h,)

# Reshape to (n_h, d_h) if needed for multi-head processing
k_C_t = k_C_t.reshape(n_h, d_h)
v_C_t = v_C_t.reshape(n_h, d_h)

你提到的这段内容讲的是 MLA（Multi-head Latent Attention）在训练阶段对 Query 的进一步压缩策略。虽然这个压缩不能减少推理时的 KV cache，但可以 减少训练时的激活内存（activation memory），提升训练效率。下面是逐句解释👇

⸻

🧠 原文解析：

Moreover, in order to reduce the activation memory during training…

此外，为了在训练过程中 减少激活内存的使用（也就是每一步中间结果要暂存的内容），

⸻

…we also perform low-rank compression for the queries, even if it cannot reduce the KV cache:

我们对 Query 也做了低秩压缩（Low-Rank Compression），即使它并不会减少推理时的 KV 缓存大小。
→ 这个压缩是为了 节省训练资源，而不是推理资源。

⸻

c_Q_t = W_DQ · h_t

第一步，把当前 token 的隐藏状态 $h_t$（维度为 $d$）
用一个 下采样矩阵 $W_{DQ}$（维度 $d_c’ × d$） 投影成一个压缩向量 $c_Q_t$。
这个向量的维度是 $d_c’$，远小于原始的 Query 维度。

⸻

q_C_t = WUQ · c_Q_t

然后再用一个 上采样矩阵 $W_{UQ}$（维度 $n_h·d_h × d_c’$）
把 $c_Q_t$ 重新映射成原本的 Query 向量 $q_C_t$（维度为 $n_h × d_h$）。

⸻

✅ 变量说明：

符号 含义
$h_t$ 当前 token 的隐藏状态，维度为 $d$
$c_Q_t$ Query 的低维 latent 表示，维度为 $d_c’$
$q_C_t$ 恢复后的 Query 向量，维度为 $n_h × d_h$
$W_{DQ}$ 压缩用的下采样矩阵，维度 $d_c’ × d$
$W_{UQ}$ 解压用的上采样矩阵，维度 $n_h·d_h × d_c’$

⸻

🔧 总结：为什么这么做？

虽然 Query 的 KV 不需要缓存（因为每次前向都会重新算），但：
• 在训练中，为了反向传播，所有中间变量都要暂存（activation）；
• Query 计算过程也会占用显存，特别是在层数、batch、sequence 较大时；
• 所以通过压缩 Query，可以节省很多训练显存，训练更轻量；

⸻

✅ 一句话总结：

MLA 对 Query 做了低秩压缩，虽然不影响推理时的缓存，但显著减小了训练时的内存压力，是一种 训练效率优化手段。

⸻

能节省多少显存

这是个非常实际的问题。下面我帮你对比一下 MLA 和传统 MHA 在 Query 压缩上的显存节省效果，并给出一个估算过程和总结。

⸻

📌 目标：对比训练阶段的 Query 部分激活内存开销

⸻

✅ 1. 传统 MHA 的 Query 激活存储成本

对于每一个 token，在每一层都要计算：

q_t = W_Q @ h_t

•	W_Q 的输出是 q_t，维度是：n_h × d_h（比如 128 × 128）
•	所以，每个 token、每一层，需要缓存 n_h × d_h 个浮点数作为中间激活

⸻

✅ 2. MLA 中的 Query 压缩策略

MLA 把 Query 的计算改成了两步：

c_Q_t = W_DQ @ h_t # 压缩到低维 latent，维度 d_c’
q_C_t = W_UQ @ c_Q_t # 再上采样回 Query 向量

•	所以在反向传播中，只需要缓存 c_Q_t（维度 d_c’）作为中间激活
•	相比原来的 n_h × d_h，节省了很多内存！

⸻

🧮 举个例子计算一下节省比例：

假设：
• n_h = 128（head 数量）
• d_h = 128（每个 head 的维度）
• d_c’ = 1536（MLA 中 Query 压缩的 latent 维度）

🔹 MHA 的激活存储：

128 × 128 = 16,384 float

🔹 MLA 的激活存储：

c_Q_t: 1536 float

🔹 节省比例：

(1 - 1536 / 16384) ≈ 90.6%

⸻

✅ 结论总结：

方法 每 token 激活量（float 数） 相对节省
MHA n_h × d_h = 16,384 -
MLA d_c’ = 1536 🟢 节省约 90.6% 激活内存

⸻

💡 一句话总结：

MLA 对 Query 的低秩压缩在训练中可 节省约 90% 的 Query 激活内存，尤其在大 batch 和长序列训练时，对显存压力的缓解非常明显。

⸻

2.2 DeepSeekMoE

2. 训练策略

Deepseek v3

MoE架构

根据这一段的描述，新的误差方程和之前的误差方程的主要区别在于专家网络的输出和它们之间的相互依赖性。

  1. 新的误差方程：
    • 每个专家必须输出整个输出向量：在新的误差方程中，每个专家网络都必须生成整个输出向量，而不是仅仅生成一个“剩余”部分来弥补其他专家的误差。这样，专家的目标是直接根据输入数据来生成完整的输出。
    • 专家之间的耦合变弱：尽管仍然存在间接的耦合，因为一个专家的权重变化可能会影响 gating 网络的选择（从而改变专家的分配），但这种耦合的影响不会直接改变专家对某个训练样本的误差。这意味着专家之间的影响减少，每个专家更独立地工作。
    • 责任分配：通过 gating 网络的选择机制，系统会根据每个专家的误差表现来动态分配责任。如果某个专家在某个样本上误差较小（比所有专家的加权平均误差要小），它就会获得更多的责任，反之则减少。最终，系统会倾向于让一个专家专门负责每个训练样本。

  2. 之前的误差方程：
    • 线性组合和残差：之前的误差方程要求每个专家的输出要与其他专家的输出共同作用，最终形成一个加权的输出。为了最小化误差，每个专家的目标是抵消其他专家输出中留下的残差。
    • 强耦合：在这种情况下，由于误差的最小化需要多个专家的合作，专家之间有强耦合，即一个专家的输出变化会影响其他专家的误差和权重。这种合作使得每个专家的学习目标和其他专家的输出密切相关，导致每个任务可能需要多个专家共同参与。

主要区别：
• 输出目标的变化：新的误差函数要求每个专家生成完整的输出向量，而不是仅仅修正残差；这使得每个专家的学习目标更加独立。
• 专家之间的耦合度：新误差函数降低了专家之间的直接耦合，专家的学习不再依赖于其他专家的输出。之前的误差函数则导致了强耦合，多个专家需要共同合作解决每个任务。
• 责任分配的机制：在新的误差函数中，责任分配更加动态和独立，专家根据其表现获得不同的责任，而不是依赖于其他专家的输出。之前的误差函数中，专家的责任更依赖于其他专家的协作。

总结：

新的误差函数鼓励每个专家独立地生成完整的输出并竞争任务的责任，而不是像之前那样依赖于其他专家的输出来补偿误差。这样，系统能更有效地分配任务，减少多个专家共同参与每个任务的情况。

误差函数

好的，我们将继续使用 $E_c = \langle | \mathbf{d_c} - \mathbf{o_{c_i}} |^2 \rangle = \sum_i p_{c_i} | \mathbf{d_c} - \mathbf{o_{c_i}} |^2$ 来举第三个例子，并最终通过表格对比三个误差函数。

  1. 最初的误差函数：
    $$
    E_c = | \mathbf{d_c} - \sum_i p_{c_i} \mathbf{o_{c_i}} |^2
    $$

例子：
• 目标输出：$d_c = [0.5, 0.5]$
• 3 个专家：
• 专家 1 输出：$o_{c_1} = [0.3, 0.7]$，贡献比例：$p_{c_1} = 0.2$
• 专家 2 输出：$o_{c_2} = [0.6, 0.4]$，贡献比例：$p_{c_2} = 0.5$
• 专家 3 输出：$o_{c_3} = [0.4, 0.6]$，贡献比例：$p_{c_3} = 0.3$

步骤 1：计算加权输出
• 专家 1 加权输出：
$p_{c_1} \mathbf{o_{c_1}} = 0.2 \times [0.3, 0.7] = [0.06, 0.14]$
• 专家 2 加权输出：
$p_{c_2} \mathbf{o_{c_2}} = 0.5 \times [0.6, 0.4] = [0.3, 0.2]$
• 专家 3 加权输出：
$p_{c_3} \mathbf{o_{c_3}} = 0.3 \times [0.4, 0.6] = [0.12, 0.18]$

步骤 2：计算总加权输出
$$
\sum_i p_{c_i} \mathbf{o_{c_i}} = [0.06, 0.14] + [0.3, 0.2] + [0.12, 0.18] = [0.48, 0.52]
$$

步骤 3：计算误差
$$
E_c = | \mathbf{d_c} - \sum_i p_{c_i} \mathbf{o_{c_i}} |^2 = | [0.5, 0.5] - [0.48, 0.52] |^2 = (0.02)^2 + (-0.02)^2 = 0.0008
$$

⸻

  1. 当前的误差函数：

$$
E_c = - \log \left( \sum_i p_{c_i} e^{-\frac{1}{2} | \mathbf{d_c} - \mathbf{o_{c_i}} |^2} \right)
$$

例子：
• 目标输出：$d_c = [0.5, 0.5]$
• 3 个专家：
• 专家 1 输出：$o_{c_1} = [0.3, 0.7]$，贡献比例：$p_{c_1} = 0.2$
• 专家 2 输出：$o_{c_2} = [0.6, 0.4]$，贡献比例：$p_{c_2} = 0.5$
• 专家 3 输出：$o_{c_3} = [0.4, 0.6]$，贡献比例：$p_{c_3} = 0.3$

步骤 1：计算每个专家的误差
• 专家 1 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_1}} |^2 = (0.5 - 0.3)^2 + (0.5 - 0.7)^2 = 0.04 + 0.04 = 0.08
$$
$$
e^{-\frac{1}{2} | \mathbf{d_c} - \mathbf{o_{c_1}} |^2} = e^{-\frac{1}{2} \times 0.08} \approx e^{-0.04} \approx 0.961
$$
• 专家 2 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_2}} |^2 = (0.5 - 0.6)^2 + (0.5 - 0.4)^2 = 0.01 + 0.01 = 0.02
$$
$$
e^{-\frac{1}{2} | \mathbf{d_c} - \mathbf{o_{c_2}} |^2} = e^{-\frac{1}{2} \times 0.02} \approx e^{-0.01} \approx 0.990
$$
• 专家 3 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_3}} |^2 = (0.5 - 0.4)^2 + (0.5 - 0.6)^2 = 0.01 + 0.01 = 0.02
$$
$$
e^{-\frac{1}{2} | \mathbf{d_c} - \mathbf{o_{c_3}} |^2} = e^{-\frac{1}{2} \times 0.02} \approx e^{-0.01} \approx 0.990
$$

步骤 2：计算加权概率
$$
E_c = - \log \left( 0.2 \times 0.961 + 0.5 \times 0.990 + 0.3 \times 0.990 \right)
E_c = - \log \left( 0.1922 + 0.495 + 0.297 \right)
E_c = - \log (0.9842) \approx 0.0163

⸻

  1. 新误差函数：

$$
E_c = \langle | \mathbf{d_c} - \mathbf{o_{c_i}} |^2 \rangle = \sum_i p_{c_i} | \mathbf{d_c} - \mathbf{o_{c_i}} |^2
$$

例子：
• 目标输出：$d_c = [0.5, 0.5]$
• 3 个专家：
• 专家 1 输出：$o_{c_1} = [0.3, 0.7]$，贡献比例：$p_{c_1} = 0.2$
• 专家 2 输出：$o_{c_2} = [0.6, 0.4]$，贡献比例：$p_{c_2} = 0.5$
• 专家 3 输出：$o_{c_3} = [0.4, 0.6]$，贡献比例：$p_{c_3} = 0.3$

步骤 1：计算每个专家的误差
• 专家 1 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_1}} |^2 = (0.5 - 0.3)^2 + (0.5 - 0.7)^2 = 0.04 + 0.04 = 0.08
$$
• 专家 2 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_2}} |^2 = (0.5 - 0.6)^2 + (0.5 - 0.4)^2 = 0.01 + 0.01 = 0.02
$$
• 专家 3 的误差：
$$
| \mathbf{d_c} - \mathbf{o_{c_3}} |^2 = (0.5 - 0.4)^2 + (0.5 - 0.6)^2 = 0.01 + 0.01 = 0.02
$$

步骤 2：加权计算误差
$$
E_c = 0.2 \times 0.08 + 0.5 \times 0.02 + 0.3 \times 0.02
E_c = 0.016 + 0.01 + 0.006 = 0.032
$$

⸻

  1. 对比总结：
误差函数 计算方法 最终误差计算
最初的误差函数 加权平均多个专家的输出与目标输出之间的差异，并计算最终输出与目标输出的误差。 计算加权输出与目标输出的平方差，得到误差 0.0008。
当前的误差函数 计算每个专家输出与目标输出之间的误差，使用指数函数对每个专家的贡献进行加权，并通过对数求和得到误差。 通过加权求和计算每个专家贡献，最终得到误差 0.0163。
新误差函数 计算每个专家的输出与目标输出的平方误差，并根据专家的贡献比例加权计算总误差。 计算专家输出与目标输出的平方误差，最终得到误差 0.032。

总结：
• 最初的误差函数 通过多个专家的输出加权平均来计算最终误差，每个专家的目标是修正其他专家的残差。
• 当前的误差函数 使用了指数加权的方式，通过最大化概率来选择合适的专家，较好的专家会被赋予更大的责任。
• 新误差函数 强调了直接计算每个专家的误差，并通过加权来得出最终误差。

本文由 Yonghui Wang 创作，采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名
最后编辑时间为: Apr 17, 2025 04:04 pm

← → ↓ ↑
wireguard
4月 06, 2025
utils
PaperReading:GPT series
3月 18, 2025
paperreading
PaperReading:Deepseek-R1
3月 16, 2025
paperreading
CLIP series
3月 10, 2025
paperreading
linux文件操作
12月 31, 2024
linux
VILA series
11月 25, 2024
paperreading