企业官网建设流程全解析

扩散式语言模型是把图像扩散模型中的加噪、去噪思想迁移到文本生成上的一种技术路线。它不再像自回归语言模型那样从左到右逐个预测下一个 token，而是先让文本对应的连续表示进入噪声空间，再通过多步去噪逐步恢复出语义完整的文本。文本本质上是离散符号序列，而扩散过程天然工作在连续空间，因此构建一个可用的扩散式语言模型，核心工作并不只是套用去噪网络的代码，而是要想清楚离散 token、连续嵌入、噪声调度和取整策略之间的关系。

这篇文章会从概念讲起，解释扩散语言模型为什么能生成文本、为什么比自回归方式更麻烦，再基于 PyTorch 搭建一个最小可运行的扩散式语言模型，覆盖数据预处理、前向加噪、反向去噪、训练、采样和取整的完整链路。最后会给出参数速查、常见失败现象定位和从实验到生产化的建议。文章中的代码用于说明核心思路，落地到真实项目时，需要根据你的词表、数据规模、算力和业务目标做调整。

1. 扩散式语言模型到底在解决什么问题

1.1 从图像扩散模型到文本生成的思路迁移

扩散模型在图像领域的基本想法很直观：对一张真实图片不断添加高斯噪声，直到它变成纯噪声；然后训练一个网络，学会从带噪图片倒推原始图片。推理时，从纯噪声出发，按照训练好的去噪过程逐步还原图片。

这个思路能成立，前提是数据本身是连续的。图像的像素值天生就是数值，可以直接叠加高斯噪声。文本不一样。一个句子由离散的 token 组成，例如“深度学习”和“学习深度”是两组完全不同的符号，中间不存在“加一点噪声变成另一个 token”的自然操作。

扩散式语言模型的迁移方式是把文本先转换到连续空间。具体做法是：把每个 token 映射成一个固定维度的嵌入向量，让整句话变成一个二维矩阵[seq_len, d_model]。这个矩阵就是连续表示，可以在它上面做加噪、去噪，最后再把去噪得到的连续向量映射回最接近的 token 嵌入，完成离散化输出。

这里的核心判断是：扩散过程并不直接作用于离散符号，而是作用于嵌入空间。所谓“构建扩散式语言模型”，本质上是在解决“如何进行连续表示上的扩散、以及如何把连续结果稳定地取整回文本”两个问题。

1.2 文本离散性带来的三个核心矛盾

实际动手之前，先要清楚文本离散性给扩散过程带来了哪些麻烦。

第一是连续与离散的语义鸿沟。加噪时，模型往嵌入向量上叠加高斯噪声，这些向量在多步去噪之后仍然带有误差。取整操作是一个离散决策，哪怕去噪误差很小，也可能把向量推到另一个 token 的嵌入附近，导致整句语义漂移。这一点与图像不同：图像像素的微小误差肉眼几乎看不出来，但文本取整错一个 token，句子含义可能完全不同。

第二是并行生成与依赖建模的矛盾。自回归模型天然使用掩码注意力，token 之间的依赖关系通过逐位置预测逐步建立。扩散模型通常在一个 Transformer 编码器里同时处理整段序列，所有位置共享同一个去噪过程，长距离依赖必须由去噪网络自己学会。这要求去噪网络的结构能力足够强，否则生成结果容易出现局部通顺、整体混乱。

第三是训练目标与评估目标的错位。自回归模型直接优化下一个 token 的对数似然，训练目标和困惑度、生成质量比较一致。扩散语言模型优化的是一步去噪误差，例如MSE(pred_x0, x0)，但最终评估时看的是取整后的 token 准确率、BLEU 分数或人工可读性。连续空间的损失下降，不代表离散空间的结果一定正确，这是所有扩散式文本生成方法都要面对的评估错位。

1.3 与自回归语言模型的核心差异

可以用下面的表格快速对比两种路线，后面调参和排错时会反复用到这些差异。

扩散式语言模型的价值不是取代自回归模型，而是在并行解码、可控生成和多样性上提供另一条技术路径。对于需要多次改写、条件控制或者非自回归生成的场景，这个方向值得深入研究。

2. 扩散式语言模型的核心机制

2.1 从 token 到连续嵌入再到文本的完整数据流

一个最小可用的扩散式语言模型，数据流可以拆成五个阶段：

