扩散式语言模型构建指南：原理、训练与部署实战

扩散式语言模型这条技术路线，这几年一直是 NLP 非自回归生成方向里比较有代表性的分支。它和 GPT 这类从左到右逐个 token 生成的自回归模型完全不同：给定一段带噪声的 token 序列，模型通过多步去噪，把整句话逐步还原出来。也就是说，生成过程不是“写一个字看一眼”，而是“先把整段文本放进噪声空间，再一步步变清晰”。

这类模型最适合关注可控文本生成、同时想摆脱自回归逐字生成限制的工程师。比如做情感控制、关键词约束、文本改写、数据增强，扩散式语言模型可以把约束条件直接揉进生成过程，不需要像自回归那样依赖复杂提示词工程。它还有一个关键能力：并行解码。因为去噪过程的每一步都同时更新所有 token，推理时可以用很少的采样步数生成几十甚至上百个 token。

这篇文章会从原理讲到落地。我会先梳理扩散式语言模型的核心技术点，然后给出一套可以直接在本机运行的构建流程：数据准备、前向加噪、去噪网络、训练循环、推理采样、接口部署。最后补充训练策略、性能观察和问题排查。内容偏实践，代码可以直接复制运行，适合刚接触扩散式语言模型，想从代码层面把整个管线打通的研究生、算法工程师和相关方向的技术爱好者。

1. 扩散式语言模型核心能力速览

需要说明的是，表格里的硬件要求和性能指标并不是某个固定数值。不同参数量、不同序列长度、不同采样步数对应的显存占用差异很大，实际表现要按本机配置和模型规模测试。后面的章节会给出系统的验证方式，方便你快速判断这套构建流程在自己的环境上是否可行。

2. 适用场景与使用边界

扩散式语言模型适合以下几类场景。

第一类是可控生成。给你的需求是“生成一句带某个关键词的积极评价”，这种任务在自回归模型里要靠提示词约束，但在扩散式语言模型里可以直接把条件向量参与生成，或者把关键词作为部分已知 token 放进初始序列。生成过程本身就是迭代修正，所以约束条件能被更明显地体现。

第二类是数据增强。很多场景需要构造大量相似但不重复的文本，比如文本分类数据扩充、对话语料回填、伪标签生成。自回归模型生成数据容易陷入重复，扩散式语言模型一次会同时生成整段内容，配合温度控制可以产生更多样的结果。

第三类是文本改写和纠错。把原文加噪到一定程度，让模型重建，输出的往往不是原文，而是语义接近、表达不同的新句子。这种特性在改写任务中很有价值。

不过也要说清楚边界。如果目标是构建通用对话助手，或者需要严格按指令执行复杂任务的自助系统，扩散式语言模型目前不如自回归模型成熟，不要轻易把生产环境核心链路完全切过来。对超长文本，全局双向注意力会造成很大的计算开销，容易出现显存不足，建议先用中短文本跑通再考虑扩展。

使用边界方面有一条红线：任何基于生成模型的文本、语音、图像服务，都必须确保训练数据来源合法，生成内容不侵犯第三方版权，不包含恶意、虚假、歧视性信息。如果系统接入真实用户数据，还要做好隐私脱敏和访问控制。这里不展开说法律细节，但工程上建议把“数据合规审查”“生成内容审核”作为构建流程的一部分来做，而不是上线前临时补。

3. 理论基础与技术拆解

3.1 文本为什么不能直接套图像扩散

图像扩散模型是在连续像素空间上做高斯加噪，前向过程连续平滑，反向过程可以用 U-Net 或 DiT 预测噪声。文本和图像有一个本质区别：token 是离散的，不存在从“半个词”到“整个词”的连续过渡。如果把 token id 直接看成连续值加高斯噪声，得到的中间状态没有任何语义含义，模型也难以学会去噪。

所以文本扩散要做两件事：要么把离散 token 映射到连续 embedding 空间，在 embedding 上做高斯扩散；要么在离散 token 空间设计一种合理的“噪声”，比如把部分 token 替换成 [MASK] 或随机 token。前者理论上更平滑，后者实现更简单、可解释性更强，本文后面的代码也主要走“离散掩码扩散”这条路线。

3.2 两条主流技术路线

