Image Generation Systems 面试 Cheat Sheet

§0 TL;DR Cheat Sheet

1. LDM 关键：VAE encode 把 $H\times W\times 3$ 压成 $h\times w\times c$（SD 1.x: $8\times$ 下采样、$c=4$），扩散在 latent 上做，计算节省 $8^2=64\times$，最后再 VAE decode 出像素（Rombach et al. 2022 CVPR）。
2. SD 1.x → SDXL → SD3 → FLUX 主线：1.x 用 CLIP-L 文本编码 + U-Net；SDXL 双编码器（OpenCLIP-G + CLIP-L）+ 2.6B U-Net + size/crop conditioning + Refiner（Podell et al. 2024 ICLR）；SD3 换 MM-DiT + Rectified Flow（Esser et al. 2024 ICML）；FLUX.1 12B MM-DiT 加 parallel attention（Black Forest Labs 2024）。
3. CFG（必考）：训练时按概率 $p_\text{drop}\approx 0.1$ 把条件 $c$ 替换成 $\emptyset$；推理时输出 $\hat\epsilon_\text{cfg} = \hat\epsilon_\emptyset + s\,(\hat\epsilon_c - \hat\epsilon_\emptyset)$，$s \in [1.5, 12]$（Ho & Salimans 2022）。
4. ControlNet 零卷积（Zhang et al. 2023 ICCV）：把 U-Net encoder 整段 trainable copy，每个连接到主干的卷积 $W=0,b=0$ 初始化——前向恒等、梯度非零（$\partial L/\partial W = \delta \cdot x \neq 0$），训练时从干净恒等映射出发逐步注入条件信号，从而保护预训练能力。
5. IP-Adapter（Ye et al. 2023）：Decoupled Cross-Attention——为图像条件新增一组 $W_K', W_V'$，与原文本 cross-attn 并行，输出相加：$\text{out} = \text{Attn}(Q, K_\text{txt}, V_\text{txt}) + \lambda\,\text{Attn}(Q, K_\text{img}, V_\text{img})$。仅训新增 K/V + projector，~22M 参数。
6. LoRA（Hu et al. 2022 ICLR）：$\Delta W = B A,\ B \in \mathbb{R}^{d\times r},\ A \in \mathbb{R}^{r\times k},\ r \ll \min(d,k)$；只训 $A, B$，原 $W$ 冻结。SD 上典型 $r \in \{4,8,16,32\}$，比全量小 50–200×；推理可 merge $W' = W + \alpha B A$。
7. DreamBooth（Ruiz et al. 2023 CVPR）：rare-token（如 sks dog）+ prior preservation loss $L = \|\epsilon - \hat\epsilon(x_t, t, \text{"a sks dog"})\|^2 + \lambda \|\epsilon' - \hat\epsilon(x_t', t, \text{"a dog"})\|^2$，第二项防 language drift / 过拟合。
8. DiT vs MM-DiT：DiT 用 AdaLN-Zero（条件 $\to$ MLP $\to$ scale/shift/gate，最后一层 $W_\text{gate}=0$ 实现恒等启动，Peebles & Xie 2023 ICCV）；MM-DiT 把 text token 和 image token 拼成一个序列做联合 self-attention（每个模态独立 QKV 投影，但 attention 是全局的），信息流双向（Esser et al. 2024）。

§1 直觉与全景

为什么需要 LDM？Pixel-space 扩散太贵：SD 时代 1024² 图像 = 3M 像素，U-Net 每个 timestep 都要全分辨率前向，单卡只能训 64×64 这种 toy 尺寸。LDM 的思路是先用预训练 VQ-VAE / KL-VAE 把图压到 latent（SD 1.x: $512\times 512\times 3 \to 64\times 64\times 4$，$64\times$ token 数减少），扩散只在 latent 上做，最后再 VAE decode 回像素，把"语义 / 结构 / 纹理"三件事解耦：

    pixels x        latent z (perceptually similar)        latent z_T (noise)
   [H,W,3]    →     [h,w,c]     →     diffuse     →     [h,w,c]
                       ▲                                    │
                       │  VAE decoder                       │  reverse SDE / ODE
                       │                                    ▼
                    pixels x̂          ←      latent z_0      ←    [h,w,c]

整个 production 栈分成 5 个正交可替换的模块：

• Semantic conditioning（文本）：text encoder embedding → cross-attention K/V，主要驱动"画什么"
• Structural conditioning（边缘 / 深度 / 姿态）：ControlNet / T2I-Adapter，驱动"按什么结构画"
• Identity / style conditioning（人脸 / 风格）：IP-Adapter / InstantID / PuLID / DreamBooth / LoRA，驱动"画成谁的样子 / 谁的画风"

§2 LDM 核心：VAE Compression + Latent Diffusion

2.1　LDM 损失（Rombach et al. 2022 CVPR）

预训练 KL-VAE 给一个 encoder $\mathcal{E}: \mathbb{R}^{H\times W\times 3} \to \mathbb{R}^{h\times w\times c}$ 和 decoder $\mathcal{D}$，满足 $\mathcal{D}(\mathcal{E}(x)) \approx x$（感知重建），$h = H/f$，下采样倍率 $f \in \{4, 8, 16\}$，SD 一族用 $f=8$。

在 latent 空间训 diffusion，目标与像素 DDPM 一致：

$$\boxed{\;\mathcal{L}_\text{LDM} = \mathbb{E}_{z_0, \epsilon, t, c}\left[\,\big\|\epsilon - \epsilon_\theta\!\left(z_t,\, t,\, \tau_\theta(c)\right)\big\|^2\,\right]\;}$$

其中 $z_0 = \mathcal{E}(x)$，$z_t = \sqrt{\bar\alpha_t}\, z_0 + \sqrt{1-\bar\alpha_t}\,\epsilon$，$\tau_\theta(c)$ 是 text encoder 输出。

2.2　为什么 $f=8$ 是 sweet spot

Rombach 2022 Table 8 ablation：

