扩散式语言模型：从噪声到文本的迭代生成-平芜编程栈

不少同学第一次看到“扩散式语言模型”这个词，第一反应是：扩散模型不是画图的吗？怎么又跑到 NLP 里来了？

这个疑问很正常。过去两年，扩散模型在图像生成领域几乎是统治级的存在，从 Stable Diffusion 到 Midjourney，背后都是“前向加噪、反向去噪”这套逻辑。而语言模型领域，GPT 系列已经把“预测下一个词”的自回归范式打成了标配。两者一个在连续空间里抹噪声，一个在离散空间里猜 token，看似八竿子打不着。

但事情正在起变化。越来越多研究开始尝试把扩散模型的迭代去噪思想引入语言建模，形成了一个叫“扩散式语言模型”（Diffusion Language Model）的方向。它的目标不是简单地用扩散模型替代 Transformer，而是想解决自回归语言模型在生成效率、可控性、方向性建模上的固有问题。

这篇文章会从零讲清楚扩散式语言模型是什么、为什么会有人做、核心组件有哪些、训练和推理是怎样的流程，以及工程落地时最容易踩哪些坑。不管你是刚接触大语言模型的初学者，还是已经在做 NLP 落地应用的工程师，读完都能对这个方向建立一套完整的认知框架。

1. 扩散式语言模型：解决什么真实问题？

先说结论：扩散式语言模型最大的价值，是让文本生成从“逐个 token 预测”变成“全局迭代精修”。

自回归语言模型（ARLM）的生成方式是线性的：给定上文，预测下一个 token，然后把这个 token 拼到输入里继续预测。这个方式在对话、写作、代码生成等场景表现非常强，但它有一个本质限制——生成方向是单向的。每一步只能根据左边的内容决定右边的内容，无法先想好句子的整体结构，再回头填充细节。

这个问题在长文本生成里尤其明显。写一篇文章时，人类通常是先列提纲、定主题、规划段落结构，再逐句组织语言。但自回归模型没有“先规划后执行”的能力，它只会从左到右逐字输出，所以长文容易出现结构松散、前后矛盾、主题漂移。

扩散式语言模型换了一套思路：先生成一个带噪声的完整文本，再通过多轮去噪逐步恢复出清晰文本。在这个过程里，模型每一轮都能看到整个句子的全部信息，可以同时考虑全局语义和局部语法，天然支持“先粗后细”的生成策略。

从工程角度看，扩散式语言模型还有一个潜在优势：并行化。

自回归生成是严格串行的，生成第 100 个 token 必须等前 99 个全部完成，推理延迟随序列长度线性增长。扩散模型在去噪时，每一轮都在处理完整的序列，理论上可以在多卡上做 token 级并行，大幅缩短长文本的生成时间。

当然，这不是说扩散式语言模型马上要取代 GPT。目前它连“成熟可用”都还算不上，更像是一个正在快速孕育的研究方向。但理解它的原理和潜力，对判断 NLP 技术趋势非常重要。

1.1 什么样的人最应该读这篇文章

如果你属于以下任一情况，这篇文章值得仔细看：

正在做文本生成相关的开发，想知道自回归之外还有哪些新的生成范式。
对扩散模型有了解，但只停留在图像领域，想把它迁移到 NLP。
做大模型应用部署，关心长文本生成效率和可控性问题的解法。
准备入坑 NLP 研究方向，想找一个有前景又还没卷透的方向。

2. 基础概念：语言模型与扩散模型的核心原理

要把“扩散式语言模型”讲清楚，得先把两位主角的原理说透。

2.1 语言模型：预测下一个词的概率分布

语言模型（Language Model, LM）的任务，是计算一段文本出现的概率。

对于一段 token 序列 w₁, w₂, ..., wₙ，自回归语言模型把它分解成条件概率的乘积：

P(w₁, w₂, ..., wₙ) = P(w₁) × P(w₂|w₁) × P(w₃|w₁,w₂) × ... × P(wₙ|w₁,...,wₙ₋₁)

生成时就是逐个采样。这个范式在 GPT、LLaMA 等模型中被验证得非常成功，但它有一个隐含假设：文本生成可以分解成严格的从左到右过程。

这个假设对大部分场景没问题，但对“需要全局规划”的生成任务并不友好。

2.2 扩散模型：从噪声中迭代还原数据

扩散模型最早在图像领域全面爆发，核心思想分两个方向：

前向过程（加噪）：对一张清晰图片逐步添加高斯噪声，经过足够多步之后，图片变成完全的高斯随机噪声。

