Attention 跑了 15 组实验，最高 3.77。Transformer 第一轮就 11.49。

为什么 Transformer 秒杀 Attention

不是因为 Transformer 更聪明——是因为 Attention 的 decoder 是 Python for-loop，而 Transformer 是全向量化的。

速度差 5 倍，BLEU 差 3 倍。这两个差距其实同源：计算效率决定了你能跑多少 epoch、多少数据、多深的网络。

Phase 6 实验矩阵

全部 30 epoch, BPE 8K, label smoothing 0.1, warmup scheduler：

B3 的启示

B3 (d256/6L) 用 17.2M 参数跑出 11.70 BLEU——BPE 首次超过词级 baseline (11.49)。

关键发现：

• 深度 > 宽度：6 层 256 维 (17M) > 3 层 512 维 (56M) ——参数效率差 3 倍
• 160K 句子匹配 ~15M 参数：B2 的 56M 严重过拟合，B3 的 17M 刚好
• BPE 的真正优势在中型模型：vocab 效率释放了 embedding 参数，让每层能更宽更深

通往学术基线的路

IWSLT14 De-En 上，标准 Transformer 论文配置（d512, 6 layers, 8 heads, BPE 8K）通常达到 20-25 BLEU。我们的路线：

从 BLEU 3 到 11，我们学到了什么

1. 架构和损失函数是一体两面——都是梯度的产生方式

Phase 2 花了 15 组实验 (A1-A15) 在损失函数上反复调试。SoftBLEU、K_lang、双头梯度相乘——最好的一组 A15 达到 3.77 (+9.3% vs CE-only)。Transformer 第一轮就用纯 CE 跑到 11.49。

看起来像是"架构 > 损失函数"。但其实不是。架构和损失函数是同一个东西的两面：都是定义了梯度的产生方式。

• 架构改变 → hidden_seq 的表示能力变了 → ∂L/∂W 经由不同路径回传 → 梯度的接收面不同
• 损失函数改变 → L 的定义变了 → ∂L/∂W 的量级和方向变了 → 梯度的来源不同

Attention 上用 K_lang + 0.18 BLEU，Transformer 上一轮架构跳变就 +7.7 BLEU——这不是因为 Architecture > Loss，而是因为 Attention 的瓶颈在表示能力（LSTM 时序链），不是损失函数的梯度。换个场景，当架构的表达力已经够用，但数据分布有偏斜，调损失函数就是唯一的出路。

梯度的多寡和方向才是学习的唯一原料。架构和损失函数只是不同的食谱。

2. BPE 在小模型上反效果——但不是永远的

BPE 的 8K vocab 把 embedding 参数从 33.5M 砍到 4M——在 d256/3L 模型上，总参数从 53.6M 缩到 11.6M。浅模型容量被压过了 BPE 的子词泛化收益。

但 B3 (d256/6L, 17.2M) 用 BPE 跑到 11.70，首次盖过词级 baseline (11.49)。BPE 的桶压缩需要深度补偿——这一点恰恰印证了 K_lang 框架。

3. K_lang 在 Transformer 上失效——SoftBLEU 是缺陷补偿器

B6 (d256/6L + K_lang, k=170, α=0.8)：BLEU 止步于 ~8.1。同样架构不用 K_lang 跑 11.70。

K_lang 在 RNN (BLEU 3.0→3.21, +7%) 上有效，在 Attention (3.45→3.77, +9%) 上有效。但在 Transformer (11.70→8.1, −31%) 上反降。模式很清楚：

• 基线越强，K_lang 增益越小。RNN 的 CE 梯度是弱鸡（BLEU 3），K_lang 的 333× 放大确有作用。Transformer 的 CE 梯度已经足够精准，SB 头的梯度穿过 6 层 Transformer，打乱了 CE 辛苦优化的 attention 模式。
• SoftBLEU 不是通用增强器，是缺陷补偿器。当模型本身表达力不足时它帮忙，当模型够强时它捣乱。

4. 梯度训练 = Hash 编码 + Riemann 积分

训练一个 Transformer，本质上就是把语言逐词逐句 hash 编码进权重张量，每一步梯度是当前 batch 的语言统计快照，训练过程就是把这些快照永久存储：

每一个 optimizer.step() 的执行流程：

1. 词 → embedding hash：token → $\mathbb{R}^d$ 向量，查表
2. 前向撞桶：hidden 层把向量推过 6 层 attention + FFN，到 output 层做 softmax 查桶
3. 比对碰撞：预测桶 vs 目标桶 → CrossEntropy 算出误差
4. 反向修正：$\nabla\mathcal{L}$ 告诉你桶壁该往哪边挪
5. 积分存储：$W \mathrel{-}= \eta \cdot \nabla\mathcal{L}$ 把这次碰撞经验热记录进权重

50 epoch × 2500 batch/epoch = 125,000 次积分。这 125,000 次 hash 碰撞的逐次累积，把 160K 句 IWSLT14 的全部语言统计模式寄存到了 17M 个参数里。

在这个框架下，所有我们调试的变量都有了统一的物理意义：

3. 早停 + 倒 U 是所有模型的共有特征

无论是 Phase 2 Attention (ep2 峰) 还是 Phase 6 词级 Transformer (ep8 峰)，BLEU 都呈现峰值后回落。这不是过拟合——loss 和 BLEU 同时变好。这是 teacher forcing 的 exposition bias。

4. 日志就是 infrastructure

Loki 驱动 + Grafana 看板 = 看一眼就知道实验跑到哪了。没有基础设施，3 个实验 15 个 epoch 的结果能让你翻半天日志。花 1 天修基础设施省 10 天找日志。

更新日志

核心发现：深度 > 宽度。d256/3L→4L→6L 步步上升 (10.66→11.52→11.70)，但 d512/3L 和 d512/6L 双双过拟合。160K 句的 IWSLT14 上，17M 参数的 d256/6L 是甜点。

May the Code be with us.

License: GPLv3
本文《SameTime》系列采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。允许任何形式的复制、修改和分发，但必须继承相同的开源协议，承认在算力宇宙中所有的迭代与变异。

512 维 hidden 撞进 32K 维词汇表：碰撞率 K_lang ≈ 0.003，有效碰撞桶 ~170 个。Linear 不是模型最后一步投影——它是翻译信息从连续空间到离散词汇的 Hash 函数。

碰撞在哪里？

NMT 的输出流程三步：

① Transformer:  输入序列 → h_t ∈ ℝ^512       （hidden space）
② Linear:       h_t → z = W·h_t + b         （logits in ℝ^{32000}）
③ Softmax:      z → p ∈ Δ^{31999}           （概率单纯形）
④ Decode:       argmax / beam → token        （离散词）

每个人都在关注 ③ 和 ④。但碰撞发生在 ②。

Linear = Hash Function

W 是一个

的矩阵。每一行

是第 i 个 token 的嵌入向量（output embedding）。

做的是内积：

把 512 维的 hidden 投影到 32K 维——32K 个内积。

这是 Hash 函数的标准定义： 把高维向量压缩到低维离散空间。

参数 W 决定了 hidden 空间中哪些方向对应哪些 token。512 维的 hidden 无法精确表示 32K 个 token 的语义——碰撞是必然的。

碰撞率 = K_lang

32K 个 token 共享 512 个维度，内积

受限于 hidden 的信息容量。有意义地区分的 token 数：

BPE 词表下（8K）：

碰撞桶从 170 缩到 24——但每个桶承担的语义负载叠加了 7 倍。

IWSLT14 的 BPE 实验证实：8K 词表下，3 个 transformer 层不够深（B0, BLEU=10.66），但 6 层可以（B3, BLEU=11.70）。深度补偿了桶压缩。

梯度怎么从碰撞桶里提取信息？

CE loss 对

的梯度是

。对

的梯度是：

每个 token 的梯度向量与

平行。梯度只沿 hidden 方向更新，而 hidden 本身是高维压缩——所有 32K 个 token 的梯度都投影到同一个 512 维空间上，再分配回各自的

行。

y_i 为 1 的 token（真实标签）和 p_i 较大的 token（top-k collision set）得到显著梯度更新。其余大多数 token 的

，

，近乎 0 更新。

碰撞桶里的 token 共享 hidden 空间的方向信息。 Softmax 不做的事情是：它不分配方向——它只归一化大小。方向是 Linear 在投影时决定的。

回到我们实验的倒 U 曲线

A8-A12 的 K_lang 扫描结果就是对这个理论最好的验证：

A8(CE-only)  BLEU=3.45     ← K_lang 全部分流失（无 collision 意识）
A9(k=50)     BLEU=3.35     ← 桶太少，过拟合
A10(k=170)   BLEU=3.63     ← K_lang 精确匹配碰撞桶数
A11(k=500)   BLEU=3.09     ← 噪音开始回流
A12(k=56652) BLEU=3.35     ← 全表 softmax，无约束，信号消失

线性层的输出 z_i 的 top-k 选择（k = K_lang×|V| ≈ 170）不是随意选的——它是碰撞常数决定的。把 softmax 分母限制在碰撞桶内，梯度不再被稀释到无关 token 上。

碰撞是双向的——正反向 Hash 不对称

Linear 的碰撞不在单方向上。正向和反向的 Hash 路径是同一组参数，但经历不同的约束条件：

Token (DE) → Encoder → h_t → W·h_t + b → Token (EN)
                              ↑ 碰撞发生在这里
                    向量回传 ← z_i = <W_i, h_t>

正向：释放

hidden 编码了一段包含多种语义的向量。Linear 把它释放到 32K 维词空间——每个 token 得到自己的内积分量。这个过程是稀疏的：一次翻译只输出一个 token，其他 31,999 个概率接近 0。

反向：碰撞

反向看同一个 W。在训练中，同一个 hidden 表示对应多个目标 token——不同的语言对同一个概念映射到同一个 hidden 空间。

以名词为例。名词的翻译大多是一一对应的：

德语 "Haus"  →  英语 "house"    同一个概念
德语 "Buch"  →  英语 "book"     同一个概念

当 “Haus” 和 “house” 分别用不同的 token ID 表示、但经过同一组 hidden → Linear 的重量时，梯度会把这两个 token 的

推向同一个方向——因为它们的 hidden 表示在语义空间里是相同的位置。

但 W 只有 512 维。两个名词挤在一起、三个名词挤在一起……所有翻译中一一对应的名词，都把 W 的对应行推到 hidden 空间的同一个区域。碰撞就此发生。

反向碰撞不是坏事——它恰恰是翻译模型学会 “Haus = house” 的方式。但如果碰撞太重（桶太小），token 之间开始混淆；如果碰撞太轻（全表），梯度被稀释到无关 token 上。

翻译的全过程：

① 编码: 源语言 → hidden      (压缩语义到连续空间)
② Hash: hidden → W·h_t       (连续→离散投影，碰撞发生)
③ 释放: z → 概率 → token     (稀疏表达在词空间)

碰撞不在第 ① 步（Transformer 本体），不在第 ③ 步（softmax 归一化），就在第 ② 步——Linear 把连续的 hidden 映射到离散的词汇空间。这是正反向不对称的核心。