关键洞察：VAE 重建质量是上限——latent diffusion 无论多强都画不出 VAE 解不出来的图。所以 $f$ 不是越大越好，要在"压缩率"和"重建上限"之间找平衡。

2.3　VAE 的"小 KL"细节

SD VAE 是 KL-VAE，不是 VQ-VAE——latent 是连续高斯，KL 项极小（$\sim 10^{-6}$ 量级），近似一个 AE 加微弱正则。Rombach 2022 Appendix 解释：太强 KL 会让 latent 退化成纯高斯，丢掉结构信息。

§3 SD 1.x → SDXL → SD3 → FLUX 主线

3.1　SD 1.x / 2.x（Stability AI 2022）

• U-Net 860M 参数：cross-attention 装在 latent 分辨率 64 / 32 / 16 三档下采样 + 对应上采样块 + middle block（SD v1 config attention_resolutions = [4, 2, 1]，DS=1/2/4 即 64/32/16；最深的 DS=8 也即 8×8 下采样和上采样块只有 ResBlock 不带 transformer，但 middle block 8×8 有 transformer），文本通过 CLIP-L (openai/clip-vit-large-patch14，768-d) 提供 77 token embedding
• Objective：$\epsilon$-prediction（DDPM Ho et al. 2020 NeurIPS）
• 训练分辨率：512²，1B+ LAION 图像
• 2.x 换 OpenCLIP-H/14（更强但 license cleaner），并在 768² 上 fine-tune

3.2　SDXL（Podell et al. 2024 ICLR）

三个关键升级：

3.3　SD3（Esser et al. 2024 ICML）

核心改动两个：

1）训练目标换成 Rectified Flow（RF）

$$x_t = (1-t)\, x_0 + t\, x_1,\quad u_t = x_1 - x_0$$

其中 $x_0 \sim \mathcal{N}(0, I)$ 噪声端，$x_1$ 数据端。模型学 $v_\theta(x_t, t, c) \approx x_1 - x_0$。Loss 用 logit-normal $t$ sampling（中间 $t$ 概率更高）+ RF 加权。注意 timestep convention 与 DDPM 相反：SD3 论文用 $t=0$ 噪声、$t=1$ 数据，但有些代码库（diffusers）会改回 SD 旧 convention，面试要主动 disambiguate。

2）Denoiser 换成 MM-DiT（Multimodal Diffusion Transformer）

文本和图像 token 拼成一个序列做联合 self-attention，每个模态有独立的 QKV 投影 + AdaLN-Zero MLP 参数，但 attention 矩阵是全局的（双向）。这意味着：

[txt tokens, img tokens]  ──╮
       │                     ├─ joint self-attention  ──→  双向信息流
       │                     │                            (txt sees img, img sees txt)
       │                     │
   独立 QKV (txt, img)       │
   独立 LN/MLP gate (txt, img)

对比 SD 1.x/SDXL 的 cross-attention：image queries 单向读 text K/V，text 不会被更新。MM-DiT 让 text 也被 image 更新（"图像 → 文本"流向打开），实验上文本对齐显著提升。

3.4　FLUX.1（Black Forest Labs 2024）

12B 参数 MM-DiT v2，主要差异：

3.5　并列开源线

• PixArt-α / Σ（Chen et al. 2024）：DiT-XL/2 + T5 文本，强调"训练成本只有 SDXL 的 12%"，small but capable。
• Hunyuan-DiT（Tencent 2024 arXiv 2405.08748）：中文友好双语 DiT，1.5B 参数，CLIP + mT5 双编码。
• DiT（Peebles & Xie 2023 ICCV）：把扩散去噪从 U-Net 换成 ViT-style transformer，类 token + AdaLN-Zero conditioning，scale 律比 U-Net 平滑——这是 SD3/FLUX 的祖先。
• U-ViT（Bao et al. 2023）：U-Net 风骨架但纯 transformer block + long skip connection，是早期 transformer-based diffusion 探索。
• Imagen（Saharia et al. 2022 NeurIPS）：Google pixel-space（不是 latent）级联扩散——$64\times 64$ base + $256\times 256$ super-res + $1024\times 1024$ super-res；文本用大 T5-XXL，结果显示文本编码器规模 > U-Net 规模对文本对齐影响更大。

§4 DiT 架构与 AdaLN-Zero（必考）

4.1　DiT block（Peebles & Xie 2023 ICCV）

DiT 把 ViT block 改成扩散友好：每个 block 由 condition $c = \text{embed}(t) + \text{embed}(\text{class})$ 控制。

Input tokens x_l (shape [B, N, D]),  condition c (shape [B, D])
                │
        ┌───────┴────────┐
        │                │
   MLP(c) → (α₁, β₁, γ₁) │  scale / shift / gate parameters
        │                │
        ▼                │
   LayerNorm(x_l)        │
        │                │
   scale·γ₁ + shift·β₁   │  ← AdaLN: normalize then conditioned affine
        │                │
   Multi-Head Attention  │
        │                │
   × α₁ (gate, 0-init)   │  ← gate × residual; α₁ starts at 0
        │                │
   +  x_l                │  residual
        │                │
        ▼                │
   ┌────────────┐        │
   │ second half│        │
   │ (LN + MLP) │       同样 (α₂, β₂, γ₂) ← MLP(c)
   └────────────┘
        │
        ▼
   Output x_{l+1}

4.2　AdaLN-Zero 推导（"为何 gate 初始化为 0"）

DiT 实际形式（Peebles & Xie 2023, Eqn. (5)–(6)）：condition $c$ 经一个 MLP 一次性产出 $(\beta_1, \gamma_1, \alpha_1, \beta_2, \gamma_2, \alpha_2)$，归一化层用 (1 + gamma) 而不是 gamma 直乘：

$$\text{AdaLN}(x, c) = \big(1 + \gamma(c)\big) \odot \text{LN}(x) + \beta(c)$$