反向过程（去噪）：训练一个神经网络，学习如何一步步去除噪声，从纯噪声中还原出清晰图片。

也就是说，扩散模型本质上是一个“从无序到有序”的生成模型。它不想着一步到位，而是把生成过程拉长成几十步甚至上千步的迭代过程。每一步只做很小的改动，逐步把结构信息“雕刻”出来。

这种方式的优势在于：

每一步都能看到全局状态，可以做全局优化。
生成过程不是单方向，而是可以反复修正。
天然适合从粗粒度到细粒度的渐进生成。

2.3 关键矛盾：离散文本 vs 连续噪声

既然扩散模型这么强，直接把图像那套搬到文本上不就行了？

问题出在数据的本质差异上。图像是连续信号，每个像素值是 0~255 的实数，加高斯噪声数学上非常自然。而文本是离散符号，词表中的每个 token 是一个索引值，不存在“在 token 和 token 之间插值”这种操作。

比如，“猫”和“狗”之间有什么中间状态？“猫 + 0.2 × 狗”是什么意思？在离散 token 空间里，这个问题没有答案。

所以，扩散式语言模型的关键设计，就是怎么把离散文本映射到连续空间，完成加噪/去噪，再映射回离散文本。

这个映射方式决定了整个模型架构的设计，也是各种扩散式语言模型实现最大的区别所在。常见的方案有嵌入空间加噪、潜在空间扩散、离散扩散三类，后面会详细展开。

3. 为什么是扩散？自回归模型的三个痛点

扩散式语言模型不是研究者拍脑袋想出来的方向，而是自回归模型在特定场景下确实存在短板。

3.1 生成效率：串行解码的瓶颈

自回归模型生成 N 个 token，需要调用 N 次模型推理。当序列很长时，这个开销呈线性增长，且几乎无法并行。

KV Cache 等优化手段能降低单步计算量，但改变不了“必须一步步来”的串行本质。扩散模型则不同，去噪的每一步都在处理整个序列，理论上可以把 token 维度拆到多卡并行。

3.2 可控性：生成过程难以干预

自回归生成过程中，模型每生成一个 token，这个 token 就固定在序列里了。想要在中途修改已经输出的内容，只能重新生成。

扩散模型天然支持“中途干预”：去噪过程没有走完之前，任何一步都可以调整潜变量、局部替换噪声向量、甚至把某段内容强制设置为目标语义。这给可控文本生成提供了更强的操作空间。

3.3 双向建模：缺少全局交互

自回归模型只能看到左侧上下文，这被称为“单向注意力”。虽然可以把文本倒过来再训练一个模型实现双向效果，但单个模型内部始终没有真正的双向信息流。

扩散模型的去噪网络使用 Transformer 时，一般都用双向注意力。每一轮去噪，每个 token 都能看到序列里的所有其他 token，可以实现真正的全局语义交互。

3.4 小结论：互补而非替代

需要强调，扩散式语言模型不是为了“干掉”自回归模型。从当前研究进展看，它在文本生成质量、训练稳定性上还远不如成熟的 GPT 系列。它的真正价值在于提供一种互补能力：当生成任务需要全局规划、灵活可控、并行加速时，扩散范式有独特的结构优势。

4. 扩散式语言模型的核心架构组件

一个完整的扩散式语言模型，不管具体实现如何，都离不开这几个核心组件。

4.1 文本与连续空间的桥接

这是最关键的一环。要让离散 token 能参与连续空间的加噪/去噪，必须先把 token 变成向量。

常见做法有三种：

嵌入空间加噪：把 token 通过 Embedding 层映射为向量，在向量空间里加噪和去噪。去噪网络的输出也是向量，再和词表向量做相似度计算，恢复出 token。这种方式实现简单，但存在嵌入空间各向异性的问题，去噪目标不够稳定。

潜在空间扩散：类似 Stable Diffusion 的思路，先用一个编码器把文本压缩到低维潜在空间，在潜在空间里做扩散，再用解码器生成文本。这个方案需要额外训练文本编码/解码器，但扩散过程更稳定。

离散扩散：直接在离散 token 空间上定义加噪和去噪操作，比如把某些 token 替换为特殊噪声符号 [MASK]，去噪时预测被替换的 token。这种方式更贴合文本的离散本质，数学定义也更复杂。

从当前研究趋势看，嵌入空间加噪是最容易上手的入门方案，也是理解整套流程最好的起点。

4.2 去噪网络

