迁移学习（十一）：跨语言迁移

英语拥有丰富的标注数据，而全球有 7000 多种语言。通过跨语言迁移，仅用英文 IMDB 数据训练的情感分类器可以直接分析西班牙语推文，在 SQuAD 上微调的问答模型能回答印地语问题，甚至从未接触过斯瓦希里语标注数据的模型也能完成可用的斯瓦希里语命名实体识别。

为什么能实现这些？我们从双语词向量对齐讲起——这是该领域的起点；接着介绍多语言预训练模型（如 mBERT、XLM-R），它们使平行语料从必需条件变为可选条件；最后探讨实际落地中的关键问题：零样本迁移、translate-train 与 translate-test 的适用场景，哪些语言对迁移效果较差，以及如何应对低资源语言。

你将学到什么#

• 共享语义空间假设的核心思想及其实现方法——Procrustes 对齐
• mBERT 在没有平行语料的情况下如何进行跨语言迁移，子词词汇表的作用
• XLM-R 的三项改进（数据、采样、规模）及其带来的提升
• translate-train、translate-test 和零样本策略的权衡及如何根据场景选择合适的方法
• 如何为没有直接标注数据的语言对设计 pivot 策略
• 迁移差距的来源——文字系统、语系、资源规模——以及应对方法

前置知识#

• BERT 预训练（MLM、[CLS] 池化），参考第 2 篇
• 迁移学习基础，涵盖第 1 到第 6 篇
• 词向量：稠密向量、余弦相似度

问题定义#

如果表示完全语言无关，那么 $\Delta = 0$ 。实际情况中，$\Delta$ 的范围从英语到德语时可能只有几个点，而从英语到斯瓦希里语时则可能超过二十个点。这篇文章的主要内容就是探讨这个差距的来源以及如何应对。

共享语义空间#

跨语言迁移的核心假设很简单，但当年很难证明：

不同语言只是符号不同，背后的概念是相通的。用一个合适的编码器 $f_\theta$ ，语义相同的输入会落在 $\mathbb{R}^d$ 中相近的位置。

上图是这个假设的简化版：每个圆圈代表一个概念，里面的三个点是同一个意思在三种语言中的向量。如果你的编码器能做到这一点，用英文数据训练的分类头自然也能识别中文和法文的数据——完全不需要翻译。

双语词向量对齐#

在多语言 Transformer 出现之前，这个假设是在静态词向量上验证的。先在英文上训练 word2vec，再在法文上训练一次，得到两个独立的嵌入矩阵 $\mathbf{X}_s, \mathbf{X}_t \in \mathbb{R}^{n \times d}$ （通过一份小的双语词典对齐行）。问题是：是否存在一个线性映射，能把一个空间完全映射到另一个？

它有闭式解。对 $\mathbf{X}_t^\top \mathbf{X}_s$ 做 SVD 分解得到 $\mathbf{U}\boldsymbol{\Sigma}\mathbf{V}^\top$ ，那么 $\mathbf{W}^* = \mathbf{V}\mathbf{U}^\top$ 。Conneau 等人（2018）后来证明，这一步甚至可以完全丢掉双语词典，用对抗训练恢复出 $\mathbf{W}$ ，这才实现了无监督的双语词典抽取。

为什么要讲这个？因为多语言 Transformer 本质上是在更高维的空间里，端到端地隐式完成同样的对齐任务。

多语言预训练#

mBERT：简单粗暴的基线#

Devlin 等人的原始方法非常直接：拿 BERT-base，用 104 种语言的维基百科拼接成一个语料库，共享一份 110K 的 WordPiece 词表，只用 MLM 目标训练，没有平行语料，也不加语言 ID。

出人意料的是，这种方法效果显著。Pires 等（2019）与 Wu & Dredze（2020）的研究指出，其有效性源于三个关键机制：

1. 锚点 token： 数字、标点、专有名词和英文借词（COVID、OK、Internet）在多种语言中长得一模一样。同一个 token 出现在不同语言的上下文中时，它的嵌入会被拉向一个语言无关的中心。
2. 子词重叠： WordPiece 会把同源词切分成共享的片段。比如，international（英语）和 internationale（法语）共享 inter 和 national。两种语言只要共享几千个子词，它们的嵌入就会被间接拉到同一个子空间里。
3. 深层参数共享： 12 层 Transformer 在 104 种语言之间完全共享。从压缩效率的角度看，模型最省比特的方式就是跨语言复用同一套电路，所以它就这么做了。

一项关键实验表明：移除所有锚点 token 后，跨语言 NER 准确率仅下降约 5 个百分点——这说明真正起决定性作用的是子词重叠。

XLM-R：堆数据、改采样、加规模#

Conneau 等（2020）问了一个简单的问题：如果扔掉那些精巧设计，纯粹靠堆规模会怎样？XLM-R 相比 mBERT 改了三点：

采样策略的调整至关重要。若不加干预，模型接触英文的频次将比斯瓦希里语高出数个数量级，导致斯瓦希里语的表征能力退化。用 $\alpha = 0.7$ 后，高资源语言仍然占主导，但长尾语言至少能分到足够的子词共现，学会基础统计规律。最终，XLM-R-large 在 XNLI 上比 mBERT 平均高出约 10 个点——这个差距主要来自长尾语言的表现提升。

子词：被低估的真正主角#