AdaLN-Zero 让产出 $(\beta, \gamma, \alpha)$ 的 MLP 最后一层 weight + bias 初始化为 0：

$$\text{Block}(x, c) = x + \alpha(c) \cdot f\!\left(\big(1 + \gamma(c)\big) \odot \text{LN}(x) + \beta(c)\right)$$

训练 step 0：MLP 全 0 → $\gamma = 0, \beta = 0, \alpha = 0$ → AdaLN 退化为 $\text{LN}(x)$、gate $\alpha = 0$ → 整个 block 输出 $= x$（恒等）。注意是 1 + gamma，所以 gamma=0 时归一化路径不会被乘 0 抹掉，只是恒等于 LN(x)。

$$\frac{\partial L}{\partial \alpha} = \frac{\partial L}{\partial \text{out}} \cdot f\!\left((1+\gamma)\odot\text{LN}(x) + \beta\right)$$

step 0 时 $\gamma = \beta = 0$，$f((1+0)\cdot\text{LN}(x) + 0) = f(\text{LN}(x))$ 非零（LN(x) 一般非零，attention/MLP 也不会把任意输入映成 0）；因此 $\partial L/\partial \alpha \neq 0$，再链式回 $W^{\text{last}}_\text{MLP}$ 即得到非零梯度——$\alpha$ 从 0 开始长大，block 逐步从恒等映射 fork 出非平凡变换，训练稳定不发散。

注意 $\gamma, \beta$ 自身在 step 0 梯度为 0（因为它们的下游被 $\alpha = 0$ 截断：$\partial L/\partial \gamma = (\partial L/\partial \alpha\cdot$ ...) 这条路径要经过 $\alpha$，而 $\alpha = 0$ 时 $\partial \text{Block}/\partial \gamma$ 包含 $\alpha\cdot f'(\cdot)$ 因子等于 0）。但 $\alpha$ 一旦长出来，下一步 $\gamma, \beta$ 立刻拿到非零梯度——所以"first $\alpha$ 长大，再 $\gamma, \beta$ 跟进"是 AdaLN-Zero 的两阶段动力学。

对比朴素初始化（标准随机 $\alpha \neq 0$）：早期 block 输出已经有大方差，叠 24-32 层后激活炸掉、训练发散。AdaLN-Zero 是 DiT scale 上去的关键设计。

4.3　时间嵌入

$$\text{TimeEmbed}(t) = \text{MLP}\!\left(\text{SinusoidalEmb}(t)\right),\quad \text{SinusoidalEmb}(t)_{2i} = \sin\!\left(t / 10000^{2i/D}\right)$$

奇偶位置分别用 sin / cos，类似 Transformer 位置编码。$t$ 在 SD 中是离散 timestep $\in \{0, 1, ..., T-1\}$，在 RF / FM 中是连续 $\in [0, 1]$。

§5 SD 推理循环 + CFG（核心代码）

5.1　CFG 公式

训练时以概率 $p_\text{drop} \approx 0.1$ 把 $c$ 替换成 null（空 text embedding 或 zero embedding），让同一个网络既学条件也学非条件。推理：

$$\boxed{\;\hat\epsilon_\text{cfg}(z_t, t, c) = \hat\epsilon_\theta(z_t, t, \emptyset) + s\cdot\left[\hat\epsilon_\theta(z_t, t, c) - \hat\epsilon_\theta(z_t, t, \emptyset)\right]\;}$$

$s$ 是 guidance scale；SD 1.x 一般 $s \in [5, 12]$；SDXL $s \approx 5$-$7$；FLUX dev $\approx 3.5$（更小，因为 RF 模型 CFG 敏感）。

v-prediction / RF 下形式相同，把 $\hat\epsilon$ 换成 $\hat v$ 即可。

5.2　SD inference loop（核心 40 行）

import torch