去噪网络负责给定当前带噪声的序列，预测噪声或还原原始序列。

在扩散式语言模型里，去噪网络通常还是选择 Transformer 架构。因为 Transformer 的双向注意力特性非常适合处理完整序列，而且已有的语言模型基础设施（分词、位置编码、注意力优化）都可以复用。

一个典型的做法是：把带噪声的 token 向量序列输入 Transformer，输出每个位置的目标向量表示，然后和词表 embedding 计算相似度，得到每个位置的概率分布。

4.3 加噪策略与时间步

扩散模型的核心特征是“分步加噪/去噪”，每一步对应一个时间步 t。

在图像扩散中，t 通常表示噪声程度：t=0 是清晰图片，t=T 是纯噪声。在文本扩散中，这个定义需要调整，因为文本没有天然的“连续噪声程度”。常见做法有：

对嵌入向量加高斯噪声，噪声强度随 t 增大。
按比例随机替换 token 为 [MASK]，替换比例随 t 增大。
按比例随机替换 token 为词表中的随机 token，替换比例随 t 增大。

无论哪种方式，时间步 t 都要编码成向量，注入去噪网络中，让模型知道当前处理的噪声程度。

4.4 训练目标：从预测噪声到预测原句

图像扩散常用的训练目标是最小化“预测噪声”和“真实噪声”的均方误差。但文本场景下，如果加噪是在 token 级别进行的，更常用的目标是交叉熵损失：让模型预测被遮挡/替换位置的原始 token。

也就是说，扩散式语言模型的训练目标和解码器语言模型在“预测被掩码位置”的预训练任务上高度相似，但推理方式完全不同。前者从高噪声逐步细化，后者对全序列掩码做一次预测。

4.5 小结论：架构上兼容、推理上不同

扩散式语言模型在底子上并没有完全另起炉灶。它可以复用 Transformer、分词器、位置编码，甚至在预训练权重上做初始化。真正的区别在于训练目标的组织方式和推理时的多轮迭代过程。

5. 核心流程拆解：构建一个最小可用的扩散式语言模型

下面用一个简化方案演示整个构建流程。重点不是给出一个能直接上生产的完整系统，而是让你理解每个环节在做什么、为什么这么做。

5.1 整体流程

构建扩散式语言模型的流程可以拆成四步：

数据预处理：把语料转成 token 序列，构建词表。
加噪过程：对 token 序列按时间步 t 逐步加噪。
训练去噪网络：输入带噪序列和时间步，预测原始 token。
推理生成：从全噪声序列出发，迭代去噪，逐步恢复文本。

5.2 数据预处理

# 文件路径：data_preprocess.py from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese") def encode_corpus(texts, max_length=128): encoded = [] for text in texts: tokens = tokenizer.encode( text, max_length=max_length, truncation=True, padding="max_length" ) encoded.append(tokens) return encoded corpus = [ "扩散语言模型是一个新的研究方向", "自回归模型存在生成效率问题" ] train_data = encode_corpus(corpus) print(train_data[0])

这里使用 BERT 这一类带 [MASK] 的分词器，因为后续加噪操作需要用到特殊符号。padding="max_length"保证每条样本长度一致，方便批训练。

5.3 加噪过程

# 文件路径：noise_process.py import random import torch MASK_TOKEN_ID = 103 # BERT 中 [MASK] 的 token id def add_noise(tokens, t, max_t=100): """ 按时间步 t 对 token 序列加噪。 t 越大，替换为 [MASK] 的比例越高。 """ noise_ratio = t / max_t noisy_tokens = tokens.clone() for i in range(len(tokens)): if random.random() < noise_ratio: noisy_tokens[i] = MASK_TOKEN_ID return noisy_tokens # 示例：原始 token 序列 original_tokens = torch.tensor(train_data[0]) noisy_tokens = add_noise(original_tokens, t=50) print("原始:", tokenizer.decode(original_tokens)) print("加噪:", tokenizer.decode(noisy_tokens))

这个实现是理解加噪最简单的方式：按时间步决定掩码比例，随机把 token 替换成 [MASK]。实际研究中还会使用更复杂的加噪策略，比如嵌入空间高斯噪声、部分随机替换等，但核心逻辑一致。

5.4 训练去噪网络

