ylhan/note_sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: ylhan/note_sync:f5b825bd4a3a605278fef1793089d9f8e9f3ed3a
Branches Tags
ylhan/note_sync:main
..
compare: ylhan/note_sync:main
Branches Tags
ylhan/note_sync:main
1 Commits
f5b825bd4a .. main
Author SHA1 Message Date
ylhan 19afe00a86 修正: deepseek 笔记 96 处块级公式改为多行写法(适配 SilverBullet 行首锚点), 索引脚本同步 _abstract 命名 2026-09-21 10:53:11 +08:00
28 changed files with 486 additions and 130 deletions
Expand all files Collapse all files
大模型/deepseek/01-基础模型/01-DeepSeek-LLM-2401.02954_abstract.md
+15 -5
View File
@@ -55,23 +55,33 @@
**超参数缩放定律**：在 1e17 预算的小规模实验上网格搜索批大小与学习率，发现泛化误差在很宽区间内保持稳定；把误差超出最小值不超过 0.25% 的参数视为「近最优」，并借多步调度器复用第一阶段，在 1e17–2e19 训练多组模型拟合得到：
$$\eta_{\mathrm{opt}} = 0.3118 \cdot C^{-0.1250}, \qquad B_{\mathrm{opt}} = 0.2920 \cdot C^{0.3271}$$
$$
\eta_{\mathrm{opt}} = 0.3118 \cdot C^{-0.1250}, \qquad B_{\mathrm{opt}} = 0.2920 \cdot C^{0.3271}
$$
即算力越大，最优批大小越大、学习率越小。作者坦承该式未考虑算力之外的因素，同等算力下不同配比的最优参数空间亦略有差异。
**新的模型规模表示**：$C=6ND$ 忽略了注意力算子的开销（完整参数版本还计入对容量贡献较小的词表计算），小模型上误差可达 50%。作者改用非嵌入 FLOPs/token $M$：
$$6N_1 = 72\,n_{layer}\,d_{model}^{2},\quad 6N_2 = 72\,n_{layer}\,d_{model}^{2}+6\,n_{vocab}\,d_{model}$$
$$
6N_1 = 72\,n_{layer}\,d_{model}^{2},\quad 6N_2 = 72\,n_{layer}\,d_{model}^{2}+6\,n_{vocab}\,d_{model}
$$
$$M = 72\,n_{layer}\,d_{model}^{2}+12\,n_{layer}\,d_{model}\,l_{seq}, \qquad C = MD$$
$$
M = 72\,n_{layer}\,d_{model}^{2}+12\,n_{layer}\,d_{model}\,l_{seq}, \qquad C = MD
$$
其中 $6N_1/M$ 在 0.43–0.92、$6N_2/M$ 在 0.81–1.32 之间，偏差具有系统性。优化目标形式化为：
$$M_{\mathrm{opt}}(C), D_{\mathrm{opt}}(C)=\underset{M,D\ \mathrm{s.t.}\ C=MD}{\mathrm{argmin}} L(N,D)$$
$$
M_{\mathrm{opt}}(C), D_{\mathrm{opt}}(C)=\underset{M,D\ \mathrm{s.t.}\ C=MD}{\mathrm{argmin}} L(N,D)
$$
采用 Chinchilla 的 IsoFLOP profile，取 8 个算力预算（1e17–3e20）、每预算约 10 种配比，超参数由上式确定，泛化误差在含 100M token 的独立验证集上以 bits-per-byte 度量。拟合结果：
$$M_{\mathrm{opt}} = 0.1715 \cdot C^{0.5243}, \qquad D_{\mathrm{opt}} = 5.8316 \cdot C^{0.4757}$$
$$
M_{\mathrm{opt}} = 0.1715 \cdot C^{0.5243}, \qquad D_{\mathrm{opt}} = 5.8316 \cdot C^{0.4757}
$$
即模型规模指数略大于数据规模指数，算力增长应更多投向模型；该曲线成功预测了 7B/67B 性能（小规模实验可预测 1000 倍算力的模型）。
大模型/deepseek/01-基础模型/02-DeepSeekMoE-2401.06066_abstract.md
+24 -8
View File
@@ -23,13 +23,19 @@
论文先给出 Transformer 语言模型中通用的 MoE 范式作为基线。标准 Transformer 语言模型由 $L$ 层 Transformer 块堆叠而成，第 $l$ 层的自注意力与 FFN 计算为：
$$\mathbf{u}_{1:T}^{l} = \operatorname{Self-Att}\left(\mathbf{h}_{1:T}^{l-1}\right) + \mathbf{h}_{1:T}^{l-1}, \qquad \mathbf{h}_{t}^{l} = \operatorname{FFN}\left(\mathbf{u}_{t}^{l}\right) + \mathbf{u}_{t}^{l}$$
$$
\mathbf{u}_{1:T}^{l} = \operatorname{Self-Att}\left(\mathbf{h}_{1:T}^{l-1}\right) + \mathbf{h}_{1:T}^{l-1}, \qquad \mathbf{h}_{t}^{l} = \operatorname{FFN}\left(\mathbf{u}_{t}^{l}\right) + \mathbf{u}_{t}^{l}
$$
构造 MoE 语言模型的典型做法，是按一定间隔把 Transformer 中的 FFN 替换为 MoE 层：每个 MoE 层包含多个结构上与标准 FFN 完全相同的专家，每个 token 被分配给 1 个（Switch Transformer）或 2 个（GShard）专家。第 $l$ 个 FFN 被替换为 MoE 层后，输出隐藏状态为：
$$\mathbf{h}_{t}^{l} = \sum_{i=1}^{N}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}$$
$$
\mathbf{h}_{t}^{l} = \sum_{i=1}^{N}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}
$$
$$g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid 1\leqslant j\leqslant N\},K\right),\\ 0, & \text{otherwise},\end{cases} \qquad s_{i,t} = \operatorname{Softmax}_{i}\left({\mathbf{u}_{t}^{l}}^{T}\mathbf{e}_{i}^{l}\right)$$
$$
g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid 1\leqslant j\leqslant N\},K\right),\\ 0, & \text{otherwise},\end{cases} \qquad s_{i,t} = \operatorname{Softmax}_{i}\left({\mathbf{u}_{t}^{l}}^{T}\mathbf{e}_{i}^{l}\right)
$$
其中 $N$ 为专家总数，$\mathbf{e}_{i}^{l}$ 是第 $l$ 层第 $i$ 个专家的质心（centroid），$s_{i,t}$ 为 token 与专家的亲和度，$g_{i,t}$ 为门控值。$g_{i,t}$ 的稀疏性（$N$ 个门控值中只有 $K$ 个非零）保证了 MoE 层的计算效率——每个 token 只在 $K$ 个专家中被计算。
@@ -39,7 +45,9 @@ $$g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t
针对知识混杂，论文的做法是：在保持专家参数量与计算成本不变的前提下，把每个专家 FFN 的中间隐藏维度压缩到原来的 $1/m$，从而把一个专家切成 $m$ 个更小的专家；由于每个专家变小了，相应地把激活专家数也提高到 $m$ 倍，以维持相同的计算量。公式上只需把 top-$K$ 的求和范围从 $N$ 扩到 $mN$、把激活数从 $K$ 扩到 $mK$：
$$\mathbf{h}_{t}^{l} = \sum_{i=1}^{mN}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}, \qquad g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid 1\leqslant j\leqslant mN\},mK\right),\\ 0, & \text{otherwise},\end{cases}$$
$$
\mathbf{h}_{t}^{l} = \sum_{i=1}^{mN}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}, \qquad g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid 1\leqslant j\leqslant mN\},mK\right),\\ 0, & \text{otherwise},\end{cases}
$$
其收益可以从组合数上直观理解：当 $N=16$ 时，典型 top-2 路由只有 $\binom{16}{2}=120$ 种激活组合；若把每个专家切成 4 个小专家，细粒度路由的可能组合数变成 $\binom{64}{8}=4{,}426{,}165{,}368$。组合灵活性的暴涨意味着模型能更精确、更有针对性地组装所需知识，而落在每个小专家上的知识类型更单一，专家因此能保持更高的专业化程度。
@@ -47,9 +55,13 @@ $$\mathbf{h}_{t}^{l} = \sum_{i=1}^{mN}\left(g_{i,t}\operatorname{FFN}_{i}\left(\
针对知识冗余，论文隔离出 $K_{s}$ 个专家作为**共享专家**：不管路由器怎么算，每个 token 都会被确定性地分配给这些共享专家，由它们专门捕捉并沉淀跨上下文通用的知识。为了保证计算量不变，路由专家中被激活的专家数相应减少 $K_{s}$ 个。完整的 DeepSeekMoE 层可写为：
$$\mathbf{h}_{t}^{l} = \sum_{i=1}^{K_{s}}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right) + \sum_{i=K_{s}+1}^{mN}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}$$
$$
\mathbf{h}_{t}^{l} = \sum_{i=1}^{K_{s}}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right) + \sum_{i=K_{s}+1}^{mN}\left(g_{i,t}\operatorname{FFN}_{i}\left(\mathbf{u}_{t}^{l}\right)\right) + \mathbf{u}_{t}^{l}
$$
$$g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid K_{s}+1\leqslant j\leqslant mN\},mK-K_{s}\right),\\ 0, & \text{otherwise},\end{cases} \qquad s_{i,t} = \operatorname{Softmax}_{i}\left({\mathbf{u}_{t}^{l}}^{T}\mathbf{e}_{i}^{l}\right)$$
$$
g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t}\mid K_{s}+1\leqslant j\leqslant mN\},mK-K_{s}\right),\\ 0, & \text{otherwise},\end{cases} \qquad s_{i,t} = \operatorname{Softmax}_{i}\left({\mathbf{u}_{t}^{l}}^{T}\mathbf{e}_{i}^{l}\right)
$$
于是在 DeepSeekMoE 中：共享专家数为 $K_{s}$，路由专家总数为 $mN-K_{s}$，非零门控数为 $mK-K_{s}$。作者说明，共享专家隔离的原型可追溯到 Rajbhandari et al. (2022)，关键区别在于后者是从工程视角出发，而本文是从算法视角出发，把它作为提升专家专精的手段。
@@ -59,11 +71,15 @@ $$g_{i,t} = \begin{cases} s_{i,t}, & s_{i,t}\in\operatorname{Topk}\left(\{s_{j,t
**专家级均衡损失**用于缓解路由崩塌，定义如下（$N'=mN-K_{s}$，$K'=mK-K_{s}$，$\mathbb{1}(\cdot)$ 为指示函数，$\alpha_{1}$ 为专家级均衡因子）：
$$\mathcal{L}_{\mathrm{ExpBal}} = \alpha_{1}\sum_{i=1}^{N'} f_{i}P_{i}, \quad f_{i} = \frac{N'}{K'T}\sum_{t=1}^{T}\mathbb{1}(\text{Token } t \text{ selects Expert } i), \quad P_{i} = \frac{1}{T}\sum_{t=1}^{T}s_{i,t}$$
$$
\mathcal{L}_{\mathrm{ExpBal}} = \alpha_{1}\sum_{i=1}^{N'} f_{i}P_{i}, \quad f_{i} = \frac{N'}{K'T}\sum_{t=1}^{T}\mathbb{1}(\text{Token } t \text{ selects Expert } i), \quad P_{i} = \frac{1}{T}\sum_{t=1}^{T}s_{i,t}
$$
**设备级均衡损失**则针对跨设备计算均衡。作者强调：过度强制专家级均衡会损害模型性能，因此不必在专家层面做严格约束，真正要保证的是设备之间计算量均衡。把全部路由专家划分为 $D$ 组 $\{\mathcal{E}_{1},\dots,\mathcal{E}_{D}\}$ 并每组部署在一个设备上后：
$$\mathcal{L}_{\mathrm{DevBal}} = \alpha_{2}\sum_{i=1}^{D} f_{i}'P_{i}', \quad f_{i}' = \frac{1}{|\mathcal{E}_{i}|}\sum_{j\in\mathcal{E}_{i}} f_{j}, \quad P_{i}' = \sum_{j\in\mathcal{E}_{i}} P_{j}$$
$$
\mathcal{L}_{\mathrm{DevBal}} = \alpha_{2}\sum_{i=1}^{D} f_{i}'P_{i}', \quad f_{i}' = \frac{1}{|\mathcal{E}_{i}|}\sum_{j\in\mathcal{E}_{i}} f_{j}, \quad P_{i}' = \sum_{j\in\mathcal{E}_{i}} P_{j}
$$
实践中的取舍是：专家级均衡因子设得较小（防止路由崩塌即可），设备级均衡因子设得较大（促进设备间计算均衡）。
大模型/deepseek/01-基础模型/04-DeepSeek-V3-2412.19437_abstract.md
+18 -6
View File
@@ -26,15 +26,23 @@ DeepSeek-V3 仍在 Transformer 框架内，沿用 DeepSeek-V2 的 MLA + DeepSeek
**MLA 的核心是对键值（KV）做低秩联合压缩**，以削减推理时的 KV 缓存：
$$\mathbf{c}_t^{KV} = W^{DKV}\mathbf{h}_t,\qquad [\mathbf{k}_{t,1}^C;\dots;\mathbf{k}_{t,n_h}^C]=\mathbf{k}_t^C = W^{UK}\mathbf{c}_t^{KV}$$
$$\mathbf{k}_t^R = \operatorname{RoPE}(W^{KR}\mathbf{h}_t),\qquad \mathbf{k}_{t,i}=[\mathbf{k}_{t,i}^C;\mathbf{k}_t^R],\qquad \mathbf{v}_t^C = W^{UV}\mathbf{c}_t^{KV}$$
$$\mathbf{o}_{t,i}=\sum_{j=1}^{t}\operatorname{Softmax}_j\!\left(\frac{\mathbf{q}_{t,i}^{T}\mathbf{k}_{j,i}}{\sqrt{d_h+d_h^{R}}}\right)\mathbf{v}_{j,i}^{C},\qquad \mathbf{u}_t=W^{O}[\mathbf{o}_{t,1};\dots;\mathbf{o}_{t,n_h}]$$
$$
\mathbf{c}_t^{KV} = W^{DKV}\mathbf{h}_t,\qquad [\mathbf{k}_{t,1}^C;\dots;\mathbf{k}_{t,n_h}^C]=\mathbf{k}_t^C = W^{UK}\mathbf{c}_t^{KV}
$$
$$
\mathbf{k}_t^R = \operatorname{RoPE}(W^{KR}\mathbf{h}_t),\qquad \mathbf{k}_{t,i}=[\mathbf{k}_{t,i}^C;\mathbf{k}_t^R],\qquad \mathbf{v}_t^C = W^{UV}\mathbf{c}_t^{KV}
$$
$$
\mathbf{o}_{t,i}=\sum_{j=1}^{t}\operatorname{Softmax}_j\!\left(\frac{\mathbf{q}_{t,i}^{T}\mathbf{k}_{j,i}}{\sqrt{d_h+d_h^{R}}}\right)\mathbf{v}_{j,i}^{C},\qquad \mathbf{u}_t=W^{O}[\mathbf{o}_{t,1};\dots;\mathbf{o}_{t,n_h}]
$$
其中 $\mathbf{c}_t^{KV}\in\mathbb{R}^{d_c}$（$d_c\ll d_h n_h$）为 KV 压缩潜在向量，$W^{KR}$ 产生携带 RoPE 的解耦键。**推理时只需缓存 $\mathbf{c}_t^{KV}$ 与 $\mathbf{k}_t^R$**，KV 缓存大幅缩小而性能与标准多头注意力相当；查询侧同样低秩压缩。
**DeepSeekMoE 相比 GShard 用更细粒度专家并隔离出共享专家**：
$$\mathbf{h}_t'=\mathbf{u}_t+\sum_{i=1}^{N_s}\operatorname{FFN}_i^{(s)}(\mathbf{u}_t)+\sum_{i=1}^{N_r}g_{i,t}\operatorname{FFN}_i^{(r)}(\mathbf{u}_t),\qquad s_{i,t}=\operatorname{Sigmoid}(\mathbf{u}_t^{T}\mathbf{e}_i)$$
$$
\mathbf{h}_t'=\mathbf{u}_t+\sum_{i=1}^{N_s}\operatorname{FFN}_i^{(s)}(\mathbf{u}_t)+\sum_{i=1}^{N_r}g_{i,t}\operatorname{FFN}_i^{(r)}(\mathbf{u}_t),\qquad s_{i,t}=\operatorname{Sigmoid}(\mathbf{u}_t^{T}\mathbf{e}_i)
$$
与 V2 不同：**V3 用 sigmoid 计算亲和度，并对选中的亲和度归一化得到门控值**。
@@ -42,7 +50,9 @@ $$\mathbf{h}_t'=\mathbf{u}_t+\sum_{i=1}^{N_s}\operatorname{FFN}_i^{(s)}(\mathbf{
负载不均会导致路由崩溃并削弱专家并行的效率，而辅助损失过大又损害性能。V3 把均衡信号从损失挪进路由：为每个专家引入偏置 $b_i$，用它参与 top-$K$ 路由决策，
$$g'_{i,t}=\begin{cases}s_{i,t}, & s_{i,t}+b_i\in\operatorname{Topk}(\{s_{j,t}+b_j\},K_r)\\ 0, & \text{otherwise}\end{cases}$$
$$
g'_{i,t}=\begin{cases}s_{i,t}, & s_{i,t}+b_i\in\operatorname{Topk}(\{s_{j,t}+b_j\},K_r)\\ 0, & \text{otherwise}\end{cases}
$$
**偏置只参与路由、不参与门控**。训练中每步监控批内负载：过载减 $\gamma$、欠载加 $\gamma$（前 14.3T token 取 0.001）；另用极小的序列级互补辅助损失（$\mathcal{L}_{\mathrm{Bal}}=\alpha\sum_i f_iP_i$，$\alpha=0.0001$）防单序列内极端失衡，并用节点受限路由限制每 token 至多发往 $M=4$ 个节点。均衡良好，故**训练与推理均不丢弃 token**。
@@ -50,7 +60,9 @@ $$g'_{i,t}=\begin{cases}s_{i,t}, & s_{i,t}+b_i\in\operatorname{Topk}(\{s_{j,t}+b
与 Gloeckle 等人并行预测 $D$ 个额外 token 不同，V3 **顺序预测并保持完整因果链**。第 $k$ 个 MTP 模块含共享嵌入层、共享输出头、Transformer 块与投影矩阵 $M_k\in\mathbb{R}^{d\times 2d}$：
$$\mathbf{h}_i'^{k}=M_k[\operatorname{RMSNorm}(\mathbf{h}_i^{k-1});\operatorname{RMSNorm}(\operatorname{Emb}(t_{i+k}))],\qquad \mathbf{h}_{1:T-k}^{k}=\operatorname{TRM}_k(\mathbf{h}_{1:T-k}'^{k}),\qquad P_{i+k+1}^{k}=\operatorname{OutHead}(\mathbf{h}_i^{k})$$
$$
\mathbf{h}_i'^{k}=M_k[\operatorname{RMSNorm}(\mathbf{h}_i^{k-1});\operatorname{RMSNorm}(\operatorname{Emb}(t_{i+k}))],\qquad \mathbf{h}_{1:T-k}^{k}=\operatorname{TRM}_k(\mathbf{h}_{1:T-k}'^{k}),\qquad P_{i+k+1}^{k}=\operatorname{OutHead}(\mathbf{h}_i^{k})
$$
训练目标是各深度交叉熵损失的加权平均 $\mathcal{L}_{\text{MTP}}=\frac{\lambda}{D}\sum_{k=1}^{D}\mathcal{L}_{\text{MTP}}^{k}$。**推理时 MTP 模块可整体丢弃**，也可复用为投机解码。
大模型/deepseek/01-基础模型/05-DeepSeek-V3.2-2512.02556_abstract.md
+12 -4
View File
@@ -23,11 +23,15 @@
论文把开闭源模型差距归因于三点：朴素注意力令长序列低效、后训练算力不足、智能体泛化与指令遵循落后；DSA 针对第一点，由闪电索引器（lightning indexer）与细粒度 token 选择组成。索引器为查询与前序 token 打分：
$$I_{t,s}=\sum_{j=1}^{H^{I}}w_{t,j}^{I}\cdot\text{ReLU}\left(\mathbf{q}^{I}_{t,j}\cdot\mathbf{k}^{I}_{s}\right)$$
$$
I_{t,s}=\sum_{j=1}^{H^{I}}w_{t,j}^{I}\cdot\text{ReLU}\left(\mathbf{q}^{I}_{t,j}\cdot\mathbf{k}^{I}_{s}\right)
$$
选 ReLU 纯为吞吐考虑；索引器头数少且可用 FP8，故效率很高。之后只对 top-$k$ 分数对应的键值条目做注意力：
$$\mathbf{u}_{t}=\text{Attn}\left(\mathbf{h}_t,\left\{\mathbf{c}_s \mid I_{t,s}\in\text{Top-k}\left(I_{t,:}\right)\right\}\right)$$
$$
\mathbf{u}_{t}=\text{Attn}\left(\mathbf{h}_t,\left\{\mathbf{c}_s \mid I_{t,s}\in\text{Top-k}\left(I_{t,:}\right)\right\}\right)
$$
为便于从 V3.1-Terminus 继续训练，DSA 实例化在 MLA 的 MQA 模式上，使每个潜向量被同一查询 token 的所有查询头共享——这是内核层面的硬约束：各头独立选 top-$k$ 反而低效。
@@ -35,11 +39,15 @@ $$\mathbf{u}_{t}=\text{Attn}\left(\mathbf{h}_t,\left\{\mathbf{c}_s \mid I_{t,s}\
起点是上下文已扩至 128K 的 V3.1-Terminus 基座，两阶段数据分布与之对齐。稠密预热保持稠密注意力、冻结除索引器外全部参数，把主注意力分数沿头求和后沿序列 L1 归一化得目标分布 $p_{t,:}$，以 KL 散度训练索引器：
$$\mathcal{L}^{I}=\sum_{t}\mathbb{D}_{\mathrm{KL}}\left(p_{t,:}\,\middle\|\,\text{Softmax}\left(I_{t,:}\right)\right)$$
$$
\mathcal{L}^{I}=\sum_{t}\mathbb{D}_{\mathrm{KL}}\left(p_{t,:}\,\middle\|\,\text{Softmax}\left(I_{t,:}\right)\right)
$$
学习率 $10^{-3}$，1000 步 × 16 条 128K 序列，共 2.1B tokens。稀疏训练引入选择机制并优化全部参数以适应稀疏模式，索引器只在被选集合 $\mathcal{S}_t$ 上对齐：
$$\mathcal{L}^{I}=\sum_{t}\mathbb{D}_{\mathrm{KL}}\left(p_{t,\mathcal{S}_t}\,\middle\|\,\text{Softmax}\left(I_{t,\mathcal{S}_t}\right)\right)$$
$$
\mathcal{L}^{I}=\sum_{t}\mathbb{D}_{\mathrm{KL}}\left(p_{t,\mathcal{S}_t}\,\middle\|\,\text{Softmax}\left(I_{t,\mathcal{S}_t}\right)\right)
$$
关键设计是把索引器输入从计算图 detach，索引器只由 $\mathcal{L}^I$ 训练、主模型只按语言建模损失优化，二者解耦。此阶段学习率 $7.3\times10^{-6}$，每查询选 2048 个键值 token，15000 步 × 480 条 128K 序列，共 943.7B tokens。
大模型/deepseek/01-基础模型/06-DeepSeek-V4-2606.19348_abstract.md
+9 -3
View File
@@ -28,11 +28,15 @@
标准超连接（HC）把残差流宽度扩大 $n_{\text{hc}}$ 倍，引入输入映射 $A_l$、残差变换 $B_l$、输出映射 $C_l$：
$$X_{l+1}=B_lX_l+C_l\mathcal{F}_l(A_lX_l)$$
$$
X_{l+1}=B_lX_l+C_l\mathcal{F}_l(A_lX_l)
$$
它把残差宽度与隐藏维度解耦，提供开销很小的额外扩展轴（$n_{\text{hc}}\ll d$），但多层堆叠时训练频繁数值不稳定。mHC 的核心是把 $B_l$ 约束到双随机矩阵（Birkhoff 多面体）流形：
$$B_l\in\mathcal{M}\coloneq\{M\in\mathbb{R}^{n\times n}\mid M\mathbf{1}_n=\mathbf{1}_n,\ \mathbf{1}_n^{T}M=\mathbf{1}_n^{T},\ M\geqslant 0\}$$
$$
B_l\in\mathcal{M}\coloneq\{M\in\mathbb{R}^{n\times n}\mid M\mathbf{1}_n=\mathbf{1}_n,\ \mathbf{1}_n^{T}M=\mathbf{1}_n^{T},\ M\geqslant 0\}
$$
该约束保证 $\|B_l\|_2\le 1$、残差变换非扩张，且 $\mathcal{M}$ 对乘法封闭，故深层堆叠仍稳定；$A_l$、$C_l$ 另用 Sigmoid 约束为非负有界以避免信号抵消。三个映射的参数动态生成（输入相关项 + 静态偏置 + 小初始化门控因子），投影到流形用 Sinkhorn-Knopp 迭代（先 $\exp$ 保证正性，再反复行列归一化，$t_{\max}=20$）。
@@ -61,7 +65,9 @@ Muon 用于绝大多数模块，embedding、预测头、mHC 的静态偏置与
后训练沿用 V3.2 流水线，但用同策略蒸馏（OPD）取代混合 RL：先按领域独立训练专家（SFT + GRPO），难验证的任务放弃标量奖励模型，改为在 rubric 引导下用生成式奖励模型（GRM）评价轨迹并把 RL 施加于 GRM 自身；随后用十余个教师模型做多教师 OPD 合并进单一学生：
$$\mathcal{L}_{\text{OPD}}(\theta)=\sum_{i=1}^{N}w_i\cdot \mathrm{D}_{\text{KL}}\!\left(\pi_\theta\parallel\pi_{E_i}\right)$$
$$
\mathcal{L}_{\text{OPD}}(\theta)=\sum_{i=1}^{N}w_i\cdot \mathrm{D}_{\text{KL}}\!\left(\pi_\theta\parallel\pi_{E_i}\right)
$$
与以往把全词表 KL 简化为逐 token 估计不同，此处保留完整 logit 分布以降低梯度方差。基础设施还包括作用于 MoE 专家权重与 CSA 索引器 QK 路径的 FP4 量化感知训练（top-k 选择器加速 2×，保留 99.7% KV 召回）。
大模型/deepseek/01-基础模型/07-DeepSeek-V4.1-Flash-2609.19969_abstract.md
+9 -3
View File
@@ -32,7 +32,9 @@
CED 针对智能体频繁工具调用造成的预填充瓶颈（受 YOCO 启发）：底部 $L/2$ 层作因果编码器，解码器（$l>L/2$）的 KV 条目与压缩权重改由编码器末层隐状态 $H_{L/2}$ 逐层投影得到，
$$C_l=H_{L/2}W_l^{KV},\qquad Z_l=H_{L/2}W_l^{Z}$$
$$
C_l=H_{L/2}W_l^{KV},\qquad Z_l=H_{L/2}W_l^{Z}
$$
故预填充只需算前一半层。SWA 仍逐层计算以保持局部表示深度，代价是解码器 SWA KV 需额外处理 $n_{\mathrm{win}}\times L/2$ 个 token——这引出解码器有界重放；与 CSA2 结合时，解码器 Full 模式层直接由 $H_{L/2}$ 计算全局 KV。
@@ -48,7 +50,9 @@ $$C_l=H_{L/2}W_l^{KV},\qquad Z_l=H_{L/2}W_l^{Z}$$
**Single-Pass m HC**：m HC 在相邻块间维持 $n$ 条残差流；V4 的三内核实现因数据依赖串行，激活访存达 $(4n+4)d$，而理想下界为 $(2n+2)d$。Single-Pass 把输入混合系数后移一个块，
$$X_{l+1}=B_lX_l+C_l\mathcal{F}_l(A_{l-1}X_l)$$
$$
X_{l+1}=B_lX_l+C_l\mathcal{F}_l(A_{l-1}X_l)
$$
使输入混合不再依赖由 $X_l$ 算出的系数，分块可立即同时用于输入混合与系数预测，达到 $(2n+2)d$ 的理想访存而实测损失可忽略；部署侧融合内核 Mega-m HC 把激活访存减半。**Engram**：沿用 tokenizer 压缩、多头哈希与门控集成，去掉短因果卷积，196B 参数均分两模块（$N$-gram 阶 $\{2,3,4\}$、8 哈希头、FP8），置于第 1、14 层，推理时经 RDMA 从主机内存预取。**DSpark**：3 个窗口 128 的块一次前向并行产出 5 个草稿位置 logits，Markov 头建模草稿间依赖、置信头估计前缀存活概率以选取验证长度；它预训练后单独训练，后训练同训但梯度不回传主干。
@@ -68,7 +72,9 @@ V4 已对 indexer 的 Q/K 使用 FP4 的 QAT；V4.1 把 QAT 扩展到主 KV，
后训练仍是 SFT → RL → OPD 且无算法改动，收益来自数据与环境：任务形式化为（问题、环境、验证系统）三元组；环境侧，通用智能体由伙伴回传的交互数据构建模拟工具，编码智能体取自内部编码会话与达星标公开仓库。RL 在算力与 scaffold 两维扩展；异步 rollout 与训练共置、按样本级派发维持并发；末段为多域全词表 OPD，用 40 多个可与学生异构的教师。可控推理力度方面，系统提示前插入 `Reasoning Effort: {effort}`（$b\in\{1,\dots,100\}$），同 $(x,b)$ 子组内做奖励均值中心化，长度惩罚
$$r_{b,j}^{\mathrm{len}}=-\min\left\{C_{\max},\;k(b)\frac{\ell_{b,j}}{L_{\mathrm{norm}}}\right\},\qquad k(b)=k_{0}\exp\left(-\frac{b-b_{\min}}{\tau}\right)$$
$$
r_{b,j}^{\mathrm{len}}=-\min\left\{C_{\max},\;k(b)\frac{\ell_{b,j}}{L_{\mathrm{norm}}}\right\},\qquad k(b)=k_{0}\exp\left(-\frac{b-b_{\min}}{\tau}\right)
$$
随请求力度指数衰减；公开 API 映射为 max=100、high=75、low=50 三档。
大模型/deepseek/02-代码模型/02-DeepSeek-Coder-V2-2406.11931_abstract.md
+3 -1
View File
@@ -35,7 +35,9 @@ Common Crawl 部分沿用 DeepSeekMath 的迭代召回流程：以 StackOverflow
DeepSeek-Coder-V2 16B 同时使用两个训练目标——下一词预测（Next-Token-Prediction, NTP）与中间填充（Fill-In-the-Middle, FIM）；236B 版本只使用 NTP。FIM 采用 PSM（Prefix, Suffix, Middle）模式，在文档级别的预打包阶段把内容重排为「前缀—后缀—中间」的重建序列：
$$\texttt{<｜fim\_begin｜>}f_{pre}\texttt{<｜fim\_hole｜>}f_{suf}\texttt{<｜fim\_end｜>}f_{middle}\texttt{<|eos\_token|>}$$
$$
\texttt{<｜fim\_begin｜>}f_{pre}\texttt{<｜fim\_hole｜>}f_{suf}\texttt{<｜fim\_end｜>}f_{middle}\texttt{<|eos\_token|>}
$$
FIM 的使用率为 0.5。这样设计的动因是：IDE 里的代码补全场景往往是「已知前后文、要补中间的空洞」，纯因果语言建模无法直接建模这种结构，而 FIM 让模型学会利用前后文双向线索完成缺省片段。
大模型/deepseek/03-数学模型/01-DeepSeekMath-2402.03300_abstract.md
+21 -7
View File
@@ -42,29 +42,41 @@ DeepSeekMath-Base 7B 以代码模型 DeepSeek-Coder-Base-v1.5 7B 为起点（论
PPO 通过最大化如下代理目标优化策略：
$$\mathcal{J}_{PPO}(\theta)=\mathbb{E}_{q\sim P(Q),\,o\sim\pi_{\theta_{old}}(O|q)}\frac{1}{|o|}\sum_{t=1}^{|o|}\min\left[\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{\theta_{old}}(o_t|q,o_{<t})}A_t,\ \mathrm{clip}\left(\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{\theta_{old}}(o_t|q,o_{<t})},1-\varepsilon,1+\varepsilon\right)A_t\right]$$
$$
\mathcal{J}_{PPO}(\theta)=\mathbb{E}_{q\sim P(Q),\,o\sim\pi_{\theta_{old}}(O|q)}\frac{1}{|o|}\sum_{t=1}^{|o|}\min\left[\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{\theta_{old}}(o_t|q,o_{<t})}A_t,\ \mathrm{clip}\left(\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{\theta_{old}}(o_t|q,o_{<t})},1-\varepsilon,1+\varepsilon\right)A_t\right]
$$
其中优势 $A_t$ 由广义优势估计（GAE）基于奖励 $\{r_{\ge t}\}$ 与价值函数 $V_{\psi}$ 计算；为抑制对奖励模型的过度优化，标准做法是在每个 token 的奖励中加入参考模型的 KL 惩罚：
$$r_t = r_{\varphi}(q,o_{\le t}) - \beta\log\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{ref}(o_t|q,o_{<t})}$$
$$
r_t = r_{\varphi}(q,o_{\le t}) - \beta\log\frac{\pi_{\theta}(o_t|q,o_{<t})}{\pi_{ref}(o_t|q,o_{<t})}
$$
GRPO 针对两个痛点：PPO 的价值函数通常与策略模型规模相当，带来可观的显存与计算负担；且 LLM 场景中往往只有最后一个 token 被奖励模型打分，逐 token 准确的价值函数很难训练。因此 GRPO 不做价值函数近似，而是对同一问题 $q$ 从旧策略 $\pi_{\theta_{old}}$ 采样一组输出 $\{o_1,\dots,o_G\}$，以组内平均奖励为基线，最大化：
$$\mathcal{J}_{GRPO}(\theta)=\mathbb{E}_{q\sim P(Q),\,\{o_i\}_{i=1}^{G}\sim\pi_{\theta_{old}}(O|q)}\frac{1}{G}\sum_{i=1}^{G}\frac{1}{|o_i|}\sum_{t=1}^{|o_i|}\left\{\min\left[\frac{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q,o_{i,<t})}\hat{A}_{i,t},\ \mathrm{clip}\left(\frac{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q,o_{i,<t})},1-\varepsilon,1+\varepsilon\right)\hat{A}_{i,t}\right]-\beta\,\mathbb{D}_{KL}\left[\pi_{\theta}||\pi_{ref}\right]\right\}$$
$$
\mathcal{J}_{GRPO}(\theta)=\mathbb{E}_{q\sim P(Q),\,\{o_i\}_{i=1}^{G}\sim\pi_{\theta_{old}}(O|q)}\frac{1}{G}\sum_{i=1}^{G}\frac{1}{|o_i|}\sum_{t=1}^{|o_i|}\left\{\min\left[\frac{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q,o_{i,<t})}\hat{A}_{i,t},\ \mathrm{clip}\left(\frac{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q,o_{i,<t})},1-\varepsilon,1+\varepsilon\right)\hat{A}_{i,t}\right]-\beta\,\mathbb{D}_{KL}\left[\pi_{\theta}||\pi_{ref}\right]\right\}
$$
其中 $\hat{A}_{i,t}$ 只基于组内各输出的相对奖励计算，这与奖励模型的比较本质相契合——奖励模型通常就在同一问题的多输出比较数据上训练。与 PPO 把 KL 惩罚加进奖励不同，GRPO 直接把 KL 散度加进损失，从而不干扰 $\hat{A}_{i,t}$ 的计算，并采用保证非负的无偏估计量：
$$\mathbb{D}_{KL}\left[\pi_{\theta}||\pi_{ref}\right]=\frac{\pi_{ref}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}-\log\frac{\pi_{ref}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}-1$$
$$
\mathbb{D}_{KL}\left[\pi_{\theta}||\pi_{ref}\right]=\frac{\pi_{ref}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}-\log\frac{\pi_{ref}(o_{i,t}|q,o_{i,<t})}{\pi_{\theta}(o_{i,t}|q,o_{i,<t})}-1
$$
### 3.5 结果监督、过程监督与迭代式 RL
**结果监督**：奖励模型只对每个输出给一个末尾分数，奖励经组内去均值、除标准差归一化后赋给该输出所有 token 的优势：
$$\hat{A}_{i,t}=\widetilde{r}_i=\frac{r_i-\mathrm{mean}(\mathbf{r})}{\mathrm{std}(\mathbf{r})}$$
$$
\hat{A}_{i,t}=\widetilde{r}_i=\frac{r_i-\mathrm{mean}(\mathbf{r})}{\mathrm{std}(\mathbf{r})}
$$
**过程监督**：论文认为结果监督只在末尾给一次奖励，对复杂数学任务不够充分高效，故沿 Wang et al. (2023b) 在每步推理结束时给奖励。设第 $j$ 步结束 token 索引为 $index(j)$、第 $i$ 个输出共 $K_i$ 步，全部步骤奖励整体归一化 $\widetilde{r}_i^{index(j)}=\dfrac{r_i^{index(j)}-\mathrm{mean}(\mathbf{R})}{\mathrm{std}(\mathbf{R})}$，再以「后续各步归一化奖励之和」作为该 token 优势：
$$\hat{A}_{i,t}=\sum_{index(j)\ge t}\widetilde{r}_i^{index(j)}$$
$$
\hat{A}_{i,t}=\sum_{index(j)\ge t}\widetilde{r}_i^{index(j)}
$$
**迭代式 RL**：随训练推进，旧奖励模型可能不再足以监督当前策略。算法 1 每轮先把当前策略复制为参考模型，用其采样结果构造奖励模型的新数据，并以混入 10% 历史数据的 replay 机制持续训练旧奖励模型，再用新模型继续训练策略。
@@ -72,7 +84,9 @@ $$\hat{A}_{i,t}=\sum_{index(j)\ge t}\widetilde{r}_i^{index(j)}$$
论文把各类方法的梯度统一写为：
$$\nabla_{\theta}\mathcal{J}_{\mathcal{A}}(\theta)=\mathbb{E}_{(q,o)\sim\mathcal{D}}\left(\frac{1}{|o|}\sum_{t=1}^{|o|}GC_{\mathcal{A}}(q,o,t,\pi_{rf})\,\nabla_{\theta}\log\pi_{\theta}(o_t|q,o_{<t})\right)$$
$$
\nabla_{\theta}\mathcal{J}_{\mathcal{A}}(\theta)=\mathbb{E}_{(q,o)\sim\mathcal{D}}\left(\frac{1}{|o|}\sum_{t=1}^{|o|}GC_{\mathcal{A}}(q,o,t,\pi_{rf})\,\nabla_{\theta}\log\pi_{\theta}(o_t|q,o_{<t})\right)
$$
三个关键组件是数据来源 $\mathcal{D}$、奖励函数 $\pi_{rf}$ 与算法 $\mathcal{A}$（把数据与奖励信号加工成决定奖惩力度的梯度系数 $GC$）。据此，SFT 用人工数据、梯度系数恒为 1；RFT 以 SFT 模型离线采样输出按答案正确性筛选；DPO 用成对偏好损失在 SFT 采样输出上优化；Online RFT 改用实时策略的采样输出；PPO/GRPO 用模型奖励信号强化实时采样输出。观察结论是：在线采样显著优于离线采样，优势主要体现在训练后期；GRPO 的独特之处是依据奖励值调节梯度系数，对不同质量回答做差异化强化与惩罚，而 Online RFT 不惩罚错误回答、对正确回答一律等强度强化；结果监督（GRPO+OS）不如过程监督（GRPO+PS），说明细粒度、步骤感知的梯度系数更有益。
大模型/deepseek/03-数学模型/02-DeepSeekMath-V2-2511.22570_abstract.md
+12 -4
View File
@@ -27,11 +27,15 @@
验证器在 DeepSeek-V3.2-Exp-SFT 上用强化学习训练，奖励由两部分相乘：**格式奖励** $R_{\text{format}}$ 检查回复是否含有关键句「Here is my evaluation of the solution:」以及「Based on my evaluation, the final overall score should be:」之后 `\boxed{}` 内的分数；**分数奖励** $R_{\text{score}}$ 衡量预测分数与标注分数的接近程度：
$$R_{\text{score}}(s_{i}',s_{i}) = 1 - |s_{i}' - s_{i}|$$
$$
R_{\text{score}}(s_{i}',s_{i}) = 1 - |s_{i}' - s_{i}|
$$
优化目标为：
$$\max_{\pi_{\varphi}} \mathbb{E}_{(X_{i},Y_{i},s_{i})\sim\mathcal{D}_{v},\ (V_{i}',s_{i}')\sim\pi_{\varphi}(\cdot|X_{i},Y_{i})}\left[R_{\text{format}}(V_{i}')\cdot R_{\text{score}}(s_{i}',s_{i})\right]$$
$$
\max_{\pi_{\varphi}} \mathbb{E}_{(X_{i},Y_{i},s_{i})\sim\mathcal{D}_{v},\ (V_{i}',s_{i}')\sim\pi_{\varphi}(\cdot|X_{i},Y_{i})}\left[R_{\text{format}}(V_{i}')\cdot R_{\text{score}}(s_{i}',s_{i})\right]
$$
其中 $V_{i}'$ 是验证器的完整回复，$s_{i}'$ 是从中抽取的分数（下同）。
@@ -47,7 +51,9 @@ $$\max_{\pi_{\varphi}} \mathbb{E}_{(X_{i},Y_{i},s_{i})\sim\mathcal{D}_{v},\ (V_{
以验证器 $\pi_{\varphi}$ 作为生成式奖励模型，训练证明生成器 $\pi_{\theta}(\cdot\mid X)$：
$$\max_{\pi_{\theta}} \mathbb{E}_{X_{i}\sim\mathcal{D}_{p},\ Y_{i}\sim\pi_{\theta}(\cdot|X_{i})}[R_{Y}]$$
$$
\max_{\pi_{\theta}} \mathbb{E}_{X_{i}\sim\mathcal{D}_{p},\ Y_{i}\sim\pi_{\theta}(\cdot|X_{i})}[R_{Y}]
$$
其中 $R_{Y}$ 即 $\pi_{\varphi}(\cdot\mid X_{i},Y_{i},\mathcal{I}_{v})$ 给出的证明分数。
@@ -57,7 +63,9 @@ $$\max_{\pi_{\theta}} \mathbb{E}_{X_{i}\sim\mathcal{D}_{p},\ Y_{i}\sim\pi_{\thet
于是训练时要求生成器在写出证明 $Y$ 后，附上遵循同一格式与量规的自分析 $Z$，自评分数记为 $s'$。为保证自评忠实，由验证器同时评估两部分：证明得 $R_{Y}=s$，自分析得元验证分 $R_{\text{meta}}(Z)=ms$。总奖励为：
$$R = R_{\text{format}}(Y,Z)\cdot(\alpha\cdot R_{Y} + \beta\cdot R_{Z}),\qquad R_{Z} = R_{\text{score}}(s',s)\cdot R_{\text{meta}}(Z)$$
$$
R = R_{\text{format}}(Y,Z)\cdot(\alpha\cdot R_{Y} + \beta\cdot R_{Z}),\qquad R_{Z} = R_{\text{score}}(s',s)\cdot R_{\text{meta}}(Z)
$$
论文取 $\alpha = 0.76$、$\beta = 0.24$。该结构产生三个激励：如实承认错误优于谎称正确；最高奖励来自「写出正确证明并准确认识其严谨程度」；因此最优策略是在收尾前尽可能多地识别并解决问题。用论文的话说，这是让模型**明确意识到自己的奖励函数，并通过深思熟虑的推理而非盲目试错去最大化它**。
大模型/deepseek/04-推理模型/01-DeepSeek-R1-2501.12948_abstract.md
+6 -2
View File
@@ -29,9 +29,13 @@
论文采用组相对策略优化（Group Relative Policy Optimization, GRPO）。对每个问题 $q$ 采样一组输出并最大化：
$$\mathcal{J}_{GRPO}(\theta)=\mathbb{E}\Big[\tfrac{1}{G}\sum_{i=1}^{G}\Big(\min\big(\tfrac{\pi_{\theta}(o_{i}|q)}{\pi_{\theta_{old}}(o_{i}|q)}A_{i},\ \text{clip}(\cdot,1-\varepsilon,1+\varepsilon)A_{i}\big)-\beta\mathbb{D}_{KL}(\pi_{\theta}||\pi_{ref})\Big)\Big]$$
$$
\mathcal{J}_{GRPO}(\theta)=\mathbb{E}\Big[\tfrac{1}{G}\sum_{i=1}^{G}\Big(\min\big(\tfrac{\pi_{\theta}(o_{i}|q)}{\pi_{\theta_{old}}(o_{i}|q)}A_{i},\ \text{clip}(\cdot,1-\varepsilon,1+\varepsilon)A_{i}\big)-\beta\mathbb{D}_{KL}(\pi_{\theta}||\pi_{ref})\Big)\Big]
$$
$$\mathbb{D}_{KL}(\pi_{\theta}||\pi_{ref})=\frac{\pi_{ref}}{\pi_{\theta}}-\log\frac{\pi_{ref}}{\pi_{\theta}}-1,\qquad A_{i}=\frac{r_{i}-\mathrm{mean}(\{r_{1},\cdots,r_{G}\})}{\mathrm{std}(\{r_{1},\cdots,r_{G}\})}$$
$$
\mathbb{D}_{KL}(\pi_{\theta}||\pi_{ref})=\frac{\pi_{ref}}{\pi_{\theta}}-\log\frac{\pi_{ref}}{\pi_{\theta}}-1,\qquad A_{i}=\frac{r_{i}-\mathrm{mean}(\{r_{1},\cdots,r_{G}\})}{\mathrm{std}(\{r_{1},\cdots,r_{G}\})}
$$
优势 $A_i$ 由组内奖励标准化直接得到，无需价值模型；PPO 则要用 GAE 并额外训练一个与策略模型同量级的值模型，显存与算力开销大，且「从部分响应预测最终奖励」在模型会反思、改写甚至推翻前文的长思维链场景下尤其难学准。KL 的处理也不同：GRPO 把 KL 无偏估计直接放进损失，PPO 作为逐 token 稠密奖励罚项，会隐式惩罚响应长度、阻碍思考变长。实验中 PPO 在 $\lambda=0.95$ 时明显不如 GRPO，调到 $1.0$ 才接近，但需额外调参。
大模型/deepseek/05-多模态/02-Janus-2410.13848_abstract.md
+6 -2
View File
@@ -46,7 +46,9 @@ Stage I 冻结视觉编码器与 LLM，只训练两个适配器与图像预测
交叉熵损失：
$$\mathcal{L}=-\sum_{i=1}\log P_{\theta}(x_{i}|x_{<i})$$
$$
\mathcal{L}=-\sum_{i=1}\log P_{\theta}(x_{i}|x_{<i})
$$
其中 $P(\cdot\mid\cdot)$ 为权重 $\theta$ 建模的条件概率。文本与多模态理解在文本序列上算损失，视觉生成只在图像序列上算损失，且不给不同任务设不同损失权重。
@@ -54,7 +56,9 @@ $$\mathcal{L}=-\sum_{i=1}\log P_{\theta}(x_{i}|x_{<i})$$
采用下一 token 预测：文本与多模态理解顺序采样，图像生成使用无分类器引导（Classifier-Free Guidance, CFG）——训练时以 10% 概率把文本条件替换为 pad token 以获得无条件生成能力，推理时
$$l_{g}=l_{u}+s(l_{c}-l_{u})$$
$$
l_{g}=l_{u}+s(l_{c}-l_{u})
$$
$l_c$、$l_u$ 为有条件与无条件 logit，$s$ 为引导尺度，评测默认取 5。
大模型/deepseek/05-多模态/03-DeepSeek-VL2-2412.10302_abstract.md
+6 -2
View File
@@ -27,7 +27,9 @@
前代把视觉特征固定在 $384\times384$ 与 $1024\times1024$ 两档，难以处理更大尺寸与极端长宽比图像。DeepSeek-VL2 定义候选分辨率集合
$$C_{R}=\{(m\cdot 384,\ n\cdot 384)\mid m,n\in\mathbb{N},\ 1\leq m,n,\ mn\leq 9\}$$
$$
C_{R}=\{(m\cdot 384,\ n\cdot 384)\mid m,n\in\mathbb{N},\ 1\leq m,n,\ mn\leq 9\}
$$
其中 $m:n$ 为目标长宽比：对 $(H,W)$ 图像先缩放长边、再保持比例填充另一维，选择**填充面积最小**的候选；随后划为 $m_i\times n_i$ 个 $384\times384$ 局部块加 1 个全局缩略图块，由单个 SigLIP-SO400M-384 编码全部 $(1+m_i\times n_i)$ 个块，每块得 $27\times27=729$ 个 1152 维嵌入。图像多于 2 张时关闭该策略以控制上下文长度。
@@ -35,7 +37,9 @@ $$C_{R}=\{(m\cdot 384,\ n\cdot 384)\mid m,n\in\mathbb{N},\ 1\leq m,n,\ mn\leq 9\
用 $2\times2$ 像素重排把每块 token 压到 $14\times14=196$ 个，并用特殊 token 标记布局：缩略图块每行末补 14 个 `<tile_newline>`（共 210 个），局部块按 $(m_i\cdot14,\ n_i\cdot14)$ 网格排列、最后一列后追加 $m_i\cdot14$ 个 `<tile_newline>`，两者间插一个 `<view_separator>`；序列长度为
$$210+1+m_i\cdot14\times(n_i\cdot14+1)$$
$$
210+1+m_i\cdot14\times(n_i\cdot14+1)
$$
最后经两层 MLP 投影进语言模型嵌入空间。
大模型/deepseek/05-多模态/05-DeepSeek-OCR-2510.18234_abstract.md
+9 -3
View File
@@ -29,7 +29,9 @@ DeepSeek-OCR 采用统一的端到端 VLM 架构：编码器（DeepEncoder）负
**架构设计（图 3）**：DeepEncoder 由「以窗口注意力为主的感知组件」与「稠密全局注意力的知识组件」构成，为继承预训练收益分别采用 SAM-base（patch size 16）与 CLIP-large；关键改动是**去掉 CLIP 的第一个 patch embedding 层**，因其输入不再是图像，而是上一段流程输出的 token。两组件之间借鉴 Vary，用 **2 层卷积做 16× 下采样**（kernel 3、stride 2、padding 1，通道 256→1024）。以 1024×1024 输入为例：
$$\frac{1024}{16}\times\frac{1024}{16}=4096\ \text{patch tokens},\qquad \frac{4096}{16}=256\ \text{tokens after compression}$$
$$
\frac{1024}{16}\times\frac{1024}{16}=4096\ \text{patch tokens},\qquad \frac{4096}{16}=256\ \text{tokens after compression}
$$
前半段由窗口注意力主导且仅 80M，激活可接受；4096 个 token 在进入全局注意力前先压成 256 个，整体激活显存因之可控。这就是「先感知、后压缩、再全局建模」的分工：窗口注意力以低成本换细节，压缩器把成本峰值挡在稠密全局注意力之外。
@@ -48,7 +50,9 @@ $$\frac{1024}{16}\times\frac{1024}{16}=4096\ \text{patch tokens},\qquad \frac{40
Tiny/Small 分辨率小，直接按原形状缩放以免浪费 token；Base/Large 为保持长宽比采用填充，填充后有效视觉 token 少于实际数量：
$$N_{valid}=\left\lceil N_{actual}\times\left[1-\frac{\max(w,h)-\min(w,h)}{\max(w,h)}\right]\right\rceil \tag{1}$$
$$
N_{valid}=\left\lceil N_{actual}\times\left[1-\frac{\max(w,h)-\min(w,h)}{\max(w,h)}\right]\right\rceil \tag{1}
$$
动态分辨率由两种原生分辨率组合，切块沿用 InternVL2.0。Gundam 由 n 个 640×640 局部视图（tile）加一个 1024×1024 全局视图构成，动机是应用需求（尤其报纸这类超高分辨率输入）——切块相当于「二级窗口注意力」，可进一步压低激活；因原生分辨率较大，图像不会被过度切碎（tile 数 2–9）。宽高均小于 640 时 $n=0$，Gundam 退化为 Base。Gundam-M 则由已训练模型继续训练 6M 采样数据得到，主要为负载均衡（其分辨率过大，混合训练会拖慢速度）。
@@ -56,7 +60,9 @@ $$N_{valid}=\left\lceil N_{actual}\times\left[1-\frac{\max(w,h)-\min(w,h)}{\max(
解码器采用 DeepSeekMoE（DeepSeek-3B-MoE）：推理时从 64 个路由专家中激活 6 个，另加 2 个共享专家，激活参数约 570M。作者认为它既有 3B 的表达能力、又享有 500M 小模型的推理效率，尤其适合以领域为中心的 VLM 研究。解码即从压缩潜变量重建文本表示：
$$f_{\text{dec}}:\mathbb{R}^{n\times d_{\text{latent}}}\rightarrow\mathbb{R}^{N\times d_{\text{text}}},\qquad \hat{\mathbf{X}}=f_{\text{dec}}(\mathbf{Z})\quad\text{where }n\le N \tag{2}$$
$$
f_{\text{dec}}:\mathbb{R}^{n\times d_{\text{latent}}}\rightarrow\mathbb{R}^{N\times d_{\text{text}}},\qquad \hat{\mathbf{X}}=f_{\text{dec}}(\mathbf{Z})\quad\text{where }n\le N \tag{2}
$$
其中 $\mathbf{Z}$ 为 DeepEncoder 输出的压缩潜（视觉）token，$\hat{\mathbf{X}}$ 为重建文本表示。作者指出这是紧致语言模型可通过 OCR 式训练学会的非线性映射，并推测 LLM 经专门预训练优化能更自然地集成该能力。
大模型/deepseek/05-多模态/06-DeepSeek-OCR-2-2601.20552_abstract.md
+6 -2
View File
@@ -40,7 +40,9 @@ DeepSeek-OCR 2 沿用 DeepSeek-OCR 的「编码器 + 解码器」架构，关键
掩码由两个区域沿序列维度拼接：左侧对原始视觉词元施加双向注意力（类似 ViT），任意词元互相可见；右侧对因果流词元施加因果注意力（三角掩码，与仅解码器 LLM 一致），每个词元只关注之前的词元。形式为
$$M=\begin{bmatrix}\mathbf{1}_{m\times m}&\mathbf{0}_{m\times n}\\ \mathbf{1}_{n\times m}&\text{LowerTri}(n)\end{bmatrix},\quad\text{其中 }n=m$$
$$
M=\begin{bmatrix}\mathbf{1}_{m\times m}&\mathbf{0}_{m\times n}\\ \mathbf{1}_{n\times m}&\text{LowerTri}(n)\end{bmatrix},\quad\text{其中 }n=m
$$
其中 $n$ 为因果查询词元数，$m$ 为朴素视觉词元数，$\text{LowerTri}$ 为下三角矩阵。
@@ -48,7 +50,9 @@ $$M=\begin{bmatrix}\mathbf{1}_{m\times m}&\mathbf{0}_{m\times n}\\ \mathbf{1}_{n
解码器不做升级，沿用 DeepSeek-OCR 的 3B 参数 MoE 结构（约 500M 激活参数）。核心前向过程为
$$\mathbf{O}=\mathcal{D}\left(\pi_{Q}\left(\mathcal{T}^{L}\left(\mathcal{E}(\mathbf{I})\oplus\mathbf{Q}_{0};\mathbf{M}\right)\right)\right)$$
$$
\mathbf{O}=\mathcal{D}\left(\pi_{Q}\left(\mathcal{T}^{L}\left(\mathcal{E}(\mathbf{I})\oplus\mathbf{Q}_{0};\mathbf{M}\right)\right)\right)
$$
其中 $\mathcal{E}$ 为视觉分词器（图像→$m$ 个视觉词元），$\mathbf{Q}_{0}$ 为可学习因果查询嵌入，$\oplus$ 为序列拼接，$\mathcal{T}^{L}$ 是带掩码注意力的 $L$ 层 Transformer，$\mathbf{M}$ 为式 (1) 的块状因果掩码，$\pi_{Q}$ 抽取最后 $n$ 个词元，$\mathcal{D}$ 为语言解码器，$\mathbf{O}$ 为词表上的输出 logits。
大模型/deepseek/05-多模态/07-JanusFlow-2411.07975_abstract.md
+18 -6
View File
@@ -23,13 +23,17 @@
**多模态 LLM**：对离散 token 序列 $x=(x_1,\cdots,x_\ell)$ 按最大似然自回归建模
$$\log P_{\theta_{LLM}}(x)=\sum_{i=0}^{\ell-1}\log P_{\theta_{LLM}}(x_{i+1}\mid x_1,\dots,x_i)$$
$$
\log P_{\theta_{LLM}}(x)=\sum_{i=0}^{\ell-1}\log P_{\theta_{LLM}}(x_{i+1}\mid x_1,\dots,x_i)
$$
处理视觉输入时外接视觉编码器与投影层，把图像特征映射进词嵌入空间（如 LLaVA 用 CLIP 编码器）。
**整流流**：对来自未知分布 $\pi_1$ 的连续数据点，学习定义在 $t\in[0,1]$ 上的常微分方程 $\frac{{\rm d}z_t}{{\rm d}t}=v_{\theta_{NN}}(z_t,t),\ z_0\sim\pi_0$（$\pi_0$ 为标准高斯噪声），训练时让速度场拟合两分布采样点间的线性路径方向：
$$\min_\theta \mathbb{E}_{t\sim P(t),z_0\sim\pi_0,x\sim\pi_1}\left[\left\|v_{\theta_{NN}}(z_t,t)-(x-z_0)\right\|^2\right],\quad z_t=tx+(1-t)z_0$$
$$
\min_\theta \mathbb{E}_{t\sim P(t),z_0\sim\pi_0,x\sim\pi_1}\left[\left\|v_{\theta_{NN}}(z_t,t)-(x-z_0)\right\|^2\right],\quad z_t=tx+(1-t)z_0
$$
容量足够且目标最优时，速度场把基分布输运到 $\pi_1$；相比扩散，它概念更简洁、采样更快、经验性能更好。
@@ -39,7 +43,9 @@ $$\min_\theta \mathbb{E}_{t\sim P(t),z_0\sim\pi_0,x\sim\pi_1}\left[\left\|v_{\th
**生成路径**：以文本为条件在 SDXL-VAE 隐空间生成：噪声 $z_0$ 经生成编码器 $g_{enc}$ 变为嵌入序列并拼接时间嵌入 $t$，LLM 输出的速度经生成解码器 $g_{dec}$ 还原为隐空间速度，用标准欧拉求解器迭代
$$z_{t+{\rm d}t}=z_t+v(z_t,t)\,{\rm d}t$$
$$
z_{t+{\rm d}t}=z_t+v(z_t,t)\,{\rm d}t
$$
把输入中的 $z_0$ 换成 $z_{{\rm d}t}$ 迭代至 $z_1$，再由 VAE 解码出图像；质量由无分类器引导（CFG）提升：$v(z_t,t)=w\,v(z_t,t\mid x^{con})+(1-w)\,v(z_t,t\mid\varnothing)$。与采用各种注意力掩码策略的前作不同，作者发现**因果注意力已经足够**，替代掩码在初步实验中并无收益。
@@ -59,15 +65,21 @@ $$z_{t+{\rm d}t}=z_t+v(z_t,t)\,{\rm d}t$$
数据统一写成 $x=(x^{con},x^{res})$（条件与响应）。理解任务只用响应 token 算自回归损失：
$$\mathcal{L}_{AR}(\theta)=-\mathbb{E}_{x\sim\mathcal{D}_{und}}\left[\sum_{i=\ell_{con}}^{\ell-1}\log P_\theta(x_{i+1}\mid x_1,\dots,x_i)\right]$$
$$
\mathcal{L}_{AR}(\theta)=-\mathbb{E}_{x\sim\mathcal{D}_{und}}\left[\sum_{i=\ell_{con}}^{\ell-1}\log P_\theta(x_{i+1}\mid x_1,\dots,x_i)\right]
$$
生成任务用整流流损失，时间分布沿用 Stable Diffusion 3 的 logit-normal，并随机丢弃 10% 文本提示以支持 CFG：
$$\mathcal{L}_{RF}(\theta)=\mathbb{E}_{x\sim\mathcal{D}_{gen},t\sim P(t),z_0\sim\mathcal{N}(0,I)}\left[\left\|v_\theta(z_t,t\mid x^{con})-(x^{res}-z_0)\right\|^2\right],\quad z_t=tx^{res}+(1-t)z_0$$
$$
\mathcal{L}_{RF}(\theta)=\mathbb{E}_{x\sim\mathcal{D}_{gen},t\sim P(t),z_0\sim\mathcal{N}(0,I)}\left[\left\|v_\theta(z_t,t\mid x^{con})-(x^{res}-z_0)\right\|^2\right],\quad z_t=tx^{res}+(1-t)z_0
$$
**表示对齐正则项**把理解编码器对真实图像的特征与 LLM 中间表示对齐：
$$\mathcal{L}_{REPA}(\theta,\varphi)=-\mathbb{E}_{x\sim\mathcal{D}_{gen}}\left[\mathrm{sim}\left(\mathrm{stop\_grad}(f_{enc}(x^{res})),\;h_\varphi(q_\theta(z_t))\right)\right]$$
$$
\mathcal{L}_{REPA}(\theta,\varphi)=-\mathbb{E}_{x\sim\mathcal{D}_{gen}}\left[\mathrm{sim}\left(\mathrm{stop\_grad}(f_{enc}(x^{res})),\;h_\varphi(q_\theta(z_t))\right)\right]
$$
其中 $q_\theta(z_t)$ 取 LLM 第 6 个 block 之后、输入为带噪 $z_t$ 时的特征，$h_\varphi$ 为三层 MLP，相似度取逐元素余弦相似度均值，梯度不回传理解编码器；作者令 $H_{gen}=H_{im}$、$W_{gen}=W_{im}$ 以便与特征图对齐。其动机是让 LLM 面对噪声输入时的内部特征空间贴近语义特征空间，使推理时从新噪声也能生成语义正确的图像。汇总：理解用 $\mathcal{L}_{AR}$，生成用 $\mathcal{L}_{RF}+\mathcal{L}_{REPA}$，贯穿各训练阶段。
大模型/deepseek/05-多模态/08-DreamCraft3D-2310.16818_abstract.md
+18 -6
View File
@@ -30,11 +30,15 @@
目标是在参考视角匹配参考图 $\hat{\bm{x}}$，同时其他视角依然合理，故对随机视角施加 SDS 损失：
$$\nabla_\theta \mathcal{L}_{\text{SDS}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;y,t)-\bm{\epsilon}\big)\frac{\partial \bm{x}}{\partial \theta}\Big]$$
$$
\nabla_\theta \mathcal{L}_{\text{SDS}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;y,t)-\bm{\epsilon}\big)\frac{\partial \bm{x}}{\partial \theta}\Big]
$$
即渲染图加噪后预测噪声与所加噪声的逐像素差，$\omega(t)$ 为权重函数。为利用参考图，在参考视角 $\hat{c}$ 上施加仅计前景的光度损失 $\mathcal{L}_{\text{rgb}}=\lVert\hat{\bm{m}}\odot(\hat{\bm{x}}-g(\theta;\hat{c}))\rVert_2$ 与掩码损失 $\mathcal{L}_{\text{mask}}=\lVert\hat{\bm{m}}-g_m(\theta;\hat{c})\rVert_2$（后者鼓励场景稀疏），并由参考图推断深度与法向先验强制一致：
$$\mathcal{L}_{\text{depth}}=-\frac{\text{conv}(\bm{d},\hat{\bm{d}})}{\sigma(\bm{d})\sigma(\hat{\bm{d}})},\qquad \mathcal{L}_{\text{normal}}=-\frac{\bm{n}\cdot\hat{\bm{n}}}{\lVert\bm{n}\rVert_2\cdot\lVert\hat{\bm{n}}\rVert_2}$$
$$
\mathcal{L}_{\text{depth}}=-\frac{\text{conv}(\bm{d},\hat{\bm{d}})}{\sigma(\bm{d})\sigma(\hat{\bm{d}})},\qquad \mathcal{L}_{\text{normal}}=-\frac{\bm{n}\cdot\hat{\bm{n}}}{\lVert\bm{n}\rVert_2\cdot\lVert\hat{\bm{n}}\rVert_2}
$$
其中 $\hat{\bm{d}}$、$\hat{\bm{n}}$ 由现成单视图估计器给出；深度损失取**负皮尔逊相关**形式以规避深度尺度不匹配。但仅此仍难保证背面语义一致，故需额外手段。
@@ -42,11 +46,15 @@ $$\mathcal{L}_{\text{depth}}=-\frac{\text{conv}(\bm{d},\hat{\bm{d}})}{\sigma(\bm
仅靠逐视角监督的 3D 优化欠约束，因此引入在大规模 3D 资产上训练的视角条件扩散模型 Zero-1-to-3：给定参考图与相对位姿 $c$ 即可「幻想」对应视角图像，编码更丰富的 3D 知识：
$$\nabla_\theta \mathcal{L}_{\text{3D-SDS}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;\hat{\bm{x}},c,y,t)-\bm{\epsilon}\big)\frac{\partial \bm{x}}{\partial \theta}\Big]$$
$$
\nabla_\theta \mathcal{L}_{\text{3D-SDS}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;\hat{\bm{x}},c,y,t)-\bm{\epsilon}\big)\frac{\partial \bm{x}}{\partial \theta}\Big]
$$
它能缓解 Janus 类缺陷，但该模型基于类别有限、渲染质量偏低的数据微调，生成能力受损，单独使用会拖坏通用图像升维质量。故采用**混合 SDS 损失**，同时纳入 2D 与 3D 先验：
$$\nabla_\theta \mathcal{L}_{\text{hybrid}}(\phi, g(\theta)) = \nabla_\theta \mathcal{L}_{\text{SDS}}(\phi, g(\theta)) + \mu \nabla_\theta \mathcal{L}_{\text{3D-SDS}}(\phi, g(\theta))$$
$$
\nabla_\theta \mathcal{L}_{\text{hybrid}}(\phi, g(\theta)) = \nabla_\theta \mathcal{L}_{\text{SDS}}(\phi, g(\theta)) + \mu \nabla_\theta \mathcal{L}_{\text{3D-SDS}}(\phi, g(\theta))
$$
取 $\mu=2$ 强调 3D 先验权重；$\mathcal{L}_{\text{SDS}}$ 使用 DeepFloyd IF base 模型（$64\times64$ 像素空间，更擅长捕捉粗粒度几何）。
@@ -58,11 +66,15 @@ $$\nabla_\theta \mathcal{L}_{\text{hybrid}}(\phi, g(\theta)) = \nabla_\theta \ma
几何阶段纹理模糊有三因：2D 先验分辨率粗（$64\times64$）、3D 感知模型锐度有限、大无分类器引导（CFG）带来过平滑与过饱和。纹理阶段改用变分分数蒸馏（VSD）并切换到 Stable Diffusion 获取高分辨率梯度，固定四面体网格只优化纹理，且刻意**不**用 Zero-1-to-3（会损害纹理质量）：
$$\mathcal{L}_{\text{VSD}}=D_{\text{KL}}\big(q^\mu(\bm{x}_0|y)\,\|\,p(\bm{x}_0|y)\big),\qquad \nabla_\theta \mathcal{L}_{\text{VSD}} = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;y,t)-\bm{\epsilon}_{\text{lora}}(\bm{x}_t;y,t,c)\big)\frac{\partial \bm{x}}{\partial \theta}\Big]$$
$$
\mathcal{L}_{\text{VSD}}=D_{\text{KL}}\big(q^\mu(\bm{x}_0|y)\,\|\,p(\bm{x}_0|y)\big),\qquad \nabla_\theta \mathcal{L}_{\text{VSD}} = \mathbb{E}_{t,\bm{\epsilon}}\Big[\omega(t)\big(\bm{\epsilon}_\phi(\bm{x}_t;y,t)-\bm{\epsilon}_{\text{lora}}(\bm{x}_t;y,t,c)\big)\frac{\partial \bm{x}}{\partial \theta}\Big]
$$
但仅用 VSD，不一致的纹理可能回归。作者观察到上一阶段的多视角渲染虽偏模糊却具备良好 3D 一致性，于是用 DreamBooth 在这些渲染 $\{\bm{x}\}$ 上微调，让模型对「场景环绕视角」形成概念——提示词含唯一标识符与类别名（如 "A [V] astronaut"），每视角相机参数作为附加条件。关键技巧是用**带噪增强**渲染 $\bm{x_r}=r_{t'}(\bm{x})$：按时间步 $t'$ 注入高斯噪声 $\bm{x}_{t'}=\alpha_{t'}\bm{x}_0+\sigma_{t'}\bm{\epsilon}$ 再由模型恢复，$t'$ 越大暴露的高频细节越多、但保真度越低。据此对 3D 场景与扩散先验做**交替优化**：初期渲染模糊就用较大的 $t'$ 增强纹理（代价是引入一些 3D 不一致）；纹理变精细后减小噪声，DreamBooth 便从更一致的渲染学习。3D 梯度由如下 BSD 损失给出：
$$\nabla_\theta \mathcal{L}_{\text{BSD}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon},c}\Big[\omega(t)\big(\bm{\epsilon}_{\text{DreamBooth}}(\bm{x}_t;y,t,r_{t'}(\bm{x}),c)-\bm{\epsilon}_{\text{lora}}(\bm{x}_t;y,t,\bm{x},c)\big)\frac{\partial \bm{x}}{\partial \theta}\Big]$$
$$
\nabla_\theta \mathcal{L}_{\text{BSD}}(\phi, g(\theta)) = \mathbb{E}_{t,\bm{\epsilon},c}\Big[\omega(t)\big(\bm{\epsilon}_{\text{DreamBooth}}(\bm{x}_t;y,t,r_{t'}(\bm{x}),c)-\bm{\epsilon}_{\text{lora}}(\bm{x}_t;y,t,\bm{x},c)\big)\frac{\partial \bm{x}}{\partial \theta}\Big]
$$
与从固定 2D 模型蒸馏的先前工作不同，BSD 学习一个**不断演化**的模型，靠正在被雕刻的 3D 模型反馈而越来越 3D 一致；交替两轮即可得到细节丰富且一致的纹理。
大模型/deepseek/06-形式化证明/02-DeepSeek-Prover-V1.5-2408.08152_abstract.md
+12 -4
View File
@@ -43,11 +43,15 @@
**选择**：从根向下按树策略挑节点：
$$\text{TreePolicy}(s)=\mathop{\arg\max}_{a\in Children(s)\cup\{\oslash\}}Q_{UCB}(s,a)$$
$$
\text{TreePolicy}(s)=\mathop{\arg\max}_{a\in Children(s)\cup\{\oslash\}}Q_{UCB}(s,a)
$$
动作既可是走向子节点 $a\in Children(s)$，也可是扩展当前节点（记 $a=\oslash$）。这里用**虚拟节点**技术：为每个节点配一个「假想子节点」代表选中自身做扩展，使搜索能持续扩展非叶节点——这对生成模型很关键，其输出范围无法用固定次数的试探界定。价值估计由利用与探索项组成：
$$Q_{UCB}(s,a)=\underbrace{Q(s,a)}_{\text{Exploitation}}+\underbrace{UCB(s,a)}_{\text{Exploration}}$$
$$
Q_{UCB}(s,a)=\underbrace{Q(s,a)}_{\text{Exploitation}}+\underbrace{UCB(s,a)}_{\text{Exploration}}
$$
$Q(s,a)$ 是依据历史的采样估计，$UCB(s,a)$ 随 $(s,a)$ 被反复执行而衰减，$Q_{UCB}(s,a)$ 可视为以高概率成立的上界。
@@ -57,13 +61,17 @@ $Q(s,a)$ 是依据历史的采样估计，$UCB(s,a)$ 随 $(s,a)$ 被反复执行
证明搜索的外在奖励极度稀疏——只有完全解出才有非零奖励，是典型的「难探索」问题。RMaxTS 借鉴 RMax「到达未见状态即给最大奖励」的思想：完成前既无外在奖励，探索便完全由内在奖励驱动，即 $R(\tau)=R_{\text{intrinsic}}(\tau)$（类似 ZeroRMax）：
$$R_{\text{intrinsic}}(\tau)=\mathbb{I}\left[\text{at least one new node is added to the search tree}\right]$$
$$
R_{\text{intrinsic}}(\tau)=\mathbb{I}\left[\text{at least one new node is added to the search tree}\right]
$$
即一次扩展只要新增节点就给奖励，从而优先扩展能生成多样 tactic state 的节点；由于不同代码可能产生相同状态转移，该启发式还减少冗余。
**非平稳性**是第二个难点：随搜索树扩张，发现含未见状态的新节点越来越难，内在奖励期望值随探索衰减；标准 UCB1（$Q_{UCB1}(s,a)=\frac{W(s,a)}{N(s,a)}+\sqrt{\frac{2\ln\sum_{a'}N(s,a')}{N(s,a)}}$，$W,N$ 为奖励之和与次数）无法适应，故改用折扣上置信界：
$$Q_{DUCB}(s,a)=\frac{W_{\gamma}(s,a)}{N_{\gamma}(s,a)}+\sqrt{\frac{2\ln\sum_{a'}N_{\gamma}(s,a')}{N_{\gamma}(s,a)}},\quad W_{\gamma}=\sum_{t=1}^{N}\gamma^{N-t}R(\tau_{t}),\quad N_{\gamma}=\sum_{t=0}^{N-1}\gamma^{t}$$
$$
Q_{DUCB}(s,a)=\frac{W_{\gamma}(s,a)}{N_{\gamma}(s,a)}+\sqrt{\frac{2\ln\sum_{a'}N_{\gamma}(s,a')}{N_{\gamma}(s,a)}},\quad W_{\gamma}=\sum_{t=1}^{N}\gamma^{N-t}R(\tau_{t}),\quad N_{\gamma}=\sum_{t=0}^{N-1}\gamma^{t}
$$
使新反馈权重更大，实践中取 $\gamma=0.99$。与无限时域 MDP 值迭代不同，此处的折扣施加在**树搜索迭代**上而非单条轨迹的动作步长上。
大模型/deepseek/07-架构/01-mHC-2512.24880_abstract.md
+6 -2
View File
@@ -23,7 +23,9 @@
标准残差连接的单元结构（图 1a）为 $\mathbf{x}_{l+1} = \mathbf{x}_l + \mathcal{F}(\mathbf{x}_l, \mathcal{W}_l)$，递归展开得 $\mathbf{x}_L = \mathbf{x}_l + \sum_{i=l}^{L-1}\mathcal{F}(\mathbf{x}_i, \mathcal{W}_i)$，其中 $\mathbf{x}_l$ 这一项即所谓恒等映射，它保证浅层信号不加修改地直达深层。HC（图 1b）把残差流宽度由 $C$ 扩到 $n\times C$，单层传播变为
$$\mathbf{x}_{l+1} = \mathcal{H}_l^{\mathrm{res}}\mathbf{x}_l + \mathcal{H}_l^{\mathrm{post}\top}\mathcal{F}(\mathcal{H}_l^{\mathrm{pre}}\mathbf{x}_l, \mathcal{W}_l),$$
$$
\mathbf{x}_{l+1} = \mathcal{H}_l^{\mathrm{res}}\mathbf{x}_l + \mathcal{H}_l^{\mathrm{post}\top}\mathcal{F}(\mathcal{H}_l^{\mathrm{pre}}\mathbf{x}_l, \mathcal{W}_l),
$$
其中 $\mathcal{H}_l^{\mathrm{res}}\in\mathbb{R}^{n\times n}$ 在残差流内部混合特征，$\mathcal{H}_l^{\mathrm{pre}}\in\mathbb{R}^{1\times n}$ 把 $nC$ 维残差流读成 $C$ 维层输入，$\mathcal{H}_l^{\mathrm{post}}\in\mathbb{R}^{1\times n}$ 把层输出写回残差流。由于 $n$（典型取 4）远小于 $C$，这些额外映射的 FLOPs 开销可忽略，HC 因而把「残差流的信息容量」从与计算量强相关的层输入维度中解耦，成为继模型 FLOPs 与数据量之外的第三条扩展轴。三组映射均由依赖输入的动态部分（经 RMSNorm、tanh 门控与初始化为小值的门控因子 $\alpha$）与静态部分（可学习偏置 $\mathbf{b}$）相加构成。消融（表 1）显示，仅启用 $\mathcal{H}_l^{\mathrm{res}}$ 即得 $-0.022$ 的损失差，三项全开为 $-0.027$，说明残差流内部的信息交换是收益主要来源，也正是 mHC 的着力点。
@@ -35,7 +37,9 @@ $$\mathbf{x}_{l+1} = \mathcal{H}_l^{\mathrm{res}}\mathbf{x}_l + \mathcal{H}_l^{\
mHC 的核心（图 1c）是把 $\mathcal{H}_l^{\mathrm{res}}$ 约束到特定流形上。作者指出，原始恒等映射靠 $\mathcal{H}_l^{\mathrm{res}}=\mathbf{I}$ 换来稳定，却完全禁止残差流内部的信息交换，浪费了多流架构的潜力；需要一个「既跨层稳定、又允许流间交互」的中间地带。他们选择双随机矩阵流形（伯克霍夫多胞形）：
$$\mathcal{P}_{\mathcal{M}^{\mathrm{res}}}(\mathcal{H}_l^{\mathrm{res}}) \coloneq \left\{\mathcal{H}_l^{\mathrm{res}}\in\mathbb{R}^{n\times n}\mid \mathcal{H}_l^{\mathrm{res}}\mathbf{1}_n=\mathbf{1}_n,\ \mathbf{1}_n^{\top}\mathcal{H}_l^{\mathrm{res}}=\mathbf{1}_n^{\top},\ \mathcal{H}_l^{\mathrm{res}}\geqslant 0\right\}.$$
$$
\mathcal{P}_{\mathcal{M}^{\mathrm{res}}}(\mathcal{H}_l^{\mathrm{res}}) \coloneq \left\{\mathcal{H}_l^{\mathrm{res}}\in\mathbb{R}^{n\times n}\mid \mathcal{H}_l^{\mathrm{res}}\mathbf{1}_n=\mathbf{1}_n,\ \mathbf{1}_n^{\top}\mathcal{H}_l^{\mathrm{res}}=\mathbf{1}_n^{\top},\ \mathcal{H}_l^{\mathrm{res}}\geqslant 0\right\}.
$$
$n=1$ 时该条件退化为标量 1，恰好恢复原始恒等映射。选择双随机性带来三条性质：**范数保持**——谱范数 $\|\mathcal{H}_l^{\mathrm{res}}\|_2\le 1$，映射非扩张，缓解梯度爆炸；**复合封闭**——双随机矩阵对乘法封闭，故任意深度的复合映射仍是双随机的，稳定性贯穿整个深度；**伯克霍夫多胞形的几何解释**——该集合是置换矩阵的凸包，残差映射相当于置换的凸组合，反复施加会单调地增强流间信息混合，构成稳健的特征融合机制。此外，输入/输出映射施加 Sigmoid 非负约束（可视作另一类特殊流形投影），防止正负系数组合导致信号抵消。
大模型/deepseek/07-架构/02-Engram-条件记忆-2601.07372_abstract.md
+18 -6
View File
@@ -29,7 +29,9 @@
对位置 $t$ 做映射后得到后缀 N-gram $g_{t,n}=(x'_{t-n+1},\dots,x'_t)$。直接参数化全部 N-gram 组合空间不可行，故用哈希方案并设 $K$ 个哈希头缓解冲突：
$$z_{t,n,k}\triangleq\varphi_{n,k}(g_{t,n}),\quad \mathbf{e}_{t,n,k}=\mathbf{E}_{n,k}[z_{t,n,k}]$$
$$
z_{t,n,k}\triangleq\varphi_{n,k}(g_{t,n}),\quad \mathbf{e}_{t,n,k}=\mathbf{E}_{n,k}[z_{t,n,k}]
$$
实践中 $\varphi_{n,k}$ 用轻量乘法-XOR 哈希实现。记忆向量由各阶各头结果拼接而成：$\mathbf{e}_t\triangleq\|_{n=2}^{N}\|_{k=1}^{K}\mathbf{e}_{t,n,k}$，表 $\mathbf{E}_{n,k}$ 取质数大小 $M_{n,k}$ 以降低冲突。
@@ -37,21 +39,29 @@ $$z_{t,n,k}\triangleq\varphi_{n,k}(g_{t,n}),\quad \mathbf{e}_{t,n,k}=\mathbf{E}_
检索到的 $\mathbf{e}_t$ 是上下文无关的先验，静态性使其缺乏适应性，还可能被哈希冲突或一词多义污染。Engram 借用注意力范式：把已聚合全局上下文的 $\mathbf{h}_t$ 作 Query，把 $\mathbf{e}_t$ 同时投影为 Key 与 Value，
$$\mathbf{k}_t=\mathbf{W}_K\mathbf{e}_t,\quad \mathbf{v}_t=\mathbf{W}_V\mathbf{e}_t$$
$$
\mathbf{k}_t=\mathbf{W}_K\mathbf{e}_t,\quad \mathbf{v}_t=\mathbf{W}_V\mathbf{e}_t
$$
为梯度稳定，对 Query 与 Key 先做 RMSNorm 再算标量门：
$$\alpha_t=\sigma\!\left(\frac{\text{RMSNorm}(\mathbf{h}_t)^{\top}\text{RMSNorm}(\mathbf{k}_t)}{\sqrt{d}}\right),\qquad \tilde{\mathbf{v}}_t=\alpha_t\cdot\mathbf{v}_t$$
$$
\alpha_t=\sigma\!\left(\frac{\text{RMSNorm}(\mathbf{h}_t)^{\top}\text{RMSNorm}(\mathbf{k}_t)}{\sqrt{d}}\right),\qquad \tilde{\mathbf{v}}_t=\alpha_t\cdot\mathbf{v}_t
$$
这强制语义对齐：若记忆与上下文矛盾，门值趋零以抑制噪声。随后用深度可分离因果卷积扩大感受野（核宽 $w=4$、膨胀取最大 N-gram 阶数、SiLU 激活）：
$$\mathbf{Y}=\text{SiLU}\left(\text{Conv1D}\left(\text{RMSNorm}(\tilde{\mathbf{V}})\right)\right)+\tilde{\mathbf{V}}$$
$$
\mathbf{Y}=\text{SiLU}\left(\text{Conv1D}\left(\text{RMSNorm}(\tilde{\mathbf{V}})\right)\right)+\tilde{\mathbf{V}}
$$
### 3.4 与多分支架构的集成
默认骨干采用多分支结构（残差流扩展为 $M$ 条并行分支、连接权重可学习，即 Manifold-Constrained Hyper-Connections，$M=4$）。为兼顾效率与表达力采用参数共享：稀疏嵌入表与 Value 投影 $\mathbf{W}_V$ 全分支共享，每分支各有独立 Key 投影 $\{\mathbf{W}_K^{(m)}\}_{m=1}^{M}$，以获得分支特异门控：
$$\alpha_t^{(m)}=\sigma\!\left(\frac{\text{RMSNorm}(\mathbf{h}_t^{(m)})^{\top}\text{RMSNorm}(\mathbf{W}_K^{(m)}\mathbf{e}_t)}{\sqrt{d}}\right),\quad \mathbf{u}_t^{(m)}=\alpha_t^{(m)}\cdot(\mathbf{W}_V\mathbf{e}_t)$$
$$
\alpha_t^{(m)}=\sigma\!\left(\frac{\text{RMSNorm}(\mathbf{h}_t^{(m)})^{\top}\text{RMSNorm}(\mathbf{W}_K^{(m)}\mathbf{e}_t)}{\sqrt{d}}\right),\quad \mathbf{u}_t^{(m)}=\alpha_t^{(m)}\cdot(\mathbf{W}_V\mathbf{e}_t)
$$
这样 $1$ 个 $\mathbf{W}_V$ 与 $M$ 个 $\mathbf{W}_K^{(m)}$ 可融合成单次稠密 FP8 矩阵乘，提升 GPU 算力利用率。
@@ -63,7 +73,9 @@ MoE 路由依赖运行时隐状态，而 Engram 索引仅取决于输入 token I
定义三个指标：总可训练参数 $P_{\mathrm{tot}}$（不含词表嵌入与 LM head）、每 token 激活参数 $P_{\mathrm{act}}$（决定 FLOPs）、非激活参数 $P_{\mathrm{sparse}}\triangleq P_{\mathrm{tot}}-P_{\mathrm{act}}$。分配比例：
$$P_{\mathrm{MoE}}^{(\mathrm{sparse})}=\rho\,P_{\mathrm{sparse}},\qquad P_{\mathrm{Engram}}=(1-\rho)\,P_{\mathrm{sparse}}$$
$$
P_{\mathrm{MoE}}^{(\mathrm{sparse})}=\rho\,P_{\mathrm{sparse}},\qquad P_{\mathrm{Engram}}=(1-\rho)\,P_{\mathrm{sparse}}
$$
$\rho=1$ 即纯 MoE；$\rho<1$ 则减少路由专家、把释放参数转为 Engram 槽位。作者在 $C=2\times10^{20}$（$P_{\mathrm{tot}}\approx5.7$B、$P_{\mathrm{act}}=568$M、106 专家）与 $C=6\times10^{20}$（$P_{\mathrm{tot}}\approx9.9$B、$P_{\mathrm{act}}=993$M、99 专家）两档、稀疏度 $P_{\mathrm{tot}}/P_{\mathrm{act}}\approx10$ 下扫描 $\rho$：$C=6\times10^{20}$ 时验证损失从 $\rho=100\%$ 的 1.7248 降到最优 $\rho\approx80\%$ 的 1.7109（$\Delta=0.0139$）；即使 MoE 份额压到 $\rho\approx40\%$（5.7B 模型 46 专家、9.9B 模型 43 专家）仍与纯 MoE 相当。U 形两端各有病因：MoE 独大时只能靠深度低效重建静态模式；Engram 独大时丧失条件计算能力，动态推理受损。无限记忆档固定 3B MoE 骨干（$P_{\mathrm{act}}=568$M、100B tokens），槽位数从 $2.58\times10^5$ 扫到 $1.0\times10^7$（最多约 13B 参数），验证损失在 log 空间线性下降，同等预算下比把 N-gram 嵌入与词表嵌入平均的 OverEncoding 潜力更大。
大模型/deepseek/07-架构/03-NSA-原生稀疏注意力-2502.11089_abstract.md
+15 -5
View File
@@ -29,9 +29,13 @@
标准注意力为 $\mathbf{o}_t=\operatorname{Attn}(\mathbf{q}_t,\mathbf{k}_{:t},\mathbf{v}_{:t})$，其中 $\alpha_{t,i}=e^{\mathbf{q}_t^{\top}\mathbf{k}_i/\sqrt{d_k}}$。NSA 的核心思路是把 $\mathbf{k}_{:t},\mathbf{v}_{:t}$ 换成更紧凑、信息密度更高的表示：
$$\tilde{K}_t=f_K(\mathbf{q}_t,\mathbf{k}_{:t},\mathbf{v}_{:t}),\qquad \tilde{V}_t=f_V(\mathbf{q}_t,\mathbf{k}_{:t},\mathbf{v}_{:t})$$
$$
\tilde{K}_t=f_K(\mathbf{q}_t,\mathbf{k}_{:t},\mathbf{v}_{:t}),\qquad \tilde{V}_t=f_V(\mathbf{q}_t,\mathbf{k}_{:t},\mathbf{v}_{:t})
$$
$$\mathbf{o}^{*}_t=\operatorname{Attn}(\mathbf{q}_t,\tilde{K}_t,\tilde{V}_t)=\sum_{c\in\mathcal{C}}g_t^{c}\cdot\operatorname{Attn}(\mathbf{q}_t,\tilde{K}_t^{c},\tilde{V}_t^{c})$$
$$
\mathbf{o}^{*}_t=\operatorname{Attn}(\mathbf{q}_t,\tilde{K}_t,\tilde{V}_t)=\sum_{c\in\mathcal{C}}g_t^{c}\cdot\operatorname{Attn}(\mathbf{q}_t,\tilde{K}_t^{c},\tilde{V}_t^{c})
$$
映射集合仅取三种：$\mathcal{C}=\{\text{cmp},\text{slc},\text{win}\}$；门控 $g_t^{c}\in[0,1]$ 由输入特征经 MLP 加 sigmoid 得到。重映射后总长度 $N_t=\sum_{c\in\mathcal{C}}\operatorname{size}[\tilde{K}^{c}_t]$，靠 $N_t\ll t$ 维持高稀疏比。
@@ -41,15 +45,21 @@ $$\mathbf{o}^{*}_t=\operatorname{Attn}(\mathbf{q}_t,\tilde{K}_t,\tilde{V}_t)=\su
**Token 选择（3.3.2）。** 只靠压缩表示会丢失细粒度信息，故再挑出最重要的若干连续块。选块而非选 token 有两个理由：GPU 对连续块访问的吞吐远高于随机索引读，块计算也能充分利用 Tensor Core（FlashAttention 的基本原则）；且注意力分数具有空间连续性，相邻 key 的重要性往往相近（已有工作与本文可视化均证实）。重要性分数**几乎不额外花钱**——直接复用压缩分支产生的中间注意力分数：
$$\mathbf{p}_t^{\text{cmp}}=\operatorname{Softmax}\left(\mathbf{q}_t^{T}\tilde{K}_t^{\text{cmp}}\right)$$
$$
\mathbf{p}_t^{\text{cmp}}=\operatorname{Softmax}\left(\mathbf{q}_t^{T}\tilde{K}_t^{\text{cmp}}\right)
$$
当压缩块与选择块切分一致（$l'=l=d$）时，选择块重要性分数 $\mathbf{p}_t^{\text{slc}}$ 就等于 $\mathbf{p}_t^{\text{cmp}}$；切分不一致时按空间关系求和聚合：
$$\mathbf{p}_t^{\text{slc}}[j]=\sum_{m=0}^{\frac{l'}{d}-1}\sum_{n=0}^{\frac{l}{d}-1}\mathbf{p}_t^{\text{cmp}}\left[\frac{l'}{d}j-m-n\right]$$
$$
\mathbf{p}_t^{\text{slc}}[j]=\sum_{m=0}^{\frac{l'}{d}-1}\sum_{n=0}^{\frac{l}{d}-1}\mathbf{p}_t^{\text{cmp}}\left[\frac{l'}{d}j-m-n\right]
$$
对 GQA/MQA 这类跨头共享 KV 的模型，组内必须做**一致的块选择**，否则解码时访存量退化为并集，故先把组内各头分数相加：${\mathbf{p}_t^{\text{slc}}}'=\sum_{h=1}^{H}\mathbf{p}_t^{\text{slc},(h)}$。随后取 top-$n$ 块：
$$\mathcal{I}_t=\{i\mid\operatorname{rank}({\mathbf{p}_t^{\text{slc}}}'[i])\leqslant n\},\qquad \tilde{K}^{\text{slc}}_t=\operatorname{Cat}\left[\{\mathbf{k}_{il'+1:(i+1)l'}\mid i\in\mathcal{I}_t\}\right]$$
$$
\mathcal{I}_t=\{i\mid\operatorname{rank}({\mathbf{p}_t^{\text{slc}}}'[i])\leqslant n\},\qquad \tilde{K}^{\text{slc}}_t=\operatorname{Cat}\left[\{\mathbf{k}_{il'+1:(i+1)l'}\mid i\in\mathcal{I}_t\}\right]
$$
由于分数来自可微的注意力计算（而非聚类或哈希），选择路径的梯度可自然回流。
大模型/deepseek/07-架构/04-Aux-Loss-Free-Load-Balancing-2408.15664_abstract.md
+12 -4
View File
@@ -24,11 +24,15 @@
MoE 层用多个专家 FFN 替换标准 Transformer 的 MLP 层，对第 $t$ 个 token 的输入 $\mathbf{u}_t$，输出为
$$\mathbf{h}_t=\mathbf{u}_t+\sum_{i=1}^{N}g_{i,t}\operatorname{FFN}_i(\mathbf{u}_t),\quad s_{i,t}=G(\mathbf{u}_t^{\top}\mathbf{e}_i),$$
$$
\mathbf{h}_t=\mathbf{u}_t+\sum_{i=1}^{N}g_{i,t}\operatorname{FFN}_i(\mathbf{u}_t),\quad s_{i,t}=G(\mathbf{u}_t^{\top}\mathbf{e}_i),
$$
其中 $g_{i,t}$ 仅在 $s_{i,t}$ 落入 top-K 时为 $s_{i,t}$，否则为 0。负载不均衡的两类危害是路由崩塌（只选少数专家，其余专家训练不足）与多设备下的计算瓶颈。为此主流做法引入辅助损失：
$$\mathcal{L}_{\text{Balance}}=\alpha\sum_{i=1}^{N}f_i P_i,\quad f_i=\frac{N}{KT}\sum_{t=1}^{T}\mathbbm{1}(\text{Token }t\text{ selects Expert }i),\quad P_i=\frac{1}{T}\sum_{t=1}^{T}s_{i,t}.$$
$$
\mathcal{L}_{\text{Balance}}=\alpha\sum_{i=1}^{N}f_i P_i,\quad f_i=\frac{N}{KT}\sum_{t=1}^{T}\mathbbm{1}(\text{Token }t\text{ selects Expert }i),\quad P_i=\frac{1}{T}\sum_{t=1}^{T}s_{i,t}.
$$
痛点是：它本质上是额外正则项，会与语言建模目标产生冲突梯度。$\alpha$ 太小则负载不均衡甚至路由崩塌，太大则明显拖累性能——即论文所称「负载均衡与模型性能之间的两难」。
@@ -36,7 +40,9 @@ $$\mathcal{L}_{\text{Balance}}=\alpha\sum_{i=1}^{N}f_i P_i,\quad f_i=\frac{N}{KT
Loss-Free Balancing 不改损失函数，而是改路由的判定依据：为每个专家加一个偏置 $b_i$，用**带偏置的分数**决定 top-K 归属，但**最终加权输出仍用原始分数**：
$$g_{i,t}=\begin{cases}s_{i,t},& s_{i,t}+b_i\in\operatorname{Topk}\left(\{s_{j,t}+b_j\mid 1\le j\le N\},K\right),\\ 0,&\text{otherwise.}\end{cases}$$
$$
g_{i,t}=\begin{cases}s_{i,t},& s_{i,t}+b_i\in\operatorname{Topk}\left(\{s_{j,t}+b_j\mid 1\le j\le N\},K\right),\\ 0,&\text{otherwise.}\end{cases}
$$
关键在于：$b_i$ 只影响「选谁」、不进入 $g_{i,t}$，因此既不改变专家输出的加权方式，也不向反向传播注入与语言建模目标无关的梯度；均衡由偏置数值承担，性能由主损失主导，两者解耦。
@@ -44,7 +50,9 @@ $$g_{i,t}=\begin{cases}s_{i,t},& s_{i,t}+b_i\in\operatorname{Topk}\left(\{s_{j,t
偏置按「重负载压低、轻负载抬高」的原则迭代更新。对每个 batch：先按上式正常前向与训练，然后统计各专家被分配的 token 数 $c_i$ 及其均值 $\overline{c_i}$，得到负载违背误差 $e_i=\overline{c_i}-c_i$，再更新
$$b_i \leftarrow b_i + u\cdot\operatorname{sign}(e_i).$$
$$
b_i \leftarrow b_i + u\cdot\operatorname{sign}(e_i).
$$
作者强调只使用**历史** batch 的负载信息：用当前序列的负载会破坏语言建模的因果约束，导致未来 token 信息泄漏。这一「事后更新」性质使本方法兼具控制力与因果安全性。
大模型/deepseek/08-训练方法/01-ESFT-专家专精微调-2407.01906_abstract.md
+15 -5
View File
@@ -24,11 +24,15 @@
MoE 层替换前馈网络（FFN），每层含多个结构相同的专家，词元按亲和度只被分配给其中一部分。第 $l$ 层第 $t$ 个词元的输出为
$$\mathbf{h}_{t}^{l}=\sum_{i=1}^{N}\left(g_{i,t}\text{FFN}^{n}_{i}(\mathbf{u}_{t}^{l})\right)+\mathbf{u}_{t}^{l},\qquad s_{i,t}=\text{Softmax}_{i}\left(\mathbf{u}_{t}^{l\top}\mathbf{e}_{i}^{l}\right)$$
$$
\mathbf{h}_{t}^{l}=\sum_{i=1}^{N}\left(g_{i,t}\text{FFN}^{n}_{i}(\mathbf{u}_{t}^{l})\right)+\mathbf{u}_{t}^{l},\qquad s_{i,t}=\text{Softmax}_{i}\left(\mathbf{u}_{t}^{l\top}\mathbf{e}_{i}^{l}\right)
$$
其中 $N$ 为专家总数，$g_{i,t}=s_{i,t}$ 当且仅当它进入 TopK 集合，否则为 0。DeepSeekMoE 另引入细粒度专家切分与共享专家隔离（共享专家处理所有词元、承载公共知识）：
$$\mathbf{h}_{t}^{l}=\sum_{i=1}^{K_{s}}\text{FFN}^{s}_{i}(\mathbf{u}_{t}^{l})+\sum_{i=1}^{N}\left(g_{i,t}\text{FFN}^{n}_{i}(\mathbf{u}_{t}^{l})\right)+\mathbf{u}_{t}^{l}$$
$$
\mathbf{h}_{t}^{l}=\sum_{i=1}^{K_{s}}\text{FFN}^{s}_{i}(\mathbf{u}_{t}^{l})+\sum_{i=1}^{N}\left(g_{i,t}\text{FFN}^{n}_{i}(\mathbf{u}_{t}^{l})\right)+\mathbf{u}_{t}^{l}
$$
其中 $K_{s}$ 为共享专家数。
@@ -42,17 +46,23 @@ $$\mathbf{h}_{t}^{l}=\sum_{i=1}^{K_{s}}\text{FFN}^{s}_{i}(\mathbf{u}_{t}^{l})+\s
**专家相关性评分**：给出两种基于词元亲和度的度量。平均门控分数（ESFT-Gate）衡量专家对采样数据的平均亲和度：
$$g_{i}^{l}=\frac{1}{N_{s}}\sum_{j=1}^{N_{s}}\frac{1}{L_{j}}\sum_{k=1}^{L_{j}}g_{i,k}^{l}$$
$$
g_{i}^{l}=\frac{1}{N_{s}}\sum_{j=1}^{N_{s}}\frac{1}{L_{j}}\sum_{k=1}^{L_{j}}g_{i,k}^{l}
$$
词元选择比例（ESFT-Token）衡量专家被选中的词元占比：
$$r_{i}^{l}=\frac{1}{N_{s}}\sum_{j=1}^{N_{s}}\frac{1}{L_{j}}\sum_{k=1}^{L_{j}}\frac{\mathbb{1}\left(g_{i,k}^{l}>0\right)}{K}$$
$$
r_{i}^{l}=\frac{1}{N_{s}}\sum_{j=1}^{N_{s}}\frac{1}{L_{j}}\sum_{k=1}^{L_{j}}\frac{\mathbb{1}\left(g_{i,k}^{l}>0\right)}{K}
$$
其中 $\mathbb{1}(\cdot)$ 为指示函数、$K$ 为每词元激活的专家数；前者看亲和度强弱，后者看调用频率。
**专家选择与微调**：每层设阈值 $p\in(0,1]$，把专家按评分从高到低累加，直到累计占比超过 $p$，得到该层待训练专家集合 $E_{s}^{l}$：
$$\sum_{i\in E_{s}^{l}}R_{i}^{l}\geqslant p,\qquad R_{i}^{l}\in\{r_{i}^{l},\ g_{i}^{l}\}$$
$$
\sum_{i\in E_{s}^{l}}R_{i}^{l}\geqslant p,\qquad R_{i}^{l}\in\{r_{i}^{l},\ g_{i}^{l}\}
$$
关键：训练与推理时词元仍可路由到任意专家，但只有 $E_{s}^{l}$ 内专家会被更新，其余专家与模块全部冻结——既保留路由能力与专精结构，又把可训练参数压到极小。
大模型/deepseek/08-训练方法/02-DeepSeek-GRM-2504.02495_abstract.md
+15 -5
View File
@@ -23,7 +23,9 @@
论文把奖励模型方法拆成两个正交维度：**奖励生成范式**（标量 scalar、半标量 semi-scalar、生成式 generative）与**打分模式**（逐点 pointwise、成对 pairwise）。给定查询 $x$ 与回复 $\{y_i\}_{i=1}^n$：
$$\mathcal{R}=\begin{cases}\bm{S}&\text{(Scalar)}\\ (\bm{S},\bm{C})&\text{(Semi-Scalar)}\\ \bm{C}&\text{(Generative)}\end{cases}\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n\right)$$
$$
\mathcal{R}=\begin{cases}\bm{S}&\text{(Scalar)}\\ (\bm{S},\bm{C})&\text{(Semi-Scalar)}\\ \bm{C}&\text{(Generative)}\end{cases}\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n\right)
$$
逐点模式为每条回复单独给分 $\{S_i\}_{i=1}^n=f_{\mathrm{point}}(\mathcal{R},\{y_i\}_{i=1}^n)$，成对模式只挑出唯一最优回复 $\hat{y}=f_{\mathrm{pair}}(\mathcal{R},\{y_i\}_{i=1}^n)$。
@@ -39,13 +41,17 @@ $$\mathcal{R}=\begin{cases}\bm{S}&\text{(Scalar)}\\ (\bm{S},\bm{C})&\text{(Semi-
难点在于规模化通用奖励建模下难以预先造出有效原则，论文遂把原则视为奖励生成过程的一部分：
$$\{p_i\}_{i=1}^m\sim p_{\theta}\left(x,\{y_i\}_{i=1}^n\right),\quad \mathcal{R}=\bm{C}\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n,\{p_i\}_{i=1}^m\right)$$
$$
\{p_i\}_{i=1}^m\sim p_{\theta}\left(x,\{y_i\}_{i=1}^n\right),\quad \mathcal{R}=\bm{C}\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n,\{p_i\}_{i=1}^m\right)
$$
即两个函数共享同一模型（共用同一个语言头）。原则能依查询与回复自适应产生，质量与粒度可经后训练提升；规模化生成原则正是推理时扩展获得更细粒度奖励的前提。
第一阶段是**拒绝式微调（Rejective Fine-Tuning, RFT）**冷启动，让 GRM 学会按规定格式、面向各种输入类型生成原则与批判。与以往混用不同格式数据不同，这里统一用逐点格式处理任意条数回复：除通用指令数据外，用预训练 GRM 采样 $N_{\mathrm{RFT}}$ 次轨迹，拒绝预测错误与全部正确的样本。奖励被判为正确的条件是：
$$\begin{cases}\forall i\neq j,\ S_j>S_i,\ j=\arg\max_l\{r_l\}_{l=1}^n,&\text{if } n\ge 2\\ S_1=r_1,&\text{if } n=1\end{cases}$$
$$
\begin{cases}\forall i\neq j,\ S_j>S_i,\ j=\arg\max_l\{r_l\}_{l=1}^n,&\text{if } n\ge 2\\ S_1=r_1,&\text{if } n=1\end{cases}
$$
预训练 GRM 在有限采样配额下对部分样本难以生成正确奖励，故可选地做**提示采样（hinted sampling）**：在输入末尾追加「The best response is: Response ...」，每条只采一次、仅错误时拒绝；但提示采样会让批判「走捷径」，尤其在推理类任务上。
@@ -53,7 +59,9 @@ $$\begin{cases}\forall i\neq j,\ S_j>S_i,\ j=\arg\max_l\{r_l\}_{l=1}^n,&\text{if
在 RFT 之上用基于规则的在线 RL 继续微调，采用 GRPO 原始设定与基于规则的结果奖励：rollout 时依查询与回复生成原则和批判，抽取预测奖励后按准确性规则与真值比较。与 DeepSeek-R1 式做法不同，**这里不用格式奖励**，而用更大的 KL 惩罚系数保证格式、避免偏差：
$$\hat{r}_i=\begin{cases}1,&\text{if } n\ge 2 \text{ and } \forall i'\neq j',\ S_{j'}>S_{i'},\ j'=\arg\max_l\{r_l\}_{l=1}^n\\ 1,&\text{if } n=1 \text{ and } S_1=r_1\\ -1,&\text{otherwise}\end{cases}$$
$$
\hat{r}_i=\begin{cases}1,&\text{if } n\ge 2 \text{ and } \forall i'\neq j',\ S_{j'}>S_{i'},\ j'=\arg\max_l\{r_l\}_{l=1}^n\\ 1,&\text{if } n=1 \text{ and } S_1=r_1\\ -1,&\text{otherwise}\end{cases}
$$
该奖励鼓励 GRM 用在线优化的原则与批判区分最优回复，有利于推理时扩展；奖励信号可无缝取自任意偏好数据集。
@@ -61,7 +69,9 @@ $$\hat{r}_i=\begin{cases}1,&\text{if } n\ge 2 \text{ and } \forall i'\neq j',\ S
推理时算力通过并行采样扩大，温度 0.5。逐点 GRM 的投票即分数求和：
$$S_i^{*}=\sum_{j=1}^{k}S_{i,j},\quad \{p_{i,j}\}_{i=1}^{m_j}\sim p_{\theta}\left(x,\{y_i\}_{i=1}^n\right),\ \mathcal{R}_j=\bm{C}_j\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n,\{p_{i,j}\}_{i=1}^{m_j}\right)$$
$$
S_i^{*}=\sum_{j=1}^{k}S_{i,j},\quad \{p_{i,j}\}_{i=1}^{m_j}\sim p_{\theta}\left(x,\{y_i\}_{i=1}^n\right),\ \mathcal{R}_j=\bm{C}_j\sim r_{\theta}\left(x,\{y_i\}_{i=1}^n,\{p_{i,j}\}_{i=1}^{m_j}\right)
$$
单次分数只落在很小的离散区间（如 $\{1,\dots,10\}$），$k$ 次求和把奖励空间扩大 $k$ 倍，并让模型产出大量原则。论文的直觉是：每条原则可视为一个判断视角的代理，原则越多越能逼近真实分布；采样前打乱回复顺序以规避位置偏差。相比之下，半标量 RM 的平均投票方差过小，成对 GRM 的多数投票在无平局、缺定量分数时易偏差。
大模型/deepseek/09-基础设施/02-Insights-into-DeepSeek-V3-2505.09343_abstract.md
+3 -1
View File
@@ -26,7 +26,9 @@
延迟侧给出上限推导：MoE 要快需让每台设备只算一个专家，这就必须 all-to-all 路由 token，故**上限由互联带宽决定**。设每设备持一个专家、每批约 32 token：
$$\text{Comm. Time}=(1\text{B}+2\text{B})\times 32\times 9\times 7\text{K}/50\text{GB/s}=120.96\,\mu s$$
$$
\text{Comm. Time}=(1\text{B}+2\text{B})\times 32\times 9\times 7\text{K}/50\text{GB/s}=120.96\,\mu s
$$
其中 dispatch 用 FP8、combine 用 BF16，隐藏维约 7K，系数 9 = 8 个路由专家 + 1 个共享专家。双微批次重叠且计算开销可忽略时，61 层共 **14.76 ms**，上限约 **67 tokens/s**；换成 GB200 NVL72 的 900 GB/s 则上限 0.82 ms ≈ 1200 tokens/s（论文强调纯属理论）。堆硬件太贵，算法必须分担：**多 token 预测（MTP）**每模块仅一个轻量单层，实测第二后继 token 接受率 80%~90%、TPS 提升 1.8 倍，略损吞吐却显著降低生成延迟，并因每步多 token 增大推理批量、提升 EP 计算强度。
大模型/deepseek/_scripts/make_index.py
+3 -1
View File
@@ -134,7 +134,9 @@ def main():
out.append('- **作者**：%s' % (a[:300] + ('…' if len(a) > 300 else '')))
out.append('- **原文 PDF**：[%s.pdf](%s)' % (stem, p['pdf_path'].replace('\\', '/')))
if done:
out.append('- **中文翻译**：[%s.md](%s)' % (stem, p['md_path'].replace('\\', '/')))
out.append('- **中文翻译**：[%s](%s)' % (
os.path.basename(p['md_path'].replace('\\', '/')),
p['md_path'].replace('\\', '/')))
else:
out.append('- **中文翻译**：（待生成）')
out.append('')
大模型/deepseek/_scripts/math_fix.py
+122
View File
@@ -0,0 +1,122 @@
"""Audit / convert single-line $$...$$ math blocks for SilverBullet compatibility.
SilverBullet's Math library defines block math with the line-anchored marker
regex ^\\$\\$$ for BOTH start and end, so `$$...$$` written on one line never
closes and is rendered as raw text.
Usage:
python math_fix.py audit <base_dir>
python math_fix.py convert <base_dir> [--apply]
"""
import os
import re
import sys
CMD = sys.argv[1]
BASE = sys.argv[2] if len(sys.argv) > 2 else '.'
APPLY = '--apply' in sys.argv
LINE_RE = re.compile(r'^\$\$(.+)\$\$$')
def notes():
for root, dirs, files in os.walk(BASE):
if any(x in root for x in ['_scripts', '_text', '_digest', '.git']):
continue
for fn in sorted(files):
if fn.endswith('.md') and fn != 'README.md':
yield os.path.join(root, fn)
def walk_lines(path):
"""Yield (index, line, in_fence)."""
fence = False
lines = open(path, encoding='utf-8').read().split('\n')
for i, line in enumerate(lines):
if line.lstrip().startswith('```'):
yield i, line, fence
fence = not fence
continue
yield i, line, fence
def audit():
total = indented = multi = in_fence = trailing = 0
samples = []
for p in notes():
for i, line, fence in walk_lines(p):
s = line.strip()
if not s.startswith('$$') or s.count('$$') < 2:
continue
total += 1
if fence:
in_fence += 1
samples.append(('FENCE', p, i, s[:90]))
if line != line.lstrip():
indented += 1
samples.append(('INDENT', p, i, s[:90]))
if s.count('$$') > 2:
multi += 1
samples.append(('MULTI', p, i, s[:90]))
if not s.endswith('$$'):
trailing += 1
samples.append(('TAILTEXT', p, i, s[-80:]))
print('单行 $$ 块总数 :', total)
print(' 其中在代码块内 :', in_fence)
print(' 其中带前导缩进 :', indented)
print(' 其中一行含 >2 个 $$ :', multi)
print(' 其中不以 $$ 结尾 :', trailing)
for kind, p, i, s in samples[:20]:
print(' [%s] %s:%d %s' % (kind, os.path.relpath(p, BASE), i + 1, s))
def convert():
files_changed = 0
blocks_changed = 0
skipped = []
for p in notes():
lines = open(p, encoding='utf-8').read().split('\n')
out = []
fence = False
n = 0
for line in lines:
if line.lstrip().startswith('```'):
fence = not fence
out.append(line)
continue
m = LINE_RE.match(line)
if m and not fence:
body = m.group(1).strip()
if '$$' in body:
skipped.append((os.path.relpath(p, BASE), line[:90]))
out.append(line)
continue
out.append('$$')
out.append(body)
out.append('$$')
n += 1
continue
out.append(line)
if n:
files_changed += 1
blocks_changed += n
print('%3d 处 %s' % (n, os.path.relpath(p, BASE)))
if APPLY:
with open(p, 'w', encoding='utf-8', newline='\n') as f:
f.write('\n'.join(out))
print()
print('文件数: %d 转换块数: %d' % (files_changed, blocks_changed))
if skipped:
print('跳过（正文含 $$，需人工确认）:')
for s in skipped:
print(' ', s)
print('模式:', '已写入' if APPLY else '预演（未写入，加 --apply 才落盘）')
if __name__ == '__main__':
if CMD == 'audit':
audit()
elif CMD == 'convert':
convert()
else:
raise SystemExit('unknown command: ' + CMD)
大模型/deepseek/_scripts/plan.json
+33 -33
View File
@@ -14,7 +14,7 @@
"dir": "01-基础模型",
"stem": "01-DeepSeek-LLM-2401.02954",
"pdf_path": "01-基础模型\\01-DeepSeek-LLM-2401.02954.pdf",
"md_path": "01-基础模型\\01-DeepSeek-LLM-2401.02954.md"
"md_path": "01-基础模型\\01-DeepSeek-LLM-2401.02954_abstract.md"
},
{
"id": "2401.06066",
@@ -31,7 +31,7 @@
"dir": "01-基础模型",
"stem": "02-DeepSeekMoE-2401.06066",
"pdf_path": "01-基础模型\\02-DeepSeekMoE-2401.06066.pdf",
"md_path": "01-基础模型\\02-DeepSeekMoE-2401.06066.md"
"md_path": "01-基础模型\\02-DeepSeekMoE-2401.06066_abstract.md"
},
{
"id": "2401.14196",
@@ -48,7 +48,7 @@
"dir": "02-代码模型",
"stem": "01-DeepSeek-Coder-2401.14196",
"pdf_path": "02-代码模型\\01-DeepSeek-Coder-2401.14196.pdf",
"md_path": "02-代码模型\\01-DeepSeek-Coder-2401.14196.md"
"md_path": "02-代码模型\\01-DeepSeek-Coder-2401.14196_abstract.md"
},
{
"id": "2402.03300",
@@ -65,7 +65,7 @@
"dir": "03-数学模型",
"stem": "01-DeepSeekMath-2402.03300",
"pdf_path": "03-数学模型\\01-DeepSeekMath-2402.03300.pdf",
"md_path": "03-数学模型\\01-DeepSeekMath-2402.03300.md"
"md_path": "03-数学模型\\01-DeepSeekMath-2402.03300_abstract.md"
},
{
"id": "2403.05525",
@@ -82,7 +82,7 @@
"dir": "05-多模态",
"stem": "01-DeepSeek-VL-2403.05525",
"pdf_path": "05-多模态\\01-DeepSeek-VL-2403.05525.pdf",
"md_path": "05-多模态\\01-DeepSeek-VL-2403.05525.md"
"md_path": "05-多模态\\01-DeepSeek-VL-2403.05525_abstract.md"
},
{
"id": "2405.04434",
@@ -99,7 +99,7 @@
"dir": "01-基础模型",
"stem": "03-DeepSeek-V2-2405.04434",
"pdf_path": "01-基础模型\\03-DeepSeek-V2-2405.04434.pdf",
"md_path": "01-基础模型\\03-DeepSeek-V2-2405.04434.md"
"md_path": "01-基础模型\\03-DeepSeek-V2-2405.04434_abstract.md"
},
{
"id": "2405.14333",
@@ -116,7 +116,7 @@
"dir": "06-形式化证明",
"stem": "01-DeepSeek-Prover-2405.14333",
"pdf_path": "06-形式化证明\\01-DeepSeek-Prover-2405.14333.pdf",
"md_path": "06-形式化证明\\01-DeepSeek-Prover-2405.14333.md"
"md_path": "06-形式化证明\\01-DeepSeek-Prover-2405.14333_abstract.md"
},
{
"id": "2406.11931",
@@ -133,7 +133,7 @@
"dir": "02-代码模型",
"stem": "02-DeepSeek-Coder-V2-2406.11931",
"pdf_path": "02-代码模型\\02-DeepSeek-Coder-V2-2406.11931.pdf",
"md_path": "02-代码模型\\02-DeepSeek-Coder-V2-2406.11931.md"
"md_path": "02-代码模型\\02-DeepSeek-Coder-V2-2406.11931_abstract.md"
},
{
"id": "2407.01906",
@@ -150,7 +150,7 @@
"dir": "08-训练方法",
"stem": "01-ESFT-专家专精微调-2407.01906",
"pdf_path": "08-训练方法\\01-ESFT-专家专精微调-2407.01906.pdf",
"md_path": "08-训练方法\\01-ESFT-专家专精微调-2407.01906.md"
"md_path": "08-训练方法\\01-ESFT-专家专精微调-2407.01906_abstract.md"
},
{
"id": "2408.08152",
@@ -167,7 +167,7 @@
"dir": "06-形式化证明",
"stem": "02-DeepSeek-Prover-V1.5-2408.08152",
"pdf_path": "06-形式化证明\\02-DeepSeek-Prover-V1.5-2408.08152.pdf",
"md_path": "06-形式化证明\\02-DeepSeek-Prover-V1.5-2408.08152.md"
"md_path": "06-形式化证明\\02-DeepSeek-Prover-V1.5-2408.08152_abstract.md"
},
{
"id": "2408.14158",
@@ -184,7 +184,7 @@
"dir": "09-基础设施",
"stem": "01-Fire-Flyer-AI-HPC-2408.14158",
"pdf_path": "09-基础设施\\01-Fire-Flyer-AI-HPC-2408.14158.pdf",
"md_path": "09-基础设施\\01-Fire-Flyer-AI-HPC-2408.14158.md"
"md_path": "09-基础设施\\01-Fire-Flyer-AI-HPC-2408.14158_abstract.md"
},
{
"id": "2410.13848",
@@ -201,7 +201,7 @@
"dir": "05-多模态",
"stem": "02-Janus-2410.13848",
"pdf_path": "05-多模态\\02-Janus-2410.13848.pdf",
"md_path": "05-多模态\\02-Janus-2410.13848.md"
"md_path": "05-多模态\\02-Janus-2410.13848_abstract.md"
},
{
"id": "2412.10302",
@@ -218,7 +218,7 @@
"dir": "05-多模态",
"stem": "03-DeepSeek-VL2-2412.10302",
"pdf_path": "05-多模态\\03-DeepSeek-VL2-2412.10302.pdf",
"md_path": "05-多模态\\03-DeepSeek-VL2-2412.10302.md"
"md_path": "05-多模态\\03-DeepSeek-VL2-2412.10302_abstract.md"
},
{
"id": "2412.19437",
@@ -235,7 +235,7 @@
"dir": "01-基础模型",
"stem": "04-DeepSeek-V3-2412.19437",
"pdf_path": "01-基础模型\\04-DeepSeek-V3-2412.19437.pdf",
"md_path": "01-基础模型\\04-DeepSeek-V3-2412.19437.md"
"md_path": "01-基础模型\\04-DeepSeek-V3-2412.19437_abstract.md"
},
{
"id": "2501.12948",
@@ -252,7 +252,7 @@
"dir": "04-推理模型",
"stem": "01-DeepSeek-R1-2501.12948",
"pdf_path": "04-推理模型\\01-DeepSeek-R1-2501.12948.pdf",
"md_path": "04-推理模型\\01-DeepSeek-R1-2501.12948.md"
"md_path": "04-推理模型\\01-DeepSeek-R1-2501.12948_abstract.md"
},
{
"id": "2501.17811",
@@ -269,7 +269,7 @@
"dir": "05-多模态",
"stem": "04-Janus-Pro-2501.17811",
"pdf_path": "05-多模态\\04-Janus-Pro-2501.17811.pdf",
"md_path": "05-多模态\\04-Janus-Pro-2501.17811.md"
"md_path": "05-多模态\\04-Janus-Pro-2501.17811_abstract.md"
},
{
"id": "2504.02495",
@@ -286,7 +286,7 @@
"dir": "08-训练方法",
"stem": "02-DeepSeek-GRM-2504.02495",
"pdf_path": "08-训练方法\\02-DeepSeek-GRM-2504.02495.pdf",
"md_path": "08-训练方法\\02-DeepSeek-GRM-2504.02495.md"
"md_path": "08-训练方法\\02-DeepSeek-GRM-2504.02495_abstract.md"
},
{
"id": "2504.21801",
@@ -303,7 +303,7 @@
"dir": "06-形式化证明",
"stem": "03-DeepSeek-Prover-V2-2504.21801",
"pdf_path": "06-形式化证明\\03-DeepSeek-Prover-V2-2504.21801.pdf",
"md_path": "06-形式化证明\\03-DeepSeek-Prover-V2-2504.21801.md"
"md_path": "06-形式化证明\\03-DeepSeek-Prover-V2-2504.21801_abstract.md"
},
{
"id": "2505.09343",
@@ -320,7 +320,7 @@
"dir": "09-基础设施",
"stem": "02-Insights-into-DeepSeek-V3-2505.09343",
"pdf_path": "09-基础设施\\02-Insights-into-DeepSeek-V3-2505.09343.pdf",
"md_path": "09-基础设施\\02-Insights-into-DeepSeek-V3-2505.09343.md"
"md_path": "09-基础设施\\02-Insights-into-DeepSeek-V3-2505.09343_abstract.md"
},
{
"id": "2510.18234",
@@ -337,7 +337,7 @@
"dir": "05-多模态",
"stem": "05-DeepSeek-OCR-2510.18234",
"pdf_path": "05-多模态\\05-DeepSeek-OCR-2510.18234.pdf",
"md_path": "05-多模态\\05-DeepSeek-OCR-2510.18234.md"
"md_path": "05-多模态\\05-DeepSeek-OCR-2510.18234_abstract.md"
},
{
"id": "2511.22570",
@@ -354,7 +354,7 @@
"dir": "03-数学模型",
"stem": "02-DeepSeekMath-V2-2511.22570",
"pdf_path": "03-数学模型\\02-DeepSeekMath-V2-2511.22570.pdf",
"md_path": "03-数学模型\\02-DeepSeekMath-V2-2511.22570.md"
"md_path": "03-数学模型\\02-DeepSeekMath-V2-2511.22570_abstract.md"
},
{
"id": "2512.02556",
@@ -371,7 +371,7 @@
"dir": "01-基础模型",
"stem": "05-DeepSeek-V3.2-2512.02556",
"pdf_path": "01-基础模型\\05-DeepSeek-V3.2-2512.02556.pdf",
"md_path": "01-基础模型\\05-DeepSeek-V3.2-2512.02556.md"
"md_path": "01-基础模型\\05-DeepSeek-V3.2-2512.02556_abstract.md"
},
{
"id": "2512.24880",
@@ -388,7 +388,7 @@
"dir": "07-架构",
"stem": "01-mHC-2512.24880",
"pdf_path": "07-架构\\01-mHC-2512.24880.pdf",
"md_path": "07-架构\\01-mHC-2512.24880.md"
"md_path": "07-架构\\01-mHC-2512.24880_abstract.md"
},
{
"id": "2601.07372",
@@ -405,7 +405,7 @@
"dir": "07-架构",
"stem": "02-Engram-条件记忆-2601.07372",
"pdf_path": "07-架构\\02-Engram-条件记忆-2601.07372.pdf",
"md_path": "07-架构\\02-Engram-条件记忆-2601.07372.md"
"md_path": "07-架构\\02-Engram-条件记忆-2601.07372_abstract.md"
},
{
"id": "2601.20552",
@@ -422,7 +422,7 @@
"dir": "05-多模态",
"stem": "06-DeepSeek-OCR-2-2601.20552",
"pdf_path": "05-多模态\\06-DeepSeek-OCR-2-2601.20552.pdf",
"md_path": "05-多模态\\06-DeepSeek-OCR-2-2601.20552.md"
"md_path": "05-多模态\\06-DeepSeek-OCR-2-2601.20552_abstract.md"
},
{
"id": "2602.21548",
@@ -439,7 +439,7 @@
"dir": "09-基础设施",
"stem": "03-DualPath-2602.21548",
"pdf_path": "09-基础设施\\03-DualPath-2602.21548.pdf",
"md_path": "09-基础设施\\03-DualPath-2602.21548.md"
"md_path": "09-基础设施\\03-DualPath-2602.21548_abstract.md"
},
{
"id": "2606.19348",
@@ -456,7 +456,7 @@
"dir": "01-基础模型",
"stem": "06-DeepSeek-V4-2606.19348",
"pdf_path": "01-基础模型\\06-DeepSeek-V4-2606.19348.pdf",
"md_path": "01-基础模型\\06-DeepSeek-V4-2606.19348.md"
"md_path": "01-基础模型\\06-DeepSeek-V4-2606.19348_abstract.md"
},
{
"id": "2609.19969",
@@ -473,7 +473,7 @@
"dir": "01-基础模型",
"stem": "07-DeepSeek-V4.1-Flash-2609.19969",
"pdf_path": "01-基础模型\\07-DeepSeek-V4.1-Flash-2609.19969.pdf",
"md_path": "01-基础模型\\07-DeepSeek-V4.1-Flash-2609.19969.md"
"md_path": "01-基础模型\\07-DeepSeek-V4.1-Flash-2609.19969_abstract.md"
},
{
"id": "2310.16818",
@@ -487,7 +487,7 @@
"dir": "05-多模态",
"stem": "08-DreamCraft3D-2310.16818",
"pdf_path": "05-多模态\\08-DreamCraft3D-2310.16818.pdf",
"md_path": "05-多模态\\08-DreamCraft3D-2310.16818.md",
"md_path": "05-多模态\\08-DreamCraft3D-2310.16818_abstract.md",
"pdf_url": "https://arxiv.org/pdf/2310.16818",
"abs_url": "https://arxiv.org/abs/2310.16818"
},
@@ -503,7 +503,7 @@
"dir": "07-架构",
"stem": "04-Aux-Loss-Free-Load-Balancing-2408.15664",
"pdf_path": "07-架构\\04-Aux-Loss-Free-Load-Balancing-2408.15664.pdf",
"md_path": "07-架构\\04-Aux-Loss-Free-Load-Balancing-2408.15664.md",
"md_path": "07-架构\\04-Aux-Loss-Free-Load-Balancing-2408.15664_abstract.md",
"pdf_url": "https://arxiv.org/pdf/2408.15664",
"abs_url": "https://arxiv.org/abs/2408.15664"
},
@@ -519,7 +519,7 @@
"dir": "05-多模态",
"stem": "07-JanusFlow-2411.07975",
"pdf_path": "05-多模态\\07-JanusFlow-2411.07975.pdf",
"md_path": "05-多模态\\07-JanusFlow-2411.07975.md",
"md_path": "05-多模态\\07-JanusFlow-2411.07975_abstract.md",
"pdf_url": "https://arxiv.org/pdf/2411.07975",
"abs_url": "https://arxiv.org/abs/2411.07975"
},
@@ -535,7 +535,7 @@
"dir": "02-代码模型",
"stem": "03-CodeIO-2502.07316",
"pdf_path": "02-代码模型\\03-CodeIO-2502.07316.pdf",
"md_path": "02-代码模型\\03-CodeIO-2502.07316.md",
"md_path": "02-代码模型\\03-CodeIO-2502.07316_abstract.md",
"pdf_url": "https://arxiv.org/pdf/2502.07316",
"abs_url": "https://arxiv.org/abs/2502.07316"
},
@@ -551,7 +551,7 @@
"dir": "07-架构",
"stem": "03-NSA-原生稀疏注意力-2502.11089",
"pdf_path": "07-架构\\03-NSA-原生稀疏注意力-2502.11089.pdf",
"md_path": "07-架构\\03-NSA-原生稀疏注意力-2502.11089.md",
"md_path": "07-架构\\03-NSA-原生稀疏注意力-2502.11089_abstract.md",
"pdf_url": "https://arxiv.org/pdf/2502.11089",
"abs_url": "https://arxiv.org/abs/2502.11089"
}
大模型/deepseek/_scripts/sync_plan_paths.py
+40
View File
@@ -0,0 +1,40 @@
"""Sync plan.json md_path with the actual note filenames on disk.
The notes were renamed with an `_abstract` suffix to avoid page-name clashes
with the same-named PDFs in SilverBullet. This rewrites plan.json accordingly.
Usage: python sync_plan_paths.py <plan.json> <base_dir>
"""
import json
import os
import sys
plan_path, base = sys.argv[1], sys.argv[2]
plan = json.load(open(plan_path, encoding='utf-8'))
changed = 0
missing = []
for p in plan:
d = p['dir']
stem = p['stem']
candidates = [
os.path.join(d, stem + '.md'),
os.path.join(d, stem + '_abstract.md'),
]
found = None
for c in candidates:
if os.path.exists(os.path.join(base, c)):
found = c
break
if not found:
missing.append((p['id'], stem))
continue
if p['md_path'] != found:
p['md_path'] = found
changed += 1
json.dump(plan, open(plan_path, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
print('md_path 已更新:', changed, '/', len(plan))
if missing:
print('未找到对应 md 的论文:')
for m in missing:
print(' !', m)