结论

Linear(h_t) = logits_z 在代码里就一行。但它下面是：

翻译的整个信息瓶颈就在这里——不是在 Transformer 的 attention 层，不是 decoder 的交叉注意力，是编码器最后一层 linear 把 continuous hidden 投射到 discrete vocab 的那一步。

K_lang 不是一个调参经验值——它是这个 Hash 函数的理论碰撞常数。

过拟合 = 碰撞桶太散

从朴素的线性回归看过拟合：

问题：

这些高频项的参数变得太大——它们不是在学习信号，是在记忆每个训练点的位置。曲线扭来扭去，拟合了噪声。

NMT 里的过拟合本质上同一个东西，只是表现形式不同：

线性回归:  高频项系数太大 → 记住了噪声的多项式
NMT:       碰撞桶太散 → 每个训练句独占一个 hash 桶 → 记住了训练样本本身

证据来自 B 系列的深度和宽度对比：

B2 有 56M 参数——在 IWSLT 的 160K 句上，每个训练样本可以独占几乎一个 hash 桶。W 有足够维度同时记住每对的德语句子和英语翻译。高频词（“的”、“了”、“is”、“the”）的梯度主导了反向传播，低频但有语义的名词被淹没在参数冗余里。

B3 只有 17M 参数——因为碰撞被强制发生，“Haus” 和 “Gebäude” 必须共享参数。模型被迫去学习：“这两个德语词在语义上是相近的”，而不是死记 “Haus = house”。

K_lang 就是要保证碰撞桶够密、参数不能太大——让模型被迫去学语义共性，而不是死记训练样本。 这条线和线性回归里"控制多项式项数防止过拟合"完全平行。

MoE + 词频 = 按语言特征路由的碰撞桶

Hidden 不一定必须是一个矩阵。MoE（Mixture of Experts）早就把一个 FFN 拆成多个专家：

标准 Transformer:   h → 一个 FFN → 输出
MoE Transformer:    h → 路由 → 选专家 → 专家 FFN → 输出

             h ─┬─→ 专家1 (第0-2层共享)
                ├─→ 专家2 (第3-4层共享)    ← gating 网络根据 h 选
                └─→ 专家3 (第5-6层共享)

已有工作（Shazeer et al. 2017, GShard, Switch Transformer）按 token 级别做路由：每个 token 被分配到一个专家 FFN。但没有人按语言特征来划分专家：

• 专家 A：短句（1-10 词）专用的 hidden 矩阵
• 专家 B：长句（30+ 词）专用的 hidden 矩阵
• 专家 C：高频词专用（“的”、“了”、“is”）

如果路由的 gating 信号不是从 h 学到的，而是从可观测的语言特征（句长、词频、TF-IDF）直接控制，MoE 就从"黑盒分配"变成了"语言学驱动的碰撞桶分配"。这等价于把 K_lang 的碰撞理论作为 MoE 架构的设计指南——每个专家就是一个碰撞桶簇。

这一思路至今未见发表。

Encoder / Decoder = 两个独立的 Hash 网络

Encoder 和 Decoder 的哈希不共享参数：

Encoder:  DE tokens → embedding → self-attn × N → h_enc
         参数: enc W_Q/K/V/O, enc FFN W₁/W₂    (hash 德语 → hidden space)

Decoder:  h_enc + EN tokens → self/cross-attn × N → W_out → logits
         参数: dec W_Q/K/V/O, dec FFN W₁/W₂, W_out  (hash hidden + 英语 → 词表)

唯一共享的是 token embedding（BPE 同词表），但哈希参数本身完全独立。交叉注意力是两者的对接点——decoder 用自己的 Key/Value 连接 encoder 的输出。

推理时 Autoencoding——源句本身即标签

每次推理都可以同时做 autoencoding。源句本身就是免费的标签：

用户输入 DE 句子:

① autoencoding: DE → Encoder → h → Decoder_DE → DE
                              ↓
                 loss = CE(预测DE, 原文DE) → ∇W_enc, ∇W_dec_de

② 翻译:        DE → Encoder(已更新) → Decoder_EN → EN

架构上只需多一个 DE 输出头——Phase 6 的 dual-head（CE+SB）已经证明双头可行：

h ─┬─→ Linear_EN → softmax → EN token   (翻译)
   └─→ Linear_DE → softmax → DE token   (autoencoding, 自监督更新)

每次推理都同时完成 autoencoding——encoder 的德语 hash 随着使用越来越密。

TODO (待实验): 在现有 dual-head 架构基础上加 autoencoding 头，对比推理阶段开启/关闭 autoencoding 时，长文本 DE→EN 翻译 BLEU 的变化曲线。预期：autoencoding 开启后，encoder hidden 聚类质量随推理量上升，BLEU 持续增长。

自学习与翻译训练的比例

Autoencoding 和翻译训练对参数的影响不对称：

autoencoding:   DE → Encoder → Decoder_DE → DE     → ∇W_enc + ∇W_dec_de  (双端更新)
翻译训练:       DE → Encoder → Decoder_EN → EN     → ∇W_enc + ∇W_dec_en  (双端更新)

两者都更新 Encoder——但 Decoder 端各管各的语言。如果在推理阶段只做 autoencoding 而不做翻译训练，Encoder 的德语 hash 会越来越密，但 Decoder_EN 长时间未更新，翻译能力退化。

所以需要资源配比：不是"一直做 autoencoding"，而是"按参数变化率配比两种学习路径"。

推理阶段配比约束: 设

$$\alpha$$

为 autoencoding 步数对翻译步数的比率。当

$$\alpha > \alpha^*$$

时，Decoder_EN 退化速度超过 Encoder 受益速度，翻译 BLEU 反降。

$$\alpha^*$$

可通过实验测量。

其他自监督方式

在没有平行语料时，还有几条路可以单独更新 Encoder 或 Decoder：

• contrastive: 相似句子（短的、主题相近的）的 hidden 拉近，不相似的推远
• masked LM: 挖掉一个词，模型猜它是什么（BERT 预训练的方式）
• autoencoding: DE→DE 自我重建，双端同时学习

Teacher forcing 需要目标语言的标准答案

来算梯度。推理阶段没有——所以参数不动。

但有源句数据本身可以更新 encoder。不需要英文标准答案——只需要德语句子自己：

推理时有的:  DE 源句 → Encoder → h_enc       ✅
推理时没有的: EN 译文                         ❌ (teacher forcing 无法算)

可以更新 encoder 的自监督方式:
  contrastive: 相似 DE 句的 h_enc 拉近，不相似的推远
  masked LM:   DE 句挖掉一个词，encoder 猜它是什么

这些全不需要 EN 标准答案——只需要 DE 源句自己的结构。Encoder 在学习源语言的空间结构，而不是翻译映射。

注意： back-translation（DE→EN→DE）只更新 Encoder 参数。更直接的自监督方式是 autoencoding——DE→Encoder→h→Decoder→DE，让模型自己翻译自己。因为解码器的输出仍是 DE，梯度可以同时更新 Encoder 和 Decoder，两端都参与 hash 碰撞校准。

迁移： Autoencoding 预训练的 Encoder 可以直接用于 DE→EN 翻译——换掉 Decoder 即可。Encoder 学的是"德语怎么压缩到 hidden 空间"，与目标语言无关。这等价于给翻译模型的 encoder 一个冷启动优势：它已经知道德语的内部结构，只需 Decoder_EN 从头学"hidden 怎么释放成英语"。

# 推理时更新 encoder（不需要 y_true）
h_enc = encoder(de_sentence)                    # 有源句，可以算 hidden
loss = contrastive_loss(h_enc, h_enc_neighbor)  # 自监督信号
loss.backward()                                  # 梯度只更新 encoder 参数

这与西瓜书第二章的自助法（bootstrap）一脉相承——用已有数据构造伪标签来训练自己。

单语言训练更新 Encoder——Phase 0 的骨架就是证明

DE 和 EN 都是现实世界的矩阵映射。德语的"Buch"和英语的"book"在物质宇宙中指同一个东西——只是投影到两个不同的词表坐标系里。

既然是同一个世界的两次投影，hash 的碰撞自然双向调整距离。

Phase 0 骨架实验（003）证明了这个假设。骨架模型只做了一件事——用 IWSLT14 的德语文本训练 Encoder 的词嵌入，用英语文本训练 Decoder 的词嵌入。没有翻译任务，没有平行句子，就是单语言训练。

Training loop 的每一步都在双向更新 hash 的参数：

Encoder:  DE → Embedding → hidden   | ∇W_enc ← 德语的内部结构
Decoder:  EN → Embedding → hidden   | ∇W_dec ← 英语的内部结构

Hash 的碰撞约束了参数运动的方向——“Buch"在德语空间里紧挨着"lesen”（阅读），在英语空间里"book"紧挨着"read"。两个语言的内部距离满足同一种几何约束。嵌入的几何被现实世界的物理结构制约——碰撞桶在两端同时被校准。

这就是为什么你可以在没有平行语料时优化 Encoder 参数——因为单语言本身已经包含了"哪些词和哪些词近"的结构信息。hash 碰撞从两端调整距离——编码一端和译码一端在各自的空间里学习物理世界的几何投影。

推论（后期实验验证）： 如果取两个完全相同的预训练模型实例——A 只做推理（冻结），B 在每次中文输入上做 masked LM 自监督更新——定期测试 DE→EN 翻译质量，预期 B 的 BLEU 持续高于 A，且 encoder hidden 的 K-means 聚类质量随时间上升。

实验设计：测量 K_lang

K_lang 不是调出来的——是可以从第一性原理里测出来的。

核心假设

存在一个常数

使得：对于任意词汇量

，最优的 softmax 限制 k 为：

如果 K_lang 是物理常数，那么用不同词表大小跑同一组实验，算出来的

应该收敛到同一个值。

扫描法：多词表验证

自变量： 三个词表大小。

表 测 K_lang 的词表

因变量： 对每个词表，扫描 k 值：

控制变量： d_model=256, 3 层 Transformer, 5 epoch, batch=128, seed=42。

输出： 每个词表画一条 BLEU(k) 曲线。曲线的峰值给出

。

预期结果

BPE 8K:     k* ≈ 24       → k*/|V| ≈ 0.003
BPE 32K:    k* ≈ 96       → k*/|V| ≈ 0.003
Word 56K:   k* ≈ 170      → k*/|V| ≈ 0.003    ← A10 已确认

如果三条曲线的峰值都落在同一个比例上——K_lang = 0.003 就是可复现的物理常数。

替代方法：梯度分布法

不靠扫描 k 值，直接从训练中测量。在大词表（56K）上做几轮全量 softmax 的 forward，收集每个 token 的梯度幅值，排序后找到 “有效梯度” 和 “噪声梯度” 的分界点——那个位置的 token 数就是

，不需要扫描。

压缩还原法：从 Hash 容量直接测量

这是最根本的测法——不需要多词表，不需要扫描，只需要一个自重建模型。