# 文件路径：train_diffusion_lm.py import torch import torch.nn as nn from transformers import BertConfig, BertForMaskedLM class DiffusionLanguageModel(nn.Module): def __init__(self, vocab_size=21128, hidden_size=768): super().__init__() config = BertConfig( vocab_size=vocab_size, hidden_size=hidden_size, num_hidden_layers=6, num_attention_heads=12 ) self.backbone = BertForMaskedLM(config) # 时间步嵌入层 self.time_embedding = nn.Embedding(100, hidden_size) def forward(self, noisy_tokens, timestep): # 将时间步嵌入与 token 嵌入相加 time_emb = self.time_embedding(timestep) hidden_states = self.backbone.bert.embeddings(token_ids=noisy_tokens) hidden_states = hidden_states + time_emb.unsqueeze(1) outputs = self.backbone(hidden_states=hidden_states) return outputs.logits model = DiffusionLanguageModel() optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5) loss_fn = nn.CrossEntropyLoss(ignore_index=-100) def train_step(batch_tokens, timestep): noisy_tokens = torch.stack([ add_noise(t, timestep) for t in batch_tokens ]) logits = model(noisy_tokens, timestep) # 只在被掩码的位置计算损失 labels = torch.where( noisy_tokens == MASK_TOKEN_ID, batch_tokens, torch.tensor(-100) ) loss = loss_fn(logits.view(-1, logits.size(-1)), labels.view(-1)) optimizer.zero_grad() loss.backward() optimizer.step() return loss.item()

这个代码是教学演示，省略了 batch 构造、学习率调度、多卡训练等工程细节。需要注意，时间步嵌入与 token 嵌入直接相加只是一种简化做法，实际项目中通常会把时间步注入到 Transformer 每一层的 attention 机制里。

5.5 推理生成：迭代去噪

推理和训练相反：从全 [MASK] 序列开始，逐步降低噪声比例，不断用模型重新预测所有被掩码位置。

# 文件路径：inference_diffusion_lm.py def generate(model, seq_length=32, steps=10): model.eval() # 初始化为全部 [MASK] tokens = torch.full((1, seq_length), MASK_TOKEN_ID, dtype=torch.long) with torch.no_grad(): for step in range(steps, 0, -1): # 当前时间步 t = torch.tensor([step]) logits = model(tokens, t) probs = torch.softmax(logits, dim=-1) # 每个位置取概率最高的 token predicted = probs.argmax(dim=-1) # 按当前时间步对应的噪声比例决定替换哪些位置 noise_ratio = step / steps for i in range(seq_length): if tokens[0][i] == MASK_TOKEN_ID: tokens[0][i] = predicted[0][i] elif random.random() < noise_ratio: tokens[0][i] = predicted[0][i] return tokenizer.decode(tokens[0], skip_special_tokens=True)

这里的做法是“温柔”版本的生成：每一轮不是一次性把所有 [MASK] 全部填完，而是随着时间步降低逐步填入。这样模型可以在后续几步继续修正早期不太确定的生成结果，这也是扩散式生成和普通掩码语言模型生成的关键区别。

6. 运行结果与效果验证

上面的设计是一个教学级的最小实现，用它来正式训练是不现实的。但通过这个小流程，我们可以验证“扩散式生成”的基本行为。

6.1 运行方式

python data_preprocess.py python train_diffusion_lm.py python inference_diffusion_lm.py

6.2 预期观察到的现象

在小规模语料上运行后，你可能会看到以下现象：

早期的去噪步骤（t 接近最大值）预测结果比较混乱，因为输入的大部分 token 都是 [MASK]，模型缺乏足够上下文。
后期的去噪步骤（t 接近 0）预测越来越准确，因为模型已经可以看到大部分内容。
对比一次性掩码预测，迭代去噪生成的结果在全局连贯性上通常更好。

6.3 判断生成质量的关键指标

指标	说明	监控方式
token 级准确率	预测 token 和真实 token 的匹配率	训练集/验证集上单独统计
困惑度（Perplexity）	生成的序列在参考语言模型下的评分	使用 GPT-2 等模型计算 PPL
多样性	多次生成结果的差异程度	Self-BLEU、distinct-n
可控性	生成结果是否符合指定主题/情感	人工评估或分类器打分

如果你把模型训练到可以稳定生成短句的程度，下一步应该重点观察：去噪步数增加是否真的提升了生成质量。如果增加步数质量不变，说明模型没有学会利用迭代信息，需要检查时间步注入是否有效。

7. 常见问题与排查思路

扩散式语言模型的构建过程中，会遇到不少问题。下面这些是新手最常见的。