看看“国际化”这个概念在四种语言里的分词结果。inter 和 national 在英语、法语和德语中都出现，共享同一份嵌入；只有中文因为字形完全不同，子词彼此独立。这解释了一个工程现象：共享文字和构词法的语言之间，跨语言迁移几乎是免费的；overlap 越少，迁移越难。 具体来说：

• en → de 很容易：共享拉丁字母，维基百科子词重叠率约 30%。
• en → zh 难一些：模型只能从上下文中学对齐，差距很明显。
• en → sw 的瓶颈不是对齐，而是模型到底见过多少斯瓦希里语。

迁移差距到底从哪来#

这张图展示了 WikiAnn 上零样本 NER 的 F1 分数。每次实验都能看到三个规律：

1. 同语系胜过跨语系： 德语、荷兰语、西班牙语、法语（印欧语系，拉丁字母）的 F1 分数都在 80 左右；阿拉伯语和中文低了大约 10 个点，尽管它们的预训练数据比荷兰语还多。
2. 资源量重要，但收益递减： 斯瓦希里语的预训练数据从 1 GB 增加到 50 GB，效果提升明显；但从 50 GB 增加到 200 GB（德语的量级），几乎没什么变化。
3. 与 in-language oracle 的差距呈现双峰分布。 高资源印欧语种的 oracle 比 XLM-R-large 零样本高 5–10 个点；低资源非拉丁文字的 oracle 则高出 15–25 个点。

把语料规模和零样本性能放在一起看，资源效应就更清楚了：

紫色虚线是 log-linear 拟合，能看出“高资源平台 + 低资源悬崖”的趋势。绿色方块是开启 $\alpha=0.7$ 平衡采样后的结果：英语几乎没有变化，斯瓦希里语和约鲁巴语提升了 5–7 个点。

三种实用迁移策略#

工业界常用的迁移方法有三种，建议在选用前充分理解各自特性。

零样本直接迁移#

用英语标注数据微调 XLM-R，然后直接部署到目标语言上。模型的编码器已经对齐了，分类头只依赖 [CLS] 表示，所以能自然泛化。

• 优点：成本最低，一个模型搞定所有语言，完全不依赖机器翻译。
• 缺点：目标语言和源语言差异大时，准确率损失最明显。
• 适用场景：需要支持大量目标语言，或者目标语言的机器翻译质量差。

翻译后训练 (Translate-train)#

把英文训练集翻译成目标语言，再用翻译后的数据微调模型（通常和原始英文数据一起训练效果更好）。

• 优点：相比零样本迁移，准确率通常能提升 2–5 个百分点，尤其是低资源语言。
• 缺点：成本随目标语言数量线性增长；翻译质量差会拖累效果；除非联合训练，否则每个目标语言都需要单独部署模型。
• 适用场景：目标语言数量少且机器翻译质量较好。

翻译后推理 (Translate-test)#

继续使用英文微调的模型。推理时，先把目标语言输入翻译成英文，再交给英文模型处理。

• 优点：只需维护一个模型，新增语言无需重新训练。
• 缺点：每次推理都要调用一次机器翻译，延迟增加；翻译错误会叠加模型本身的错误。
• 适用场景：临时新增语言，但没有预算重新训练模型。

图中下半部分的表格总结了各类方法的权衡。实践中，多数团队采用分层策略：先以零样本迁移快速上线覆盖全部语言的基线模型；再对流量最高的若干语言启用 translate-train；最后以 translate-test 作为长尾语言的兜底方案。

难点语言对的 Pivot 策略#

对于双向机器翻译都不靠谱的语言对（比如约鲁巴语 → 豪萨语），可以通过高资源语言中转。这三种模式基本涵盖了工业界的主流做法：

• 源端 Pivot（通过英文翻译后推理）。 约鲁巴语输入 → 英文机器翻译 → 英文模型。只要约鲁巴语 → 英文的机器翻译勉强可用就行。
• 目标端 Pivot（通过英文翻译后训练）。 把英文标注翻译成豪萨语，然后训练模型。前提是英文 → 豪萨语的机器翻译质量过关。
• 多源集成： 分别用不同源语言（如英文、西班牙语、德语）训练多个分类器，在目标语言上取预测结果的平均值。当多个源语言的归纳偏置互补时，这种方法往往效果最强。

跨语言提示与代码转换#

现代系统中常见的两个实用技巧。

编码器保持冻结且跨语言；提示则学会了一个任务特定的锚点，不偏向任何一种语言。

代码转换增强： 训练时随机把源语言的一部分词换成目标语言的翻译，同时保留语法结构。这教会编码器更关注 token 的语义，而不是它属于哪种语言。在 GLUECoS 和 LinCE 这些代码混合基准测试中，这种方法能稳定提升 5 到 10 个点。

实现示例#

一个最简化的零样本跨语言分类器，基于 mBERT 或 XLM-R 实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import torch
import torch.nn as nn
from transformers import AutoModel, AutoTokenizer

class CrossLingualClassifier(nn.Module):
    """基于多语言编码器 [CLS] 池化的分类器。"""

    def __init__(self, model_name: str = "xlm-roberta-base",
                 num_classes: int = 3, dropout: float = 0.1) -> None:
        super().__init__()
        self.encoder = AutoModel.from_pretrained(model_name)
        hidden = self.encoder.config.hidden_size
        self.head = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(hidden, hidden),
            nn.Tanh(),
            nn.Dropout(dropout),
            nn.Linear(hidden, num_classes),
        )

    def forward(self, input_ids, attention_mask):
        out = self.encoder(input_ids=input_ids,
                           attention_mask=attention_mask)
        cls = out.last_hidden_state[:, 0]      # [CLS] 向量
        return self.head(cls)

