DDIM 深度剖析：从随机马尔可夫链到确定性隐式模型

1. DDPM 的致命弱点：为什么需要 DDIM？#

1.1 从 DDPM 到 DDIM 的动机#

回顾 DDPM 文章：DDPM 用一个 $T = 1000$ 步的马尔可夫链逆向去噪，每一步都加随机噪声。生成一张 512×512 图像需要：

1
DDPM 生成时间 ≈ 1000 步 × 每步 ~100ms ≈ 100 秒 (GPU)

这对实际应用来说是不可接受的。核心矛盾：

问题	DDPM 的选择	后果
逆向过程是随机的	$x_{t-1} \sim \mathcal{N}(\mu, \sigma^2)$	每步独立随机噪声，无法利用前面的信息
马尔可夫假设	$p(x_{t-1}\\|x_t)$ 只依赖 $x_t$	无法”跳跃”——必须一步步走
生成轨迹	高度发散（随机游走）	步数少时质量急剧下降

1.2 DDIM 的核心洞察#

放弃马尔可夫假设，换取确定性和速度。

Song et al. 2021 提出的 DDIM（Denoising Diffusion Implicit Models）发现：

1
DDPM 的核心假设"逆向过程必须是马尔可夫的"是人为加的。
2
如果只要求:
3
  1. 逆向过程是"隐式概率模型"（Implicit Probabilistic Model）
4
  2. 边际分布 q(x_t) 不变（训练数据分布不变）
5
那么逆向过程可以完全自由设计——包括非马尔可夫的确定性过程！

这就是”Implicit Models”（隐式模型）名称的由来：不再显式定义 $p(x_{t-1}|x_t)$ 的概率密度，而是定义一个确定性映射 $x_{t-1} = f_\theta(x_t, t)$ ，通过 ODE 积分来生成样本。

1.3 一句话概括 DDIM#

DDIM 通过放弃”逆向过程必须是马尔可夫链”的约束，把 DDPM 的随机走路径变成确定性的直线路径——从而用 10-50 步生成与 1000 步 DDPM 相当甚至更好的图像质量。

1.4 论文信息#

1
论文: "Denoising Diffusion Implicit Models" (DDIM)
2
作者: Jiaming Song, Chenlin Meng, Stefano Ermon
3
单位: Stanford University
4
发表于: ICLR 2021
5
引用: > 5,000 次 (截至 2024)
6
开源: https://github.com/ermongroup/ddim

2. 数学框架：非马尔可夫逆向过程#

2.1 隐式概率模型的定义#

DDPM 定义了一个生成过程（马尔可夫链）：

p_\theta(x_{0:T}) = p(x_T) \prod_{t=1}^T p_\theta^{(t)}(x_{t-1} | x_t)

其中 $p_\theta^{(t)}$ 是神经网络近似的逆向分布。

DDIM 则定义了一个更一般的生成过程，称为非马尔可夫链：

p_\theta(x_{0:T}) = p(x_T) \prod_{t=1}^T \tilde{p}_\theta^{(t)}(x_{t-1} | x_t, x_0)

注意： $\tilde{p}_\theta^{(t)}$ 依赖 $x_0$ （不只是 $x_t$ ）——这打破了马尔可夫假设。

关键约束：边际分布 $q(x_t)$ 必须保持不变（即与前向过程定义的分布一致），否则训练目标会失效。

2.2 边际分布约束#

设 $q(x_{1:T}|x_0)$ 是前向过程定义的联合分布。DDIM 要求生成模型的边际分布 $p_\theta(x_t)$ 与 $q(x_t)$ 匹配：

p_\theta(x_t) = q(x_t) \quad \forall t

这是一致性约束：不管用马尔可夫还是非马尔可夫方式生成，边际分布必须一致。

从 $q(x_{1:T}|x_0)$ 的马尔可夫链结构出发，可以推导出 $q(x_{t-1}|x_t, x_0)$ 的解析形式（贝叶斯定理）：

q(x_{t-1} | x_t, x_0) = \mathcal{N}\left(x_{t-1}; \tilde{\mu}_t(x_t, x_0), \tilde{\sigma}_t^2 I\right)

其中均值和方差与 DDPM 中的逆向条件分布完全相同（来自 DDPM 文章的推导）。

2.3 DDIM 逆向过程的定义#

设 $\sigma_t \in [0, 1]$ 是自由参数（DDPM 中固定为 $\beta_t^{1/2}$ ）。DDIM 定义逆向过程为：