连续空间路线是目前学术论文里比较常见的做法。具体思路是先把 token embedding 拿出来，按扩散模型的方式加高斯噪声，训练一个去噪网络，让它在带噪声的 embedding 上预测原始 embedding 或 token。代表性工作包括 Diffusion-LM、DiffuSeq、SSD-LM 等。这条路线生成质量通常更细腻，但需要对 embedding 空间做额外校准，否则模型容易只恢复出相似 embedding，并不能还原成合法 token。

离散空间路线是在 token id 空间直接做 mask 噪声。训练时随机选一部分 token 替换为 [MASK]，模型根据上下文和当前时间步，预测这些位置原本是什么 token。推理时从全 [MASK] 序列开始，多轮迭代，每轮把置信度高的位置固定下来。这条路线实现门槛低，训练稳定，适合做第一版系统。下面给出的代码示例都基于这条路线。

3.3 前向过程、反向过程与训练目标

用 T 表示训练时的最大时间步。前向过程就是给定原始 token 序列 x0，随机采样一个时间步 t，计算噪声比例 t/T，然后把 x0 中约 t/T 比例的 token 替换为 [MASK]。时间步越大，mask 比例越高。反向过程由模型完成：输入部分 mask 的序列 xt 和时间步 t，模型输出每个位置上的 token 概率分布。训练目标就是让被 mask 位置的预测尽量接近原始 token，典型的损失函数是交叉熵。

训练完成后，推理就是一个从高噪声到低噪声的逐步迭代过程。模型在每一步输出整段序列的预测结果，系统按置信度决定哪些 token 可以直接保留，哪些要继续保留为 [MASK] 并进入下一轮。相比自回归模型一次只能生成一个 token，这里的并行度很高。

3.4 扩散式语言模型与自回归模型的对比

从表格可以看出来，扩散式语言模型的价值不是替代自回归，而是在可控生成、并行解码、数据重构这些场景里提供不同的选择。

4. 环境准备与前置条件

构建扩散式语言模型需要准备 Python、PyTorch、Transformers 等基础依赖。以本地部署为例，推荐使用 conda 创建独立环境，避免和已有项目冲突。

conda create -n dlm python=3.10 -y conda activate dlm

接下来安装 PyTorch。PyTorch 的安装命令要根据本机 CUDA 驱动版本选择，不同版本差异较大。如果本机是 NVIDIA 显卡且驱动已正确安装，可以使用 PyTorch 官方镜像源安装带 CUDA 支持的版本。

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

如果 CUDA 版本不是 12.1，需要到 PyTorch 官网选择对应命令。确定不了版本时，可以先运行nvidia-smi查看驱动支持的 CUDA 版本，再选择不高于该版本的 PyTorch。没有 NVIDIA 显卡的机器也可以安装 CPU 版，小规模调试时能跑通完整流程，只是训练和采样速度会慢很多。

接下来安装模型训练和文本处理相关的依赖。

pip install transformers datasets tokenizers accelerate tensorboard

如果后面要启动 API 服务，还需要安装 FastAPI 和 Uvicorn。

pip install fastapi uvicorn

硬件方面，建议至少有一块 8 GB 显存的 NVIDIA 显卡。用这样的配置可以跑一个小规模的去噪 Transformer，第一版验证管线足够了。如果显存更大，可以提升 hidden size、层数或 batch size。CPU 可以完成代码调试和函数验证，但真正训练建议还是用 GPU。

5. 构建扩散式语言模型完整流程

这一章是全文的核心。我会按照数据准备、前向加噪、去噪网络、训练循环、推理采样、验证指标的顺序逐步展开。

5.1 数据准备

训练扩散式语言模型不需要特别复杂的数据格式，普通句子级别的文本就可以。关键是先做清洗，去掉过长、过短、乱码和明显重复的句子，然后统一 tokenizer 编码为 token id，按固定长度截断或 padding。

下面是一个简化的 Dataset 示例，实际使用时要根据数据格式调整字段名。

import torch from torch.utils.data import Dataset from transformers import AutoTokenizer class TextDataset(Dataset): def __init__(self, texts, tokenizer, max_len=64): self.texts = texts self.tokenizer = tokenizer self.max_len = max_len def __len__(self): return len(self.texts) def __getitem__(self, idx): text = self.texts[idx] enc = self.tokenizer( text, truncation=True, max_length=self.max_len, padding="max_length", return_tensors="pt", ) return { "input_ids": enc["input_ids"].squeeze(0), "attention_mask": enc["attention_mask"].squeeze(0), }