思路：hash 碰撞桶的信息容量是有上限的。用一个过大的 hidden 空间（2× 容器）做同语言自学习——骨架实验已经证明 autoencoding BLEU 可达 90+。然后逐层压缩 d_model，观察 BLEU 的衰减曲线。

实验设计：

① 起点: DE → Encoder(d=1024) → Decoder(1024) → DE
        多语自学习 → BLEU≈90 (整个 hash 空间足够稀疏)

② 压缩: 1024 → 768 → 512 → 384 → 256 → 128 → 64
        每压缩一次 → 重新评估 BLEU
        
③ 观察: 压缩到某个点 → BLEU 开始明显下跌
        那个膝盖点的压缩比 = 信息容量的上限
        = K_lang

背后的原理：

Hash 空间的每个维度承载信息。当维度过高（1024），信息极度稀疏——桶太多，每个桶只装极少数 token，BLEU 很高但不是"泛化好"而是"记住了"。当维度过低（128），信息被压缩到极限——hash 碰撞变得过于密，BLEU 暴跌。

K_lang 就出现在 BLEU 曲线的膝盖处——那个恰好在"记住"和"压缩"之间的维度数。

如果 K_lang 真的是物理常数，那这个膝盖点应该对不同的语言、不同的词表大小都稳定。一个 DE→DE 自重建模型就够了——不需要平行语料，不需要翻译训练。

TODO (待实验): Phase 0 骨架验证。d_model 从 1024 逐层压缩到 64（10 个点），每层 autoencoding 10 epoch 测 BLEU。画出 BLEU(d_model) 曲线，膝盖点即 K_lang。与扫描法（A8-A12 已做）和梯度分布法交叉验证。预期：三种方法收敛到同一个 K_lang ≈ 0.003。

K_lang 量化下限：INT8 训练的理论下界

碰撞桶理论不仅控制哈希参数密度——它还给了训练精度一个硬下限。

每个碰撞桶只需区分

个有效 token。INT8 有 256 个离散级别——恰好覆盖这个下限。FP32 的 7 位有效数字（

个级别）完全过量——多出来的级别存在噪声，不是信号。

量化梯度净化效应： (p−y)·h_t 里低于 1/256 的梯度分量被 INT8 截断——等于自动滤掉了碰撞桶外的噪声。桶内有效信号更干净。

精度下限公式

每维度至少需要

个精度级别，其中：

表 精度 vs K_lang 下限

INT8 能满足碰撞桶的分辨需求——不多不少。K_lang 不是调参值，是衡量必要模型精度的物理常数。

实验验证： FP32 / autocast FP16 / QAT INT8 三组对照训练 T2。预期：INT8 的 BLEU 与 FP32 差异 < 0.5%，同时 batch 可增至 512。若 INT8 的 BLEU 反而更高，则证实 “FP32 存储了噪声，量化截断净化了梯度”。

May the Code be with us.

License: GPLv3
本文《SameTime WMT》系列采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。

RNN 的悲剧不是 hash 桶不够大——是 50 个词共用一条链。Attention 解决了图的问题。但 SoftBLEU 遇到了新问题。

Phase 2 实验总览：SoftBLEU 在 Attention 上失效

H=256, E=256, epochs=5, 64 batch, Attention decoder：

关键发现： SoftBLEU 在 RNN 上 +0.15 (3.06→3.21)。在 Attention 上增益归零。不是 SoftBLEU 的公式错了——是在 56K vocab 上梯度被稀释到了噪声水平。

问题不在 SoftBLEU 的函数形式——在梯度量级

CE 梯度：dCE/dlogit[target] = softmax(target) − 1 ≈ −1

SoftBLEU 梯度：

其中 softmax(c) ≈ 1/56652 ≈ 1.8×10⁻⁵。20 个 ref token 累加后 ≈ 3.6×10⁻⁴。

SoftBLEU 梯度 / CE 梯度 ≈ 1/2800。

在 RNN 上 SB 有 0.15 增益，因为 RNN 的 CE 本身只有 3.06——有足够空间被纠正。在 Attention 上 CE 已到 3.76，2800:1 的梯度差让 SB 信号完全沉没。

K_lang：语言系统的碰撞常数

第 4 层 hash (vocab) 的碰撞空间：

K_lang ≈ 0.003
有效碰撞词数 = K_lang × |V| = 0.003 × 56652 ≈ 170

56K 词汇表里，有意义的碰撞只发生在 ~170 个词之间。其余 56K−170=56482 个词对翻译质量无影响——但在 softmax 分母里均匀稀释梯度。

SoftBLEU 不该在全表上做 softmax——应该在 170 个碰撞桶上做。

Restricted Softmax：把分母从 56K 缩到 170

# 旧：softmax 分母在全表 56652 上求和
probs = softmax(logits, dim=-1)  # 每个 token 概率 ≈ 1.8e-5

# 新：softmax 分母只在 topk + ref ∪ 上求和  
topk_idx = topk(logits, k=170)
restricted = fill(-inf) + topk + ref_tokens
probs = softmax(restricted, dim=-1)  # 每个 token 概率 ≈ 0.006

梯度放大 333 倍：

双头架构与损失函数

定义

设 $T$ 为目标句长，$V$ 为词表大小（56,652），$\alpha$ 为 SB 权重：

其中：

这里 $p_{\text{CE}}$ 是 CE 头产生的概率分布，$p_{\text{SB}}$ 是 SB 头产生的概率分布，$\text{ref}_n$ 是参考译文中长度为 $n$ 的 n-gram 集合。

受限 softmax

全表 softmax 在 $V$=56,652 上计算分母，每个 token 的平均概率 $\approx 1/V \approx 1.8\times10^{-5}$，梯度被均匀稀释。语言系统碰撞常数 $K_{\text{lang}} \approx 0.003$ 指出有效碰撞空间仅有 $k = K_{\text{lang}} \cdot V \approx 170$ 个词。

受限 softmax 只在 top-$k$ + 参考词 ∪ 上归一化：

其中 $\mathbb{K} = \text{topk}(z_t, k) \cup \text{ref}$ 为碰撞桶集合。

梯度分析

对 SB 头输出权重 $W_{\text{SB}}$ 的梯度：

其中 $\partial \text{SB} / \partial W_{\text{SB}}$ 通过受限 softmax 反传。由于分母 $|\mathbb{K}| \approx 190$（vs 全表 56,652），梯度量级放大约 300 倍，从噪声水平（$\sim 10^{-5}$）提升到与 CE 可比（$\sim 10^{-2}$）。

对共享 LSTM 参数 $\theta$ 的梯度：

早期 $\text{SB} \approx 0$ 时 SB 贡献项 $\propto \mathcal{L}_{\text{CE}} \approx 11$（放大），后期 $\text{SB} \to 0.35$ 时 $\partial \text{SB}/\partial \theta \to 0$（梯度衰减）。α 从 0.5 提到 0.8 有效补偿了衰减，维持 $\nabla_{\text{SB}} \neq 0$ 到训练晚期。

          ┌─ out_ce (Linear) ── L_CE ──┐
LSTM ─ hidden_seq ─┤                     ├─ L = L_CE × (1 + α × (1−SB))
                    └─ out_sb (Linear) ── SB ──┘

两个独立的 out 层共享同一个 LSTM。CE 头负责精确 token 学习，SB 头通过碰撞空间内的受限 softmax 提供 n-gram 覆盖度信号。

A8–A12 K_lang 扫描结果

4 epoch, H=256, E=256, seed=42：

k 值画出倒 U 曲线

梯度放大 333 倍生效了——但只在合适的桶数上。桶太少（50），梯度太猛导致超调；桶太多（>500），稀释回噪声。

核心对比：A10 vs A12

同样的双头结构，同样的 CE×SB 乘法损失，唯一变量是 softmax 分母——170 vs 56652。

• A12（全表）：SB_head 的 ∇out_sb 始终在 0.01-0.04 量级，而 ∇out_ce 在 0.24-0.29——信号完全被 CE 淹没
• A10（170）：早期 ∇sb=0.10 vs ∇ce=0.71（7×），SB 头真正参与了学习

SoftBLEU 在 Attention 上首次显著超越 CE 基线。K_lang 碰撞理论验证成立。

A13–A15：梯度衰减修复

A10 的 SB 头梯度在 ep3 衰减到 ∇sb=0.00。测试两种修复方向——换函数形式 vs 加大 α：

结论：换函数形式（sqrt）反降——梯度因子太小（β=0.5 时仅 0.5-0.63×线性）。直接加大 α 从 0.5 到 0.8，SB 头梯度晚期 ∇sb=0.02-0.11 未衰减到零，BLEU 从 3.63 飙到 3.77（+9.3% vs CE-only）。

当前最优：A15：k=170 (K_lang), multiply_linear, α=0.8, BLEU=3.77。

未解问题

1. 峰后衰退——即使 α=0.8，BLEU 仍从 ep3=3.77 滑到 ep4=3.68。可能需 α 渐进升温（--sb-alpha-step）
2. 真实 n-gram——当前 2/3/4-gram 仍是几何衰减占位，只有 1-gram 是 scatter_add

相关文献：可微 BLEU 的学术谱系

可微 BLEU 有两条路——RL 采样估计和直接可微替代。我们的 K_lang restricted softmax 属于后者，但与已有工作在关键细节上不同。

核心对比

详细分析

BoN Difference (arXiv:1911.09320)：将 Bag-of-Ngrams (BoN) 差异直接作为可微 loss，在 NAT 上 +5 BLEU。与我们的 1-gram soft 匹配核心思想一致，但他们在全 vocabulary 上做 softmax——NAT 的基线 BLEU 只有 10-15，梯度稀释问题不如我们的 3.x BLEU 底线明显。无人提出限制 softmax 分母到碰撞空间。

Probabilistic N-gram Matching (arXiv:1809.03132)：EMNLP 2018，用概率 n-gram 匹配计算训练时未来词的匹配度，同时做 greedy search 缓解 exposure bias。+1.5 BLEU。我们的 SoftBLEU 可以视为其简化版（省去搜索，保留概率匹配）——但他们也没限制分母。

MRT (arXiv:1606.02006)：ACL 2016，采样 k 个翻译候选，用 BLEU 加权梯度。n-gram 上的 BLEU 精确但梯度方差高。我们的方案恰好相反——梯度确定性低方差（soft 匹配），但丢失 n-gram 结构。

K_lang Restricted Softmax 的新颖性

三条分叉点：

1. 碰撞空间限制：BoN 和 N-gram Matching 都假设 softmax 在整个 vocabulary 上是有效的——这在 BLEU 15+ 的系统上成立（概率峰值集中）。但在 BLEU 3.x 的小模型上，softmax 概率被 56K 分母均摊到噪声水平。K_lang 理论指出有效碰撞桶只有 170 个，把分母从 56652 砍到 170——这在前人工作中未见。

2. 双头独立梯度：前人用单头（同一个 out layer 接收 CE+BLEU 混合梯度），导致 CE 的强梯度压制 BLEU 的弱梯度。我们的双头架构（out_ce 和 out_sb 两个独立的 Linear 层共享 LSTM）让两个信号在 LSTM 层面乘法叠加，不在 out 层打架。