# 训练：输入英文 (input_ids, labels)，反向传播更新编码器和分类头。
# 评估：模型和 tokenizer 不变，直接输入中文或法文数据。
# 编码器共享的子词空间和对齐的 [CLS] 表示承担了主要工作。

比代码更重要的几点实践经验：

• 训练和测试用同一个 tokenizer。tokenizer 不一致是这个领域最常见的隐性问题。
• 零样本场景下，不要冻结编码器。在源语言上完整微调，效果比冻结编码器加线性探针稳定高出 3–5 个点。
• 使用 translate-train 时，按 1:1 混合英文和翻译数据放在同一批次中。如果只用翻译数据训练，不仅无法提升目标语言性能，还会导致源语言性能下降。

Tokenization 的隐性成本#

跨语言迁移有个隐藏成本，几乎没人会在论文摘要里提到：tokenization。像 XLM-R 这种拥有 250K 词表的多语言模型，听起来似乎是“语言无关”的，但它的 BPE 合并规则是为压缩训练语料优化的，而这些语料主要由英语、中文、法语、西班牙语和德语主导。对于语料较少的语言——比如泰卢固语、约鲁巴语、缅甸语——同样意思的句子会被切分成更多子词片段。

具体来看，在 Flores 基准测试中，表达相同意思的一句话会有以下差异：

这带来了两个问题。第一，逐 token 的计算量 ≠ 逐字符的计算量：处理一个泰卢固语请求的成本，是处理信息量相同的英语请求的 2.5 到 3 倍。如果延迟 SLO 是按英语设定的，低资源语言用户很容易超时。第二，模型能用来捕捉实际信号的上下文“槽位”更少了：4096 个 token 的上下文可以容纳 23K 英语字符，却只能装下 8K 泰卢固语字符。长文档任务的表现会悄然下降。

解决办法都不完美。可以重新训练 tokenizer，给低资源语言加权（NLLB 就是这么做的），但这会破坏与下游 checkpoint 的兼容性。也可以改用字节级 BPE（比如 ByT5、GPT-4o），这样每字符成本均等了，但所有语言的序列长度都会变长。还有一种方法是加一个语言检测器，把泰卢固语请求路由到专门的单语模型——虽然运维复杂，但如果真在意低资源语言的质量，这通常是最佳选择。

下次看到论文声称“泰卢固语 zero-shot 达到英语性能的 84%”，先看看 tokenization 的情况。很多时候，差距的一半其实是这个隐性成本，而不是模型本身的问题。

评测中那些悄悄拔高数字的坑#

跨语言评测里有很多看似不起眼、实则容易“注水”的地方。我亲自踩过三个大坑。

Translation-test、zero-shot 和 translate-train 是三码事#

XTREME 基准（Hu et al., 2020）对每个任务都会给出三个数字：zero-shot（用英语训练，用目标语言 X 测试）、translate-test（推理时把语言 X 的测试数据翻译成英语）、translate-train（把英语训练数据翻译成语言 X，然后训练和测试）。这三种方法测的东西完全不同，但很多论文只挑最好的那个数字来报。

Translate-test 在机器翻译系统表现好的语言上占优势，但它会让推理成本翻倍，还引入了额外的 MT 失败风险。Translate-train 在机器翻译质量好且任务对翻译腔不敏感的情况下表现不错，但训练数据的质量完全依赖于翻译系统的水平。真正的 zero-shot 才是衡量多语言迁移能力的诚实指标，通常比论文标题里的数字低 5 到 15 个百分点。

英语测试污染问题#

如果你的“印地语”基准是用 Google Translate 把英语基准翻译过去的，那么你的模型——预训练时见过大量类似翻译文本——很可能已经见过这些数据的某种变体。这种污染会表现为：在翻译派生的基准（如 XNLI）上，zero-shot 分数异常高；而在原生构建的基准（如 TyDiQA）上，分数却低得多。评估多语言模型时，应该给原生构建的基准至少两倍于翻译基准的权重。

算术平均会误导人#

如果一个基准覆盖了 40 种语言，而你报告的是无权重平均值，那么一个高资源语言提升 2% 就能掩盖一个低资源语言下降 8% 的事实。永远要同时报告每种语言的四分位数和平均值，并重点关注最低四分位——这才是模型真正出问题的地方。NLLB 的评估方法堪称典范：他们为每个翻译方向都报告了 mean、median 和最低十分位的 spBLEU。

跨语言评测的自查清单#

在报告结果之前，请先检查以下几点：

1. 明确说明使用的是 zero-shot、translate-test 还是 translate-train。
2. 每个语系至少在一个原生构建的基准上报告性能。
3. 提供最低四分位语言的分数，而不仅仅是平均值。
4. 公开每种被评测语言的分词成本（每个 token 对应的字符数）。

只要在论文里加上这四点说明，就能解决跨语言文献中一半的混乱问题。

通过对抗学习实现无监督嵌入对齐#

上文提到的 Procrustes 解法假设你有一个种子词典 —— 即几千对 $(x_i, y_i)$ ，其中 $x_i$ 是某个词在源语言中的嵌入，$y_i$ 是其翻译在目标语言中的嵌入。但对于大多数语言对，这样的词典并不存在，或者仅存在于同源词和专有名词层面。Conneau 等人（MUSE, 2018）提出的问题是：能否仅从两个嵌入云的分布中恢复对齐 —— 完全不需要平行语料信号？

