想象这样一个场景：一位米其林大厨（旧时代U-Net）在厨房里炒菜，他有一套传承多年的固定流程——先把食材切成小块（卷积下采样），一锅一锅分层处理（多尺度特征），最后再重新拼回一整盘（上采样恢复分辨率）。这套流程虽然味道稳定，但每次换新菜谱、加新食材，都要大厨亲自手工调整，而且厨房规模越大，他越忙不过来。 现在，一位天才学徒（DiT）提出了一种全新的思路：把厨房彻底模块化。所有食材一律切成统一大小的“标准方块”（Patch化），不管什么菜，都走同一条流水线——每个工作站（Transformer层）都做同样的事：观察食材之间的相互作用（注意力机制），然后统一调整火候和调料（条件注入）。这个学徒说：“我不需要记住每道菜的特殊流程，我只需要让流水线足够长、足够宽、训练得足够好，任何菜谱我都能做出来，而且加工作站就能扩大产量。” 这个“模块化流水线”就是DiT的核心精神：用统一的Transformer架构替代精心设计的U-Net，用规模换能力，用简单换灵活。本篇文章将带你走进DiT的厨房，看懂Patch化输入、条件注入、缩放规律，以及Sora和Stable Diffusion 3的真实实践。

岗位关联

理解DiT是看懂Sora、Stable Diffusion 3等顶尖文生图/文生视频模型的钥匙。掌握它，你就能理解为什么业界正在从“手工设计架构”转向“规模化堆算力”，也能在架构选型时做出更前瞻的判断。

目录
  1. 可视化演示
  2. 扩散模型基础
  3. U-Net的局限
  4. Patch化输入
  5. 条件注入方式
  6. 缩放规律验证
  7. DiT与U-Net对比
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

分步展示Diffusion Transformer的核心架构：图像Patch化输入与Token嵌入、Transformer Block堆叠与条件注入、adaLN自适应层归一化、DiT与U-Net架构对比，交互切换深入理解。

本节配有交互动效（进入视口后自动加载，约 3KB）。

Patch化输入：图像到Token序列 将输入噪声图像切分为固定大小的Patch，每个Patch经线性投影映射为一个Token，加入位置编码形成序列 image → patches → linear proj → tokens + pos Patch化让Transformer能处理二维图像，是DiT区别于U-Net的第一步。

扩散模型基础

还记得我们开头那位米其林大厨吗？在他学会“从噪声里炒出一盘菜”之前，他得先明白一个基本训练：把菜一步步毁掉，再一步步还原。 这个过程就像把一张照片先复印一百次，每次复印都会增加一些噪点，直到最后完全看不清原图；然后让 AI 学会反向操作——从一张纯噪点的图，一步步猜出原图长什么样。

技术上，这个过程被分为两个阶段。前向过程（Forward Process）是逐渐往图片中加入高斯噪声，经过 \(T\) 步后，图片完全变成纯噪声；逆向过程（Reverse Process）则训练一个神经网络，让它从带噪图片预测出“纯噪声”是什么，然后通过减去预测的噪声来一步步还原。训练目标很简单：让模型预测的噪声和真实加入的噪声尽可能一致。

整个过程就好比：大厨知道一道菜毁掉需要几步（加多少盐、炒多久），于是他就学会了反向操作——从“毁掉的菜”推断出“该加什么料”。扩散模型就是这么一个“反向大厨”，唯一的问题在于：这个“反向大厨”用什么灶台最合适？