1. 嵌入阶段：把 token id 序列[B, seq_len]查表得到嵌入矩阵x0，形状为[B, seq_len, d_model]。
2. 加噪阶段：随机采样时间步t，按噪声表计算x_t = sqrt(alpha_bar_t) * x0 + sqrt(1 - alpha_bar_t) * noise。
3. 去噪阶段：把x_t和时间步编码输入去噪网络，输出预测的pred_x0，形状与x0相同。
4. 取整阶段：把pred_x0与词表嵌入计算相似度，取最大值对应的 token id。
5. 解码阶段：把 token id 映射回字符串。

下面每个阶段都有独立的参数和陷阱。先理解整体流程，再进入代码，会比较顺。

2.2 前向加噪与噪声表设计

前向过程是固定的，不需要学习。给定嵌入x0，在时间步t的带噪结果为：

x_t = sqrt(alpha_bar_t) * x0 + sqrt(1 - alpha_bar_t) * epsilon

其中epsilon是从标准正态分布采样的噪声，alpha_bar_t是噪声表的前缀累积乘积，表示在第t步还保留多少原始信号。t越大，alpha_bar_t越接近 0，x_t就越接近纯噪声。

噪声表有两种常见设计。线性噪声表在早期工作里用得最多，设置beta_start=1e-4、beta_end=0.02，让噪声强度线性增长。余弦噪声表在T个时间步内按余弦函数衰减信号，能够在更多步数上保持较平稳的去噪难度，训练时更容易收敛。对小规模实验，余弦表通常是更稳妥的起点。

设计噪声表时要特别注意嵌入向量的尺度。上述公式假设x0的方差接近 1。如果嵌入向量没有做归一化或缩放，x_t的实际信噪比会和噪声表的理论值对不上，训练会非常不稳定。

2.3 反向去噪网络和时间步编码

反向过程做的事情是：给定x_t和t，预测原始嵌入x0。网络必须知道当前处于噪声过程的哪个阶段，因此需要时间步编码。

时间步编码通常参照 Transformer 中的位置编码方式，把标量t转换成d_model维向量，再经过一个 MLP 映射，然后加到序列表示上。去噪网络可以用 Transformer 编码器，因为它能并行处理整段序列，天然适合扩散模型的全局去噪需求。

这里有两种常见预测目标：预测噪声epsilon和预测原始数据x0。图像扩散模型中二者都可选，但文本场景更推荐预测x0。原因是最终取整阶段需要的是一个逼近原始嵌入的连续向量，直接预测x0让训练目标和推理目标保持对齐。混合方案也可以把两个目标用权重组合起来，但最小实现里先选x0最容易排查问题。

2.4 为什么取整是真正的瓶颈

图像模型去噪后直接输出像素值，没有离散取整这一步。文本模型去噪后得到一个连续矩阵，必须和词表嵌入做最近邻匹配，这里会有三类问题。

第一是嵌入空间的不均匀性。词表中不同 token 的嵌入在空间中分布不均匀，某些 token 很近，某些 token 很稀疏，去噪误差对每个 token 的影响并不一致。

第二是尺度失配。如果直接使用点积相似度取整，预测向量的模长变化会影响排序结果。更稳的做法是计算余弦相似度，也就是先对预测向量和词表嵌入分别做 L2 归一化，再计算内积。

第三是取整不可微。训练时用的是 MSE 重构损失，无法感知取整错误；推理时取整错误又无法往回传播修正。要缓解这个问题，可以在训练阶段额外加入一个辅助的交叉熵损失，用pred_x0和词表嵌入的相似度作为 logits，让网络在重构和分类之间取得平衡。

3. 用 PyTorch 搭建最小可运行项目

3.1 环境准备与目录结构

建议使用 Python 3.9 及以上版本，PyTorch 2.x，依赖较少，主要用到torch、numpy、math标准库。如果原始环境没有确定版本，先执行以下命令确认：

python --version pip show torch

如果没有安装 PyTorch，按官方方式安装 CPU 或 CUDA 版本：

pip install torch

最小项目目录可以这样组织：

diffusion_lm_demo/ ├── data.py # 数据读取、词表构建、编码 ├── model.py # 噪声表、时间步编码、去噪网络、扩散模型 ├── train.py # 训练循环 ├── sample.py # 采样与取整 └── corpus.txt # 训练语料，每行一句

这种方式把每个环节拆开，排查问题时不需要在单个大文件里翻找。

3.2 数据预处理与词表构建

为了演示核心流程，这里使用一个按空格分词的小型中文语料。真实项目建议用 SentencePiece、BPE 等成熟分词器，但最小示例先用简单分词保证可运行。