为何要求 $W$ 正交？因为旋转和反射保持内积不变，从而保持余弦相似度，也保留了 word2vec 花费大量损失预算构建的类比结构（如 $\mathrm{king} - \mathrm{man} + \mathrm{woman} \approx \mathrm{queen}$ ）。无约束的线性映射会轻易压缩低频词方向以欺骗判别器；而正交映射则无法做到这一点。我们在每次梯度更新后执行一次廉价的投影操作来强制正交性：$W \leftarrow (1 + \beta) W - \beta\,(W W^\top) W$ ，其中 $\beta \approx 0.01$ 。这是朝 Stiefel 流形迈出的一阶牛顿步，可在整个训练过程中使 $W^\top W$ 与单位矩阵的偏差保持在 $10^{-3}$ 以内。

在切空间中走一步，再通过 QR 分解回缩到流形上：设 $W - \eta\,\mathrm{grad}\,f(W) = QR$ ，则更新为 $W' = Q$ 。Geoopt 和 PyManopt 将此封装为一行优化器替换。实践中，上述廉价牛顿投影与严格的 Stiefel 优化器在双语词典诱导任务上的 P@1 差距不超过 0.5；前者每步更快，也是 MUSE 实际采用的方法。

对抗阶段能得到粗略对齐 —— 在留出测试词典上通常达到 40–55% 的 P@1。MUSE 的精调技巧能弥补大部分剩余差距：在当前 $W$ 下提取 top-$k$ 互为最近邻的词对，将其视为伪词典，并在此上运行闭式 Procrustes 对齐。迭代两到三次后，en-es、en-fr、en-de 等语言对的 P@1 可提升至 75–82%，仅比使用 5K 词典监督训练的结果低几个百分点。

其中 $r_T(W x)$ 是 $W x$ 与其在目标语言中 $K$ 个最近邻的平均余弦相似度，$r_S(y)$ 同理。在 procrustes_refine 的互最近邻步骤中用 CSLS 替代原始余弦相似度，可在所有已测语言对上再提升 2–4 个 P@1 点。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import torch
import torch.nn as nn
import torch.nn.functional as F

class Discriminator(nn.Module):
    def __init__(self, d=300, hidden=2048, p_drop=0.1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Dropout(p_drop),
            nn.Linear(d, hidden), nn.LeakyReLU(0.2),
            nn.Linear(hidden, hidden), nn.LeakyReLU(0.2),
            nn.Linear(hidden, 1),
        )

    def forward(self, x):
        return torch.sigmoid(self.net(x)).squeeze(-1)


def orthogonal_init(d):
    W = torch.empty(d, d)
    nn.init.orthogonal_(W)
    return nn.Parameter(W)


def project_orthogonal(W, beta=0.01):
    # 朝 W^T W = I 方向的一阶牛顿步
    with torch.no_grad():
        W.copy_((1 + beta) * W - beta * (W @ W.t()) @ W)


def train_muse(X, Y, d=300, n_iter=5000, batch=128, lr=0.1):
    W = orthogonal_init(d)
    D = Discriminator(d)
    opt_W = torch.optim.SGD([W], lr=lr)
    opt_D = torch.optim.SGD(D.parameters(), lr=lr)

    for step in range(n_iter):
        # 采样小批量
        xs = X[torch.randint(0, X.size(0), (batch,))]
        ys = Y[torch.randint(0, Y.size(0), (batch,))]

        # 判别器更新
        opt_D.zero_grad()
        d_src = D(xs @ W.detach().t())
        d_tgt = D(ys)
        loss_D = -(torch.log(1 - d_src + 1e-8).mean()
                   + torch.log(d_tgt + 1e-8).mean())
        loss_D.backward(); opt_D.step()

        # 映射更新（翻转标签）
        opt_W.zero_grad()
        d_src = D(xs @ W.t())
        loss_W = -torch.log(d_src + 1e-8).mean()
        loss_W.backward(); opt_W.step()
        project_orthogonal(W)

    return W


def procrustes_refine(X, Y, W, k=10000):
    # 从 top-k 高频词的互最近邻构建伪词典
    Xs, Yt = X[:k] @ W.t(), Y[:k]
    sim = Xs @ Yt.t()
    src2tgt = sim.argmax(dim=1)
    tgt2src = sim.argmax(dim=0)
    pairs = [(i, j.item()) for i, j in enumerate(src2tgt)
             if tgt2src[j] == i]
    Xp = torch.stack([X[i] for i, _ in pairs])
    Yp = torch.stack([Y[j] for _, j in pairs])
    U, _, Vt = torch.linalg.svd(Yp.t() @ Xp)
    return (U @ Vt).t()

先运行对抗训练循环，再调用 procrustes_refine 两到三次 —— 每次迭代都会改进伪词典和对应的 $W$ 。对抗阶段才是真正起支撑作用的部分：若跳过它而从随机 $W$ 开始精调，则毫无效果，因为随机旋转下的互最近邻纯属噪声。判别器的作用正是将 $W$ 推入 Procrustes 能够接手的优化盆地。

需警惕的一种失败模式是：当源语言和目标语言的嵌入云具有显著不同的各向同性（isotropy） —— 例如一个集中在低维流形上，另一个在 $\mathbb{R}^d$ 中更均匀分布 —— 正交约束会变得过于严格，导致判别器轻松获胜，生成器无法取得进展。诊断方法是绘制 $X$ 和 $Y$ 的奇异值谱；若其有效秩相差超过约 30%，则应在对抗训练前对两个嵌入云进行各向同性归一化预处理（减去均值，再将每个嵌入除以其 $\ell_2$ 范数并重新居中）。这能大致均衡两者的谱分布，使正交 $W$ 按预期工作。掌握这一手段后，多语言预训练看起来就不再像魔法，而更像是在数百种语言和数亿参数上联合求解同一个对齐问题。