Forward: xT=αˉTx0+1−αˉTϵTraining Loss: L=E[∥ϵθ(xt,t)−ϵ∥2]\text{Forward: } x_T = \sqrt{\bar{\alpha}_T} x_0 + \sqrt{1 - \bar{\alpha}_T} \epsilon \\\text{Training Loss: } \mathcal{L} = \mathbb{E} \left[ \| \epsilon_\theta(x_t, t) - \epsilon \|^2 \right]
  1. 前向过程公式表示经过 T 步加噪后，图片从清晰的 \(x_0\) 变成噪声图 \(x_T\)。
    xT=αˉTx0+1−αˉTϵx_T = \sqrt{\bar{\alpha}_T} x_0 + \sqrt{1 - \bar{\alpha}_T} \epsilon
  2. 噪声系数 \(\bar{\alpha}_T\)控制每一步保留多少原图信息、加入多少噪声，\(\bar{\alpha}_T\) 随 T 增大而减小。
    αˉT=∏t=1Tαt\bar{\alpha}_T = \prod_{t=1}^{T} \alpha_t
  3. 训练损失让模型预测的噪声 \(\epsilon_\theta(x_t, t)\) 逼近真实噪声 \(\epsilon\)。
    L=E[∥ϵθ(xt,t)−ϵ∥2]\mathcal{L} = \mathbb{E} \left[ \| \epsilon_\theta(x_t, t) - \epsilon \|^2 \right]

U-Net的局限

传统的扩散模型（如 Stable Diffusion 1/2）用的灶台是 U-Net。U-Net 像一个经验丰富的老师傅，它有一套精心设计的流程：先不断下采样（把图片缩小，提取特征），再不断上采样（把特征放大回原尺寸）。这种“漏斗形”结构让它在图片局部细节上表现出色。但问题也随之而来：

第一，手工设计太多。 U-Net 每个层级的通道数、下采样次数、跳跃连接位置都需要人工调参，就像大厨的每道菜都有自己的专属秘方，换一道菜就要重新摸索。第二，下采样丢信息。 图片被缩小再放大，中间总有信息损失——就像复印再复印，原图的细节越来越模糊。第三，缩放瓶颈。 当你想让模型更大、效果更好时，U-Net 的收益会迅速衰减——老师傅的体力是有限的，场地再大他也只能一桌一桌炒。

研究人员开始思考：为什么不让所有生成任务共用一套统一的 Transformer 架构？ 毕竟 Transformer 已经在 NLP 领域被证明——只要模型够大、数据够多，效果就会持续提升。于是，DiT 应运而生：它把图片处理彻底标准化，让“去噪”变成一个纯粹的 Transformer 序列建模任务。

Patch化输入

Transformer 擅长处理序列，但图片是二维网格。怎么让 Transformer“看懂”图片？DiT 的做法很简单：像切披萨一样，把整张图片切成很多个固定大小的小方块，每个小方块叫一个 Patch。然后把每个 Patch 拉平成一维向量，经过一个线性层映射成 token 的 embedding 向量。

举个例子：一张 \(32 \times 32\) 像素的图片，如果 Patch 大小为 \(8 \times 8\)，那么它会被切成 \(4 \times 4 = 16\) 个 Patch，每个 Patch 变成一个 token，最终得到 16 个 token 组成的序列。这就像把一盘完整的炒饭先分成 16 个小碗，每个碗都贴上标签（位置编号），然后让流水线上的工人逐一处理每一碗。

这种处理的好处是：图片变成了一串标准 token，Transformer 的注意力机制可以自由建模任意两个 Patch 之间的关系——远处的 Patch 也能直接关联，而不像卷积那样只能看局部。这就像一个厨师可以同时观察所有灶台上的菜，而不是只能盯着眼前这一口锅。

Token Sequence=Linear(Patch(x))+Positional Embedding\text{Token Sequence} = \text{Linear}( \text{Patch}(x) ) + \text{Positional Embedding}
  1. Patch 切分将图片 \(x \in \mathbb{R}^{H \times W \times C}\) 切成 \((H/p) \times (W/p)\) 个大小为 \(p \times p\) 的 Patch。
    Patch(x)∈R(H/p)×(W/p)×(p2C)\text{Patch}(x) \in \mathbb{R}^{(H/p) \times (W/p) \times (p^2 C)}
  2. 线性嵌入把每个 Patch 展平后通过线性层映射到 \(d\) 维的 token 向量。
    Linear:Rp2C→Rd\text{Linear}: \mathbb{R}^{p^2 C} \rightarrow \mathbb{R}^{d}
  3. 位置编码给每个 token 加上位置信息，让 Transformer 知道每个 Patch 原来在图片的哪个位置。
    Tokeni=Embeddingi+Posi\text{Token}_i = \text{Embedding}_i + \text{Pos}_i