# data.py from collections import Counter import torch from torch.utils.data import Dataset def build_vocab(corpus, min_freq=1): counter = Counter() for line in corpus: counter.update(line.split()) vocab = {"<pad>": 0, "<unk>": 1} for word, freq in counter.items(): if freq >= min_freq: vocab[word] = len(vocab) return vocab def encode(line, vocab, seq_len): tokens = line.split()[:seq_len] ids = [vocab.get(w, vocab["<unk>"]) for w in tokens] ids = ids + [vocab["<pad>"]] * (seq_len - len(ids)) return torch.tensor(ids, dtype=torch.long) class TextDataset(Dataset): def __init__(self, path, vocab, seq_len): self.lines = [l.strip() for l in open(path, encoding="utf-8") if l.strip()] self.vocab = vocab self.seq_len = seq_len def __len__(self): return len(self.lines) def __getitem__(self, idx): return encode(self.lines[idx], self.vocab, self.seq_len)

这里有两个注意点。第一，补充<unk>是为了避免测试阶段出现词表外词导致崩溃。第二，固定seq_len并用<pad>补齐，对最小实验来说最简单。真实项目里如果直接对 padding 位置做重构损失，会让模型浪费大量能力去恢复无意义的 pad 向量，需要为 padding 位置构造掩码并屏蔽损失。

3.3 定义噪声表、时间步编码和去噪网络

先实现噪声表和时间步编码，这两个函数是整个扩散过程的基石。

# model.py import math import torch import torch.nn as nn import torch.nn.functional as F def linear_beta_schedule(T, beta_start=1e-4, beta_end=0.02): return torch.linspace(beta_start, beta_end, T) def cosine_beta_schedule(T, s=0.008): steps = torch.arange(T + 1, dtype=torch.float32) f_t = torch.cos(((steps / T + s) / (1 + s)) * math.pi / 2.0) ** 2 alphas_cumprod = f_t / f_t[0] betas = 1.0 - alphas_cumprod[1:] / alphas_cumprod[:-1] return torch.clip(betas, 0.0, 0.999) def timestep_embedding(t, d_model, max_period=10000): half = d_model // 2 freqs = torch.exp(-math.log(max_period) * torch.arange(half, dtype=torch.float32) / half) args = t[:, None].float() * freqs[None, :] return torch.cat([torch.cos(args), torch.sin(args)], dim=-1)

去噪网络这里用一个轻量 Transformer 编码器。它的输入是带噪嵌入x_t与时间步编码相加后的结果。

class DenoiseTransformer(nn.Module): def __init__(self, d_model, nhead, num_layers, dim_feedforward, max_len): super().__init__() self.pos_embed = nn.Parameter(torch.randn(1, max_len, d_model) * 0.02) self.time_mlp = nn.Sequential( nn.Linear(d_model, d_model), nn.GELU(), nn.Linear(d_model, d_model), ) encoder_layer = nn.TransformerEncoderLayer( d_model=d_model, nhead=nhead, dim_feedforward=dim_feedforward, batch_first=True, activation="gelu", ) self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) def forward(self, x_t, t_emb): B, L, D = x_t.shape t = self.time_mlp(t_emb).unsqueeze(1) x = x_t + self.pos_embed[:, :L, :] + t return self.encoder(x)

3.4 把扩散过程封装成模型

下面把噪声表、前向加噪、去噪网络组合起来。模型对外只需要接收 token id 和时间步，返回去噪重构误差。

class DiffusionLM(nn.Module): def __init__(self, vocab_size, d_model, T, max_len, beta_schedule="cosine"): super().__init__() self.vocab_size = vocab_size self.d_model = d_model self.T = T self.token_embed = nn.Embedding(vocab_size, d_model) self.denoiser = DenoiseTransformer( d_model=d_model, nhead=8, num_layers=4, dim_feedforward=1024, max_len=max_len, ) if beta_schedule == "cosine": betas = cosine_beta_schedule(T) else: betas = linear_beta_schedule(T) self.register_buffer("betas", betas) self.register_buffer("alphas", 1.0 - betas) self.register_buffer("alpha_bar", torch.cumprod(self.alphas, dim=0)) def q_sample(self, x_0, t, noise): alpha_bar_t = self.alpha_bar[t].view(-1, 1, 1) return torch.sqrt(alpha_bar_t) * x_0 + torch.sqrt(1.0 - alpha_bar_t) * noise def forward(self, token_ids, t): x_0 = self.token_embed(token_ids) noise = torch.randn_like(x_0) x_t = self.q_sample(x_0, t, noise) t_emb = timestep_embedding(t, self.d_model) pred_x0 = self.denoiser(x_t, t_emb) loss = F.mse_loss(pred_x0, x_0) return loss, pred_x0