这里建议固定 max_len，避免同一个 batch 内出现不同长度导致 padding 混乱。对第一版实验，max_len 取 32 或 64 都比较合适。分词器建议选择词表较小的模型，比如 BERT 系列或 GPT-2 系列的 tokenizer，词表太大会让最后的输出层参数过多。

5.2 前向加噪实现

前向加噪的核心是按时间步计算 mask 比例，并随机替换 token。一个很直接的做法是线性调度，也就是 mask 比例等于 t / T。虽然简单，但很多任务都能跑通。后续可以换成 cosine 或 sigmoid 调度。

下面实现 batch 版本，每个样本有自己的时间步 t。输入是原始 token 序列和每个样本的时间步，输出是加噪后的序列和 mask 掩码。

import torch def add_mask_noise_batch(input_ids, t, max_timesteps, mask_token_id): """ input_ids: [batch, seq_len] t: [batch] 每个样本对应的时间步 mask_token_id: tokenizer 的 mask token id """ noised = input_ids.clone() noise_ratio = (t.float() / max_timesteps).unsqueeze(1) # [batch, 1] rand = torch.rand_like(input_ids.float()) mask = rand < noise_ratio noised[mask] = mask_token_id return noised, mask

采样时间步时，不建议完全均匀采样。均匀采样会让模型过多看到 mask 比例在中间区域的样本，而极端噪声和极少噪声阶段的样本不够。可以考虑使用 log-normal 分布，让模型花更多时间学习中等偏大噪声的情况。后面训练循环里会给出示例。

5.3 去噪网络搭建

去噪网络的核心是一个非因果 Transformer encoder。所谓非因果，是指模型能看到序列中所有位置的 token，不受“只能看左边”的限制。这一点和自回归语言模型完全不同，也是并行去噪的基础。

模型输入是加噪后的 token id 和时间步 t。时间步需要映射成向量，常见做法是先做正弦位置编码，再过一个小型 MLP 得到时间 embedding，然后加到 token embedding 上。每个 Transformer block 仍然继续处理序列信息。

import torch import torch.nn as nn class TimeEmbedding(nn.Module): def __init__(self, hidden_size): super().__init__() self.linear = nn.Sequential( nn.Linear(hidden_size, hidden_size * 4), nn.SiLU(), nn.Linear(hidden_size * 4, hidden_size), ) def forward(self, t): # t: [batch] half_dim = 64 emb = torch.exp(torch.arange(half_dim, device=t.device) * -1.44 / half_dim) emb = t.unsqueeze(1).float() * emb.unsqueeze(0) emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1) return self.linear(emb) class DenoisingTransformer(nn.Module): def __init__(self, vocab_size, hidden_size=256, num_layers=4, num_heads=4, max_len=128): super().__init__() self.token_embed = nn.Embedding(vocab_size, hidden_size) self.pos_embed = nn.Embedding(max_len, hidden_size) self.time_embed = TimeEmbedding(hidden_size) encoder_layer = nn.TransformerEncoderLayer( d_model=hidden_size, nhead=num_heads, batch_first=True, activation="gelu", ) self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) self.out_proj = nn.Linear(hidden_size, vocab_size) def forward(self, input_ids, t): seq_len = input_ids.size(1) positions = torch.arange(seq_len, device=input_ids.device).unsqueeze(0) x = self.token_embed(input_ids) + self.pos_embed(positions) x = x + self.time_embed(t).unsqueeze(1) hidden = self.encoder(x) return self.out_proj(hidden)

这里使用 nn.TransformerEncoder 默认的注意力，不会有 causal mask，符合并行去噪的需求。如果序列较长，建议后续替换成更高效的注意力实现，否则显存占用会比较高。

5.4 训练循环

训练循环整体和普通语言模型训练没有太大区别，只是损失只计算被 mask 的位置。下面这段代码是最小可运行的训练循环。