条件注入方式

扩散模型不是盲目去噪——它必须知道“当前是第几步”（时间步 \(t\)）以及“用户想要什么类别”（比如想生成猫还是狗）。这些信息在 DiT 中被称为条件。如何把条件注入到 Transformer 里？DiT 论文对比了几种方式，最重要的叫自适应归一化（Adaptive Layer Normalization, AdaLN）。

AdaLN 的思路是：每一层 Transformer 的归一化参数（scale 和 shift）不是固定的，而是由条件信息动态生成的。 就像流水线上，每个站点的火候和调料用量会根据“这道菜做到哪一步”而动态调整——第 5 步要大火，第 20 步要收汁。公式如下：

除了 AdaLN，DiT 还试验了交叉注意力（将条件作为 key/value 让 token 去查询）和 In-context 拼接（把条件 token 直接拼进序列）。实验结果表明 AdaLN 效果最好且计算开销最低。这告诉了我们一个道理：在生成任务中，条件信息应该“无孔不入”地渗透进每一层，而不是只在开头注入一次。

AdaLN(h,c)=γ(c)⊙h−μσ+β(c)\text{AdaLN}(h, c) = \gamma(c) \odot \frac{h - \mu}{\sigma} + \beta(c)
  1. 归一化操作先将 token 向量 \(h\) 标准化为均值 0、方差 1。
    h^=h−μσ\hat{h} = \frac{h - \mu}{\sigma}
  2. 条件调制用条件 \(c\) 通过 MLP 生成缩放参数 \(\gamma\) 和偏移参数 \(\beta\)。
    γ,β=MLP(c)\gamma, \beta = \text{MLP}(c)
  3. 调制结果用 \(\gamma\) 乘、\(\beta\) 加，将条件信息注入到每一层的输出中。
    Output=γ⊙h^+β\text{Output} = \gamma \odot \hat{h} + \beta

缩放规律验证

DiT 论文提出一个重要问题：如果把模型和计算量越堆越大，生成效果会一直提升吗？ 这在 NLP 领域的 Transformer 上已被证实（就是著名的“缩放定律”），但在扩散模型上还没有人系统验证过。于是作者训练了一系列不同规模的 DiT 模型，从最小的 DiT-S 到巨大的 DiT-XL，在 ImageNet 上系统测量了图像生成质量（用 FID 指标评估）。

结果的趋势非常清晰：模型参数越多、训练计算量越大，FID 分数就越低（生成质量越好），而且这种提升在对数坐标下几乎是线性的。 这意味着 DiT 的扩展性能非常“诚实”——你投入多少算力和参数，它就回报你多少生成质量，不存在“堆料到一定程度就没用了”的瓶颈。

这个规律后来被 OpenAI 在 DiO（Diffusion with Offset Noise） 中进一步验证——即使在更大规模、更复杂的训练设定下，DiT 架构的缩放收益依然稳如磐石。这也为 Sora 的出现铺平了道路：既然缩放有效，那就放心大胆地把视频生成的模型做大。