3. 乘法损失 CE × f(1−SB)：CE+SB 的加法混合假设两个信号独立，乘法假设条件依赖——这与 n-gram 的马尔可夫链统计性质一致。但形式 f(x) = 1 + 0.5x 在 SB→0.35 时退化，需要更激进的函数形式（指数等）。

K_lang 框架的最终形态：四层 hash，桶数与深度互补

Phase 2 到 Phase 6 跨越了 Attention → Transformer 的架构鸿沟，但 K_lang 碰撞理论跨架构成立：

四层 hash 压缩表

BPE 以 7× 因子压缩了第 1、3、4 层的桶数。

桶越少，深度要求越高

Phase 6 实验结果直接验证了这一点：

BPE 把 vocab 从 56K 压到 8K——第 4 层的碰撞桶从 170 缩到 24。在 24 个桶里区分 token，每个桶承担 7× 更多的语义负载。浅模型（3L）的 hidden 层没有足够深度把这些语义分离开。深模型（6L）每层递进一步，在 hidden 维度里重建了被压缩的分辨率。

这就是 hash 碰撞框架的完整闭环：

170→24 的桶压缩需要 3L→6L 的深度补偿。深度不是越大越好——d512/6L 的 56M 参数在 160K 句 IWSLT14 上过拟合，反向证明桶的容量有一个上限：桶再多，没有足够数据灌满就成了空洞。

推论：对于给定的训练数据量，存在最优桶数 × 最优深度的乘积——这解释了 B3 (d256/6L, 17.2M, 24 桶) 为什么是最优甜点。

May the Code be with us.

License: GPLv3
本文《SameTime》系列采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。允许任何形式的复制、修改和分发，但必须继承相同的开源协议，承认在算力宇宙中所有的迭代与变异。

全局实验 ID：全部实验跨系列统一编号 E-001 ~ E-030。E 系列=R01-08, A 系列=E09-23, TI 系列=E24-30。

Phase 1：RNN（纯 tanh）

Phase 2：Attention（LSTM + Bahdanau）

全局结论

1. 换 hash 架构（RNN→Attention）不改变过拟合模式——loss ↓ 时 BLEU ↓
2. SoftBLEU 是缺陷补偿器：RNN 上 +0.15，Attention 上 −0.02。基线越好增益越小
3. 纯 BLEU 梯度永远无法替代 CE：1-BLEU 梯度太小，-log(BLEU) 梯度够但 soft 匹配和 argmax 之间存在结构性鸿沟（BLEU=0）
4. E6（CE+SB λ=0.5）在 RNN 上是最优方案，但在 Attention 上不产生增益

全局结论

换 hash 架构（RNN→Attention）不改变过拟合模式。loss 持续下降时 BLEU 仍在衰退——梯度方向问题比架构问题更深。

May the Code be with us.

License: GPLv3

黑板上的公式是对的。Python 循环是错的。

问题的起点

上一篇 提出了 SoftBLEU——给 BLEU 套一层 softmax，让翻译质量的评价直接参与梯度计算。

写完公式，写完伪代码，写完 base/soft_bleu.py。

然后跑了两小时，0 个 epoch 完成。

不是你代码写得丑——是 Python 循环不该碰 loss 函数

CrossEntropy 的计算复杂度是：

一行 F.cross_entropy(logits, targets)。PyTorch 底层是 CUDA kernel——所有操作在 GPU 上并行，一步完成。每 step 约 0.5 毫秒。

SoftBLEU 的 Python 实现：

def soft_bleu(logits, ref_ids, vocab, max_n=4):
    B, T, V = logits.shape
    probs = F.softmax(logits, dim=-1)

    for b in range(B):                    # Python 循环 ← 64 次
        ref_set = set()                   # Python 数据结构
        for r in ref_ids[b]:              # Python 循环 ← ~50 次
            ref_set.add(r.item())         # tensor→Python 转换

        for t in range(T):                # Python 循环 ← ~50 次
            prob_t = probs[b, t, :]       # 切片
            matched[b] += prob_t[list(ref_set)].sum()  # Python list→tensor

四层嵌套 Python 循环。每一个 probs[b, t, :] 都在触发 tensor→Python→tensor 的往返——这种往返在 GPU 和 CPU 之间产生了几百次数据传输。

每 step 约 500 毫秒。同等条件下 CE 只需要 0.5 毫秒。

差距不是 10 倍或 100 倍——是 1000 倍。

CE 为什么那么快

CE 从 logits 到 loss 走的全是 GPU 原生操作：

logits (B,T,V) → reshape → GPU 矩阵索引 → CrossEntropyLoss kernel → 标量
     ↑                                                              ↑
    全是浮点运算，没有 Python 插足                                  梯度一步到位

SoftBLEU 为什么那么慢

每行 Python 代码都在打断 GPU 流水线：

GPU:  [softmax 算完] → wait...
CPU:  [for b in B] → [for t in T] → [构建 ref_set] → [tensor 切片]
         ↑
    GPU 在等 CPU 把数据从显存拉回来
    每一毫秒的等待 = 几百个 CUDA core 空转

这不是 “Python 慢”。这是一个结构性错误：把 GPU 当成 CPU 在用。Python 循环里切片 tensor，等价于把 CUDA 的并行管线切成一段一段的串行任务——每个 prob_t[list(ref_set)].sum() 都在 GPU 上起一个全新的 kernel launch，而 launch 的时间开销本身就大于计算本身。

结论不在于"不用 SoftBLEU"——在于"正确实现"

SoftBLEU 的理论是对的：给 BLEU 套 softmax，可微，能参与梯度。错的不是理论——是把一个应该在 CUDA 内核里完成的计算写成了四层 Python 循环。

解决方案不是放弃 SoftBLEU。是用向量化操作重写——去掉 Python 循环，用 torch.scatter、torch.where、torch.einsum 这些可以在 GPU 上一步完成的算子。

下一篇：SoftBLEU 的向量化实现——把 1000 倍的差距压回个位数。

SoftBLEU 公式剖析——为什么 2/3/4-gram 是假的

E6 实验使用的 SoftBLEU（bdf4a63 版本）的实际公式：

1-gram（真实的）：

对每个位置 t，求和参考 token 的 softmax 概率 → 除以句子长度 → 得到软 1-gram 精度。这个是真的，可导的。

2/3/4-gram（假的）：

只是 1-gram 精度乘以一个衰减系数。没有真正的 bigram/trigram/4-gram 匹配。 等于把 DC 分量复制三份乘以衰减——高频信息全丢了。

BLEU 合成：

损失函数（E6 混合模式）：

CE 和 1-gram 等价 → 两者本质上在做同一件事 → E6 只是在 CE 上套了个衰减壳。这就是 SoftBLEU 在 RNN 上只加了 +0.15、在 Attention 上只加了 -0.26 的根本原因。

要真正发挥 SoftBLEU 的作用，必须把真实的 2/3/4-gram 软匹配算出来——相邻位置的概率乘积，或者用卷积在 GPU 上一步完成。

时间线

前方的路

SoftBLEU 已验证可行。现在有三条路：

路线 B 最合理——Attention 是自然演进。路线 C 最激进——跳过中间 Phase 直接验证终极架构。

建议先跑 B（Attention + SoftBLEU），验证"更好的 hash 策略 + BLEU 感知梯度"的联合效果。

May the Code be with us.

License: GPLv3

sin 和 tanh 之间的距离不是 0.76 到 3.06。是"自己打自己"和"方向从不出错"之间的距离。

一个失败的实验，一条意外的规律

Phase 1.0 的 RNN 实验测了 7 组 hidden_size，最佳 BLEU 3.06。到此为止，这是一个标准的调参实验。

然后我们做了一个看似无厘头的尝试：把 RNN 的激活函数从 tanh 换成 sin。

理由很朴素——sin 是周期函数。如果翻译本质是 hash 碰撞，周期函数天然支持"多桶"碰撞——同一个输出值可以从无限多个输入周期产生。tanh 只有一个桶（全局单调），sin 有无限个桶。理论上，多桶应该提供更多自由度。

结果：sin RNN 的最佳 BLEU = 0.76。 远低于 tanh 的 3.06。loss 从 6.32 跌到 6.19 就几乎不动了。

这不是"sin 比 tanh 差"这么简单。这个 0.76 里藏着一个更根本的问题。

梯度函数就是学习规律

神经网络的每一步训练都遵循同一个模式：

loss → 计算梯度 → 用梯度更新参数

而"计算梯度"这一步，激活函数的选择是决定性的一环。换个激活函数，就是换一套梯度规则——也就是换一种学习方式。

tanh’ 的范围是 (0,1]。值可以很小（接近饱和区），但符号不变。每一步梯度指向的方向，和全局最优方向一致。衰减只是让步子变小，不会让方向反了。

cos(x) 在每一个 π/2 的倍数处翻转符号。前半句学的方向，后半句亲手推翻。

模拟：为什么方向会反转

假设一段 RNN 的前激活值 z 随句子长度逐步偏移（模拟 W·h_{t-1} 的累积）：

tanh 所有时间步都往同一个方向推——力度越来越小，但方向一致。箱子被慢慢推到目标位置。

sin 在第 3 步翻转了方向。第 1-2 步往东推，第 3-5 步往西推。净位移接近零——箱子在原点附近来回跳舞。

这就是 BLEU=0.76 的根因。不是学不到东西，是学到的东西被自己亲手毁掉了。

好的梯度函数 = 自洽的向量场

把梯度想象成地形图上的箭头。每个参数位置都有一个箭头指向"下山"的方向——这就是向量场。

• tanh 的向量场：所有箭头指向同一个象限。可以弱，但方向一致。优化器只要跟着走，迟早到谷底。
• sin 的向量场：箭头来回翻转。优化器往前走两步，发现箭头指向回头了——刚走的路被否定。

“好的梯度函数"的标准不是"梯度够不够大”，而是"梯度方向是否和全局最优方向一致"。

tanh 的梯度小不是缺陷——它宁愿走得慢，也不走错方向。这是工程上的"慢就是快"。

loss 和 BLEU——两把不同的尺子

如果梯度函数的问题是方向，那还有一个更隐蔽的问题：梯度的方向是谁定的？

答案是 loss——CrossEntropy。但 CrossEntropy 追求的是"逐 token 预测精准"，而 BLEU 考察的是"整句 n-gram 碰撞率"。两把尺子量的是不同的事。

H=512 跑 20 epoch 的铁证：

loss 持续下降（模型自认为越来越好），BLEU 在 epoch 2 达峰后一路衰退（实际翻译质量越来越差）。模型在 teacher forcing 的镜子里觉得自己很美，但别人看到的是东施效颦。

这意味着：即使我们选了一个"方向自洽"的梯度函数（如 tanh），梯度函数追的目标（loss）和最终评价标准（BLEU）之间存在结构性分歧。

BLEU 为什么不能直接当 loss