x_{t-1} = \sqrt{\bar\alpha_{t-1}} x_0 + \sqrt{1 - \bar\alpha_{t-1} - \sigma_t^2} \cdot \epsilon_\theta(x_t, t) + \sigma_t \cdot \epsilon

其中：

$\epsilon_\theta(x_t, t)$ 是神经网络预测的噪声（与 DDPM 相同）
$\epsilon \sim \mathcal{N}(0, I)$ 是可选的随机噪声
当 $\sigma_t = 0$ 时，过程完全确定性——这就是 DDIM 的核心

2.4 三种特殊情形#

情形	$\sigma_t$ 取值	过程类型	采样步数影响
DDPM（完全随机）	$\sigma_t = \sqrt{1 - \bar\alpha_{t-1}}$	随机马尔可夫	必须多步，质量急剧下降
DDIM（完全确定）	$\sigma_t = 0$	确定性非马尔可夫	步数减少时质量下降最慢
插值（部分随机）	$0 < \sigma_t < \sqrt{1 - \bar\alpha_{t-1}}$	随机非马尔可夫	介于两者之间

1
def ddim_reverse_step(xt, eps_theta, t, t_prev, sigma_t):
2
    """
3
    DDIM 单步逆向过程。
4

5
    参数:
6
        xt:        当前位置 x_t
7
        eps_theta: 神经网络预测的噪声
8
        t:         当前时间步 (整数)
9
        t_prev:    上一个时间步 (整数)
10
        sigma_t:   随机性参数 [0, 1]
11
    """
12
    # 从 xt 估计 x0
13
    alpha_bar_t = alphas_cumprod[t]
14
    sqrt_ab     = torch.sqrt(alpha_bar_t)
15
    sqrt_1m     = torch.sqrt(1 - alpha_bar_t)
16
    x0_pred     = (xt - sqrt_1m * eps_theta) / sqrt_ab
17

18
    # 计算 x_{t-1}
19
    alpha_bar_prev = alphas_cumprod[t_prev]
20
    sqrt_ab_prev   = torch.sqrt(alpha_bar_prev)
21
    sqrt_1m_prev   = torch.sqrt(1 - alpha_bar_prev)
22

23
    # 确定性方向（始终存在）
24
    pred_eps    = eps_theta
25
    x_prev_deterministic = sqrt_ab_prev * x0_pred + sqrt_1m_prev * pred_eps
26

27
    # 随机性方向（sigma_t > 0 时加入）
28
    if sigma_t > 0:
29
        noise     = torch.randn_like(xt)
30
        x_prev    = x_prev_deterministic + sigma_t * noise
31
    else:
32
        x_prev    = x_prev_deterministic
33

34
    return x_prev

3. 轨迹视图：从 SDE 到 ODE#

3.1 把 DDPM 看作 SDE#

连续时间下，DDPM 的前向过程是一个随机微分方程（SDE）：

dx = f(x, t) dt + g(t) dw

其中 $dw$ 是维纳过程（Wiener process），引入随机性。

DDPM 的逆向过程（在连续时间下）对应 SDE 的反向：

d\bar{x} = \left[ f(\bar{x}, t) - g(t)^2 \nabla_x \log p_t(\bar{x}) \right] dt + g(t) d\bar{w}

3.2 把 DDIM 看作 ODE#

当 $\sigma_t = 0$ 时，随机项消失，DDIM 变成常微分方程（ODE）：

\frac{dx}{dt} = \left[ f(x, t) - \frac{1}{2} g(t)^2 \nabla_x \log p_t(x) \right]

ODE 的好处：

1
SDE (DDPM):    随机轨迹，每步独立，无法加速
2
                ↓
3
ODE (DDIM):    确定性轨迹，可以用 ODE 求解器加速
4
                - 自适应步长
5
                - 高阶积分（Heun, RK45）
6
                - 逆向轨迹固定，步数减少时误差可预测

3.3 ODE 求解器与采样#

1
@torch.no_grad()
2
def ddim_ode_sampler(model, num_steps=50, eta=0.0):
3
    """
4
    DDIM ODE 采样器（确定性）。
5
    eta = 0   → 完全确定性 DDIM
6
    eta = 1   → 等效 DDPM（随机）
7
    """
8
    T     = len(alphas_cumprod) - 1
9
    shape = (batch_size, channels, height, width)
10