from torch.utils.data import DataLoader from transformers import AutoTokenizer import math tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") vocab_size = tokenizer.vocab_size mask_token_id = tokenizer.mask_token_id hidden_size = 256 num_layers = 4 num_heads = 4 max_len = 64 epochs = 3 batch_size = 16 T = 1000 # 训练最大时间步 model = DenoisingTransformer( vocab_size=vocab_size, hidden_size=hidden_size, num_layers=num_layers, num_heads=num_heads, max_len=max_len, ) optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4) dataset = TextDataset(texts, tokenizer, max_len=max_len) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True) for epoch in range(epochs): for step, batch in enumerate(dataloader): x0 = batch["input_ids"] # 时间步采样，偏向中高噪声 log_t = torch.rand(x0.size(0)) * math.log(T) # 按 log 均匀采样 t = torch.clamp(log_t.exp().long(), min=1, max=T) xt, mask = add_mask_noise_batch(x0, t, T, mask_token_id) logits = model(xt, t) # [batch, seq_len, vocab] loss = nn.functional.cross_entropy( logits.reshape(-1, vocab_size), x0.reshape(-1), reduction="none", ).view_as(mask) loss = (loss * mask).sum() / mask.sum().clamp(min=1.0) optimizer.zero_grad() loss.backward() optimizer.step() if step % 100 == 0: print(f"epoch {epoch}, step {step}, loss {loss.item():.4f}")

这个训练循环里损失只回传 mask 位置的误差。模型没有 mask 的位置不产生监督信号，这样可以强迫模型把注意力放在“需要修复的 token”上，同时让未被 mask 的 token 为预测提供上下文。

5.5 推理采样

推理时从全 [MASK] 序列开始。每一步，模型对所有 mask 位置给出预测概率，然后根据置信度决定哪些 token 被固定下来，剩下的位置进入下一轮。采样步数通常远小于训练时间步数，比如训练用到 1000 步，推理只用 20 到 50 步。

下面是一个简化版的生成函数。它通过置信度阈值筛选 token，逐步降低剩余 mask 比例。

def generate( model, tokenizer, max_len=32, sampling_steps=50, temperature=1.0, device="cuda", ): model.eval() mask_token_id = tokenizer.mask_token_id x = torch.full((1, max_len), mask_token_id, dtype=torch.long, device=device) with torch.no_grad(): for step in range(sampling_steps, 0, -1): t = torch.full((1,), int(T * step / sampling_steps), dtype=torch.long, device=device) logits = model(x, t) probs = torch.softmax(logits / temperature, dim=-1) pred_ids = torch.argmax(probs, dim=-1) conf = probs.max(dim=-1).values # 每一轮剩余 mask 占比逐渐降低 remain_ratio = step / sampling_steps threshold = torch.quantile(conf[0], remain_ratio) updated = x.clone() keep = conf[0] >= threshold updated[0, keep] = pred_ids[0, keep] x = updated return tokenizer.decode(x[0], skip_special_tokens=True)

这里的关键是 threshold 的确定方式。如果直接取 0.9 这种固定阈值，后期很多位置可能同时满足条件，导致 token 被过早固定；如果太严格，去噪步数不够时又会有很多位置漏掉。上面用分位数作为一个动态阈值，让每轮固定一部分高置信度 token，整体思路更合理。实际项目中，可以对每个位置同时设置“置信度阈值 + 剩余 mask 预算”，双条件都满足才固定。

5.6 功能验证指标

模型训练完成后，不要只看 loss 曲线。建议按下面几个维度验证：

• 加噪重建测试：取一段训练集里没有出现过的文本，把 30% 的 token 替换为 [MASK]，用训练好的模型去预测这些位置，计算 token 级准确率。
• 生成文本连贯性：随机采样几十条生成结果，人工看是否通顺、是否重复、能否表达完整语义。
• 条件约束成功率：如果是带条件的训练方式，验证关键词、情感等条件是否真的被满足。
• 多样性：用不同采样步数和温度多次生成，观察结果差异。如果结果几乎一样，说明采样策略或训练过程有问题。

第一版实验不用追求很高的指标，更重要的目的是跑通整条链路，确认前向、反向、训练、推理这些环节都能正常工作。

6. 训练策略与调参建议

6.1 噪声调度