BLEU 的公式里有一个不可微的步骤——argmax。模型输出 logits 后，必须选一个词（argmax），然后在 n-gram 表里计数。argmax 是离散跳变：无论你把 cat 的概率从 0.4 提到 0.49，选出来的词不变——选的都是其他词。直到概率超过 0.51，argmax 的结果才会突然跳变。

所以 BLEU 对每个参数 W 的偏导链中，∂argmax/∂logits 这一项处处为零。整个梯度链直接断了。

全行业用 CrossEntropy 当 loss 不是因为 CE 比 BLEU “好”——是只有 CE 能传梯度。BLEU 更好，但数学不让你用。

Soft BLEU——让 BLEU 听到梯度的声音

如果把 argmax 换成 softmax，把硬 n-gram 计数换成概率加权：

$p(w|ctx)$ 是模型预测 w 的连续概率。整条链可微——梯度可以直接从 BLEU 近似值流回模型参数。

训练时与 CrossEntropy 混合：

当前仅测试了 λ=0.5（均衡权重）。λ 的最优值、λ 的退火策略（从 1.0 逐步降）仍需实验验证。

四层 Hash 碰撞框架

把翻译过程看作四次 hash 碰撞：

前三次碰撞都参与梯度。第四次——BLEU 碰撞——模型根本听不到。

RNN 的悲剧是第 2 层（时间轴压缩破坏信息结构），Transformer 换了第 2 层（Attention 选择性碰撞），但第 4 层的问题——BLEU 不参与梯度——Transformer 也没解决。

实验结果：SoftBLEU 突破 CE 天花板

H=512, E=128, seed=42, batch=64, 在纯 RNN 上对比 CE-only 和 SoftBLEU 混合损失：

SoftBLEU best BLEU = 3.21（epoch 1），CE-only best = 3.06（epoch 0）。首次突破纯 CE 天花板。

SoftBLEU 值自身从 0.204 → 0.239 逐步提升——模型在学会优化 BLEU 的 soft 近似。但提升幅度只有 +0.15，随后也陷入了过拟合。

向量化是关键。最初的 Python 循环版 2 小时跑不出一个 epoch（详见 第六篇）。用 scatter_add_ 替代 4 层 Python 循环后，5 epoch 仅需 5 分钟，速度提升 1000 倍。

这条路通向哪里

sin 实验的失败，不是告诉我们"sin 不好"。它告诉我们：梯度函数的选择不是调参——是选择一种学习规律。 一个不能自洽的梯度函数，再大的模型也救不回来。

tanh 的梯度方向自洽，但目标是 loss 而非 BLEU。模型沿着 loss 的梯度方向走得太远，BLEU 反而掉进了过拟合的沟。这条沟就是 Soft BLEU 要填的。

后来的实验完整验证了这条规律——从 RNN (BLEU=3.0) 到 Attention (3.77) 再到 Transformer (11.70)，架构在变，但 hash 编码 + 梯度积分的底层逻辑不变。K_lang 在弱模型上补缺陷，在强模型上多此一举。梯度方向的正确性，从 sin→tanh 到 CE→SoftBLEU 到词级→BPE，是一条贯穿 9 篇文章的红线。

详见 008 — 从 3 到 11 的跃迁。

DAG 的血——为什么多项式不是前提，可用 backward() 才是

神经网络的训练本质是一个图上的血液系统：

DAG 骨架 = 拓扑结构（矩阵运算的依赖关系）
grad 血液 = 方向信号（∂L/∂W 沿树往回流动）
矩阵肌肉 = 存储信息（被梯度反复拉扯，最终成形）

ReLU 不是多项式——分段线性，x=0 有折角，数学上不可导。但它能进 DAG——PyTorch 约定折角处梯度为 0，一根人造血管填了那个洞。BLEU 的 argmax 进不了 DAG——不是因为它不光滑，是因为它的 backward 被设计成返回全零。血凝固了。但如果给 argmax 一个人造的 backward：

argmax backward (0/1 风格):
  预测词 ∈ reference → grad = 1
  预测词 ∉ reference → grad = 0

它就有了血。矩阵就能动。数学纯度不重要，方向正确才重要。 sin 失败不是因为进不了 DAG——它是真导数。它失败是因为 cos 正负交替，方向自己打自己。

神经网络的训练，只需要两个条件：血在流（不全零），血的方向不对冲（不反转）。满足这两条，不管信号来自微积分、次梯度、还是 0/1 人造血，矩阵都会进化。

梯度训练 = Hash 编码 + Riemann 积分

神经网络的训练，本质上是把语言逐词逐句 hash 编码进权重张量。每一步梯度是当前 batch 的语言统计快照，训练过程就是把这些快照永久存储：

每一个 optimizer.step() 的执行流程：

1. 词 → embedding hash：token → $\mathbb{R}^d$ 向量，查表
2. 前向撞桶：hidden 层把向量推过 attention/FFN，到 output 层做 softmax 查桶
3. 比对碰撞：预测桶 vs 目标桶 → 算出误差
4. 反向修正：$\nabla\mathcal{L}$ 告诉你桶壁该往哪边挪
5. 积分存储：$W \mathrel{-}= \eta \cdot \nabla\mathcal{L}$ 把这次碰撞经验热记录进权重

这就是 DAG 之血的完整循环：血液（梯度）在骨架（DAG）上流动，每次循环把一次 hash 碰撞的教训写入肌肉（权重矩阵）。

架构和损失函数——同一枚硬币的两面

在 hash 编码框架下，架构和损失函数不再是竞争关系：

• 架构改变 → hidden_seq 的表示能力变了 → ∂L/∂W 经由不同路径回传 → 梯度的接收面不同
• 损失函数改变 → L 的定义变了 → ∂L/∂W 的量级和方向变了 → 梯度的来源不同

Attention 上用 K_lang +0.18 BLEU，Transformer 上一轮架构跳变就 +7.7 BLEU。不是因为 Architecture > Loss，而是因为 Attention 的瓶颈在表示能力（LSTM 时序链），不是梯度方向。当架构表达力够了，但梯度目标离 BLEU 太远——这就是 SoftBLEU / K_lang 该上场的时候。

梯度的多寡和方向才是学习的唯一原料。架构和损失函数只是不同的食谱。

在这个框架下，所有调试的变量都有了统一的物理意义：

其中 lr 和 K_lang 是耦合的——同一个参数更新公式 ΔW = η · ∂L/∂W 里，η 决定走多远，K_lang 决定梯度分配到哪些桶。桶数错了，lr 再调也白搭。

频域梯度——用 IFFT 把离散 BLEU 变成可微曲面

HM 提出一个新的视角：离散函数不可导，不是因为"离散不好"——是微积分不自洽。如果换个数学基底，离散也许就可导了。

傅里叶逆变换就是把时域的离散方波变成频域的正弦波叠加：

原信号是二值的（0 或 1，n-gram 碰上了没有），IFFT 重建后变成一个带限连续函数——在采样点之间自动做了光滑插值。

梯度会学到什么？ 不是每个 token 该改什么——是整句的频谱结构应该向哪个方向偏移：

IFFT 的梯度天然多尺度——同时看低频和高频，不会像 CE 那样在 token 级别上过拟合。本质上是给 BLEU 套了一个频域的正则化外壳——在频率空间里，离散跳变被展开成了光滑的正弦基底。

待验证：Phase 1 RNN 上跑 CE + DCT 频谱损失对照实验。

May the Code be with us.

License: GPLv3
本文《SameTime》系列采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。允许任何形式的复制、修改和分发，但必须继承相同的开源协议，承认在算力宇宙中所有的迭代与变异。

“不要跳过推车直接开跑车。先造一辆吱嘎作响的木板车，体会它为什么散架，再理解锻造淬火的钢架好在哪。”

Phase 1 拆分为两步

Phase 1 原计划走 “RNN Seq2Seq”，但代码里全是 nn.LSTM——中间缺了一环。

现在拆成两步：

Phase 1.0：Vanilla RNN — 推车

RNN 如何"记忆"

每个时间步，RNN 把 上一个隐藏状态 $h_{t-1}$（历史）和 当前输入 $x_t$（现在）揉在一起，过一层 tanh，得到新的隐藏状态 $h_t$。

直观类比：h_t 像一张便签。你每读一个词，擦掉便签上的一部分旧内容，写上当前词的摘要。

• 读第 1 个词 → h_1 记着 “I”
• 读第 5 个词 → h_5 记着一些语法信息 + 部分语义
• 读第 50 个词 → h_50 中，第 1 个词的信息早已被 tanh(W) 连乘 50 次碾成粉末

tanh 的罪：|tanh'(…)| ≤ 1，但实际值通常 « 1。乘以一个权重矩阵 W（通常元素也 < 1），50 步连乘后 ≈ 0。

BPTT：为什么梯度消失了

反向传播需要计算 $\partial L / \partial W$。对于时间步 $t=1$ 的单词，梯度需要穿过 $T-1$ 个时间步才能到达损失函数：

其中 $\frac{\partial h_{k+1}}{\partial h_k} = W_{hh}^T \cdot \mathrm{diag}(\tanh'(\dots))$

连乘项中 $W_{hh}$ 的特征值如果 $\lt 1 \to$ 梯度消失；如果 $\gt 1 \to$ 梯度爆炸。tanh 的导数范围是 $(0, 1]$，进一步压低梯度。

结论：50 个词的句子，前 10 个词 ≈ 没有梯度信号。训练只学到了靠 target 端最近的词。

代码级变化（vs. Phase 0）

# Phase 0: 只处理 target
class DummyModel(nn.Module):
    def forward(self, src, tgt_in):
        return self.out(self.embed(tgt_in))

# Phase 1.0: Encoder 处理 src，Decoder 处理 tgt
class Seq2Seq(nn.Module):
    def forward(self, src, tgt, src_len):
        enc_out, hidden = self.encoder(src, src_len)  # 编码源句
        logits, _ = self.decoder(tgt, hidden)          # hidden 是唯一的信息传递者
        return logits

注意 nn.RNN 只返回 hidden（没有 cell），Decoder 签名更简洁。代价就是"便签"容量极其有限。

对照分析实验 start

实验目的：控制 hidden_size 为唯一自变量，观测 RNN Seq2Seq 的容量-质量关系，验证"信息瓶颈"假说。

固定变量：

自变量：hidden ∈ {16, 32, 64, 128, 256, 512, 1024}（$2^4 \sim 2^{10}$）

运行时间：74 分钟，7 组全通过，无一 OOM。

实验前假设（2026-05-01 修订）

hash 碰撞发生在 embedding lookup，而非 hidden。

从 hash 碰撞的视角：

token "der" → lookup(embedding[74360×E]) → [e₁, e₂, ..., e_E]      ← hash 碰撞在这里
                                                    ↓
RNN 逐词读取 → hidden 随时间步推移，前面的词被 tanh 碾碎              ← 不是碰撞，是擦除
                                                    ↓
最后 hidden₅₁₂ → 前 40 个词的信息 ≈ 消失                         ← 时序破坏，非容量不足

hidden 拥有 512 维空间，但 RNN 不会利用——不是"装不下"，而是前面的内容在时间轴上被后续写入覆盖了。hash 空间够大，写入方式却是有损的。

因此假设：

1. 增大 hidden 对 BLEU 的提升应极小——hash 碰撞不发生在 hidden 维度，hidden 再大也不能阻止时间轴上的信息擦除
2. 真正的瓶颈在两方面：
   • a) embedding 宽度（hash key 长度）：74K 德文词挤在 E 维空间，E 太小则碰撞频繁
   • b) RNN 的时序写入方式：Attention 才能解决（Phase 2）