11
    # 从纯噪声开始
12
    x = torch.randn(*shape, device=device)
13

14
    # 生成时间步序列（均匀或非线性）
15
    # 非线性调度: t 越接近 0，变化越慢
16
    ts = torch.linspace(1.0, 0.0, num_steps + 1)
17

18
    for i in range(num_steps):
19
        t     = int(ts[i] * T)          # 当前时间步
20
        t_prev = int(ts[i + 1] * T)     # 上一个时间步
21

22
        eps_theta = model(x, t)
23

24
        # sigma_t: 由 eta 控制
25
        # eta = 0 → 完全确定
26
        # eta = 1 → 随机性等于 DDPM
27
        sigma_t = eta * ((1 - alphas_cumprod[t_prev] / alphas_cumprod[t]) ** 0.5) \
28
                  * ((1 - alphas_cumprod[t] / alphas_cumprod[t_prev]) ** 0.5)
29

30
        alpha_bar_t     = alphas_cumprod[t]
31
        alpha_bar_prev  = alphas_cumprod[t_prev]
32

33
        sqrt_ab         = alpha_bar_t ** 0.5
34
        sqrt_1m         = (1 - alpha_bar_t) ** 0.5
35
        sqrt_ab_prev    = alpha_bar_prev ** 0.5
36
        sqrt_1m_prev    = (1 - alpha_bar_prev) ** 0.5
37

38
        # 估计 x_0
39
        x0_pred = (x - sqrt_1m * eps_theta) / sqrt_ab
40

41
        # 预测 x_{t-1}
42
        x_pred = sqrt_ab_prev * x0_pred + sqrt_1m_prev * eps_theta
43

44
        # 加入随机性（仅当 eta > 0）
45
        if sigma_t > 0:
46
            std = sigma_t * ((1 - alpha_bar_prev) ** 0.5)
47
            x_pred = x_pred + std * torch.randn_like(x)
48

49
        x = x_pred
50

51
    return x

3.4 自适应步长求解器#

1
from scipy.integrate import solve_ivp
2

3

4
def ddim_neural_ode_sampler(model, rtol=1e-5, atol=1e-6):
5
    """
6
    用 scipy 的自适应 ODE 求解器（精度驱动的采样）。
7

8
    与固定步数相比:
9
    - 在低噪声区域(t→0)自动用更小步长
10
    - 在高噪声区域(t→T)自动用更大步长
11
    - 总步数可能更少，精度更高
12
    """
13
    dim = channels * height * width
14

15
    def ode_function(t_float, x_flat):
16
        """
17
        t_float ∈ [0, 1]: 连续时间（0=数据，1=噪声）
18
        这里用反向时间，t=0 是噪声，t=1 是数据
19
        """
20
        t_int = int((1.0 - t_float) * (T - 1))
21
        t_int = max(0, min(T - 1, t_int))
22

23
        x = torch.tensor(x_flat.reshape(1, channels, height, width),
24
                         device=device, dtype=torch.float32)
25
        eps = model(x, t_int)
26

27
        alpha_bar     = alphas_cumprod[t_int]
28
        sqrt_ab       = alpha_bar ** 0.5
29
        sqrt_1m       = (1 - alpha_bar) ** 0.5
30
        x0_pred       = (x - sqrt_1m * eps) / sqrt_ab
31

32
        # dx/dt = -(预测方向) / T
33
        # 近似: 速度场方向
34
        dx_dt = -(eps - x0_pred).cpu().numpy().flatten() / T
35
        return dx_dt
36

37
    x0 = torch.randn(1, channels, height, width).cpu().numpy().flatten()
38
    sol = solve_ivp(
39
        ode_function,
40
        t_span=(0.0, 1.0),
41
        y0=x0,
42
        method='RK45',
43
        rtol=rtol, atol=atol,
44
        dense_output=True,
45
    )
46
    final = sol.y[:, -1].reshape(channels, height, width)
47
    return torch.from_numpy(final).to(device).unsqueeze(0)

4. 与 DDPM 的关系：严格的数学联系#

4.1 训练目标完全相同#

最重要的事实：DDIM 的训练目标与 DDPM 完全相同！

\mathcal{L} = \mathbb{E}_{t, x_0, \epsilon} \left\| \epsilon - \epsilon_\theta(x_t, t) \right\|^2

这意味着：

不需要重新训练 DDPM 模型——已有的 DDPM checkpoint 可以直接用于 DDIM
DDIM 只是不同的采样策略，不是新的训练方法