@torch.no_grad()
def sd_sample(unet, vae, text_encoder, tokenizer, scheduler,
              prompt, neg_prompt="", num_steps=30, cfg_scale=7.0,
              height=512, width=512, device="cuda", dtype=torch.float16):
    # 1) text 编码：把 prompt 和 negative prompt 都 forward 一次
    ids_pos = tokenizer(prompt, padding="max_length", max_length=77,
                        truncation=True, return_tensors="pt").input_ids.to(device)
    ids_neg = tokenizer(neg_prompt, padding="max_length", max_length=77,
                        truncation=True, return_tensors="pt").input_ids.to(device)
    emb_pos = text_encoder(ids_pos)[0]                  # [1, 77, D_text]
    emb_neg = text_encoder(ids_neg)[0]
    emb = torch.cat([emb_neg, emb_pos], dim=0)          # [2, 77, D_text]  (uncond, cond)

    # 2) latent 初始化：纯噪声 [1, 4, h/8, w/8]
    lat_shape = (1, 4, height // 8, width // 8)
    z = torch.randn(lat_shape, device=device, dtype=dtype) * scheduler.init_noise_sigma

    # 3) scheduler 设定 timestep
    scheduler.set_timesteps(num_steps, device=device)

    # 4) 主循环
    for t in scheduler.timesteps:
        # 拼 batch：两份 latent 分别配 (uncond, cond) 一次性 forward,
        # 比顺序两次 forward 省一次 kernel launch + 利用 cuDNN batch 友好
        z_in = torch.cat([z, z], dim=0)                  # [2, 4, h, w]
        z_in = scheduler.scale_model_input(z_in, t)      # 某些 sampler 要 sigma scaling

        eps = unet(z_in, t, encoder_hidden_states=emb).sample   # [2, 4, h, w]
        eps_neg, eps_pos = eps.chunk(2, dim=0)

        # 5) CFG combine
        eps_cfg = eps_neg + cfg_scale * (eps_pos - eps_neg)

        # 6) scheduler step：根据 eps 推回 z_{t-1}
        z = scheduler.step(eps_cfg, t, z).prev_sample

    # 7) VAE decode + denormalize 回像素 [0, 1]
    z = z / 0.18215                                       # SD 1.x scaling factor
    x = vae.decode(z).sample                              # [1, 3, H, W] in [-1, 1]
    x = ((x.clamp(-1, 1) + 1) / 2)                        # → [0, 1]
    return x

§6 ControlNet 与 IP-Adapter：条件扩展

6.1　ControlNet 架构（Zhang et al. 2023 ICCV）

问题：要把 edge / depth / pose 等结构条件灌进预训练 SD，从头训成本太高，全量 fine-tune 又会破坏 text-to-image 能力。

方案：

    Input latent z_t  ──┬───────────────────►  原 SD U-Net Encoder (frozen)
                        │                              │
                        │    Condition image c_img     │
                        │           │                  │
                        │           ▼                  │
                        │    Hint Encoder (conv stack) │
                        │           │                  │
                        │           ▼                  │
                        └────► Trainable Copy ←────────┤  encoder 部分 deep copy,
                                    │                  │  开始训练
                                    │                  │
                              Zero Conv (W=0, b=0)     │
                                    │                  │
                                    ▼                  │
                              add to skip connection ──┘  ─────►  Decoder (frozen)

• Trainable copy：完整复制 SD U-Net encoder + middle block，作为副本，初始权重 = 原 SD encoder weights
• Zero-conv：每个连接到主干 skip 路径的 $1\times 1$ 卷积，weight 与 bias 全初始化为 0
• Hint encoder：4 层 conv 把 condition image (1 或 3 channel) 投到 latent shape
• 训练时：原 SD encoder/decoder 冻结，只训 trainable copy + zero-conv + hint encoder

6.2　零卷积梯度推导（L3 必问）

零卷积 layer：$y = W \star x + b$，$W = 0, b = 0$，则 $y = 0$；加到主干 skip 上等于"什么都不加"，前向恒等。

反向传播时分两条路径：

(a) zero-conv 自身权重：

$$\frac{\partial L}{\partial W_{ij}} = \frac{\partial L}{\partial y_i} \cdot x_j$$

$x_j$（zero-conv 的输入，来自 trainable copy 输出）非零、$\partial L / \partial y_i$ 非零，梯度非零——所以 $W$ 会从 0 开始更新。

(b) trainable copy 的参数 $\theta_c$：要经过 $x \to y$ 这条路径，链式法则的关键因子是 $\partial y / \partial x = W$。step 0 时 $W = 0$，所以第一步 trainable copy 自身的梯度也是 0。

收敛过程因此是两阶段：

1. Step 0：$W = 0$ → ControlNet 完全不影响主干 → 输出 = 原 SD 输出 → 不可能比 baseline 差
2. Step 1：zero-conv 自己 break 零（路径 (a)）→ $W \neq 0$ → 路径 (b) 解锁
3. Step 2+：trainable copy 开始接收梯度并学习
4. 训练结束：$W$ 与 trainable copy 共同达到合适幅度，结构条件被纳入

6.3　Hint encoding + zero-conv（核心 50 行）

import torch
import torch.nn as nn

def zero_module(m: nn.Module) -> nn.Module:
    """ 把模块所有参数清零（用于 ControlNet zero-conv 与 IP-Adapter projector） """
    for p in m.parameters():
        nn.init.zeros_(p)
    return m

class HintEncoder(nn.Module):
    """ 把 condition image (e.g. canny edge, depth) 编码到 latent 分辨率 """
    def __init__(self, in_ch=3, out_ch=320):  # 320 = SD U-Net first hidden dim
        super().__init__()
        # 渐进下采样到 1/8（与 VAE 同倍率）；最后一层是 zero-conv
        self.net = nn.Sequential(
            nn.Conv2d(in_ch, 16, 3, padding=1),       nn.SiLU(),
            nn.Conv2d(16, 16, 3, padding=1),          nn.SiLU(),
            nn.Conv2d(16, 32, 3, padding=1, stride=2), nn.SiLU(),   # /2
            nn.Conv2d(32, 32, 3, padding=1),          nn.SiLU(),
            nn.Conv2d(32, 96, 3, padding=1, stride=2), nn.SiLU(),   # /4
            nn.Conv2d(96, 96, 3, padding=1),          nn.SiLU(),
            nn.Conv2d(96, 256, 3, padding=1, stride=2), nn.SiLU(),  # /8
            zero_module(nn.Conv2d(256, out_ch, 3, padding=1)),
        )

    def forward(self, hint):     # hint: [B, 3, H, W]
        return self.net(hint)    # [B, out_ch, H/8, W/8]

class ControlNetBlock(nn.Module):
    """ Trainable copy 输出 → zero-conv → 加到主干 skip 上 """
    def __init__(self, ch):
        super().__init__()
        # 这是连接到主干 skip 的"输出 zero-conv"
        self.zero_conv = zero_module(nn.Conv2d(ch, ch, 1))   # 1×1, init 0

    def forward(self, x_copy, x_main_skip):
        # x_copy: trainable copy 当前层输出
        # x_main_skip: 原 SD U-Net 对应层的 skip activation
        return x_main_skip + self.zero_conv(x_copy)

6.4　T2I-Adapter（Mou et al. 2024）对比

ControlNet 的 trainable copy 太重（参数量 ≈ 半个 SD），T2I-Adapter 的思路是纯 adapter：

6.5　IP-Adapter（Ye et al. 2023）

IP-Adapter 用 reference image 做 conditioning，跨身份 / 风格保持。核心是 Decoupled Cross-Attention：

    image  ──► CLIP image encoder ──► [N_img, D_clip]
                                            │
                                            ▼
                                    Projector (Linear, ~22M params)
                                            │
                                            ▼
                                    image embeddings [N_img, D_text]
                                            │
                                            │  与 text embedding 并行使用
                                            │
    text   ──► text encoder ──► [N_txt, D_text]
                │                                                          ▲
                │                                                          │
                ▼                                                          │
   ┌───────────────────────────────────────────────────────────────┐
   │   每个 U-Net cross-attention 层:                                │
   │                                                                │
   │   Q = z W_Q                                                    │
   │                                                                │
   │   原文本路径:    K_txt = c_txt W_K^txt,   V_txt = c_txt W_V^txt   │
   │   新图像路径:    K_img = c_img W_K^img,   V_img = c_img W_V^img   │
   │                                                                │
   │   out = Attn(Q, K_txt, V_txt) + λ · Attn(Q, K_img, V_img)      │
   │                                                                │
   │   只训练 W_K^img, W_V^img, projector                            │
   └───────────────────────────────────────────────────────────────┘

参数量约 22M（projector ~10M + 每层新增 K/V 投影合计 ~12M），是 SD 全量的 ~1%。

6.6　Decoupled Cross-Attention（核心 45 行）

import torch
import torch.nn as nn
import torch.nn.functional as F

class DecoupledCrossAttention(nn.Module):
    """ 文本 + 图像并行 cross-attention，输出相加 """
    def __init__(self, d_model, num_heads, d_text, d_image, lam=1.0):
        super().__init__()
        self.h = num_heads
        self.d = d_model
        self.d_head = d_model // num_heads
        self.lam = lam

        # 文本路径：与原 SD 一致，加载预训练权重后**冻结**
        self.W_Q     = nn.Linear(d_model, d_model, bias=False)   # query 来自 latent
        self.W_K_txt = nn.Linear(d_text,  d_model, bias=False)
        self.W_V_txt = nn.Linear(d_text,  d_model, bias=False)
        self.W_O     = nn.Linear(d_model, d_model, bias=False)
        for p in (*self.W_Q.parameters(),
                  *self.W_K_txt.parameters(),
                  *self.W_V_txt.parameters(),
                  *self.W_O.parameters()):
            p.requires_grad_(False)        # ← IP-Adapter 只训新增 K/V

        # 图像路径：新增 K/V，仅这两个 + projector 是 trainable 的
        self.W_K_img = nn.Linear(d_image, d_model, bias=False)
        self.W_V_img = nn.Linear(d_image, d_model, bias=False)

    def _split_heads(self, x):     # [B, L, D] → [B, H, L, d_head]
        B, L, _ = x.shape
        return x.view(B, L, self.h, self.d_head).transpose(1, 2)

    def _attn(self, Q, K, V):       # 标准 scaled dot-product
        return F.scaled_dot_product_attention(Q, K, V)   # [B, H, L_q, d_head]

    def forward(self, z, c_text, c_image):
        # z: [B, L_z, D]   c_text: [B, L_t, d_text]   c_image: [B, L_i, d_image]
        Q     = self._split_heads(self.W_Q(z))
        K_txt = self._split_heads(self.W_K_txt(c_text))
        V_txt = self._split_heads(self.W_V_txt(c_text))
        K_img = self._split_heads(self.W_K_img(c_image))
        V_img = self._split_heads(self.W_V_img(c_image))

        out_txt = self._attn(Q, K_txt, V_txt)
        out_img = self._attn(Q, K_img, V_img)
        out = out_txt + self.lam * out_img            # ← 解耦相加

        # [B, H, L_q, d_head] → [B, L_q, D]
        B, _, L_q, _ = out.shape
        out = out.transpose(1, 2).contiguous().view(B, L_q, self.d)
        return self.W_O(out)

6.7　InstantID / PuLID / PhotoMaker

目标都是单参考图 → 保 ID 文生图，主流路线：

共同思路：ID-relevant 信号 用专门 adapter，ID-irrelevant 信号（pose / 表情 / 光照）让 prompt 控制，避免身份直接 paste。

§7 个性化微调：DreamBooth / Textual Inversion / LoRA / Custom Diffusion

7.1　Textual Inversion（Gal et al. 2023 ICLR）

只训一个 token embedding，不动模型：

1. 引入新 token S*（如 <my-cat>），其 embedding $e_{S^*} \in \mathbb{R}^{d_\text{text}}$ 是唯一可训参数
2. 训练目标：

$$e_{S^*}^* = \arg\min_{e} \mathbb{E}_{z, \epsilon, t}\left[\|\epsilon - \epsilon_\theta(z_t, t, c(\text{"a photo of } S^*\text{"}; e))\|^2\right]$$

1. ~3-5K steps 收敛，embedding 总参数 768-1024 维，文件 < 10KB

优点：极轻，无 catastrophic forgetting；缺点：表达力有限（一个 embedding 装不下复杂概念）。

7.2　DreamBooth（Ruiz et al. 2023 CVPR）

核心配方两条：

1）Rare token + class word：用罕见 token（如 sks、zwx）+ 类别词（dog、person），prompt 形如 "a photo of sks dog"。罕见 token 在预训练时 embedding 是"语义死角"，不会被原有概念干扰。

2）Prior Preservation Loss：

$$\boxed{\;\mathcal{L} = \mathbb{E}\!\left[\|\epsilon - \hat\epsilon_\theta(z_t, t, c_\text{sks})\|^2\right] + \lambda\,\mathbb{E}\!\left[\|\epsilon' - \hat\epsilon_\theta(z_t', t, c_\text{class})\|^2\right]\;}$$