3. 下一步应拆耦合实验：固定 hidden=512（最优容量），vary embed，验证 hash 宽度才是硬瓶颈

实验结果

完整 jsonl 数据存储于 io: /data/homecicd/sametime/results/metrics_h*.jsonl

实验结论

1. BLEU 天花板 ≈ 3.0 —— 信息瓶颈真实存在

所有配置中最高 BLEU 仅 3.02（H=512, epoch 2）。这验证了 Phase 1.0 理论：无 Attention 的 Seq2Seq 中，Encoder 必须把整个源句压缩成一个固定维度向量，无论 hidden 多大，信息丢失不可逆。增大 hidden 只能缓解，不能突破。

看完整曲线：

• H=16→64：BLEU 随容量从 0 涨到接近 3，这是"容量不足→够用"的阶段
• H=128→512：BLEU 在 2.3~3.0 之间震荡，增长停止——遇到硬天花板
• H=1024：BLEU 反而降到 2.42——过参数化开始损害泛化

2. Loss 下降 ≠ BLEU 提升 —— 过拟合的硬证据

所有 7 组 loss 随 epoch 单调递减（收敛正常），但 BLEU 曲线不是：

这就是经典过拟合信号：模型在训练集上 loss 越来越低，但评估时 BLEU 却往下掉。

3. 最佳容量出现在 H=512

H=256→512→1024 形成倒 U 曲线：

• H=256: 49M, BLEU=2.32
• H=512: 100M, BLEU=3.02
• H=1024: 207M, BLEU=2.42

对 IWSLT14 de-en（160K 训练句），100M 参数恰好匹配数据量。再翻倍参数只是给过拟合喂了更多自由度。

4. 小模型 BLEU 低但"诚实"

H=16 和 H=32 在 epoch 0 时 BLEU 接近 0——容量太小，还没学会任何翻译。但它们的好处是：BLEU 持续上升，不会过拟合，训练到 20 个 epoch 可能最终追上大模型。

5. 时间成本基本线性

206M 参数（H=1024）耗时 29 分钟，3M 参数（H=16）耗时 5 分钟。规模-时间近似 $T \propto N^{0.85}$（接近线性），瓶颈在 vocab embedding （V×H）上而非 RNN 计算。

6. 假设验证：hash 碰撞不在 hidden

64 倍的 hidden 宽度（16→1024），BLEU 仅从 2.13→2.42。这验证了实验前假设：hidden 不是 hash 碰撞的现场。hidden=16 时信息容量才 16 维，但 BLEU 仍达 2.13——说明即使极端压缩，信息仍在传递。更大的 hidden 只是给了 RNN 更多"便签空间"，但没有改变"便签被不断重写"的本质。

因此 Phase 2（Attention）才是突破点，不是更大的 hidden。

实验二：解耦合——固定 hidden=512，vary embed

目的：验证 hash 碰撞究竟发生在 embedding 宽度还是 hidden 容量。

固定：hidden=512（实验一最佳点），epochs=5, lr=1e-3, layers=2, seed=42

自变量：embed ∈ {32, 64, 128, 256, 512, 1024}

实验二结论：倒 U 形，非单调

修正此前判断——embed 对 BLEU 有显著影响，但呈倒 U 形：

1. E=32→128：hash 宽度主导。BLEU 从 2.64 涨到 3.06（+0.42）。74K 德文词挤在 32 维时碰撞频繁，扩到 128 维后每维仅承载 ~580 词，碰撞锐减。
2. E=128→1024：过拟合主导。BLEU 从 3.06 降到 2.74。即使 hash 碰撞更低（1024 维时每维仅 73 词），过大的 embedding 矩阵（168M 参数中的 134M 来自两个 embedding table）让 160K 训练句无法有效训练。
3. 最佳 hash 宽度 = 128 维。对 74K 词表，~580 词/维是最优碰撞密度。
4. 两块天花板合并：增加 hidden 上限 ~3.02（实验一），增强 embed 上限 ~3.06（实验二）。RNN 的 BLEU 硬上限 ≈ 3.0，无论怎么调参都破不了。

两张实验合并解读

实验一: hidden vary, embed=hidden (耦合)
        16→512:  BLEU ↑ (容量不足到够用)
        512→1024: BLEU ↓ (过拟合)

实验二: hidden=512, embed vary (解耦合)
        32→128:  BLEU ↑ (hash 碰撞减少)
        128→1024: BLEU ↓ (过拟合)

共同规律：IWSLT14 de-en（160K 句）的最佳模型容量约 50M 参数（H=256，E=128 均在此附近）。超过此值的参数对 BLEU 贡献为负。

深度解释：为什么是倒 U，而不是"越大越好"？

直觉告诉你：hidden 越大，模型越强，BLEU 越高。但实验事实是倒 U。错在哪儿？

翻译是 hash 碰撞问题。增大 hidden 没有让碰撞变容易——它让碰撞变难了。

把翻译过程看作 hash 运算：

Encoder(德语 "der Mann")  ──→  hidden₅₁₂  ──→  Decoder  ──→  "the man"
      ↑                                   ↑
  把德文"打散"进 512 维空间       从 512 维"还原"出英文

hidden 就是 hash 的密钥空间。问题在于：翻译不是找"任意碰撞"，而是找恰好对应的那个语义映射。

• H=16：hash 空间极小（16 维），但目标也少——梯度下降很容易探索完整个空间，很快找到可行解。代价：空间太小，碰撞是粗糙的（“随便一碰就对上”，翻译不准）。
• H=512：hash 空间恰好——梯度能在 160K 样本指引下找到足够精细的碰撞映射。
• H=1024：hash 空间太大。每个训练的 step 梯度给你一点方向，但 1024 维空间里方向太多，160K 个训练信号根本不够覆盖。梯度在迷雾中摸索，沿着训练集的特征走错了岔路——把训练噪声当成了规律。这就是过拟合的物理本质：hash 空间太大，梯度迷路了。

类比：你在北京找一个地址。

• H=16 是"朝阳区"——很小，你随便走几步就撞到了目的地。但地址过于模糊。
• H=512 是"朝阳区望京街道"——刚好。你有 160K 个路人给你指方向，能精确定位。
• H=1024 是"朝阳区望京街道阜通东大街 6 号院 3 号楼 2 单元 1501 室"——太细了。160K 个路人只能给你含糊的"大概在那边"。你走进了一个巨大的 hash 迷宫，而指点方向的样本量没有变多。你最终停在了一个看起来很像但其实是错误的位置——这就是过拟合的 hash 解释。

直觉的错位：我们混淆了"表示能力"和"学习难度"。更大的 hidden 确实能表示更精细的映射（hash 分辨率更高），但梯度下降未必能找到它。表示能力是线性的，搜索难度是超线性的——两条线交叉处就是倒 U 的顶点。

形式化：碰撞密度模型

HM 提出以下模型：BLEU 由碰撞密度决定，分子控制碰撞概率，分母控制碰撞精度。

其中：

• $N_{\text{data}}$ = 分子 = 训练数据量。增大分子 → hash 碰撞概率增大 → 更容易找到映射。但过大则碰撞太容易，映射粗糙。
• $N_{\text{params}}$ = 分母 = 模型参数量。增大分母 → 碰撞概率减小 → 需要更精确的碰撞。但过大则找不到碰撞。
• $K_{\text{lang}}$ = 语言常数 = 该语言对的最优碰撞密度。这是语言对的固有属性——由源语言词表大小、目标语言词表大小、语法复杂度差异共同决定。当前的实验任务（IWSLT14 de-en）中 $K_{\text{lang}} \approx 0.003$。

epoch 不在公式里。epoch 是"逼近精度"——给定分子分母后，用多少步迭代去逼近理论 BLEU 上限。epoch 提高相当于计算 π 时用更多项——能提高精度，但不改变圆周率本身。

实验验证：

峰值聚集：两个实验的最佳 BLEU 均出现在 P ≈ 0.003 附近（49M 参数 / 160K 句）。

待证伪的预测：

1. 若 $N_{\text{data}}$ 加倍到 320K，最佳 $N_{\text{params}}$ 应翻倍到 ~98M，$K_{\text{lang}}$ 不变。
2. 换语言对（如 en-fr），$K_{\text{lang}}$ 应不同——语法越相似，最优 P 越大。
3. epoch 增大仅逼近理论 BLEU，不改变 $K_{\text{lang}}$ 的位置。

预测 3 证伪测试：epoch 深度

H=1024 完整 20 轮（350W 功耗限制下稳定跑完，零故障）：

H=1024 过拟合更猛烈——epoch 1 即达峰，随后彻底崩溃。Loss 在 epoch 6 见底后反弹至 epoch 19，BLEU 持续震荡在 1.4~2.1 之间低位徘徊。

结论：预测 3 成立，双重验证。 epoch 不改变 $K_{\text{lang}}$。增加 epoch 对 BLEU 的提升为零甚至为负——模型在 teacher forcing 强约束下迅速过拟合训练集，泛化能力 epoch 2 即达上限，之后都是噪声学习。

预测 1 初步测试：数据加倍

假设：若 $N_{\text{data}}$ 加倍（160K→320K），$N_{\text{params}}$ 的最佳点应右移。H=1024（207M）在大数据下应摆脱过拟合，BLEU 从 2.42 上升。

结果（3/5 epoch，GPU 中途掉卡）：

epoch 0 BLEU 从 1.57 跳到 2.50（同 epoch 对比 +0.93），数据加倍大幅缓解了训练初期的冷启动——模型在更多梯度步数的指引下，epoch 0 就能学到不错的映射。但 epoch 1 之后 BLEU 依然衰退（2.33 vs data×1 的 2.42），过拟合路径没有改变——只是起始点提高了。

结论：预测 1 方向正确——数据加倍在 epoch 0 产生了 +0.93 的显著提升。但过拟合路径未被改变，epoch 1 后 BLEU 依然衰退。$K_{\text{lang}}$ 可能不是纯碰撞密度问题——当参数多到 207M 时，即使是 320K 样本也不够填充 hash 空间。需要至少 10 倍数据量（1.6M+ 句）才能在 1024 维 hidden 空间里提供足够的梯度信号。

对照分析实验 end

对照分析实验 end

Phase 1.1：LSTM — 锻造淬火

LSTM 的三扇门 + 细胞状态

关键洞察：$c_t$ 的更新是 加性更新——$f_t \cdot c_{t-1} + i_t \cdot \tilde{c}_t$。没有连乘 tanh！