这段代码里alpha_bar是通过torch.cumprod计算得到的累积乘积，它决定了每个时间步保留多少原始信号。q_sample的公式对应前面讲的加噪过程，训练时每个 batch 随机采样一批t，让模型看到不同噪声强度的样本。

3.5 训练循环

训练循环本身并不复杂，核心是随机采样时间步、加噪、去噪、计算损失。

# train.py import torch from torch.utils.data import DataLoader from data import build_vocab, TextDataset from model import DiffusionLM corpus = open("corpus.txt", encoding="utf-8").read().strip().splitlines() vocab = build_vocab(corpus, min_freq=1) dataset = TextDataset("corpus.txt", vocab, seq_len=32) loader = DataLoader(dataset, batch_size=16, shuffle=True) device = "cuda" if torch.cuda.is_available() else "cpu" model = DiffusionLM( vocab_size=len(vocab), d_model=256, T=200, max_len=32, beta_schedule="cosine", ).to(device) optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4) for epoch in range(50): total_loss = 0.0 for batch in loader: batch = batch.to(device) t = torch.randint(0, model.T, (batch.shape[0],), device=device) loss, _ = model(batch, t) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() print(f"epoch {epoch:02d} loss {total_loss / len(loader):.4f}")

训练时要注意t的随机采样范围是[0, T)，也就是包括接近纯噪声的最大时间步。如果T很小，例如 50，每个时间步的加噪跨度大，模型很难学会精准还原；如果T很大，例如 1000，训练稳定但采样要迭代 1000 步，速度很慢。最小实验用 100 到 200 步比较合适。

3.6 采样与取整

采样时从纯噪声x_T开始，按时间步从大到小依次去噪。下面实现采用一个简化的更新公式：每步直接用预测的pred_x0重新加噪得到下一步，教学上更直观。

# sample.py import torch import torch.nn.functional as F @torch.no_grad() def sample(model, seq_len, batch_size=1, device="cpu"): model.eval() x = torch.randn(batch_size, seq_len, model.d_model, device=device) for t in reversed(range(model.T)): t_tensor = torch.full((batch_size,), t, device=device, dtype=torch.long) t_emb = timestep_embedding(t_tensor, model.d_model) pred_x0 = model.denoiser(x, t_emb) if t > 0: alpha_bar_t = model.alpha_bar[t] alpha_bar_prev = model.alpha_bar[t - 1] noise = torch.randn_like(x) x = torch.sqrt(alpha_bar_prev) * pred_x0 + torch.sqrt(1.0 - alpha_bar_prev) * noise else: x = pred_x0 # 取整：使用余弦相似度，避免向量模长干扰 x_norm = F.normalize(x, dim=-1) embed_norm = F.normalize(model.token_embed.weight, dim=-1) logits = x_norm @ embed_norm.T ids = logits.argmax(dim=-1) return ids

这里使用余弦相似度取整，比直接点积更稳定。简化更新公式不等于标准 DDPM 的后验采样，但它能快速验证模型是否学到了一定重构能力。真实项目中建议换成标准后验采样或 DDIM 采样，生成质量会明显提升。

运行采样并打印结果：

python train.py python sample.py

如果语料只有几百行，训练几十轮后模型可能只能重构高频 token，这本身符合实验预期。关键不是得到完美文本，而是验证整条链路已经跑通。

4. 验证结果：如何判断模型真的学会了生成

4.1 训练阶段应该关注什么

训练 loss 下降是最基本的信号。扩散模型的 loss 是不同时间步加噪难度下的平均重构误差，因此还要观察不同t区间上的表现。可以每隔几个 epoch 做一次小采样，用一批句子的 token id 和预测结果对比。

更细的验证是重构率：对训练集里的一条句子，在某个时间步t加噪，再通过去噪网络和取整还原，统计还原 token 与原始 token 一致的比率。这个指标能反映去噪网络在某个噪声强度下的实际能力。