FID∝−klog⁡(Compute)+b\text{FID} \propto -k \log(\text{Compute}) + b
  1. FID（Fréchet Inception Distance）衡量生成图片与真实图片分布的距离，值越低越好。
    FID=∥μr−μg∥2+Tr(Cr+Cg−2(CrCg)1/2)\text{FID} = \| \mu_r - \mu_g \|^2 + \text{Tr}(C_r + C_g - 2(C_r C_g)^{1/2})
  2. 计算量（Compute）训练时消耗的总算力，通常用 FLOPs 或 GPU 小时数衡量。
    Compute=参数量×训练步数×每步计算量\text{Compute} = \text{参数量} \times \text{训练步数} \times \text{每步计算量}
  3. 对数线性关系FID 与计算量的对数成正比，说明“每翻一倍算力，FID 稳定下降一个量”。
    log⁡(FID)∝−log⁡(Compute)\log(\text{FID}) \propto -\log(\text{Compute})

DiT与U-Net对比

到了总结时刻，我们把 U-Net 和 DiT 这两套“灶台”放在一起对比。U-Net 像是经验丰富但固守成规的老师傅，DiT 则是标准化程度极高、可以无限复制的模块化流水线。

第一，架构简洁性：U-Net 需要精心设计下采样/上采样结构、跳跃连接；DiT 只需要堆叠相同的 Transformer Block，架构完全统一，代码实现也更简单。第二，信息保留能力：U-Net 下采样会丢失空间细节；DiT 直接对 Patch 序列建模，没有信息压缩过程，注意力机制还能捕捉全局依赖。第三，扩展性：U-Net 的收益随着参数增加快速饱和；DiT 的性能在对数坐标下几乎线性增长，参数量、计算量和数据量都能无缝放大。

实际效果也印证了这一点：在 ImageNet 256×256 生成任务上，DiT-XL/2 的 FID 达到 2.27，显著优于同规模 U-Net 架构。而此后 Sora 直接采用 DiT 作为视频生成基础架构，Stable Diffusion 3 也将 U-Net 替换为全新的 DiT 结构——这标志着扩散模型的“Transformer 化”已经成为行业共识。那位天才学徒，终于用自己的标准化流水线，取代了老师傅的独家秘方。

AI 应用场景

Sora 文生视频的 DiT 架构

阶段：模型架构选型与实施

解决的问题：传统 U-Net 在处理视频时空数据时需要复杂的 3D 卷积设计，难以扩展到长视频和高分辨率生成。Sora 团队将视频视为“时空 Patch 序列”，用 DiT 统一处理空间和时间维度，让模型能够学习视频中物体运动的物理规律。

具体案例：用户输入“一位时尚女性走在霓虹闪烁的东京街头”，Sora 通过 DiT 将视频帧切成时空 Patch，用 Transformer 注意力建模跨帧的物体运动轨迹，生成一段 60 秒的高质量视频，并且物体运动连贯、光影一致。

Stable Diffusion 3 的文本理解升级

阶段：文本编码与条件注入设计

解决的问题：Stable Diffusion 1/2 使用 CLIP 文本编码器 + U-Net 架构，对复杂提示词（如“猫在月亮上钓鱼，旁边有棵树”）的理解经常出错。SD3 改用 DiT 架构后，可以在 Transformer 内部通过注意力机制让文本 token 与图像 patch 深度交互，显著提升图文对齐能力。

具体案例：当用户输入“一个宇航员骑着马在火星上奔跑，夕阳西下”时，SD3 能够准确生成宇航员、马、火星、夕阳四个元素并且位置关系正确——这在旧版 U-Net 架构中经常出现元素遗漏或位置错误。

Python 演示