• 忘了 0.3 旧记忆 + 写入 0.7 新信息 = 新细胞状态
• 梯度通过 c_{t-1}→c_t 可以"直线传递"（LSTM 论文称 “Constant Error Carousel”）
• 遗忘门 f_t 可以在训练中学到 “保留重要信息” vs “丢弃无关信息”

类比：c_t 是一张有"编辑权限"的便签。RNN 只能整张擦掉重写，LSTM 可以选择性地划掉某些字、补上新字。因此 50 步后，第一步的"签名"仍然可能清晰可辨。

RNN vs LSTM 实战对比

代码级变化

# Phase 1.0: RNN
self.rnn = nn.RNN(input_size, hidden_size, num_layers, ...)
output, hidden = self.rnn(embedded, hidden)
# hidden: (num_layers, B, H)

# Phase 1.1: LSTM
self.rnn = nn.LSTM(input_size, hidden_size, num_layers, ...)
output, (hidden, cell) = self.rnn(embedded, (hidden, cell))
# hidden: (num_layers, B, H)
# cell:   (num_layers, B, H)  ← 细胞状态，梯度高速通道

PyTorch 层面: nn.RNN → nn.LSTM 仅改一行。但 LSTM 需要额外维护 cell state，Decoder 的 forward 签名从 (tgt, hidden) 变成 (tgt, (hidden, cell))。

提问环节

Q1: RNN 记忆的本质

RNN 把历史信息"折叠"进一个向量 h_t。这更像"压缩/蒸馏"还是更像"遗忘/丢弃"？如果用信息论的语言描述：h_t 的信息容量由 hidden_size 决定——256 维的向量能无损"记住"多长的句子？

Nio：参考 Phase 0 Q2 的 hash 碰撞理论——如果 h_t 是源语言的 hash 摘要，Decoder 需要从这个固定大小 hash 中"解压"出目标语言。信息容量随句子变长指数下降，这就是信息瓶颈。

HM: 如果只看RNN的问题，也就是h_t的形成过程。公式是

首先是梯度消失，可以看到tanh是单调的，随着刻意的梯度下降，W的元素会越来越小，tanh的输入也会越来越小，tanh的输出也会越来越小，最终导致梯度消失。其次是信息瓶颈，h_t的维度是固定的，无论输入多长的句子，h_t只能提供有限的信息容量。重点来了，我认为梯度下降的操作，就是本质的压缩操作。而这个过程在压缩时，没有一个衡量标准，确认多少信息量丢失了。最终压缩到至极，以至于没有信息增加，梯度消失了。后面的LSTM的设计，就是为了在压缩的过程中，用cell的恒定参数，保存所有信息量，可以看到随着梯度下降，cell是没有压缩的，保持恒定的维度和信息量。这样就解决了梯度消失带来的信息丢失的问题。这也告诉我们，压缩的过程开始写入信息，所以信息的写入顺序也注定了hidden的训练效果。也就是说，越靠近输入端的词，越早被写入hidden，越容易被压缩掉；越靠近输出端的词，越晚被写入hidden，越不容易被压缩掉。这就是为什么RNN更容易记住句子末尾的信息，而忘记句子开头的信息。所以神经网络是一种天然包含时序的压缩方式。

Q2: tanh 的驯服

RNN 用 tanh 激活 → 输出在 (-1, 1) 之间 → 导数最大为 1。LSTM 用 sigmoid (遗忘/输入/输出门) + tanh (候选记忆 + 输出门)。

为什么门控函数用 sigmoid 而不是 tanh？如果所有门都换成 tanh 会发生什么？

HM：看不懂，嚼不动，先放着

Q3: 细胞状态的加法

LSTM 的核心创新是 c_t = f_t*c_{t-1} + i_t*c̃_t——加法而非连乘。除了梯度直通，这种"选择性遗忘 + 选择性写入"与你之前提到的"最低频率过滤"（min_freq=2）有什么本质相似之处？

HM：这里的假设都是抽象的。什么是选择性遗忘 选择性写入？我觉得AI在乱提问。我写点我的理解，首先，一个h_t的容量是有限的，而RNN的选择是，不断覆盖，在h_t域内，只留下最近的信息，这个信息怎么进入h_t的？信息在h_t中选中的概率是不同的。改变参数就是改变获得decode结果的概率。每一次正确的hash碰撞，就是一次BLEU的增加。所以增加层数，能增加参数，容量就越大。而参数越多，encoding的过程需要的时间算力就越大，因为是一个压缩过程。所以为了在合适尺度获得更好的效果，需要找到训练数据和训练顺序的完美搭配。为什么LSTM比朴素RNN好？答案是，并不是一定好，如果h_t本身很小，两者应该没有区别，熵增速度太大，h_t根本存不下，所以完全没有差别。在h_t尺度足够的情况下，LSTM因为encoding的方式不同，hash的效果就有变化。cell存在，使得信息能均匀分布到h_t的每个hash位上，而不是重复覆盖在所有位上，这样就能更好地利用h_t的容量，hash碰撞的概率更高效，从而提高BLEU分数。理论上讲，应该可以通过计算h_t的熵增量，来提前评价要一个 encoder 的性能，比如一个长句的熵增显著大于一个短句，一个重复句子的熵增应该更小。而对于h_t的直接评价算法，目前没有。只有loss评价算法。

Q4: RNN→LSTM 的参数膨胀

LSTM 比 RNN 参数多了约 4 倍。在 IWSLT14 这种小数据集（160K 句）上，这个参数冗余是浪费还是必要？如果用 GRU（2 扇门，参数约为 LSTM 的 3/4），BLEU 会不会差不多？

Q5: 信息瓶颈仍然存在

即使换上 LSTM，“上下文向量 c”（Encoder 最后 hidden state）仍然是固定 512 维。Phase 2 引入 Attention 后，Decoder 可以"跳过 c，直接看 Encoder 所有时间步的输出"。

从 LSTM 的 c_t（细胞内记忆）到 Attention 的 c（动态加权上下文），这两个 “c” 从命名到作用有什么本质不同？LSTM 的 c_t 能不能替代 Attention？如果不能，为什么？

Q6: 训练速度与算力

在显存限制下（GTX 3090 24GB），如果 batch_size 从 64 降到 16 才能跑 LSTM，低 batch 引入的噪音和 LSTM 门控的稳定性之间如何权衡？

与Nio的讨论 start

梯度函数的本质：选择一种学习规律

HM 提出：换个激活函数 = 换个梯度函数 = 换种学习方式。sin 是周期函数——周期桶让 hash 碰撞有更多自由度。但实验结果 BLEU=0.76（tanh 3.06），彻底失败。

失败原因：sin 的梯度 cos(x) 正负交替——前半句学的方向，后半句自己推翻。余弦每穿过 $\pi/2, 3\pi/2...$ 就翻转符号，模型在 hash 桶之间来回跳跃，净位移为零。tanh’ 永远正、永远衰减——笨但方向从不出错。

好的梯度函数 = 自洽的向量场：每一步梯度指向的方向必须和全局最优方向一致。sin 的梯度在周期桶里反复翻转——不是没力气走，是走回来的路正好抵消了走出去的路。

loss 和 BLEU 不是一回事——训练听不到翻译质量

H=512 ep20 的实证：

loss 持续下降（5.69→4.46），BLEU 在 epoch 2 达峰后一路衰退。模型在 teacher forcing 的镜子里觉得自己越来越好，但实际翻译质量越来越差。

根因：CrossEntropy 度量的是"逐 token 预测是否和 tgt 一致"，BLEU 度量的是"整句 n-gram 和 ref 的碰撞率"——两个不同的 hash 空间。loss 在训练 hash 桶里找一模一样的 token，BLEU 在测试 hash 桶里考 n-gram 的碰撞。train 的碰撞太完美（teacher forcing 提供完美答案），test 的碰撞太稀疏（greedy decode 没有完美参考）。

BLEU 为何不能直接当 loss

BLEU 的公式里有 argmax——把 logits 变成离散的词序列。这一步数学上不可导：

第二项 $\partial \text{argmax}/\partial \text{logits}$ 处处为零——无论你预测 cat 的概率是 0.4 还是 0.49，选出来的词不变，直到 0.51 才跳变。梯度在跳变之前为零，在跳变点不存在。

CrossEntropy 能传梯度是因为它不选词——它直接用整个概率分布和 one-hot 目标比对，每个词的预测概率都参与计算。

解决方案：Soft BLEU

把硬 BLEU 的 argmax 换成 softmax，把硬 n-gram 计数换成概率加权：

$p(w|ctx)$ 是模型预测 w 的连续概率，不是 agrmax 的离散结果。整个链条可微——梯度可以直接从 BLEU 近似值流回模型参数。

训练时与 CrossEntropy 混合使用：

$\lambda$ 从 1.0 逐步降到 0.5，让模型从"学 token"平滑过渡到"学翻译"。

四层 hash 碰撞统一框架

HM 提出：翻译本质是四次 hash 碰撞的链式查找：

前三次碰撞都参与梯度，模型拼了命优化。第四次——BLEU 碰撞——模型根本听不到。整个训练的悲剧在于：优化器在追第 1~3 层的碰撞，但评分用第 4 层。

Transformer 改了第 2 层（Attention 替代 RNN 的时序压缩），但第 4 层的问题——BLEU 不参与梯度——Transformer 也没解决。Soft BLEU 是填这条沟的可行方向。

sin 激活函数实验

sin 的多桶 hash 理论方向对——周期桶提供了更多自由度。但 cos 梯度的方向交替翻转让参数在桶之间跳跃，净学习量为零。

与Nio的讨论 end

May the Code be with us.

License: GPLv3
本文《SameTime》系列采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。允许任何形式的复制、修改和分发，但必须继承相同的开源协议，承认在算力宇宙中所有的迭代与变异。

“千里之行，始于足下。用最简模型跑通全流程，才能洞察系统的每一寸肌理。”

专题介绍

本专题聚焦 holds/SameTime/benchmark/wmt/ 目录下的渐进式 WMT 学习路线。 从 Phase 0 开始，逐级深入翻译模型的构建与演化。

Phase 0 是什么

Phase 0 (phase0_skeleton/) 是整套 WMT Benchmark 的实验底座骨架——用最简单的 DummyModel（复制模型）跑通数据加载、训练循环、评估评测的完整管线。

核心组件

学习要点

1. IWSLT14 的数据格式（translation 字段）
2. word-level vocab 的构建与 OOV 处理
3. collate_fn 如何对齐 batch 长度
4. BLEU 的数值范围与意义

提问环节

在深入代码之前，我想先了解你对以下几个问题的看法，以此确立学习起点：

Q1: 整体认知

你如何理解 Phase 0 在整个 WMT 渐进路线（Phase 0 → RNN → Attention → BPE → Transformer）中的定位？它只是一个调试工具，还是另有更深层的工程哲学意义？

从0开始一般都是从简单开始，一则搭建环境，二则明白任务。即是工具的熟练，也是技能的开始。

从环境来说，有以下的几个概念：

