Transformer机器翻译模型入门

可视化演示

动态演示Transformer机器翻的核心机制，通过总览/传输/转换/输出四种模式展示关键概念与交互流程。

翻译任务概览：从“词表对照”到“理解式翻译”

回到那家跨国餐厅。最早的“固定对照表”相当于早期机器翻译的规则翻译——语言学家手工编写转换规则，把源语言逐条映射成目标语言。这种方案脆弱得像一张没有余量的菜单：遇到“麻婆豆腐要中辣不要葱”这种组合句，规则就瞬间崩盘。后来餐厅改用“点菜统计”——收集大量双语菜单，用统计规律猜测翻译，这就是统计机器翻译，它比规则灵活，但仍依赖繁琐的特征工程。

直到“理解式翻译官”登场，她不再背词表，而是把整句读进脑海，理解每个词在语境中的角色后再整体写出译文。这个思路对应神经机器翻译，其基石是 Seq2Seq 架构：一个网络负责“读”（编码器），把源句压缩成一个语义表示；另一个网络负责“写”（解码器），逐词生成译文。而 Transformer 的突破在于：它抛弃了 RNN 的循环结构，用“自注意力”让每个词直接与全句所有词互动，训练更快、长句处理更强。翻译官从“顺着菜单一行行读”升级为“一眼扫完整个菜单、同时看清所有搭配”。

数学上，翻译问题可以写成“已知源句 x，最大化译文 y 的概率”：

理解式翻译官的一切本领——读、记、写、挑、评——本质上都是在逼近这个条件概率最大化的目标。这就是机器翻译的“总任务书”。

编码器结构：通读菜单的接待员

接待员的第一件事，是把顾客的中文菜名逐个转换成她能“思考”的格式。每个词先经过输入嵌入，被映射成一个稠密向量——这相当于在菜单上给每道菜贴一个独特的二维码，机器只认这个码。但二维码不含位置信息，“红烧肉”和“肉红烧”码一样，意思却不同。于是需要位置编码，好比在每道菜旁边写上序号：“1号菜、2号菜……”。

位置编码的巧妙之处在于，它不是简单地写一个数字，而是用一组正弦波函数生成。为什么用正弦波？因为不同频率的正弦波组合，既能区分不同位置，又能让模型自然感知“相邻位置”的相似性，就像门牌号既能定位又能推断邻里远近：

有了带序号的词向量，接下来就是接待员的核心动作——自注意力层：每个词都向全句其他词“发问”，看谁和自己的语义关联最强，并把关联紧密的词的信息吸收进来。这相当于接待员看到“红烧”，立刻联想到“肉”和“酱汁”，在脑中形成语境。最后经过前馈网络做一次逐位加工，一层层堆叠后，接待员就产出了整句的深度语义表示，留给后面的出单员使用。

解码器结构：边写边回看的出单员

出单员的工作是“按顺序写英文菜单”，但他有个重要规矩：不能偷看未来的菜名。这对应解码器的掩码自注意力——生成第 3 个词时，只允许看前 2 个已经写出的词，未来的词全部遮住。为什么？因为翻译是逐词生成的，如果允许看未来，模型就会“作弊”，推理时又看不到未来，训练和推理就脱节了。这就好比出单员写菜单时，后面还没想好的菜不能提前写进脑海。

写完一个词后，出单员要做一件关键动作：交叉注意力——翻看接待员的便利贴。在交叉注意力层，解码器的每个词会拿着“查询”去编码器的输出中检索相关信息。比如写 “love“ 时，它查询到源句”爱“和”猫“的语义关联，从而确认动作的对象。交叉注意力让”写“和”读”之间建立了桥梁，这是 Transformer 翻译模型中最核心的信息通道。

逐词生成的过程，就是一个循环：预测下一个词 → 把它加入已生成序列 → 再预测下一个，直到输出结束符。每轮生成都依赖两部分输入：已生成的前置词（经过掩码自注意力），以及编码器输出的源句语义（经过交叉注意力）。出单员就这样一个词一个词地“挤”出整个译文，速度不快但步步为营。这就像写英文菜单：先写主菜名，再写配料，再写做法，写完一个回头看一眼便利贴，确认没写偏，才继续下一个。

注意力机制：译员“说哪看哪”的便利贴

注意力机制是整个 Transformer 的灵魂，它回答了一个问题：写某个英文词时，模型到底该关注源句的哪些部分？在餐厅比喻里，便利贴上写着每道菜和周围菜的关系；在模型里，这个机制被形式化为 Q、K、V 三个角色——查询（Query）、键（Key） 和 值（Value）。