python84 行
import mathimport random class SimpleDiT:    def __init__(self, img_size=32, patch_size=8, d_model=32, num_layers=2):        self.img_size = img_size        self.patch_size = patch_size        self.num_patches = (img_size // patch_size) ** 2        self.d_model = d_model        self.num_layers = num_layers        # 模拟 patch 线性嵌入层和位置编码        self.patch_proj = [[random.random() for _ in range(d_model)]                           for _ in range(patch_size * patch_size * 3)]        self.pos_embed = [[random.random() for _ in range(d_model)]                          for _ in range(self.num_patches)]        # 模拟 AdaLN 条件调制参数        self.ada_mlp = [[random.random() for _ in range(d_model * 2)]                        for _ in range(num_layers)]     def patchify(self, image):        # 将图片切成 num_patches 个 patch，每个展平为向量        p = self.patch_size        n = self.img_size // p        patches = []        for i in range(n):            for j in range(n):                vec = []                for k in range(p):                    for l in range(p):                        vec.extend(image[(i * p + k) * self.img_size * 3 +                                         (j * p + l) * 3: (i * p + k) * self.img_size * 3 +                                         (j * p + l) * 3 + 3])                patches.append(vec)        return patches     def linear_embed(self, patch_vec):        # 线性层将 patch 向量映射为 d_model 维 token        token = [0.0] * self.d_model        for i in range(self.d_model):            for j in range(len(patch_vec)):                token[i] += patch_vec[j] * self.patch_proj[j][i]        return token     def add_pos_embed(self, tokens):        # 给每个 token 叠加位置编码        return [[tokens[i][j] + self.pos_embed[i][j] for j in range(self.d_model)]                for i in range(len(tokens))]     def conditional_modulate(self, tokens, t):        # 用时间步 t 生成 gamma, beta 调制 token（模拟 AdaLN）        cond = [math.sin(t / 10.0), math.cos(t / 20.0), t / 100.0]        for layer in range(self.num_layers):            gamma_beta = self.ada_mlp[layer]            gamma = [gamma_beta[j] * cond[j % 3] for j in range(self.d_model)]            beta = [gamma_beta[self.d_model + j] * cond[j % 3]                    for j in range(self.d_model)]            tokens = [[gamma[j] * tokens[i][j] + beta[j]                       for j in range(self.d_model)]                      for i in range(len(tokens))]        return tokens     def forward(self, image, t):        # 完整前向：patch -> 嵌入 -> 加位置 -> 条件调制        patches = self.patchify(image)        tokens = [self.linear_embed(p) for p in patches]        tokens = self.add_pos_embed(tokens)        tokens = self.conditional_modulate(tokens, t)        # 模拟预测噪声（取平均 token 的均值作为噪声标量）        all_vals = [v for token in tokens for v in token]        return sum(all_vals) / len(all_vals)  def make_noisy_image(img_size=32):    # 生成一张带噪图片: 3 通道叠成一维列表    return [random.uniform(-1, 1) for _ in range(img_size * img_size * 3)]  if __name__ == "__main__":    model = SimpleDiT(img_size=32, patch_size=8, d_model=32, num_layers=2)    x_t = make_noisy_image(32)    t = 50    pred_noise = model.forward(x_t, t)    print("DiT 预测噪声得分: %.4f" % pred_noise)    print("Patch 数量:", model.num_patches)
目的：这段代码极简模拟了 DiT 的完整前向流程——把图片切 Patch、线性嵌入成 token、加位置编码、用时间步条件做自适应调制，最终输出预测噪声。
  1. class SimpleDiT定义了一个极简 DiT 模型类，包含 patch 化、嵌入、条件调制三个核心步骤。
  2. self.num_patches = (img_size // patch_size) ** 2计算一张图能切成多少个 patch，32×32 图配 8×8 patch 就是 16 个。
  3. patches.append(vec)把每个 patch 展平为一维向量，等价于把“小碗炒饭”端到流水线上。
  4. def linear_embed(self, patch_vec)线性层把 patch 向量投影到 d_model 维 token 空间。
  5. self.pos_embed预生成的位置编码，让 Transformer 知道每个 patch 的原始位置。
  6. def conditional_modulate(self, tokens, t)用时间步 t 生成 γ 和 β，模拟 AdaLN 的条件注入。
  7. tokens = [[gamma[j] * tokens[i][j] + beta[j] ...]]对 token 逐元素乘以 γ 再加 β，即条件调制公式。
  8. pred_noise = model.forward(x_t, t)完整前向传播，输入噪声图和当前时间步，输出预测噪声。

常见误区

误区很多人以为 DiT 只是在 U-Net 的某些层上做“局部改造”，把卷积换掉就行，整体框架还是 U-Net 那套下采样-上采样结构。

正解DiT 是一次彻底的架构革命——它完全抛弃了 U-Net 的漏斗形结构，不再有任何下采样和上采样。图片被切成 Patch 后直接进入纯 Transformer 堆叠，整个过程没有分辨率变化，只是 token 序列在深度方向不断变换。就像流水线不再是大厨的多口锅，而是一条完全平整的传送带。

为何常见：因为很多人对“Transformer 替代 U-Net”的理解停留在“换组件”层面，没有意识到这是一次“换整条产线”的级变化。

误区初学者认为既然 Patch 越大 token 越少，计算开销越小，那就用大 Patch，图像质量应该不受影响。

正解Patch 大小是计算量和信息保留的权衡。Patch 越大，每个 token 包含的局部细节越少，模型在生成时就越容易丢失精细纹理（如毛发、叶片）。DiT 实验中 patch size=2 的效果优于 patch size=8，代价是计算量更大。就像切菜，块切得太大，炒出来的菜就没什么口感了。

为何常见：因为计算量的优势太直观，初学者容易忽略“信息粒度”对生成质量的关键影响。

误区有人认为把条件信息拼到序列开头或注入一次就够了，反正 Transformer 的注意力都能看到。

正解DiT 论文的实验明确显示，条件注入方式对效果影响巨大。AdaLN 在每个 Transformer Block 的归一化层都注入条件，效果远好于只在开头拼接一次。条件信息越充分渗透，模型在每一步去噪时越能“记住”当前状态。就像做菜时，盐和调料需要在每个阶段调整，而不是一遍就定终身。

为何常见：因为 Transformer 的全局注意力让人误以为“条件放哪里都能被注意到”，忽略了归一化层的调制作用。

误区有人认为 OpenAI 的缩放定律是 NLP 专属，图像生成模型堆参数只会过拟合，不会持续提升。

正解DiT 论文首次在扩散模型上验证了缩放规律，DiO 进一步在大规模设定下确认——模型参数量和计算量与生成质量在对数坐标系中呈线性关系。这说明只要数据充分、优化稳定，生成模型的规模红利同样存在。Sora 也是靠这个规律才敢一路把模型做到极大。

为何常见：因为扩散模型训练不稳定、调参繁琐，很多人把工程困难误判为“缩放无效”。

面试题

Q1. DiT 中，一张 32×32×3 的图片，patch_size=8，会得到多少个 token？

单选题 · mid

  • A.4 个
  • B.16 个← 正确答案
  • C.32 个
  • D.64 个

答案：B。token 数量 = (img_size / patch_size)² = (32/8)² = 4² = 16 个。选项 A 少了平方运算，C 是行数或列数的一半，D 是 patch_size 的平方，都不正确。

Q2. DiT 中 AdaLN 的全称和核心思想是什么？

单选题 · mid

  • A.Adaptive Layer Normalization，用条件生成归一化的缩放和偏移参数← 正确答案
  • B.Advanced Linear Network，用线性层替代所有注意力
  • C.Auto Decoding Latent Norm，用解码器自动归一化
  • D.Attention-based Layer Normalization，用注意力计算归一化参数

答案：A。AdaLN 即 Adaptive Layer Normalization，核心是用条件信息 c 通过 MLP 动态生成 γ 和 β 来调制每一层的归一化输出。B 是杜撰的“线性网络”，C 混淆了 Latent 与 Adaptive，D 把注意力机制错误地安到归一化上。

Q3. DiT 替代 U-Net 的最核心动机是什么？

单选题 · easy

  • A.U-Net 生成质量太差，完全不可用
  • B.Transformer 架构更统一且具备更好的扩展性← 正确答案
  • C.U-Net 无法处理 256×256 以上图片
  • D.Transformer 天然支持视频生成

答案：B。DiT 的动机是让扩散模型拥有和 NLP 一样统一的架构与缩放能力——简单、标准化、堆参数量就有收益。A 是错误前提（U-Net 质量不差），C 纯属误解，D 不是 DiT 诞生的核心原因。

Q4. DiT 论文中，条件注入的方式包括哪些？

多选题 · hard

  • A.自适应归一化 AdaLN← 正确答案
  • B.交叉注意力机制← 正确答案
  • C.条件 token 直接拼接进序列← 正确答案
  • D.通过修改损失函数注入条件

答案：ABC。DiT 论文明确对比了 AdaLN、交叉注意力和 In-context 拼接三种条件注入方式，结论是 AdaLN 效果最好。D 修改损失函数属于训练策略，与条件注入方式无关。

Q5. 在 DiT 的缩放规律实验中，FID 与训练计算量是什么关系？

单选题 · mid

  • A.FID 随计算量线性上升
  • B.FID 与计算量无关
  • C.FID 随计算量对数线性下降← 正确答案
  • D.FID 随计算量指数上升

答案：C。DiT 实验显示，模型越大、训练计算量越多，FID 越低（生成质量越好），且在对数坐标下几乎呈线性下降。A 和 D 方向完全反了，B 否认了缩放规律的存在。

Q6. 在扩散模型中，前向过程做的是什么？

单选题 · easy

  • A.从噪声逐步还原出清晰图片
  • B.逐步向清晰图片加入噪声直至完全噪声← 正确答案
  • C.将图片压缩成低维潜空间
  • D.将文本编码成向量

答案：B。前向过程是逐步加噪，把清晰图片 x₀ 在 T 步内变成纯噪声 x_T，训练目标是学逆向去噪。A 描述的是逆向过程，C 是 VAE 的功能，D 是文本编码器的工作。

Q7. DiT 中 Patch 化输入后，为什么要加位置编码？

单选题 · mid

  • A.让 token 在 Transformer 中能区分先后顺序← 正确答案
  • B.增加模型参数量以提升效果
  • C.防止过拟合
  • D.加速训练收敛

答案：A。位置编码给每个 token 打上“原图的坐标标签”，让注意力机制知道 patch 之间的空间关系。B 是副作用不是目的，C 和 D 是正则化与优化的范畴。

Q8. 以下哪些是 U-Net 在扩散模型中被 DiT 替代的原因？

多选题 · hard

  • A.U-Net 下采样操作会丢失空间细节← 正确答案
  • B.U-Net 架构手工设计复杂、调参工作量大← 正确答案
  • C.U-Net 性能随参数量增加快速饱和← 正确答案
  • D.U-Net 无法使用 GPU 训练

答案：ABC。U-Net 的三大问题——下采样信息丢失、手工设计繁琐、缩放性差——正是 DiT 要解决的。D 完全不成立，U-Net 一直用 GPU 训练。

Q9. 以下哪个模型没有使用 DiT 架构？

单选题 · easy

  • A.OpenAI Sora
  • B.Stable Diffusion 3
  • C.原始 Stable Diffusion 1.4← 正确答案
  • D.Google DiO

答案：C。原始 SD 1.4 使用 U-Net 架构，而 Sora、SD3 和 DiO 都采用 DiT 路线的探索或实践。注意题干问的是“没有使用 DiT”。

Q10. 关于 DiT 的缩放能力，以下说法正确的是？

多选题 · hard

  • A.模型参数量增大，FID 分数更低← 正确答案
  • B.训练计算量翻倍，生成质量稳定提升← 正确答案
  • C.缩放收益会很快饱和，模型再大也没用
  • D.DiO 在更大规模上验证了 DiT 的缩放规律← 正确答案

答案：ABD。DiT 实验和 DiO 验证都表明了参数和算力的持续投入带来稳定的质量提升，A、B、D 正确。C 恰恰是 U-Net 的困境，而不是 DiT 的特征。