跨文字系统的子词统计#

前文“子词是隐藏英雄”的说法是可以验证的。如果共享的子词片段确实是将两种语言拉入同一嵌入子空间的关键，那么两种语言间重叠子词类型的比例应能直接预测迁移准确率。事实的确如此 —— 而文字系统（script）几乎决定了全部，因为 BPE 合并几乎从不跨越文字边界。

其中 $V(\ell)$ 是语言 $\ell$ 在固定大小单语样本分词后实际出现的词元类型集合（注意不是模型的完整词表 —— 那 25 万词元对任一语言大多都是静默的）。同时我们还计算生育率（fertility） —— 每个词元对应的字符数 —— 用于衡量分词器对各语言的编码效率。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from collections import Counter
from typing import Dict, Iterable

def tokenization_stats(tokenizer, corpus: Iterable[str]) -> Dict[str, float]:
    """返回一种语言的生育率、词表集合和总词元数。"""
    types: Counter = Counter()
    n_chars = 0
    n_tokens = 0
    for line in corpus:
        ids = tokenizer.encode(line, add_special_tokens=False)
        types.update(ids)
        n_chars += len(line)
        n_tokens += len(ids)
    return {
        "fertility_chars_per_tok": n_chars / max(n_tokens, 1),
        "vocab": set(types.keys()),
        "n_tokens": n_tokens,
    }


def overlap_matrix(tokenizer, corpora: Dict[str, Iterable[str]]):
    stats = {lang: tokenization_stats(tokenizer, c)
             for lang, c in corpora.items()}
    langs = list(stats.keys())
    M = {}
    for i, a in enumerate(langs):
        for b in langs[i:]:
            va, vb = stats[a]["vocab"], stats[b]["vocab"]
            jacc = len(va & vb) / max(len(va | vb), 1)
            M[(a, b)] = M[(b, a)] = jacc
    return M, {l: stats[l]["fertility_chars_per_tok"] for l in langs}

在每种语言 10 万行样本上使用 XLM-R-base 分词器运行上述代码，得到下表。具体数值随采样略有波动，但整体结构非常稳健：

将其与 XNLI 零样本准确率对照，回归关系几乎过于清晰：重叠度每下降 0.1，XLM-R-base 在 XNLI 上的 F1 就损失约 1.2；而文字系统边界（拉丁 → 非拉丁）还会带来额外约 10 F1 的断崖式下跌，这是仅靠重叠度无法完全解释的。这个“断崖”正是重叠度未能捕捉的部分 —— 当两种语言完全没有共享子词时，模型只能依赖位置和上下文共现来学习对齐，这比直接共享词元 ID 的信号弱得多。

一个有用的直觉类比：子词重叠是跨语言信号的直接通道，上下文共现则是间接通道。直接通道带宽高效 —— 两种语言若都包含 inter，那么每一步中 inter 的嵌入都会免费接收来自双方的梯度更新。间接通道则需要模型进行三角测量：“这个中文句子中第 3 个词元在句法上类似于那个英文句子中第 3 个词元，因此它们的嵌入应位于同一子空间”。这种三角测量需要更多参数和更多训练步数才能收敛，这也正是本文前面资源曲线所展示的现象。

有时比原始重叠度更具预测力的是锚点密度（anchor density） —— 目标语言样本中与源语言完全相同的词元比例（包括数字、命名实体、标点、拉丁字母借词等）。锚点密度与重叠度相关但不等同：中文的锚点密度约为 0.04（主要是数字和如 WTO、iPhone 等拉丁借词），尽管其 Jaccard 重叠度仅为 0.02。锚点密度低于 0.02 的语言（如缅甸语、高棉语、阿姆哈拉语）正是零样本迁移崩溃的语言 —— 它们既无直接子词通道，也缺乏足够的拉丁字母侵入来锚定对齐。

我们只需对上述辅助函数稍作扩展即可计算锚点密度：统计目标样本中同时在源样本中以非平凡频率出现的词元 ID 比例。将阈值设为“在两个样本中均至少出现 5 次”可过滤单次噪声，所得数值在 14 种 XTREME 语言上与零样本 XNLI 准确率的相关系数达 $r \approx 0.78$ —— 优于仅用重叠度（$r \approx 0.61$ ）和语料规模（$r \approx 0.55$ ）。将这三个预测因子组合成一个小型线性回归模型，即可在训练任何模型前将零样本迁移差距预测到 ±3 F1 以内，足以决定是否值得尝试。

这一度量的实际用途是优先级排序。在针对新目标语言微调多语言模型前，先用 overlap_matrix 与你的源语言（如英语）对比。若与英语的重叠度低于 0.10 且无法承受预测的性能差距，你就已知零样本不够用 —— 应提前规划翻译训练或自适应预训练。有了这一诊断工具，下一个问题便是：当重叠度尚可但生育率不佳时该怎么办？即分词器在类型层面高效，却对每个词花费六个词元。

针对低资源语言的分词器再平衡#