4.2 采样分布的数学联系#

设 $q_\sigma(x_{t-1}|x_t, x_0)$ 是 DDIM 定义的逆向分布， $q(x_{t-1}|x_t, x_0)$ 是 DDPM 的真实逆向分布。

定理：对任意 $\sigma_t$ ，DDIM 的边际分布与 DDPM 的边际分布相同：

\int q_\sigma(x_{t-1}|x_t, x_0) q(x_t|x_0) dx_0 = q(x_{t-1}|x_0)

这就是 DDIM 的”隐式”特性——不显式定义概率密度函数，但边际分布自动保持一致。

4.3 采样轨迹的几何对比#

1
采样轨迹对比 (x_0 → x_T 方向为正向)
2

3
DDPM (随机马尔可夫):
4
    x_0 ──→ x_1 ──→ x_2 ──→ ... ──→ x_T
5
             ↑        ↑               ↑
6
           随机     随机             随机
7
           发散     发散             发散
8
    → 每步独立随机偏移
9
    → 步数少时轨迹高度发散
10

11
DDIM (确定性非马尔可夫):
12
    x_0 ────────→ x_{S_1}
13
        ↑                   ↑ 跳步
14
    x_{S_2} ←───────────────
15
        ↑ 跳步
16
    x_{S_3} ←───────────────
17
    ...
18
    x_T = x_{S_k}
19

20
    → 确定性轨迹，每步连续
21
    → 跳步后仍沿同一条光滑曲线
22
    → 步数减少时轨迹仍光滑

4.4 为什么确定性更好？#

直觉解释：

1
DDPM 每步: x_{t-1} = μ + 随机噪声
2
           ↑ 每个时间步的随机偏移是独立的
3
           → 走 N 步后，总偏移 ~ √N × 单步偏移（随机游走）
4
           → 步数减半，偏移翻倍，误差爆炸
5

6
DDIM 每步: x_{t-1} = F(x_t)  (确定性函数)
7
           ↑ 跳步仍沿同一光滑 ODE 曲线
8
           → 走 N 步 = 直接求 ODE 的 N 个点
9
           → 步数减半，只是不采样中间点，不影响精度
10
           → 误差可预测（由 ODE 求解器控制）

5. 采样调度策略#

5.1 均匀时间步调度#

最简单的策略：将 $[0, T]$ 均匀分割：

1
def uniform_timestep_schedule(num_steps, T=1000):
2
    """均匀调度。"""
3
    return torch.linspace(T - 1, 0, num_steps).long().tolist()

5.2 DDIM 论文推荐的调度#

论文发现，噪声强度越大（ $t$ 越接近 $T$ ），ODE 变化越剧烈。因此建议用非线性调度，在高噪声区域用更多步：

1
def ddim_timestep_schedule(num_steps, T=1000, eta=0.0):
2
    """
3
    DDIM 论文推荐的时间步调度。
4

5
    核心思想:
6
    - 高噪声区域 (t > 100): 变化剧烈，多放步
7
    - 低噪声区域 (t < 100): 变化平缓，少放步
8
    """
9
    # 从 [1, T] 均匀选 num_steps 个