1. 数据集，IWSLT14，数据集分为三部分 train+valid+test。其中主要语言是德语和英语。其中德语→英语（de-en） 是最受研究者欢迎的基准方向。
2. 拿到数据该干嘛。
   1. 数据转换，xml转你需要的格式，json text等等
   2. 分词 Tokenization ，没错，token大概就是这个词的缩写，就是"我一把把把把住了"-> “我 一把 把 把 把住 了”。分词的方式有很多，最简单的就是空格分词，当然还有更复杂的BPE分词，WordPiece分词等等。
   3. 过滤,我也没看懂为啥要过滤
   4. 分集，就是训练集和验证集划分，很多技巧，比如抽样划分等等，可按需使用
   5. BPE Byte-Pair Encoding 处理，BPE是一种基于统计的分词方法，主要用于处理未登录词（OOV）问题。它通过将频率较高的子词组合成新的词来减少词汇表的大小，从而提高模型的泛化能力。HM:用颗粒度小的词来组成颗粒度大的词，这样可以减少原子量。这也告诉我们，也许本来的向量化过程，已经被向量复合过一次了
   6. 格式化，把数据转换成模型需要的输入格式，比如很多，这里就不多说了
   7. 写代码，写代码，写代码…
3. 代码的开车步骤是什么? 这个可以看看西瓜书的原理说明，一般来说是这样的：
   1. 建立词表
      • 先读训练集合train_raw
      • 从训练集json中抽取de语和en语文本list,de是src，en是target
      • Vocab构建词表。就是量化的前一步，把文本转成数字的过程。这个过程会把文本中的每个词映射到一个唯一的整数ID上，这样模型就可以处理这些数字了。
   2. DataLoader
      • 加载数据，我的理解，就是每次不能处理全量数据，内存放不下，所以要分批加载，每次加载一部分数据进行训练，这就是batch的概念。
      • collate_fn的作用是把每个batch的数据进行处理，使得它们的长度一致，方便模型进行训练。比如说，句子长度不一样，那么就需要进行padding，collate_fn就可以帮我们完成这个工作。
      • 然后选是否shuffle，打乱数据的顺序，这样可以增加模型的泛化能力。我的理解，这里存在较大性能问题，因为句序可能影响句子含义，shuffle可能会打乱句子顺序，导致模型学习到错误的语义关系。
   3. 选模型
      • 选模型，选个简单的模型，DummyModel，Embedding层和Linear层组成的简单模型，不做翻译，仅验证管线。
      • 详细内容Q2记录
   4. 训练
      • 可参考西瓜书，训练过程一般包括前向传播、计算损失、反向传播和参数更新。前向传播是指将输入数据通过模型进行计算，得到输出结果；计算损失是指将模型的输出结果与真实标签进行比较，得到一个数值来衡量模型的性能；反向传播是指根据损失值计算梯度，并将梯度传递回模型的参数；参数更新是指根据计算得到的梯度来调整模型的参数，以使得损失值最小化。内容机器生成
      • 这里的训练过程使用了 Teacher Forcing，Teacher Forcing 是一种训练技巧，在训练过程中，模型在每个时间步都会使用真实的目标输出作为输入
   5. 验证 内容机器生成
      • 验证，验证过程一般包括评估模型的性能和调整模型的参数。评估模型的性能可以使用各种指标，如准确率、精确率、召回率、F1分数等；调整模型的参数可以使用各种优化算法，如随机梯度下降（SGD）、Adam等。
      • 这里的评估使用了 sacreBLEU，sacreBLEU 是一种用于评估机器翻译系统性能的指标，它通过比较机器翻译输出与参考翻译之间的 n-gram 重叠来计算得分。sacreBLEU 的得分范围通常在 0 到 100 之间，得分越高表示翻译质量越好。

Q2: DummyModel 的设计

DummyModel 使用 teacher forcing + next-token prediction。如果错误地将 tgt[:, :-1] 改为 tgt（即直接预测整句而非 next-token），训练会如何崩溃？这对理解自回归模型的因果结构有什么启示？如果去掉 teacher forcing 中的 shift 操作（即用 tgt 同时作为输入和输出），模型会学到什么？为什么这违背了自回归模型的自回归假设？

先学习：

1. teacher forcing 的概念，teacher forcing 是一种训练技巧，在训练过程中，模型在每个时间步都会使用真实的目标输出作为输入，而不是使用模型之前预测的输出。这种方法可以加速训练过程，并帮助模型更快地收敛。内容机器生成

2. 我的理解

   1. 首先，DummyModel和src语言无关，就是分析target语言而已，请注意，输入的训练数据是target语言，对实验来说，是用自己翻译成自己。
   2. 如果没有相位移动，直接原相位计算，应该和shift差别很大，自己翻译成自己，误差应该是0。因为依然是target语言到target语言的信息分布，相位差0等于没有丢失或者差异，但相位差大于0带来的差别应该很大，尤其是距离越远差距越大。

   logits = model(src, tgt[:, :-1])  # (B, T, V)
   loss = criterion(logits.reshape(-1, logits.size(-1)), tgt[:, :-1].reshape(-1))
   [Phase 0] device=cuda
   building vocab...
   |vocab_src|=74360  |vocab_tgt|=56652
   epoch=0  loss=1.483  BLEU=91.23
   epoch=1  loss=0.292  BLEU=97.32
   [Phase 0] done
   
   logits = model(src, tgt[:, :-1])  # (B, T, V)
   loss = criterion(logits.reshape(-1, logits.size(-1)), tgt[:, 1:].reshape(-1))
   [Phase 0] device=cuda
   building vocab...
   |vocab_src|=74360  |vocab_tgt|=56652
   epoch=0  loss=7.006  BLEU=1.80
   epoch=1  loss=5.777  BLEU=1.88
   [Phase 0] done
   
   logits = model(src, tgt[:, :-2])  # (B, T, V)
   loss = criterion(logits.reshape(-1, logits.size(-1)), tgt[:, 2:].reshape(-1))
   [Phase 0] device=cuda
   building vocab...
   |vocab_src|=74360  |vocab_tgt|=56652
   epoch=0  loss=7.559  BLEU=0.00
   epoch=1  loss=6.696  BLEU=0.00
   [Phase 0] done
   

   如上测试数据，分别是相位差0 1 2的数据结果

Q3: BLEU 的意义

Phase 0 的 BLEU 会极低（接近 0），你如何看待"明知 BLEU 很低仍要跑评估"的行为？这在工程验证中是否必要？

1. 对于DummyModel的相位0的情况，BLEU会很高。因为DummyModel的设计就是让模型直接复制输入的文本作为输出，所以在相位0的情况下，模型的输出与目标文本完全一致，因此BLEU得分会非常高，接近100。

2. 本质上，翻译问题是一个hash碰撞的问题。可以这样认为，一个语言模型描述世界模型的过程，是一次hash运算，将世界知识hash存储到一个矩阵中。而翻译问题，是找到一个算法，可以实现一次巧妙的hash碰撞，使得两个语言模型的hash值，获得同一个矩阵中的存储知识。一般来说，embedding的相似性搜索，就是找到hash碰撞的算法之一。但算法并不唯一，且并不高明。找到hash碰撞的算法，也就是找到一个翻译算法，使得输入和输出的hash值相同，这样就实现了翻译。

3. 问题中说，BLEU很低，这个过程，在上述实验结果中可以看出。0相位 1相位 2相位，BLUE快速降低。我们知道0相位很高是因为自己和自己发生hash碰撞是很容易的，属于同一个语言模型。而1相位，是整个语言模型做了一次相位位移，可以认为，如果存在一个客观知识矩阵，整体距离偏移了1，那么hash碰撞的概率就会大幅降低。2相位，距离偏移了2，hash碰撞的概率就更低了。请注意，如果存在客观知识矩阵的说法并不是已知问题，这里有巨大的危险性，需要慎重对待。

4. 工程必要性，是必须的，因为我们需要验证整个评测流程的正确性。即使我们知道BLEU得分会很低，但如果评测流程有任何错误，我们可能会得到一个不合理的BLEU得分，这会误导我们对模型性能的评估。因此，运行评测是必要的，以确保我们的评测流程是正确的，并且能够正确地反映模型的性能。内容机器生成

HM：这个假设就是一个假设，就是客观知识矩阵，比如也许存在某种外星语言，他们的语言是支持相位位移的，就是相位n之后，依然能保持BLEU很高，那么…我们就得到一个奇怪的teacher forcing的结果，模型在相位n之后，依然能保持高BLEU，这就说明了这个假设的危险性，因为我们并没有任何证据表明存在这样的客观知识矩阵，所以我们需要谨慎对待这个假设。比如《誓食狮》。

Q4: 数据管线

IWSLT14 的 word-level vocab 用了 min_freq=2 过滤低频词，这意味着什么？OOV 词在编码时被映射为 UNK token——在后续 Phase 中这个问题会如何被解决？

内容机器生成过滤低频词的意思是，在构建词汇表时，只有那些在训练数据中出现至少两次的词才会被包含在词汇表中。那些只出现一次的词会被视为低频词，并且不会被包含在词汇表中。这种过滤方法可以帮助减少词汇表的大小，从而降低模型的复杂度和计算资源的需求。

HM:我的理解，如果需要计算低频词，需要足够的信息量。例如一个完型填空问题，用周围的词场，重新扰动word bag的概率分布，是需要有价值的计算。低频词往往代表很大或者几乎全部的word bag，也就无法做预测了。也就是说，预测低频词和从全部word bag中选词是等价的，这样的处理方式，没有意义。

OOV词是什么？OOV（Out-Of-Vocabulary）词是指在训练数据中没有出现过的词。当模型遇到这些词时，由于它们不在词汇表中，无法为它们分配一个唯一的ID，因此会将它们映射为一个特殊的UNK（Unknown）token。这样，模型就可以处理这些未知词，但它无法区分不同的未知词，这可能会影响模型的性能。内容机器生成

Q5: 代码结构

base/dataset.py、base/eval.py、base/utils.py 被所有 Phase 共享。这种设计模式叫什么？它给后续递增式开发带来了哪些好处与风险？

这种设计模式叫做模块化设计（Modular Design）。模块化设计是一种软件设计方法，将系统划分为独立的模块，每个模块负责特定的功能。这些模块可以被多个不同的部分共享和重用。内容机器生成

HM：我觉得是组成的设计模式，就是一个功能，外挂一个组成的模块，这个模块可以被多个功能共享和重用。比如说，数据集模块，评测模块，工具模块，这些都是组成的模块，可以被不同的功能共享和重用。这个问题没啥糖分，不甜，不说了。

请逐一回答上述问题。你的回答将作为本专题的第一篇学习记录，在后续 Phase 中被持续引用和迭代。

May the Code be with us.

License: GPLv3
本文《SameTime》系列 采用 GNU 通用公共许可证第三版 (GNU General Public License v3.0) 协议进行开源发布与分发。允许任何形式的复制、修改和分发，但必须继承相同的开源协议，承认在算力宇宙中所有的迭代与变异。