本文早前提到的“分词税”表格只是症状，根源在上游。SentencePiece（及一般 BPE）通过贪心合并语料中最频繁的字符序列来训练。如果你的语料包含 40% 英语、8% 中文和 0.1% 泰卢固语，那么最终保留的合并规则只会优化英语和中文 —— 泰卢固语的字符序列永远积累不到足够计数以触发合并。结果是，分词器虽能“处理”泰卢固语（每个字符都有回退方案），但会将一个 40 字符的泰卢固语句子编码为 80 个词元，而同等英语句子仅需 12 个。

其中 $|D_\ell|$ 是语言 $\ell$ 的原始字节数。当 $T = 1$ 时即为自然分布（英语通吃）；当 $T = \infty$ 时所有语言等权重（英语嵌入崩溃）。XLM-R 在训练数据采样中使用 $T \approx 1.43$ （$\alpha = 0.7$ ）；而对于分词器训练，最佳温度更高 —— $T = 3$ 到 $T = 5$ —— 因为词表是一次性固定预算，应优先保障覆盖度而非语言建模能力。

在同一维基百科语料上以 $T = 3$ 重新训练分词器后，生育率显著改善：

英语几乎不变；长尾语言的字符/词元效率大致翻倍。最小化的重训练封装如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import sentencepiece as spm

def retrain_tokenizer(corpus_paths: dict[str, str],
                      out_prefix: str, vocab_size: int = 250_000,
                      T: float = 3.0):
    """corpus_paths: {lang: 单语文本路径}"""
    sizes = {l: __import__("os").path.getsize(p)
             for l, p in corpus_paths.items()}
    weights = {l: s ** (1 / T) for l, s in sizes.items()}
    Z = sum(weights.values())
    probs = {l: w / Z for l, w in weights.items()}

    # SentencePiece 支持按文件设置采样权重
    input_files = ",".join(corpus_paths.values())
    input_weights = ",".join(f"{probs[l]:.6f}" for l in corpus_paths)
    spm.SentencePieceTrainer.train(
        input=input_files,
        input_format="text",
        model_prefix=out_prefix,
        vocab_size=vocab_size,
        model_type="unigram",
        character_coverage=0.9999,
        input_sentence_size=10_000_000,
        shuffle_input_sentence=True,
        # 通过输入权重实现再平衡
        input_weights=input_weights,
    )

def fertility(sp: spm.SentencePieceProcessor, text: str) -> float:
    ids = sp.encode(text, out_type=int)
    return len(text) / max(len(ids), 1)

不幸的是，更换分词器会使所有下游检查点失效。原来词元 ID 8492 表示 ▁the，现在可能表示别的东西。你不能简单地将 XLM-R 权重加载到重新平衡的词表上并期望其正常工作。补救方法是在新分词器上继续预训练 —— 随机初始化新的嵌入层（或对保留下来的词表项通过多对一映射复制旧嵌入），然后在平衡语料上运行 5K–10K 步掩码语言建模。嵌入表收敛很快；底层 Transformer 主体几乎无需调整。

当完整重训练超出预算时，一个更廉价的替代方案是：不重训练分词器，仅进行词表手术。识别当前分词器过度切分的 $k$ 个最常见低资源子词，将它们作为新条目添加到词表末尾，并通过对其组成子词嵌入取平均来暖启动每个新嵌入。分词器的编码逻辑采用最长匹配优先，因此新条目会自动优先生效。这种方法能获得完整重训练约一半的生育率提升，却无需承担灾难性的兼容性成本 —— 在无需重新验证整个模型表面的情况下快速发布修复时非常有用。这也自然引出了一个更广泛的问题：何时值得运行继续预训练？

在目标语言上进行自适应预训练#

零样本迁移假设多语言编码器已经为目标语言提供了可用的表示。对于高资源语言（如德语、西班牙语），确实如此；但对于斯瓦希里语、乌尔都语、缅甸语，虽然表示存在，但训练不足——模型每种语言仅见过数亿个 token，而英语则有 3000 亿个。自适应预训练（adaptive pretraining）是在不破坏跨语言对齐的前提下，将更多算力投入到目标语言上的最经济方式：直接使用现成的 XLM-R checkpoint，在单语目标语料上继续进行 1 万步的掩码语言建模（MLM），然后像往常一样在源语言标签上微调。

为什么这不会破坏跨语言迁移？因为斯瓦希里语文本上的 MLM 梯度只会显著更新嵌入表中与斯瓦希里语高频子词对应的行，并对 Transformer 主干做小幅调整。英语表示则停留在其优化盆地内——它们被两方面锚定：一是缺乏针对它们的训练信号，二是预训练最优解周围的高曲率区域。模型先验向斯瓦希里语形态偏移（在此例中，更好地处理黏着式名词类别前缀），而它与英语共享的跨语言子空间保持不变。随后在英语标签上微调时，就能干净地映射到如今更优的斯瓦希里语表示上。

在 XNLI 上的实证结果如下：

提升幅度与目标语言初始训练不足的程度成正比。那些已接近性能上限的语言（如 de、es）从自适应 PT 中获得的增益不到 0.5 分，不值得投入算力；最大收益出现在表现最差的十分位语言上——这些语言在预训练阶段根本没看到足够数据，无法形成可用表示。自适应 PT 的算力开销与所服务的低资源语言用户数量成正比，而非总流量，这使其成为跨语言预算中杠杆率最高的干预手段。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

import torch
from torch.utils.data import DataLoader
from transformers import (AutoModelForMaskedLM, AutoTokenizer,
                          DataCollatorForLanguageModeling)