第二项是"class-prior preservation"——用模型自身生成的 class images（如 200 张 "a photo of dog"）做 anchor，告诉模型"sks dog 是特殊的，但普通 dog 还得画对"。$\lambda$ 一般 1.0。

7.3　LoRA（Hu et al. 2022 ICLR）

核心数学：对 weight $W \in \mathbb{R}^{d \times k}$ 不直接 fine-tune，而是学低秩增量：

$$\boxed{\;W' = W + \Delta W,\quad \Delta W = B A,\quad B \in \mathbb{R}^{d \times r},\ A \in \mathbb{R}^{r \times k},\ r \ll \min(d, k)\;}$$

通常 $A$ 用 $\mathcal{N}(0, \sigma^2)$ 初始化，$B$ 初始化为 0 → $\Delta W = 0$（保留预训练）→ 训练时只更新 $A, B$。推理时 $W' = W + \alpha B A$（$\alpha$ scaling factor）。

参数节省：原 $W$ 有 $d \cdot k$ 参数；LoRA 有 $r(d + k)$ 参数。SD U-Net cross-attn 一个 $W_K$ 是 $D \times d_\text{text}$（如 $1280 \times 2048 = 2.6M$）；$r = 8$ 时 LoRA 是 $8(1280 + 2048) = 26K$，100× 少。

7.4　LoRA inject 到 nn.Linear（核心 40 行）

import torch
import torch.nn as nn

class LoRALinear(nn.Module):
    """ Wrap nn.Linear with low-rank delta. Original weight is frozen. """
    def __init__(self, base: nn.Linear, rank=8, alpha=8.0, dropout=0.0):
        super().__init__()
        self.base = base                          # 冻结原 Linear
        for p in self.base.parameters():
            p.requires_grad_(False)

        d_in, d_out = base.in_features, base.out_features
        self.rank, self.alpha = rank, alpha
        self.scale = alpha / rank                 # 推理时统一 scaling

        # ΔW = B A,  A: [r, d_in],  B: [d_out, r]
        self.A = nn.Parameter(torch.empty(rank, d_in))
        self.B = nn.Parameter(torch.zeros(d_out, rank))   # B = 0  → ΔW = 0
        nn.init.kaiming_uniform_(self.A, a=5**0.5)        # 类似 nn.Linear 默认

        self.drop = nn.Dropout(dropout) if dropout > 0 else nn.Identity()

    def forward(self, x):
        # 原路径：用 frozen base
        out = self.base(x)
        # LoRA 增量：x @ A^T @ B^T  (顺序很重要——避免 [d_out, d_in] 大矩阵)
        out = out + self.drop(x) @ self.A.t() @ self.B.t() * self.scale
        return out

def inject_lora(model, target_module_names=("to_q", "to_k", "to_v"),
                rank=8, alpha=8.0):
    """ 把 SD U-Net 内 cross-attn / self-attn 的 to_q/to_k/to_v Linear 替换为 LoRALinear；
        to_out 在 Diffusers 里是 nn.Sequential([Linear, Dropout])，要用 to_out.0 单独处理 """
    replaced = 0
    for name, mod in model.named_modules():
        for child_name, child in list(mod.named_children()):
            # 1) to_q / to_k / to_v：单层 Linear，直接替换
            if (child_name in target_module_names
                    and isinstance(child, nn.Linear)):
                setattr(mod, child_name, LoRALinear(child, rank=rank, alpha=alpha))
                replaced += 1
            # 2) to_out：Diffusers Attention 的 to_out 是 nn.Sequential(Linear, Dropout)
            #    SDXL LoRA 习惯只 wrap 第 0 个（Linear）
            if child_name == "to_out" and isinstance(child, nn.Sequential):
                lin = child[0]
                if isinstance(lin, nn.Linear):
                    child[0] = LoRALinear(lin, rank=rank, alpha=alpha)
                    replaced += 1
    return replaced

7.5　DreamBooth + LoRA = LoRA-DreamBooth

实战中很少用纯 DreamBooth（全量训太重），主流是 LoRA-DreamBooth：只对 attention 的 Q/K/V/O 注入 LoRA，配 prior preservation。文件 ~50-200MB，单卡 30 分钟，复现性远好于纯 DreamBooth。

7.6　DreamBooth 训练 step（核心 35 行）

import torch
import torch.nn.functional as F

def dreambooth_train_step(unet, vae, text_encoder, scheduler,
                          x_instance, c_instance,    # 训练图像 + "a sks dog" embedding
                          x_class, c_class,          # 自生 class 图像 + "a dog" embedding
                          lam_prior=1.0, dtype=torch.float16, device="cuda"):
    """ 一个 DreamBooth + prior preservation 训练 step """
    bs = x_instance.shape[0]

    # 1) 把 instance & class 拼成 2× batch 一次 forward
    x = torch.cat([x_instance, x_class], dim=0)
    c = torch.cat([c_instance, c_class], dim=0)        # text embeddings

    # 2) encode 到 latent + scale
    with torch.no_grad():
        z = vae.encode(x).latent_dist.sample() * 0.18215    # [2bs, 4, h, w]

    # 3) 随机采 timestep + 噪声
    t = torch.randint(0, scheduler.num_train_timesteps, (z.shape[0],), device=device)
    eps = torch.randn_like(z)
    z_t = scheduler.add_noise(z, eps, t)

    # 4) 预测 ε
    eps_pred = unet(z_t, t, encoder_hidden_states=c).sample

    # 5) 分两组算 loss：instance / class 各一份
    eps_pred_inst, eps_pred_cls = eps_pred.chunk(2, dim=0)
    eps_inst, eps_cls = eps.chunk(2, dim=0)

    loss_inst = F.mse_loss(eps_pred_inst.float(), eps_inst.float(),
                           reduction="mean")
    loss_cls  = F.mse_loss(eps_pred_cls.float(),  eps_cls.float(),
                           reduction="mean")
    loss = loss_inst + lam_prior * loss_cls

    return loss

7.7　HyperDreamBooth / Custom Diffusion 对比

• HyperDreamBooth (Ruiz et al. 2024)：用 hypernetwork 直接预测每张参考图的 LoRA 权重，inference-time 个性化（~5 秒，对比 DreamBooth ~10 分钟训练）。
• Custom Diffusion (Kumari et al. 2023)：只更新 cross-attention 的 $W_K, W_V$（不动 $W_Q$），加 regularization image 防过拟合。本质是更窄的 LoRA-DreamBooth。

§8 图像编辑：SDEdit / InstructPix2Pix / Prompt-to-Prompt

8.1　SDEdit（Meng et al. 2022 ICLR）

思路：图像编辑 = "把输入图加部分噪声 → 用 prompt 引导 reverse 回去"。

   输入图 x (e.g. 草图)
         │
         │   noise_strength = 0.6 (例)
         ▼
   z_0 = VAE_enc(x)
         │
   z_τ = √(ᾱ_τ) z_0 + √(1 - ᾱ_τ) ε,   τ = noise_strength × T
         │
         ▼
   reverse SDE / ODE from t=τ to t=0    (受 prompt c 引导)
         │
         ▼
   z_0' →  VAE_dec → 编辑后图 x'

关键参数 strength $\in [0, 1]$：

• $\text{strength} \to 0$：noise 极少，输出 $\approx$ 输入（不编辑）
• $\text{strength} \to 1$：完全噪声化，输出 = 纯文生图（输入信号丢失）
• 常用 $0.3$–$0.8$ 范围找 balance

8.2　SDEdit 核心代码

import torch

@torch.no_grad()
def sdedit_sample(unet, vae, text_encoder, tokenizer, scheduler,
                  init_image, prompt, neg_prompt="",
                  strength=0.7, num_steps=30, cfg_scale=7.0,
                  device="cuda", dtype=torch.float16):
    assert 0.0 < strength <= 1.0, "strength=0 == 不编辑（直接返回输入）；strength>1 不合法"

    # 1) text 编码（与 §5 一致）
    ids_pos = tokenizer(prompt, padding="max_length", max_length=77,
                        truncation=True, return_tensors="pt").input_ids.to(device)
    ids_neg = tokenizer(neg_prompt, padding="max_length", max_length=77,
                        truncation=True, return_tensors="pt").input_ids.to(device)
    emb = torch.cat([text_encoder(ids_neg)[0],
                     text_encoder(ids_pos)[0]], dim=0)

    # 2) 把输入图 encode 到 latent
    z0 = vae.encode(init_image).latent_dist.sample() * 0.18215   # [1, 4, h, w]

    # 3) 设 timestep 子集，只走后 strength 段
    scheduler.set_timesteps(num_steps, device=device)
    import math
    # 用 ceil + max(1, .) 保证 strength>0 时至少有 1 步要跑
    n_edit = max(1, math.ceil(num_steps * strength))
    t_start = num_steps - n_edit               # 0 ≤ t_start < num_steps
    timesteps = scheduler.timesteps[t_start:]  # 至少有 1 个 timestep

    # 4) 给 z_0 加 timesteps[0] 那一档噪声
    eps = torch.randn_like(z0)
    z = scheduler.add_noise(z0, eps, timesteps[:1])

    # 5) 主循环（与 §5 完全一致）
    for t in timesteps:
        z_in = torch.cat([z, z], dim=0)
        z_in = scheduler.scale_model_input(z_in, t)
        eps_pred = unet(z_in, t, encoder_hidden_states=emb).sample
        eps_neg, eps_pos = eps_pred.chunk(2, dim=0)
        eps_cfg = eps_neg + cfg_scale * (eps_pos - eps_neg)
        z = scheduler.step(eps_cfg, t, z).prev_sample

    # 6) decode
    z = z / 0.18215
    return ((vae.decode(z).sample.clamp(-1, 1) + 1) / 2)

8.3　InstructPix2Pix（Brooks et al. 2023 CVPR）

做指令式编辑："add a hat to the dog"。训练数据用 GPT-3 + Prompt-to-Prompt 合成（pair-wise (源图, 指令, 目标图)），fine-tune SD 1.x。架构：

• U-Net 输入 channel 数 4 → 8（原 latent 4 + 源图 latent 4）
• 两种 CFG scale：text guidance $s_T$ 和 image guidance $s_I$，独立调

$$\hat\epsilon = \hat\epsilon(\emptyset, \emptyset) + s_I [\hat\epsilon(c_I, \emptyset) - \hat\epsilon(\emptyset, \emptyset)] + s_T [\hat\epsilon(c_I, c_T) - \hat\epsilon(c_I, \emptyset)]$$

8.4　Prompt-to-Prompt（Hertz et al. 2023 ICLR）

Training-free 编辑：通过操纵 cross-attention map 实现"换词不换结构"。

• 跑原 prompt P 得到每层每步的 cross-attn map $M_t$（shape $[H_q, L_t]$，对每个图像 token 给出每个文本 token 的权重）
• 跑新 prompt P\*（只改一个词，如 cat → dog）但强制把对应文本 token 的 attention map 替换为原 P 的对应位置
• 因此结构（哪些图像 patch 关注哪些文本位置）保留，只有内容（softmax 之后被指向的 value）更新

适合 "swap one word"、"add adjective"、"reweight emphasis" 三类编辑。

§9 蒸馏：少步采样

9.1　LCM / LCM-LoRA（Luo et al. 2023）

Latent Consistency Model：把 latent diffusion 蒸馏成 Consistency Model（Song et al. 2023），让单步预测 $f_\theta(z_t, t)$ 直接给出 $z_0$，从 50 步压到 4-8 步。

LCM-LoRA：把上述蒸馏写成 LoRA，base SDXL/SDXL-1.0 + 一个 ~200MB LCM-LoRA = 4 步出图。零样本切换，可与个性化 LoRA 叠加。

9.2　SDXL-Turbo：ADD（Sauer et al. 2024 ECCV）/ SD3-Turbo：LADD（Sauer et al. 2024）

SDXL-Turbo = ADD (Adversarial Diffusion Distillation, arXiv 2311.17042 / ECCV 2024)；SD3-Turbo = LADD (Latent Adversarial Diffusion Distillation, arXiv 2403.12015) —— 两套独立方法，ADD 在 pixel 空间用 vision encoder 做判别器，LADD 改到 latent 空间训判别器，规模化到 SD3 大模型。

Adversarial Diffusion Distillation (ADD)：

• Teacher：原 SDXL（多步扩散模型）
• Student：与 teacher 同架构，目标 1-4 步出图

• 三个 loss：

  1. Distillation loss：student 输出与 teacher 多步采样结果 MSE / LPIPS
  2. Adversarial loss：DINOv2-based discriminator 判 student 输出真假
  3. Score loss：score distillation 类似 SDS 形式

ADD 是少步蒸馏 SOTA 路线之一；FLUX schnell 也基于类似思想（"timestep distillation" + adversarial）。

9.3　DMD / DMD2 / Hyper-SD 简表

§10 评测：FID / CLIP-Score / ImageReward / HPSv2 / PickScore

§11 复杂度 / 资源

11.1　训练侧（数量级估计）

11.2　推理侧（粗估，依赖实现）

SD 1.5 512×512（原生分辨率，latent 64×64×4）：

• 单步 U-Net FLOPs：~0.5T
• 单步 cross-attn QKV：(L_z=4096) × (L_t=77) → 0.3M score 矩阵 × 多层
• 单步显存：~2-3 GB（FP16，无 cross-attn KV cache）
• 30 步 ≈ 1.5-2 秒 / 张（A100，FP16）

（SD 1.5 在 1024² 上运行会比 512² 大约慢 4×；社区不建议非原生分辨率直接推理，常配合 SDXL 或 super-res。）

SDXL 1024×1024：

• 单步 U-Net FLOPs：~1.2T
• 30 步 ≈ 4-5 秒 / 张（A100，FP16）

FLUX.1-dev 1024×1024：

• MM-DiT FLOPs ≈ 2.5T / step
• 28 步 ≈ 12-15 秒（A100）；H100 ~5-7 秒

11.3　Memory footprint cheat sheet

§12 与相关方法对比

12.1　扩散族 vs 其他生成模型

12.2　扩散 internal route

§13 25 高频面试题（codex 5.5 xhigh 顶级 lab 面试官视角）

每题点开看答案要点 + 易踩坑。

L1必会题（任何视觉 / multimodal 工程岗都会问）

L2进阶题（research / production 岗位）

L3顶级 lab / 深入题（research lead 视角）

image latent Q  ─►───┐
                     │   softmax(QK^T/√d) V
                     │
text K/V (frozen)  ──┘──► attended_out → 加到 image latent residual

                 [txt | img] 拼成一个序列
                       │
        ┌──────────────┼──────────────┐
        │              │              │
  独立 QKV (txt)   独立 QKV (img)
        │              │              │
        └──────────────┼──────────────┘
                       ▼
              joint self-attention
                  (全局 attn matrix)
                       │
        ┌──────────────┼──────────────┐
        │              │              │
   text 输出更新    image 输出更新

§A 附录：参考与 reference list

主要论文（按时间）

• DDPM — Ho, Jain, Abbeel 2020 NeurIPS
• LDM / Stable Diffusion — Rombach, Blattmann et al. 2022 CVPR
• Classifier-Free Guidance — Ho & Salimans 2022 (workshop / arXiv)
• DiT — Peebles & Xie 2023 ICCV
• U-ViT — Bao, Nie et al. 2023 CVPR
• LoRA — Hu, Shen et al. 2022 ICLR
• DreamBooth — Ruiz, Li et al. 2023 CVPR
• Textual Inversion — Gal, Alaluf et al. 2023 ICLR
• Custom Diffusion — Kumari, Zhang et al. 2023 CVPR
• HyperDreamBooth — Ruiz, Li et al. 2024 CVPR
• ControlNet — Zhang, Rao, Agrawala 2023 ICCV
• T2I-Adapter — Mou, Wang et al. 2024 AAAI
• IP-Adapter — Ye, Zhang et al. 2023 (arXiv 2308.06721)
• InstantID — Wang, Bai et al. 2024 (arXiv 2401.07519)
• PuLID — Guo, Wu et al. 2024 NeurIPS
• PhotoMaker — Li, Cao et al. 2024 CVPR
• SDEdit — Meng, He et al. 2022 ICLR
• InstructPix2Pix — Brooks, Holynski, Efros 2023 CVPR
• Prompt-to-Prompt — Hertz, Mokady et al. 2023 ICLR
• SDXL — Podell, English et al. 2024 ICLR
• SD3 — Esser, Kulal et al. 2024 ICML
• FLUX.1 — Black Forest Labs 2024 (technical report)
• PixArt-α / Σ — Chen, Yu et al. 2024 ICLR / ECCV
• Hunyuan-DiT — Zhimin Li, Jianwei Zhang et al. 2024 (arXiv 2405.08748)
• Imagen — Saharia, Chan et al. 2022 NeurIPS
• ADD / SDXL-Turbo — Sauer, Lorenz et al. 2024 ECCV (arXiv 2311.17042)
• LCM — Luo, Tan et al. 2023 (arXiv 2310.04378)
• LCM-LoRA — Luo, Tan et al. 2023 (arXiv 2311.05556)
• DMD — Yin, Gharbi et al. 2024 CVPR
• ImageReward — Xu, Liu et al. 2023 NeurIPS
• HPSv2 — Wu, Hao et al. 2023 (arXiv 2306.09341)
• PickScore / Pick-a-Pic — Kirstain, Polyak et al. 2023 NeurIPS
• FID — Heusel, Ramsauer et al. 2017 NeurIPS

一句话总结

本 cheat sheet 覆盖从 latent diffusion 数学（VAE + DDPM/RF + CFG）到主流架构演进（SD 1.x → SDXL → SD3 → FLUX）、conditioning 体系（ControlNet / T2I-Adapter / IP-Adapter / InstantID）、个性化微调（DreamBooth / Textual Inversion / LoRA / Custom Diffusion）、编辑（SDEdit / InstructPix2Pix / Prompt-to-Prompt）、蒸馏（LCM / ADD / DMD）与评测（FID / CLIP-Score / ImageReward / HPSv2）。25 题按 L1/L2/L3 分布，L3 题强调 production lab 视角（零卷积 chain rule 推导、size conditioning 训练效果、MM-DiT 信息流、LoRA Q/K/V 选择、SDXL + LCM-LoRA + ControlNet + IP-Adapter 同栈部署 trade-off）。