@torch.no_grad() def reconstruction_rate(model, ids, t, device="cpu"): ids = ids.to(device) x_0 = model.token_embed(ids) noise = torch.randn_like(x_0) x_t = model.q_sample(x_0, t, noise) t_emb = timestep_embedding(t, model.d_model) pred_x0 = model.denoiser(x_t, t_emb) x_norm = F.normalize(pred_x0, dim=-1) embed_norm = F.normalize(model.token_embed.weight, dim=-1) pred_ids = (x_norm @ embed_norm.T).argmax(dim=-1) return (pred_ids == ids).float().mean().item()

t=0时重构率应该接近 100%，因为几乎没有加噪。t越大，重构率越低，这是正常现象。如果t=0的重构率都不高，说明去噪网络本身没有学习到有效映射，要优先检查嵌入尺度、学习率和噪声表。

4.2 生成文本的可用性怎么判断

对扩散语言模型来说，第一步看 token 层级的还原情况，第二步看整句语义是否连贯。在最小数据规模下，不要指望它能生成有深层语义的长文本。

可执行的三项检查：

• 生成结果是否包含大量<unk>或<pad>。
• 生成结果是否出现整句重复，例如同一个 token 连续出现多次。
• 生成结果是否与原语料中的句子在词面上有部分重合。

如果三个问题同时出现，先确认数据规模和训练轮次是否足够，再去检查采样代码里时间步索引是否越界、alpha_bar是否计算正确。

4.3 一个合格的实验输出长什么样

在几百行小语料、d_model=256、T=200的情况下，训练 50 轮后，模型在t=10附近的单句重构率通常会明显高于随机水平。由于嵌入随机初始化和取整的不确定性，个别 token 会替换成形态相近的 token。

判断标准不要定得太高。最小项目跑通的标志是：采样不会崩溃、loss 稳定下降、小噪声重构率接近 1。到了这一步，再考虑扩大数据、加长序列、更换噪声表和优化采样过程。

5. 关键参数与调优方向

5.1 参数速查表

5.2 噪声表、时间步与嵌入尺度的联动

这三者必须一起考虑。余弦噪声表在T比较大时更容易训练，因为相邻步的加噪差异更小。如果嵌入向量没有归一化，还需要在训练前计算语料嵌入的统计方差，据此调整beta_start和beta_end，或者对嵌入做缩放。

一个常见做法是把嵌入初始化为标准正态分布采样，并在训练前对嵌入矩阵做一次归一化。也可以在q_sample前手动将x0乘以一个缩放因子，让x0的方差接近 1，从而和噪声表匹配。这里推荐在数据加载阶段先跑一次统计：

with torch.no_grad(): sample_embed = model.token_embed(batch) variance = sample_embed.var().item() print("embed variance:", variance)

如果方差远大于 1，说明需要调整噪声表或者对嵌入做归一化。

5.3 预测目标：epsilon 还是 x0

预测x0的优点是和取整阶段对齐，缺点是x0在嵌入空间中的分布可能很复杂，预测误差对取整结果更敏感。预测epsilon的优点是与标准扩散公式配合更自然，采样时直接用 DDPM 或 DDIM 更新公式，但取整时需要先把预测结果转换回x0，链路更长。

最小实现里选x0就够了。进阶实验可以用两者加权：

loss = mse(pred_x0, x0) + lambda * mse(pred_eps, eps)

这种方式兼具重构稳定性和标准扩散的采样便利性。加权系数lambda通常取 0.1 到 1.0 之间，需要小范围搜索。

5.4 采样加速与温度控制

扩散模型最大的工程痛点是采样慢。标准采样要从T走到 0，步数不可减少。常用的加速手段是 DDIM，它把采样过程压缩到几十步甚至十几步，同时保持不错的生成质量。DDIM 的实现并不复杂，核心是不再为每一步添加随机噪声，采样增量由确定性的隐变量控制。

取整阶段还可以引入温度。把取整 logits 除以温度系数tau，再通过 softmax 采样而不是直接argmax，可以增加生成多样性。tau越小越接近贪心，tau越大越随机。实际项目中通常从tau=1.0开始，根据重构率和多样性做权衡。

6. 常见问题排查：从现象到根因

6.1 训练 loss 不下降或震荡

现象：训练几十轮后 loss 仍然在 1 到 3 之间波动，没有明显下降趋势。

可能原因有三个方向。第一，学习率过大导致优化不稳定；第二，嵌入向量尺度与噪声表不匹配，导致不同时间步的损失量纲相差过大；第三，数据量过小，模型无法从随机初始化中学会有效映射。