def adaptive_pretrain(model_name: str,
                      target_corpus_path: str,
                      out_dir: str,
                      n_steps: int = 10_000,
                      lr: float = 1e-5,
                      batch: int = 32,
                      mask_prob: float = 0.15,
                      device: str = "cuda"):
    tok = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForMaskedLM.from_pretrained(model_name).to(device)
    model.train()

    # 流式读取目标语言语料
    def iter_examples():
        with open(target_corpus_path) as f:
            buf = []
            for line in f:
                ids = tok(line.strip(), truncation=True,
                          max_length=512)["input_ids"]
                buf.extend(ids)
                while len(buf) >= 512:
                    yield {"input_ids": buf[:512]}
                    buf = buf[512:]

    collator = DataCollatorForLanguageModeling(
        tokenizer=tok, mlm=True, mlm_probability=mask_prob
    )
    loader = DataLoader(list(iter_examples())[:n_steps * batch],
                        batch_size=batch, collate_fn=collator)

    opt = torch.optim.AdamW(model.parameters(), lr=lr,
                            weight_decay=0.01)
    sched = torch.optim.lr_scheduler.LinearLR(
        opt, start_factor=1.0, end_factor=0.1, total_iters=n_steps
    )

    for step, batch_d in enumerate(loader):
        batch_d = {k: v.to(device) for k, v in batch_d.items()}
        loss = model(**batch_d).loss
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        opt.step(); sched.step(); opt.zero_grad()
        if step + 1 >= n_steps:
            break

    model.save_pretrained(out_dir); tok.save_pretrained(out_dir)

失败模式是过训练。若超过 5 万步，编码器会开始过度拟合目标语言的 MLM 分布，损害跨语言子空间——等到用英语标签微调时，源语言表示已发生漂移，导致分类头迁移效果甚至不如未适配的基线。从业者称之为灾难性遗忘；操作上的信号是：在自适应 PT 过程中，英语的同语言验证准确率下降超过 1 个百分点。一旦出现就应停止。更好的做法是使用低学习率（$1\mathrm{e}{-5}$ 或更低）并严格限制步数在 1 万至 2 万之间。自适应 PT 只提供一次跃升；将其视为离散步骤，即可完全避开悬崖。

有两个改进值得了解。第一，词汇扩展（vocabulary extension）：如果你的分词器导致目标语言的平均词元长度（fertility）超过 4，可基于单语目标语料额外训练一个小型（约 5K 词元）SentencePiece 模型，并将其拼接到现有词汇表中。新嵌入行的初始化方式是：对原分词器下该词元会被拆解成的子词嵌入取平均——这种热启动方式仅需约 2K 步 MLM 即可收敛，而随机初始化则需约 10K 步。第二，混合语言 MLM（mixed-language MLM）：不用纯目标语言批次，而是以 4:1 的比例交替使用目标语言和源语言。少量源语言信号起到锚定作用，防止跨语言子空间漂移；实测表明，这能将灾难性遗忘的临界点从 5 万步推迟到约 10 万步——当你标注数据有限、希望榨取每一滴预训练收益时，这一点至关重要。当单一源语言耗尽后，自然的下一步就是组合多个源语言。

多源跨语言迁移的枢纽集成法#

当你在多个语言（例如情感任务中的英语、西班牙语、德语、法语）上都有标注数据，而目标语言是中文时，问题就变成了：该用哪个源语言进行微调？经验上错误的答案是“最大的那个”（总是英语）。正确答案是全部使用。不同源语言编码了不同的归纳偏置；在目标语言上集成它们的效果稳定优于任一单一源语言，且增益在跨语系目标上最为显著——恰恰是迁移最难的地方。

直觉如下：每种源语言让编码器接触到输入分布与标签之间略有不同的相关结构；推理时，这些差异通过平均作用，形成一种正则化机制，避免模型依赖任一源语言的特异性捷径。这与普通分类器集成的逻辑相同，但在跨语言场景下效果叠加更强，因为源语言特有的捷径更加多样——有更多残余分歧可供平均。

混合权重 $\alpha$ 在一个代理目标分布的源语言验证池上学习——通常是所有源语言开发集的并集，作为迁移质量的估计器。等权平均已是强基线；学习权重可再带来 0.5–1.5 的 F1 提升。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import torch
import torch.nn as nn
import torch.nn.functional as F

class PivotEnsemble(nn.Module):
    def __init__(self, encoder, n_sources: int, n_classes: int,
                 hidden: int = 768, route_per_input: bool = False):
        super().__init__()
        self.encoder = encoder
        self.heads = nn.ModuleList([
            nn.Linear(hidden, n_classes) for _ in range(n_sources)
        ])
        self.route_per_input = route_per_input
        if route_per_input:
            self.router = nn.Sequential(
                nn.Linear(hidden, hidden), nn.Tanh(),
                nn.Linear(hidden, n_sources),
            )
        else:
            self.alpha_logits = nn.Parameter(torch.zeros(n_sources))

    def encode(self, input_ids, attention_mask):
        return self.encoder(input_ids=input_ids,
                            attention_mask=attention_mask
                            ).last_hidden_state[:, 0]

    def forward(self, input_ids, attention_mask, source_idx=None):
        h = self.encode(input_ids, attention_mask)
        if source_idx is not None:                  # 训练第 s 个头
            return self.heads[source_idx](h)
        logits = torch.stack([head(h) for head in self.heads], dim=1)
        if self.route_per_input:
            w = F.softmax(self.router(h), dim=-1).unsqueeze(-1)
        else:
            w = F.softmax(self.alpha_logits, dim=-1).view(1, -1, 1)
        return (w * logits).sum(dim=1)