线性调度虽然简单，但不一定最优。因为它会让中间时间步的 mask 比例分布较密，而极端时间的样本较少。实际训练时可以试试 cosine 或 sigmoid 调度。cosine 调度在中间阶段变化更平缓，能提高训练稳定性。实现上和线性调度类似，只是把t / T替换为对应的调度函数。

6.2 时间步采样

在训练循环里我给出了 log 均匀采样示例，目的是让模型在训练时看到更多中高噪声样本。中高噪声样本对模型学习“从零修复一句话”的能力更关键，因为推理初期面对的正是大量 mask 的状态。如果你发现模型能重建 30% mask，但全 mask 生成效果很差，大概率就是时间步采样分布不理想，需要调整采样方式。

6.3 采样步数与 token 固定策略

训练时 T=1000 只是一个参考。推理时采样步数建议从 50 开始，观察生成效果。如果效果好，逐步降低到 20，看是否还能保持质量。步数过多会增加耗时，过少则可能导致句子结构不完整。固定 token 时，不建议一步固定太多，否则后续模型缺少修正机会，生成结果容易在局部语义上跑偏。

6.4 混合精度与 EMA

模型训练建议开启混合精度，在 NVIDIA GPU 上可以明显减少显存占用和训练时间。PyTorch 2.x 里可以直接使用torch.autocast配合GradScaler，或者使用 Accelerate 库的accelerator封装。EMA（指数移动平均）对生成模型通常有帮助，因为它能让模型参数在训练中保持更平滑，采样阶段往往能获得更稳定的输出。对于扩散式语言模型，EMA 机制可以作为第二步优化来加上。

6.5 优化器与学习率

AdamW 是首选的优化器。学习率可以先从 1e-4 开始，如果训练不稳定或 loss 发散，降低到 5e-5。训练前期建议用一个短的 warmup 阶段，让学习率从较小值逐渐升到设定值，避免模型一开始就出现剧烈震荡。序列长度较长时，batch size 和隐藏层维度都要相应调低，否则显存很容易不够。

7. 推理采样与批量生成

推理采样是扩散式语言模型最能体现优势的环节。由于模型不是逐 token 生成，而是整段并行去噪，所以天然适合批量生成。批量生成可以通过两种方式实现：一种是在请求层面循环调用生成函数，另一种是在模型内部直接增加 batch size，一次性生成多条文本。

下面是一个简单的批量生成脚本思路。

def batch_generate(model, tokenizer, num_samples=16, max_len=32, sampling_steps=50): device = next(model.parameters()).device mask_token_id = tokenizer.mask_token_id x = torch.full((num_samples, max_len), mask_token_id, dtype=torch.long, device=device) with torch.no_grad(): for step in range(sampling_steps, 0, -1): t = torch.full((num_samples,), int(T * step / sampling_steps), dtype=torch.long, device=device) logits = model(x, t) probs = torch.softmax(logits / 1.0, dim=-1) pred_ids = torch.argmax(probs, dim=-1) conf = probs.max(dim=-1).values remain_ratio = step / sampling_steps # 对整个 batch 计算分位数 threshold = torch.quantile(conf, remain_ratio) updated = x.clone() keep = conf >= threshold updated[keep] = pred_ids[keep] x = updated return [tokenizer.decode(seq, skip_special_tokens=True) for seq in x]

这里一次性生成 num_samples 条文本，模型并行处理所有样本。显存充足的情况下，这种批量方式比循环调用快很多。温度控制同样适用于批量生成，如果希望结果更多样，可以把 temperature 提高；如果需要稳定结果，则降低温度。

性能观察方面，建议重点观察三组数据：训练时的显存占用和单 step 耗时，推理时 batch size 变化对显存的影响，以及采样步数对生成质量和耗时的折中关系。显存不够时，优先减少 batch size，其次降低 max_len，再考虑减小模型 hidden size。不要一开始就牺牲模型规模，先用可控配置把问题定位清楚，再做性能优化。

8. 接口 API 部署示例

模型训练好后，可以封装成一个 HTTP 服务，方便接到自己的业务系统里。这里用 FastAPI 做一个最小可用的接口，包含生成参数和批量返回。