排查方式：把T临时调小到 50，观察 loss 是否下降；打印嵌入方差确认尺度是否在 1 附近；把学习率从1e-4下调到5e-5再训练。

处理建议：修正嵌入尺度、降低学习率、增大数据量。如果问题仍然存在，用固定t=50训练几轮，确认单时间步上模型能否学会重构，再切回随机t。

6.2 生成结果全是重复 token 或乱码

现象：采样结果中出现大量相同 token 或多个<unk>。

可能原因包括：取整温度过高、去噪网络容量不足、训练语料太小导致词表覆盖差、采样步数过少导致早期误差无法修正。

排查方式：先用训练集句子做重构率测试，确认不是取整阶段的问题；检查采样输出的 token id 分布，看是否集中在少数几个高频词上。

处理建议：降低取整温度，用argmax或tau=0.5做对比；增加去噪网络层数；扩充语料并重新构建词表；把采样迭代改为标准 DDPM 后验更新，而不是简化重加噪。

6.3 采样速度过慢

现象：T=1000时生成一个句子需要几秒钟甚至更久。

原因很直接：每步都要做一次完整的前向推理，1000 步就是 1000 次 Transformer 前向。这在生产环境中几乎不可接受。

处理建议：优先把T降到 200 以内做验证；实现 DDIM 采样，用 50 步替代 1000 步；如果仍不够，考虑蒸馏采样步数或用潜在扩散结构降低序列维度。

6.4 取整后语义漂移

现象：连续向量的重构 loss 很低，但取整出来的 token 完全不对。

这是文本扩散最典型的失败模式。连续空间距离近，不代表离散 token 一致。一个 token 的嵌入周围可能被多个近邻 token 包围，去噪误差稍大就会跳到错误位置。

处理建议：

• 训练时加入取整辅助 loss，把pred_x0和词表嵌入的相似度 logits 计算交叉熵。
• 取整时使用余弦相似度而不是点积。
• 在采样最后几步加入小范围修正，例如用模型对取整结果重新加噪再精化。

6.5 排查清单

排查顺序建议：先确认数据输入正确，再检查词表和路径，然后确认模型结构与维度匹配，接着看噪声表和嵌入尺度，最后才怀疑训练和采样代码。

7. 最佳实践与扩展方向

7.1 学习环境与生产环境的差别

实验里跑通一个小模型，和生产环境落地是两回事。学习环境可以容忍少量死循环、不完整的日志和手动重启，生产环境必须在设计阶段就把这些问题考虑进去。

7.2 落地检查清单

上线前至少过一遍下面这些检查项：

• 词表是否包含业务必须的领域词，<unk>比例是否可接受。
• 嵌入方差是否和噪声表匹配，训练和采样的调度是否一致。
• 是否做了序列长度掩码，padding 位置是否参与了损失计算。
• 采样时是否使用了和训练一致的预测目标。
• 重构率、困惑度、生成多样性是否有基线对比。
• 生成文本是否经过规则过滤和人工抽检。
• 模型是否做了量化或剪枝，单次采样耗时是否满足业务要求。
• 是否有监控告警，生成质量下降时能否快速回滚到上一版本。

7.3 从最小模型到真实项目的扩展路径

最小模型跑通后，扩展方向通常是沿着三条线走。

第一条是提升生成质量。把简单分词换成 BPE 或 SentencePiece，扩大语料规模，增加去噪网络层数和注意力头，引入取整辅助损失。第二条是提升采样效率。实现 DDIM、引入蒸馏或者使用潜在扩散结构，把高维序列压缩到低维潜在空间再扩散。第三条是增强可控性。利用扩散模型每步都能接受梯度的特性，在采样阶段加入条件引导，实现情感、主题、风格等维度的控制。

7.4 与自回归模型结合的混合路线

扩散式语言模型不一定要完全替代自回归模型。工程上更现实的方案是用自回归模型生成骨架，用扩散模型做局部改写和精化；或者先用扩散模型快速生成候选，再用自回归模型重排序。这样既利用了扩散模型的多样性和并行优势，又保留了自回归模型的生成稳定性和成熟评估体系。

对刚开始接触这个方向的读者，建议先花时间把本文的最小项目完整跑通，特别要动手实验噪声表、嵌入尺度和取整方式三个环节。能独立解释清楚“为什么连续重构 loss 很低但取整结果不对”，比记住再多的模型结构都有价值。这个问题的答案，才是扩散式语言模型和普通扩散图像模型最本质的差异所在。