问题现象	可能原因	排查方式	解决方案
训练 loss 不下降	时间步嵌入没有正确生效	打印输入向量，检查 time_embedding 是否参与计算	把时间步注入换成更深层的特征相加，或注入每一层 attention
生成的文本全是重复 token	模型只学到了高频 token	检查加噪比例是否过高，导致训练目标过于困难	降低最大噪声比例，或从低噪声预训练开始逐步增加
迭代去噪没有带来收益	推理时每轮把所有 [MASK] 都填完了	检查推理代码中 mask 替换逻辑	改成逐步替换，保留部分不确定位置留到后续步骤
训练时显存不足	序列太长，batch 太大	查看显存占用分布	减小 batch、缩短 max_length，或使用梯度累积
生成结果语义混乱	去噪步数太少	尝试更大的 steps 值	初始从 50~100 步开始调
和图像扩散训练方式混用不兼容	直接套用了图像扩散的 MSE 损失	确认损失是否为交叉熵	文本场景优先用交叉熵预测原始 token

7.1 最容易忽略的问题：数据噪声比例调度

训练时如果每个时间步的加噪比例固定且随机，模型会面临一个困难：同样一个 [MASK] 位置，可能来自低噪声样本，也可能来自高噪声样本。这会导致模型难以收敛。实际项目中通常采用“从低到高”的课程学习策略，先让模型学会预测低噪声样本，再逐步提高噪声比例。

8. 最佳实践与工程建议

了解了原理和流程，最后说几条实践的工程建议。

8.1 从掩码语言模型初始化开始

不要从头训练去噪网络。直接用 BERT 这类掩码语言模型的权重初始化 backbone，会让整个训练过程稳定得多。因为掩码语言模型本质上训练的就是“给部分掩码，预测原 token”，和扩散式语言模型的训练目标高度重合。

8.2 训练阶段要混合噪声级别

如果训练时每个 batch 只用同一个时间步，模型的泛化能力会不足。更稳妥的方式是每个 batch 内混合不同时间步的样本，让模型同时学习处理不同噪声程度。这就像图像扩散训练时随机采样时间步一样。

8.3 推理阶段要设计“确定性↔随机性”的平衡

纯 argmax 解码容易让生成结果过于单一，而纯随机采样又会让结果不稳定。可以借鉴大语言模型里的 temperature 参数：在去噪时，根据当前时间步调整温度，早期随机性高一些，后期更确定。

8.4 与自回归模型做对比评估

任何扩散式语言模型项目，都应该同时用一个同等规模的自回归模型做 benchmark。只有证明扩散式方法在某个指标上确实优于自回归基线，这个方向的投入才是有价值的。建议至少对比三个维度：生成质量、生成延迟、可控性。

8.5 留意计算资源消耗

扩散式语言模型的训练和推理都比自回归模型更重。训练时需要为多个时间步生成样本，推理时需要执行多轮去噪。如果项目对单次推理延迟要求较高，需要做好量化裁剪、蒸馏等工程优化，否则很难达到生产可用标准。

在团队协作上，建议把这个方向的探索分成三个里程碑：第一阶段只验证“能否在小语料上跑通迭代生成”；第二阶段验证“迭代生成是否优于单次掩码预测”；第三阶段才进入大语料训练和应用开发。前两个阶段投入小、判断快，能有效避免在错误方向上浪费大量算力。

9. 总结与后续学习方向

扩散式语言模型，本质上是一次“把图像扩散范式迁移到文本领域”的尝试。它的核心价值不是要取代自回归语言模型，而是为文本生成提供一种新思路：全局迭代代替逐 token 预测，双向交互代替单向建模，多步精修代替一步到位。

这篇文章讲清楚了四件事：

扩散式语言模型要解决什么问题：自回归模型在效率、可控性、全局建模上的不足。
它的核心架构有什么：文本连续化、去噪网络、加噪策略、训练目标，四者缺一不可。
最小实现如何搭建：数据预处理、加噪、训练、迭代去噪推理，四步走通流程。
实践中的关键坑：噪声调度、时间步注入、初始化策略、评估方式。

如果你准备继续深入研究，下一步可以关注几个具体方向：扩散模型在潜在空间如何压缩文本信息、离散扩散的数学定义如何优化、去噪步数如何用蒸馏压缩、扩散式生成在机器翻译和文本编辑任务上的效果。

对开发者来说，还有一个更实际的建议：先用一个小型中文数据集把文中的代码跑通，感受一次“从全噪声到完整句子”的生成过程。技术趋势可以慢慢看，但对生成范式的体感，只有亲手做一遍才能真正建立起来。