可以把注意力理解成“在便利贴墙上找信息”：Q 是你手里的问题（“我要写下一个词，该参考什么？”），K 是每张便利贴的标题（“这张贴是关于什么食材的？”），V 是便利贴上的具体内容（“食材的具体做法是什么？”）。模型先让 Q 和所有 K 做点积，算出“这个问题和每张贴的匹配度”，再用 softmax 归一化成权重，最后用权重对所有 V 加权求和——注意力有多集中在某张贴，就取多少那张贴的内容。公式如下：

单靠一组 Q/K/V，相当于只有一个便利贴视角。多头注意力则让模型同时开多个“视角”——有的头关注语法关系，有的头关注语义指代，有的头关注位置远近。就像多位助理同时从不同角度读菜单，最后把意见汇总，让理解更全面。正是这种“多视角并行查询”的机制，让 Transformer 翻译长句时比传统模型稳健得多。

束搜索解码：同时试菜，选出最顺口的表达

翻译官写完译文草稿后，还有个关键抉择：如果每个词都有多种候选表达，该选哪条路走到底？ 最朴素的方案是贪心解码——每步只挑概率最高的那个词，一条路走到黑。这就像点菜时只看眼前最贵的那道菜，不管后面搭配是否合理。贪心的问题在于“局部最优不等于全局最优”：第一步选了概率高的 “I“，后面可能把整句带偏；而概率略低的 ”I'll” 也许能引出更通顺的后文。

束搜索（Beam Search） 则聪明得多：它每一步同时保留 K 条概率最高的候选路径（K 称为束宽），像同时试吃几道候选菜，保留最顺口的几份继续往下试。K=1 时束搜索退化为贪心；K 越大，搜索空间越大，效果越好但计算越贵。实际翻译中 K 通常取 4~8。评分时，每条路径的分数是各词对数概率之和，但直接相加会让长句吃亏（概率连乘后数值越来越小），所以还要做长度归一化：

束搜索就像一位细心的传菜主管：不急于定稿，而是手里同时端着几盘候选表达，边走边尝，最后端出整体最顺口的那一道。这个“少而精”的思路，让翻译质量在计算代价可控的前提下显著提升。

BLEU评估：顾客对照标准答案打分

译文生成之后，怎么知道翻得好不好？最直接的办法是请翻译专家人工打分，但成本太高。BLEU（Bilingual Evaluation Understudy） 提供了一种自动化评分法：拿模型译文和一份“标准答案”（参考译文）对照，看两者在 n-gram 层面重合多少。

想象顾客手里有一份名厨定的“标准菜单”，模型译者端出的菜要和标准菜单比对——配料一样算 1-gram 命中，搭配一样算 2-gram 命中，以此类推。BLEU 的核心是修正的精确率（modified precision）：每个 n-gram 的出现次数不能被“重复利用”超过参考译文中出现的次数。比如模型译文把“猫”写了三次，但参考里只有一次，那最多只算一次命中，防止“车轱辘话刷分”。同时还有简洁惩罚（brevity penalty）：译文太短即使全对也要扣分，就像只端出一道“我”不可能是一份完整菜单。综合公式如下：

BLEU 的聪明之处在于：它不用理解语义，只用“词面重合”来估算质量，计算快、可复现，因此成为机器翻译研究中最通用的指标。但顾客打分只看“菜名像不像”，不管“好不好吃”——这就是 BLEU 的局限，我们在后面误区部分会细说。对于翻译工程师来说，BLEU 是快速迭代模型的“仪表盘”，而最终质量还是要靠人工抽查兜底。

训练与展望：教出好译员的“师傅带徒弟”

一台翻译模型是怎么训练出来的？核心方法叫 Teacher Forcing（教师强制）。在训练时，模型生成第 t 个词时，我们不给它看自己前一步生成的“错词”，而是直接喂入参考译文的真实前词——就像师傅在旁边扶着徒弟的手写：即使徒弟第 2 步写错了，第 3 步依然按标准答案教，而不是将错就错。这样训练收敛快、稳定性好；推理时不再有“老师”，模型只能靠自己已生成的词继续写，这就是训练和推理的“暴露偏差”。

训练目标是最小化交叉熵损失。模型对每个位置输出一个词表上的概率分布，我们希望它的预测分布尽量贴近“标准答案”（一个 one-hot 分布）。偏离越远，惩罚越大：