在 XNLI 上，以 {en, es, de, fr} 为源语言，对中文、阿拉伯语和印地语目标进行实验，集成方法比最佳单一源语言高出 +1.5 至 +3 F1——而在三个案例中有两个的最佳单一源语言并非英语（德语在中文上胜出，略显反直觉，因为德语训练的分类器倾向于依赖词序线索而非功能词，而这恰好契合中文特点）。逐样本路由（per-input router）变体在此基础上再提升约 0.5 分：短正式句路由到德语，口语化句子到英语，含糊表述到法语。该路由器很小（2 层 MLP，XLM-R 上约 100 万参数），在分类头冻结后只需几分钟即可训练完成。

一个实用细节：在混合前，用温度缩放的 softmax 输出（$T \approx 2$ ）训练各分类头，否则不同头的 logit 尺度会主导集成计算。最“热”的头会实际上垄断预测，无论 $\alpha$ 如何。通过对各头在其源语言开发集上进行温度校准（在留出集上最小化 $\mathrm{NLL}$ 来优化 $T$ ），可均衡各头贡献，使学习到的 $\alpha$ 真正具有信息量。

一个更微妙的设计选择是：训练时是否共享编码器，还是微调 $S$ 个独立编码器、仅在推理时集成。共享编码器版本在训练和推理时都节省约 $S$ 倍算力，但迫使编码器在所有源语言间折衷——这对零样本迁移有益，但单源性能略弱。独立编码器在内存允许时是最强配置；在 XNLI（$S = 4$ ）上，独立编码器比共享版本再提升约 1 F1，代价是服务时 GPU 内存增加 4 倍。大多数生产系统采用的折中方案是：共享底部 9 层，每源语言微调顶部 3 层加分类头。内存成本约为单模型的 1.4 倍，准确率与完全独立设置相差不到 0.3 F1，且共享的底层在微调时仍能受益于跨源预训练梯度。

有了集成工具，跨语言迁移的完整策略就基本成型了：对齐嵌入、平衡分词器、适配目标语言、再组合多个源语言——每一步都弥合迁移差距的不同切片，而将它们堆叠起来，才是构建严肃多语言系统的真正方式。

常见问题#

mBERT 没有平行语料，为什么还能跨语言？#

三个因素起了作用：跨语言共享的锚点 token（数字、标点、借词）、同源词的子词重叠把嵌入表连接起来，以及深层参数共享让语言无关特征成为最经济的表示。去掉任何一个都会削弱迁移效果；全去掉的话，跨语言能力就彻底没了。

怎么选择源语言？#

优先选标注数据最多的语言，基本就是英语。如果迁移效果差得离谱，再试试同语系的源语言。比如目标是西班牙语时，用意大利语或葡萄牙语标注数据微调，往往比英语效果更好。但目标是斯瓦希里语时，还是得选英语——因为其他语言根本没有标注数据。

XLM-R 和 mBERT，选哪个？#

默认选 XLM-R，除非设备推理资源有限。XLM-R-base（270M）推理速度比 mBERT（110M）慢 1.5 倍，但在所有长尾语言上高出 5–10 个点；XLM-R-large 慢 3 倍，但还能再高 2–4 个点。

理论上限在哪里？#

跨语言迁移的上限由编码器表示空间中源语言和目标语言分布之间的互信息决定。实际观察到的结果是：印欧语系内部的同族语言对差距能缩小到 3–5 个点；跨语系（英 → 中、英 → 阿）通常稳定在 8–12 个点；极低资源语言（如约鲁巴语、斯瓦希里语）的瓶颈不在对齐，而在模型见过这种语言的数据量太少。

translate-train 准确率更高，为什么还要用零样本？#

成本问题。translate-train 需要为目标语言单独跑 MT（训练时增加延迟，还得维护 MT 系统），而且最终通常是“一种语言一个模型”。零样本是一个模型服务 100 种语言。工业界的常见做法是混合策略：零样本兜底，再加上针对头部流量语言的 translate-train。

目标是低资源语言，操作步骤是什么？#

（a）先试 XLM-R-large 零样本。（b）如果效果不够好，做适应性预训练：在目标语言的单语语料上继续跑几个 epoch 的 MLM，然后再微调。（c）如果有对应的 MT 数据，加一份 translate-train。（d）如果能收集到哪怕 100 条目标语言的标注数据，混进去——少量标注数据在零样本基础上的边际收益非常高。

参考文献#

• Conneau, A., Lample, G., Ranzato, M.A., et al. (2018). Word translation without parallel data. ICLR.
• Devlin, J., Chang, M.W., Lee, K., Toutanova, K. (2019). BERT: Pre-training of deep bidirectional Transformers for language understanding. NAACL.
• Pires, T., Schlinger, E., Garrette, D. (2019). How multilingual is multilingual BERT? ACL.
• Wu, S., Dredze, M. (2020). Are all languages created equal in multilingual BERT? RepL4NLP.
• Conneau, A., Khandelwal, K., Goyal, N., et al. (2020). Unsupervised cross-lingual representation learning at scale (XLM-R). ACL.
• Hu, J., Ruder, S., Siddhant, A., et al. (2020). XTREME: A massively multilingual multi-task benchmark. ICML.
• Lauscher, A., Ravishankar, V., Vulic, I., Glavas, G. (2020). From zero to hero: On the limitations of zero-shot language transfer. EMNLP.