from fastapi import FastAPI from pydantic import BaseModel import uvicorn app = FastAPI() class GenerateRequest(BaseModel): max_len: int = 32 sampling_steps: int = 50 temperature: float = 1.0 num_return_sequences: int = 1 @app.post("/generate") def generate_endpoint(req: GenerateRequest): results = [] for _ in range(req.num_return_sequences): text = generate( model, tokenizer, max_len=req.max_len, sampling_steps=req.sampling_steps, temperature=req.temperature, device=device, ) results.append(text) return {"results": results} if __name__ == "__main__": uvicorn.run(app, host="127.0.0.1", port=8000)

启动服务后，可以用 curl 验证接口是否正常。

curl -X POST http://127.0.0.1:8000/generate \ -H "Content-Type: application/json" \ -d '{"max_len": 32, "sampling_steps": 50, "temperature": 1.0, "num_return_sequences": 3}'

Python 客户端请求示例：

import requests resp = requests.post( "http://127.0.0.1:8000/generate", json={ "max_len": 32, "sampling_steps": 50, "temperature": 1.0, "num_return_sequences": 8, }, timeout=120, ) print(resp.json())

接口部署后，需要重点处理并发和资源限制。如果同时有多个请求进来，每个请求都会占用显存。建议在服务层面加一个简单的任务队列，或者把请求数量限制在模型可承受的范围内。生产环境还要加鉴权，避免任何人都能调用生成接口。API 服务返回的文本应当经过内容审核后再进入下游业务。

9. 常见问题与排查方法

第一次跑通扩散式语言模型时，遇到上述问题是很正常的。关键不是一次性把所有参数调到最优，而是先把最小链路跑通，然后针对具体现象做单点分析。比如生成重复，就优先关闭温度、降低采样步数观察；如果是全 mask 生成差，就优先调整时间步采样分布。

10. 最佳实践与使用建议

构建扩散式语言模型，工程实践上有几个建议值得从一开始就落实。

第一，先小参数跑通，再放大模型。用 hidden_size=128、num_layers=2、max_len=32 这种小配置完整跑一个 epoch，确认训练、采样、接口链路都正常，再逐步扩大模型规模。这样能避免在链路不通时浪费大量训练时间。

第二，固定随机种子。扩散模型的训练和采样都涉及随机性，如果不固定种子，同一个问题复现起来很麻烦。建议在训练和推理脚本开头固定 Python、NumPy、PyTorch 的随机种子，并记录训练参数。

第三，模型、数据、输出分目录管理。推荐目录结构大致如下：

experiments/ configs/ # 训练配置 data/ # 清洗后的训练数据 checkpoints/ # 模型权重 outputs/ # 生成结果 logs/ # 训练日志

第四，批量任务一定要加日志和失败重试。批量生成文本时，如果某条数据因为显存波动或服务重启失败，需要记录失败原因，稍后重试。不要让一个失败样本中断整个批处理。

第五，合规与安全问题。文本生成模型可能被用于批量生成虚假信息、侵权内容或恶意文本。作为技术构建方，应该在使用说明、服务协议中明确用途边界，对生成结果进行人工或自动审核。如果模型训练数据来自公开语料，需要确认数据许可协议；如果涉及用户数据，必须脱敏处理。

11. 总结与下一步

扩散式语言模型最值得动手验证的点，是把“前向 mask 加噪 + 去噪网络 + 并行采样”这条链路从零跑通。整个过程并不复杂，代码量比图像扩散模型少很多，难点主要集中在时间步采样、mask 比例调度和推理时的 token 固定策略上。

第一次实验建议先做小规模重建测试：拿 20 句训练集内的句子，把 30% token mask 掉，看模型能否恢复。这一步能快速暴露数据管线、时间步采样、模型结构是否正常。全 mask 并行生成放到第二步，再考虑条件生成和接口部署。

最容易踩的坑有三个：mask 比例分布不均匀导致模型对中高噪声学习不足；推理时固定 token 过于激进导致生成结果局部重复；采样步数设置过大或过小导致生成质量不稳定。把这三个点控制好，扩散式语言模型的基本效果就能稳定下来。

后续扩展方向可以考虑三条：第一，在去噪网络中加入条件向量，实现情感、关键词、主题约束生成；第二，从离散 mask 扩散切换到连续 embedding 空间扩散，追求更精细的语义还原；第三，把训练好的模型接入现有业务系统，用批量接口处理数据增强、文本改写、内容生成等真实任务。