当翻译官训练完成，她的能力就可以部署到现实世界：实时翻译设备把语音切成小块逐句翻译，同声传译场景要求低延迟和高流畅度的平衡，而更深远的意义在于——Transformer 这套“编码器-解码器 + 注意力”的架构，正是今天大语言模型（GPT、LLaMA 等）的底层模板。理解翻译模型，就等于拿到了理解整个现代 NLP 大厦的钥匙。从一间小餐厅走出的翻译官，如今已经成长为千家万户的智能助手。

AI 应用场景

Python 演示

"""Transformer 翻译核心算法演示：束搜索解码 + BLEU 评估"""import mathfrom collections import Counter  def bleu_score(reference, hypothesis, max_n=4):    """计算 BLEU 分数    reference:  参考译文（标准答案）分词列表    hypothesis: 模型生成译文分词列表    """    bp = math.exp(1 - len(reference) / max(len(hypothesis), 1)) \        if len(hypothesis) <= len(reference) else 1.0     total_log, valid_n = 0.0, 0    for n in range(1, max_n + 1):        if len(hypothesis) < n or len(reference) < n:            continue        ref_ngrams = Counter()        for i in range(len(reference) - n + 1):            ref_ngrams[tuple(reference[i:i + n])] += 1        hyp_ngrams = Counter()        for i in range(len(hypothesis) - n + 1):            hyp_ngrams[tuple(hypothesis[i:i + n])] += 1        match = 0        for gram, count in hyp_ngrams.items():            match += min(count, ref_ngrams.get(gram, 0))        precision = match / max(len(hypothesis) - n + 1, 1)        if precision == 0:            return 0.0        total_log += math.log(precision)        valid_n += 1     if valid_n == 0:        return 0.0    return bp * math.exp(total_log / valid_n)  def beam_search_decoding(step_fn, beam_width=3, max_len=10):    """束搜索解码    step_fn: 输入已生成 token 列表，返回下一个 token 的概率分布 dict    """    vocab = ["我", "爱", "猫", "狗", "喜欢"]    end_token = "</s>"    beam = [(0.0, ["<s>"])]     for _ in range(max_len):        new_beam = []        for log_prob, seq in beam:            if seq[-1] == end_token:                new_beam.append((log_prob, seq))                continue            probs = step_fn(seq)            for token in vocab + [end_token]:                prob = probs.get(token, 1e-6)                new_beam.append((log_prob + math.log(prob), seq + [token]))        beam = sorted(new_beam, key=lambda x: x[0], reverse=True)[:beam_width]        if all(seq[-1] == end_token for _, seq in beam):            break     best = max(beam, key=lambda x: x[0])    return best[1][1:-1]  def main():    """模拟一个'训练好的解码器'做演示"""    def mock_step(seq):        last = seq[-1]        if last == "<s>":            return {"我": 0.6, "爱": 0.3, "猫": 0.1}        if last == "我":            return {"爱": 0.7, "喜欢": 0.3}        if last in ("爱", "喜欢"):            return {"猫": 0.6, "狗": 0.4}        return {"</s>": 1.0}     print("=== Beam Search 束搜索解码 ===")    for k in (1, 2, 3):        result = beam_search_decoding(mock_step, beam_width=k, max_len=6)        print(f"束宽={k}: 译文={' '.join(result)}")     print("\n=== BLEU 评估演示 ===")    ref = ["我", "爱", "猫"]    perfect = bleu_score(ref, ["我", "爱", "猫"])    scrambled = bleu_score(ref, ["猫", "爱", "我"])    print(f"完美译文 BLEU: {perfect:.4f}")    print(f"乱序译文 BLEU: {scrambled:.4f}")  if __name__ == "__main__":    main()

1. bleu_score(reference, hypothesis, max_n=4)计算修正的 n-gram 精确率，n 从 1 到 4 加权平均，并用简洁惩罚压制过短译文。
2. hyp_ngrams[gram] += 1统计模型译文的 n-gram 出现次数，用于和参考译文做匹配计数。
3. match += min(count, ref_ngrams.get(gram, 0))关键的一行：对每个 n-gram 取“模型出现次数”和“参考出现次数”的较小值，防止重复刷分。
4. beam_search_decoding(step_fn, beam_width=3, max_len=10)束搜索主逻辑：每一步扩展所有候选词，排序后只保留概率最高的 beam_width 条。
5. probs.get(token, 1e-6)用极小概率兜底词表中未出现的 token，保证对数运算不崩溃。
6. if all(seq[-1] == end_token for _, seq in beam)如果所有候选都已生成结束符，提前终止搜索，节省计算量。
7. mock_step(seq)模拟一个训练好的解码器：根据已生成的最后一个词，返回下一个词的概率分布。

常见误区

面试题