10
    steps = torch.arange(0, T, T // num_steps).flip(0)
11

12
    # 如果步数不够 T，调整最后一步
13
    if len(steps) < num_steps:
14
        steps = torch.cat([steps, torch.tensor([0])])
15

16
    return steps[:num_steps].long().tolist()

5.3 重要性采样：跳过 vs 插值#

DDIM 支持两种子序列策略：

策略	方法	效果
跳步 (skip)	跳过中间时间步，只采样子序列	更直接，减少步数
插值 (interpolate)	在相邻时间步之间插值	平滑过渡，更稳定

1
def get_ddim_schedule(num_steps, T=1000, method="skip"):
2
    """
3
    生成 DDIM 子序列。
4

5
    skip:       [999, 949, 899, ..., 49, 0]
6
    interpolate: [999, 997, 995, ..., 5, 3, 1]
7
    """
8
    if method == "skip":
9
        # 每 T/num_steps 步跳一次
10
        step_size = T // num_steps
11
        schedule = list(range(T - 1, -1, -step_size))
12
    elif method == "interpolate":
13
        # 均匀分布 + 线性插值
14
        uniform = torch.linspace(T - 1, 0, num_steps)
15
        schedule = uniform.round().long().tolist()
16

17
    return schedule

5.4 噪声调度的敏感性#

1
def sensitivity_analysis():
2
    """
3
    不同 eta 和 num_steps 的 FID 表现（经验值）。
4
    来自 DDIM 论文实验。
5
    """
6
    # num_steps=100 时
7
    configs = [
8
        (100, 0.0, "DDIM (完全确定)"),   # FID ~5.8
9
        (100, 0.5, "DDIM (部分随机)"),  # FID ~6.2
10
        (100, 1.0, "DDPM (完全随机)"),  # FID ~20.0+
11
    ]
12

13
    # num_steps=20 时
14
    configs_20 = [
15
        (20, 0.0, "DDIM (完全确定)"),   # FID ~7.5
16
        (20, 0.5, "DDIM (部分随机)"),  # FID ~12.0
17
        (20, 1.0, "DDPM (完全随机)"),  # FID ~100+ (几乎无法用)
18
    ]
19

20
    return configs, configs_20

关键发现： $\eta = 0$ （完全确定）在所有步数下都优于 $\eta = 1$ （完全随机）。这是 DDIM 最重要的实践结论。

6. 轨迹坍缩与多样性#

6.1 轨迹坍缩现象#

DDIM 的 $\eta = 0$ （完全确定性）有一个副作用：多样性降低。

1
多样性 vs 确定性 trade-off:
2

3
高多样性 (η=1, DDPM):
4
    提示: "a cat on a sofa"
5
    生成: [猫1], [猫2], [猫3], ... [猫N]
6
    每张猫都不同（颜色、姿势、背景）
7

8
低多样性 (η=0, DDIM):
9
    提示: "a cat on a sofa"
10
    生成: [猫A], [猫A], [猫A], ... [猫A]
11
    几乎完全相同（只有微小随机性来自初始噪声）
12

13
原因: 确定性映射 f_θ: x_t → x_{t-1} 是固定的
14
     相同的初始噪声 x_T → 相同的生成结果
15
     初始噪声的多样性 = 生成的多样性

6.2 数学解释#

随机 DDPM 的多样性来源：

每一步逆向过程都加随机噪声：

x_{t-1} = \mu_t + \sigma_t \cdot \epsilon_t

这意味着 $x_{t-1}$ 的分布是”展宽”的（convolution），引入额外随机性。

确定性 DDIM 的多样性来源：

无随机噪声：

x_{t-1} = \mu_t^{\text{det}}

只有初始噪声 $x_T \sim \mathcal{N}(0, I)$ 引入多样性。

6.3 解决方案：调整 $\eta$ #

1
def trade_off_eta():
2
    """
3
    eta 对多样性-质量 trade-off 的影响。
4

5
    η = 0.0:  质量最高，多样性最低（轨迹坍缩）
6
    η = 0.3:  质量高，多样性适中（推荐默认值）
7
    η = 0.5:  质量中等，多样性中等
8
    η = 1.0:  质量低（步数少时），多样性最高
9
    """
10
    pass

6.4 不同任务的最佳 $\eta$ #

任务	推荐 $\eta$	理由
高保真生成	$0.0$	质量优先，不在乎多样性
多样化生成	$0.3 \sim 0.5$	平衡质量和多样性
图像编辑	$0.0$	确定性保证编辑一致性
Inpainting	$0.0$	需要精确控制
视频生成	$0.0 \sim 0.2$	时间一致性优先

7. 图像生成实验结果#

7.1 步数 vs 质量#

1
def cifar10_results():
2
    """
3
    CIFAR-10 32x32 上的 FID vs 采样步数。
4
    """
5
    results = {
6
        # (num_steps, eta): FID
7
        (1000, 1.0): 3.85,   # DDPM baseline
8
        (100,  0.0): 4.20,   # DDIM 100步确定
9
        (50,   0.0): 4.60,   # DDIM 50步确定
10
        (20,   0.0): 5.90,   # DDIM 20步确定
11
        (10,   0.0): 8.10,   # DDIM 10步确定
12
        (5,    0.0): 15.20,  # DDIM 5步确定
13
        (100,  1.0): 25.50,  # DDPM 100步随机（很差！）
14
        (50,   1.0): 55.00,  # DDPM 50步随机（几乎失败）
15
    }
16
    return results
17

18

19
def imagenet_results():
20
    """
21
    ImageNet 256x256 上的 FID vs 采样步数。
22
    """
23
    results = {
24
        (1000, 1.0, "ADM-Improved"): 10.4,
25
        (100,  0.0, "DDIM"):         11.3,
26
        (50,   0.0, "DDIM"):         12.8,
27
        (20,   0.0, "DDIM"):         17.2,
28
    }
29
    return results

核心数据：DDIM 50 步（ $\eta=0$ ）的 FID 与 DDPM 1000 步相当，而速度快 20 倍。

7.2 感知质量分析#

1
def perceptual_quality():
2
    """
3
    DDIM 的感知质量特点。
4
    """
5
    observations = {
6
        "优点": [
7
            "细节更锐利（确定性路径避免随机模糊）",
8
            "颜色更一致（无每步随机偏移累积）",
9
            "构图更稳定（适合编辑/控制任务）",
10
        ],
11
        "缺点": [
12
            "多样性降低（相同初始噪声产生相同结果）",
13
            "部分图像出现"超锐化"伪影（尤其 10 步以内）",
14
            "某些类别容易陷入局部最优",
15
        ]
16
    }
17
    return observations

8. 加速技术的演进#

8.1 DDIM 的后续加速方法#

1
DDIM (2021): 非马尔可夫, 20-50步, 确定性
2

3
    ├── LDM (2022): Latent Diffusion → 压缩到隐空间，速度再次提升
4
    │
5
    ├── Consistency Models (2023): Song et al.
6
    │      一致性蒸馏 → 1-4 步
7
    │
8
    ├── LCM (Latent Consistency Models) (2023): Luo et al.
9
    │      蒸馏 + 隐空间 → 2-4 步 ★ (SD + LCM)
10
    │
11
    ├── SDXL-Turbo / SDXL-Lightning (2024)
12
    │      步蒸馏 → 1-2 步
13
    │
14
    └── Rectified Flow (2023): Liu et al.
15
           最优传输 → 4-10 步
16
           (见 [Flow Matching 文章](/posts/flow-matching/))

8.2 为什么 DDIM 之后还需要新方法？#

维度	DDIM	新方法（LCM/RF）
采样步数	10-50 步	1-4 步
训练方式	同一训练目标	需要额外蒸馏
模型兼容性	复用 DDPM 模型	需要重新训练
生成质量	10步 FID ~8	4步 FID ~6

8.3 DDIM 的持续重要性#

尽管有更快的方法，DDIM 仍被广泛使用：

1
# Stable Diffusion 推理管线中的 DDIM
2
from diffusers import DDIMScheduler, StableDiffusionPipeline
3

4
pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
5
pipeline.scheduler = DDIMScheduler.from_config(pipeline.scheduler.config)
6

7
# 使用 DDIM 调度器
8
image = pipeline(
9
    prompt="a cat on a sofa",
10
    num_inference_steps=20,    # DDIM: 20步即可
11
    eta=0.0,                  # 完全确定性
12
).images[0]

9. 图像编辑与 DDIM#

9.1 DDIM 的编辑优势#

确定性是编辑任务的关键：

1
编辑任务: 把 [原图] 中的 [对象] 替换为 [新对象]
2

3
DDPM 方法:
4
    原图 → 加噪到某步 → 编辑条件 → 去噪
5
    问题: 加噪和去噪都是随机的
6
         同一张图多次处理会得到不同结果
7

8
DDIM 方法:
9
    原图 → 加噪到某步（确定性反向 ODE）→ 编辑条件 → 去噪
10
    优点: 加噪路径是确定性的
11
         同一张图→同一条轨迹→可逆
12
         编辑结果可复现

9.2 DDIM Inpainting#

1
def ddim_inpainting():
2
    """
3
    DDIM Inpainting 流程。
4

5
    1. 原图 x_0 → 加噪到 t=T-edit（如 T=500）
6
       (确定性反向 ODE, 可以精确恢复)
7
    2. 在隐空间中修改对应区域（inpaint mask）
8
    3. 从 x_t=500 用 DDIM 去噪到 x_0
9
    4. 合并编辑区域和原始区域
10
    """
11
    pass

9.3 引导编辑#

DDIM 与 CFG（无分类器引导）完美结合：

\hat{\epsilon} = (1 + w) \cdot \epsilon_\theta(x_t, t, c) - w \cdot \epsilon_\theta(x_t, t, \emptyset)

CFG 的引导强度 $w$ 与 DDIM 的 $\eta$ 可以独立调节：

$w$	效果	典型值
$w = 1$	无引导	默认
$w = 7$	中度引导	文本对齐好
$w = 15$	强度引导	高保真

10. 完整实现#

1
import torch
2
import torch.nn.functional as F
3

4

5
class DDIMScheduler:
6
    """
7
    DDIM 调度器实现。
8
    完全兼容 Diffusers 库的接口。
9
    """
10

11
    def __init__(self, num_train_timesteps=1000, beta_start=1e-4, beta_end=0.02,
12
                 beta_schedule="linear", clip_sample=False, set_alpha_to_one=False):
13
        self.num_train_timesteps = num_train_timesteps
14
        self.clip_sample = clip_sample
15
        self.final_alpha_cumprod = 1.0 if set_alpha_to_one else 0.0
16

17
        # 噪声调度
18
        if beta_schedule == "linear":
19
            betas = torch.linspace(beta_start, beta_end, num_train_timesteps)
20
        elif beta_schedule == "cosine":
21
            betas = self._cosine_beta_schedule(num_train_timesteps)
22
        else:
23
            raise ValueError(f"Unknown beta_schedule: {beta_schedule}")
24

25
        alphas = 1.0 - betas
26
        alphas_cumprod = torch.cumprod(alphas, dim=0)
27
        self.alphas_cumprod = alphas_cumprod
28

29
    def _cosine_beta_schedule(self, timesteps, s=0.008):
30
        """余弦噪声调度（更平滑）。"""
31
        steps = timesteps + 1
32
        x = torch.linspace(0, timesteps, steps)
33
        alphas_cumprod = torch.cos((x / timesteps + s) / (1 + s) * torch.pi * 0.5) ** 2
34
        alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
35
        betas = 1 - alphas_cumprod[1:] / alphas_cumprod[:-1]
36
        return torch.clamp(betas, 0.0001, 0.9999)
37

38
    def set_timesteps(self, num_inference_steps, offset=0):
39
        """
40
        设置推理时间步。
41

42
        参数:
43
            num_inference_steps: DDIM 采样步数（如 50）
44
            offset: 偏移量
45
        """
46
        self.num_inference_steps = num_inference_steps
47
        step_ratio = self.num_train_timesteps // num_inference_steps
48
        # 生成从 T-1 到 0 的时间步序列
49
        timesteps = (torch.arange(0, num_inference_steps) * step_ratio
50
                     + step_ratio // 2).flip(0)
51
        self.timesteps = timesteps.long()
52

53
    @torch.no_grad()
54
    def step(self, model_output, timestep, sample, eta=0.0):
55
        """
56
        DDIM 单步采样。
57

58
        参数:
59
            model_output:  模型预测的噪声 ε_θ(x_t, t)
60
            timestep:       当前时间步 t
61
            sample:         当前状态 x_t
62
            eta:            随机性参数 (0=确定, 1=随机)
63
        返回:
64
            prev_sample:    下一状态 x_{t-1}
65
        """
66
        t = timestep
67
        prev_t = timestep - self.num_train_timesteps // self.num_inference_steps
68

69
        # 当前和上一步的 alpha_cumprod
70
        alpha_prod_t     = self.alphas_cumprod[t]
71
        alpha_prod_t_prev = self.alphas_cumprod[prev_t] if prev_t >= 0 else self.final_alpha_cumprod
72

73
        # 预测 x_0
74
        pred_original_sample = (sample - (1 - alpha_prod_t).sqrt() * model_output) \
75
                               / alpha_prod_t.sqrt()
76
        if self.clip_sample:
77
            pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
78

79
        # 计算方差
80
        # DDIM 方差 (公式来自论文)
81
        var = (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)
82
        std = (var ** 0.5) * eta
83

84
        # 预测 x_{t-1} 的方向
85
        pred_sample_direction = (1 - alpha_prod_t_prev - std ** 2).sqrt() * model_output
86

87
        # 确定性部分
88
        prev_sample = alpha_prod_t_prev.sqrt() * pred_original_sample + pred_sample_direction
89

90
        # 随机噪声（仅当 eta > 0）
91
        if eta > 0:
92
            noise = torch.randn_like(sample)
93
            variance_noise = std * noise
94
            prev_sample = prev_sample + variance_noise
95

96
        return prev_sample
97

98
    def add_noise(self, original_samples, timesteps, noise=None):
99
        """前向加噪（用于重建目标）。"""
100
        if noise is None:
101
            noise = torch.randn_like(original_samples)
102

103
        sqrt_alpha_prod     = self.alphas_cumprod[timesteps] ** 0.5
104
        sqrt_one_minus_alpha = (1 - self.alphas_cumprod[timesteps]) ** 0.5
105

106
        noisy_samples = sqrt_alpha_prod.view(-1, 1, 1, 1) * original_samples \
107
                       + sqrt_one_minus_alpha.view(-1, 1, 1, 1) * noise
108
        return noisy_samples

11. 与 Flow Matching 的理论联系#

11.1 DDIM 的 ODE 就是 Flow Matching#

回想 Flow Matching 文章的核心：

Flow Matching 把从噪声到数据的路径建模为 ODE $dx/dt = v_\theta(x, t)$ ，训练目标是 MSE(预测速度, 真实速度)。

DDIM 的 $\sigma_t = 0$ 情形正是 Flow Matching 的一个特例：

1
DDIM (η=0) 的 ODE:
2

3
x_{t-1} = √ᾱ_{t-1} · x̂_0 + √(1-ᾱ_{t-1}) · ε_θ(x_t, t)
4

5
将 t-1 写成 dt，并整理成 dx/dt 的形式：
6

7
dx/dt =  (ᾱ_{t-1} - ᾱ_t) / dt · x̂_0  + ...
8
       = v_θ(x_t, t)
9

10
其中 v_θ(x_t, t) = ε_θ(x_t, t) - x̂_0
11

12
而 x̂_0 = (x_t - √(1-ᾱ_t) · ε_θ) / √ᾱ_t
13

14
→ v_θ(x_t, t) = ε_θ - (x_t - √(1-ᾱ_t) · ε_θ) / √ᾱ_t
15
             = (1 - 1/√ᾱ_t) · ε_θ - x_t/√ᾱ_t
16

17
这恰好是 RF 直线路径的向量场！

11.2 三种路径的理论统一#

1
所有扩散类生成模型 = Flow Matching 的特例
2

3
路径设计空间:
4
  ├── Rectified Flow:     直线 x_t = (1-t)x_0 + tε    → v = ε - x_0
5
  ├── DDPM (VP-SDE):      弧线 x_t = √ᾱ_t x_0 + √(1-ᾱ_t)ε
6
  └── DDIM (η=0):         与 DDPM 相同的路径，但 ODE 求解
7

8
采样策略:
9
  ├── DDPM:    SDE → 1000步随机马尔可夫
10
  ├── DDIM:    ODE → 10-50步确定性非马尔可夫
11
  └── RF:      ODE → 10-50步确定性直线

12. 总结#

12.1 核心要点#

维度	关键要点
核心洞察	逆向过程不需要是马尔可夫的，边际分布不变即可
数学框架	非马尔可夫链 + 边际分布约束
训练目标	与 DDPM 完全相同（不需要重新训练）
采样	$\sigma_t = 0$ 时为确定性 ODE 采样
质量	50 步 DDIM ≈ 1000 步 DDPM（FID 相当）
速度	20 倍加速（1000 步 → 50 步）
权衡	$\eta = 0$ 质量最高但多样性最低
编辑优势	确定性使加噪/去噪可逆，完美支持图像编辑
与 FM	DDIM $\eta=0$ 的 ODE 路径是 Flow Matching 的特例

12.2 一句话总结#

DDIM 通过放弃”逆向必须是马尔可夫链”的人为约束，把 DDPM 的随机走路径变成确定性的 ODE 轨迹——不改变任何训练目标，只改变采样方式，就实现了 20 倍加速，同时保持了生成质量。这是非马尔可夫隐式概率模型在生成建模中的首次成功应用，也是 Rectified Flow 和一致性模型的理论先驱。

12.3 推荐资源#

1
论文:
2
  - DDIM (Song et al., 2021): "Denoising Diffusion Implicit Models"
3
  - Consistency Models (Song et al., 2023): "Consistency Models"
4
  - Flow Matching (Lipman et al., 2022): "Flow Matching for Causal Inference"
5

6
代码:
7
  - ermongroup/ddim (官方实现)
8
  - huggingface/diffusers (DDIMScheduler)
9
  - CompVis/stable-diffusion (集成 DDIM)
10

11
教程:
12
  - Lilian Weng 博客: "Diffusion Models as a Kind of ODE"
13
  - Hugging Face 博客: "Speed up inference with DDIM"

Federico