手把手教你使用AIGC条件生成模型（附代码）

手把手教你使用AIGC条件生成模型（附代码）

关键词：AIGC、条件生成模型、CGAN、CVAE、扩散模型、可控生成、PyTorch实现

摘要：本文从AIGC（人工智能生成内容）的核心需求出发，系统讲解条件生成模型的底层逻辑、算法原理与实战方法。通过对比无条件生成模型的局限性，重点解析条件生成模型的“条件控制”本质，并以经典的Conditional GAN（CGAN）和当前主流的条件扩散模型为例，结合PyTorch代码实现，手把手演示从模型构建到训练调优的全流程。文章覆盖数学模型推导、关键技术细节（如条件信息融合策略）、常见问题解决（如模式崩溃），并提供实际应用场景（如图文生成、游戏资产定制）与工具资源推荐，帮助读者快速掌握AIGC条件生成的核心技术。

---

1. 背景介绍

1.1 目的和范围

AIGC的核心挑战是“可控性”——如何让模型生成符合特定需求的内容（如“生成一张戴红帽子的猫的图片”或“写一篇关于量子计算的科普文章”）。传统无条件生成模型（如经典GAN、VAE）仅能生成数据分布内的随机样本，无法直接接受外部条件约束。本文聚焦条件生成模型（Conditional Generative Model），系统讲解其技术原理与实战方法，覆盖从理论到代码的全链路实现，帮助读者掌握AIGC中“按需生成”的关键能力。

1.2 预期读者

• 具备基础机器学习知识（熟悉PyTorch/TensorFlow，了解GAN、VAE原理）的开发者；
• 希望将AIGC技术落地到实际场景（如内容创作、游戏开发）的工程师；
• 对生成式AI前沿方向（如多模态条件生成）感兴趣的研究者。

1.3 文档结构概述

本文遵循“理论→原理→实战→应用”的递进逻辑：

1. 核心概念：对比无条件与条件生成模型，定义“条件”的本质；
2. 算法原理：以CGAN和条件扩散模型为例，解析条件信息融合策略；
3. 数学模型：推导条件生成的概率模型与损失函数；
4. 项目实战：基于PyTorch实现CGAN，演示“按类别生成手写数字”任务；
5. 应用场景：列举图文生成、个性化内容定制等实际案例；
6. 工具资源：推荐学习资料、开发框架与前沿论文。

1.4 术语表

1.4.1 核心术语定义

• 条件生成模型（Conditional Generative Model）：输入包含额外条件信息（如标签、文本、图像），生成与条件强相关的目标数据的模型。
• 控制变量（Control Variable）：用于约束生成内容的外部信息，记为 ( c )（如类别标签、文本嵌入）。
• 潜在变量（Latent Variable）：模型内部用于捕捉数据分布的随机向量，记为 ( z )。
• 模式崩溃（Mode Collapse）：生成模型仅能生成有限类型样本，无法覆盖数据分布的所有模式的现象。

1.4.2 相关概念解释

• 无条件生成模型：仅输入随机噪声 ( z )，生成数据 ( x \sim p(x) )（如经典GAN的 ( G(z) )）。
• 多模态条件生成：输入多种类型条件（如图像+文本），生成多模态内容（如根据“一只白色的猫在草地上”文本生成图像）。

1.4.3 缩略词列表

• CGAN：Conditional GAN（条件生成对抗网络）
• CVAE：Conditional VAE（条件变分自编码器）
• DDPM：Denoising Diffusion Probabilistic Models（去噪扩散概率模型）

---

2. 核心概念与联系

2.1 无条件生成 vs 条件生成：从“随机”到“可控”

无条件生成模型的目标是学习数据分布 ( p(x) )，生成符合该分布的随机样本（如GAN生成随机手写数字）。但实际需求中，用户需要“指定类别的数字”“特定风格的图像”等带约束的生成，这要求模型学习条件分布 ( p(x|c) )，其中 ( c ) 是控制条件（图1）。

graph LR
    A[无条件生成] --> B[输入: 随机噪声z]
    B --> C[生成器G]
    C --> D[输出: 随机样本x ~ p(x)]
    
    E[条件生成] --> F[输入: 随机噪声z + 条件c]
    F --> G[条件生成器G_c]
    G --> H[输出: 样本x ~ p(x|c)]

图1：无条件生成与条件生成的核心差异

2.2 条件生成的关键要素

条件生成模型的设计需解决三个核心问题：

1. 条件类型：( c ) 可以是离散标签（如MNIST的数字类别）、连续向量（如图像风格编码）、文本（如自然语言描述）或多模态组合（如图像+文本）。
2. 信息融合：如何将 ( c ) 与 ( z ) 融合输入生成器？常见策略包括：
   • 拼接（Concatenation）：将 ( z ) 和 ( c ) 的嵌入向量直接拼接（如 ( [z; \text{Emb}©] )）；
   • 条件批归一化（Conditional BN）：用 ( c ) 动态调整批归一化层的均值和方差（如BigGAN的关键技术）；
   • 注意力机制（Attention）：通过注意力头让生成器动态关注 ( c ) 的关键部分（如扩散模型中的交叉注意力）。
3. 损失函数：需同时约束生成样本与条件的对齐性（如分类损失）和数据分布的真实性（如GAN的对抗损失）。

2.3 主流条件生成模型对比

模型类型	代表模型	核心思想	适用场景	优势	局限性
条件GAN	CGAN、BigGAN	对抗训练，生成器输入 ( z ) 和 ( c )	图像生成、风格迁移	生成质量高、速度快	训练不稳定、模式崩溃
条件VAE	CVAE、InfoVAE	变分推断，学习 ( p(x	c) ) 的后验分布	结构化数据生成（如分子）	概率建模清晰、可解释性强
条件扩散模型	Stable Diffusion	逐步去噪，条件信息指导每一步去噪过程	多模态生成（图文、视频）	生成多样性高、可控性强	计算成本高、推理速度慢

---

3. 核心算法原理 & 具体操作步骤

3.1 以CGAN为例：条件生成对抗网络的原理

CGAN（Conditional GAN）是条件生成模型的经典实现，通过在生成器（Generator）和判别器（Discriminator）中同时输入条件 ( c )，强制模型学习 ( p(x|c) ) 的分布（图2）。

graph TD
    Z[随机噪声z] --> G[生成器]
    C[条件c] --> G
    G --> X_fake[生成样本x_fake]
    X_real[真实样本x_real] --> D[判别器]
    C --> D
    D --> D_out[判别结果：真假+条件匹配度]

图2：CGAN模型架构

3.1.1 生成器设计

生成器 ( G(z, c) ) 的输入是噪声 ( z ) 和条件 ( c )，输出为生成样本 ( x_{\text{fake}} )。以图像生成为例，( z ) 通常是100维的随机正态分布向量，( c ) 是类别标签的嵌入向量（如10维的one-hot编码，通过全连接层映射到100维后与 ( z ) 拼接）。

3.1.2 判别器设计

判别器 ( D(x, c) ) 同时接收真实样本 ( x_{\text{real}} )（或生成样本 ( x_{\text{fake}} )）和条件 ( c )，输出两个判断：

1. 样本是否真实（对抗损失）；
2. 样本是否与条件 ( c ) 匹配（分类损失）。

3.1.3 损失函数

CGAN的目标函数是对抗损失与条件对齐损失的结合：
[
\min_G \max_D \mathbb{E}{x \sim p{\text{data}}(x), c \sim p©} [\log D(x, c)] + \mathbb{E}_{z \sim p_z(z), c \sim p©} [\log (1 - D(G(z, c), c))]
]
其中，( D(x, c) ) 输出样本 ( x ) 与条件 ( c ) 匹配的概率。生成器 ( G ) 试图让 ( D(G(z,c), c) ) 接近1（以假乱真），判别器 ( D ) 试图区分真实样本与生成样本，并验证样本与条件的一致性。

3.2 具体操作步骤（以PyTorch实现CGAN为例）

3.2.1 环境准备

• Python 3.8+、PyTorch 2.0+、TorchVision、Matplotlib
• 硬件：建议GPU（如NVIDIA GTX 1080Ti及以上，支持CUDA）

3.2.2 数据加载与预处理（以MNIST为例）

MNIST是手写数字数据集（28×28灰度图，10个类别）。我们需要为每个样本添加类别标签作为条件 ( c )。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import save_image

# 数据预处理：转换为张量并标准化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=(0.5,), std=(0.5,))  # 归一化到[-1, 1]
])

# 加载MNIST数据集
train_dataset = datasets.MNIST(
    root='./data', train=True, download=True, transform=transform
)
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

3.2.3 模型定义：生成器与判别器

生成器结构：输入为 ( z )（100维噪声）和 ( c )（10维one-hot标签），拼接后通过全连接层和上采样层生成28×28图像。

class Generator(nn.Module):
    def __init__(self, latent_dim=100, num_classes=10, img_dim=28*28):
        super(Generator, self).__init__()
        self.latent_dim = latent_dim
        self.num_classes = num_classes
        self.img_dim = img_dim
        
        # 条件嵌入：将标签映射到与噪声同维度
        self.label_emb = nn.Embedding(num_classes, latent_dim)
        
        # 生成器网络：噪声+条件 → 图像
        self.model = nn.Sequential(
            nn.Linear(latent_dim + latent_dim, 256),  # z(100) + c_emb(100) → 200 → 256
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, img_dim),
            nn.Tanh()  # 输出归一化到[-1, 1]，与数据预处理一致
        )
    
    def forward(self, z, labels):
        # 嵌入标签：[batch_size] → [batch_size, latent_dim]
        c_emb = self.label_emb(labels)
        # 拼接噪声与条件嵌入
        input = torch.cat([z, c_emb], dim=1)
        img = self.model(input)
        return img.view(-1, 1, 28, 28)  # 转换为图像形状[batch, channel, height, width]

判别器结构：输入为图像（28×28）和标签 ( c )，输出样本真实性的概率。

class Discriminator(nn.Module):
    def __init__(self, num_classes=10, img_dim=28*28):
        super(Discriminator, self).__init__()
        self.num_classes = num_classes
        self.img_dim = img_dim
        
        # 条件嵌入：将标签映射到与图像同维度
        self.label_emb = nn.Embedding(num_classes, img_dim)
        
        # 判别器网络：图像+条件 → 真实性概率
        self.model = nn.Sequential(
            nn.Linear(img_dim + img_dim, 1024),  # 图像(784) + c_emb(784) → 1568 → 1024
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(1024, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Dropout(0.3),
            nn.Linear(256, 1),
            nn.Sigmoid()  # 输出概率（0为假，1为真）
        )
    
    def forward(self, img, labels):
        # 展平图像：[batch, 1, 28, 28] → [batch, 784]
        img_flat = img.view(img.size(0), -1)
        # 嵌入标签：[batch_size] → [batch_size, 784]
        c_emb = self.label_emb(labels)
        # 拼接图像与条件嵌入
        input = torch.cat([img_flat, c_emb], dim=1)
        validity = self.model(input)
        return validity

3.2.4 训练循环

训练过程交替优化判别器和生成器：

1. 判别器训练：用真实样本（真实标签）和生成样本（生成标签）更新判别器，使其能区分真假；
2. 生成器训练：用生成样本（生成标签）更新生成器，使其能欺骗判别器。

# 超参数设置
latent_dim = 100
num_classes = 10
lr = 0.0002
epochs = 100
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 初始化模型、优化器、损失函数
generator = Generator(latent_dim, num_classes).to(device)
discriminator = Discriminator(num_classes).to(device)
optimizer_G = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_D = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))
adversarial_loss = nn.BCELoss()  # 二分类交叉熵损失

# 训练循环
for epoch in range(epochs):
    for i, (imgs, labels) in enumerate(train_loader):
        batch_size = imgs.size(0)
        imgs = imgs.to(device)
        labels = labels.to(device)
        
        # ---------------------
        #  训练判别器
        # ---------------------
        # 真实样本标签：全1（真实）
        valid = torch.ones(batch_size, 1).to(device)
        # 生成样本标签：全0（虚假）
        fake = torch.zeros(batch_size, 1).to(device)
        
        # 生成随机噪声
        z = torch.randn(batch_size, latent_dim).to(device)
        # 生成器生成假图像
        gen_imgs = generator(z, labels)
        
        # 判别器对真实样本的判断
        real_validity = discriminator(imgs, labels)
        d_loss_real = adversarial_loss(real_validity, valid)
        # 判别器对生成样本的判断
        fake_validity = discriminator(gen_imgs.detach(), labels)  # 不更新生成器
        d_loss_fake = adversarial_loss(fake_validity, fake)
        # 总判别器损失
        d_loss = (d_loss_real + d_loss_fake) / 2
        
        # 反向传播更新判别器
        optimizer_D.zero_grad()
        d_loss.backward()
        optimizer_D.step()
        
        # ---------------------
        #  训练生成器
        # ---------------------
        # 生成器希望判别器将生成样本判断为真实（标签为1）
        gen_validity = discriminator(gen_imgs, labels)
        g_loss = adversarial_loss(gen_validity, valid)
        
        # 反向传播更新生成器
        optimizer_G.zero_grad()
        g_loss.backward()
        optimizer_G.step()
        
        # 打印训练日志
        if i % 100 == 0:
            print(f"[Epoch {epoch}/{epochs}] [Batch {i}/{len(train_loader)}] "
                  f"[D loss: {d_loss.item():.4f}] [G loss: {g_loss.item():.4f}]")
    
    # 保存每轮生成的样本（以标签0-9为例）
    with torch.no_grad():
        test_z = torch.randn(10, latent_dim).to(device)
        test_labels = torch.arange(10).to(device)  # 生成0-9的标签
        gen_imgs = generator(test_z, test_labels)
        save_image(gen_imgs.data, f"images/epoch_{epoch}.png", nrow=10, normalize=True)

---

4. 数学模型和公式 & 详细讲解 & 举例说明

4.1 条件生成的概率模型

条件生成模型的核心是建模条件概率分布 ( p(x|c) )，其中 ( x ) 是生成数据（如图像），( c ) 是控制条件（如标签）。根据贝叶斯定理：
[
p(x|c) = \frac{p(x, c)}{p©}
]
但直接估计 ( p(x, c) ) 困难，因此生成模型通过引入潜在变量 ( z )（如噪声），将 ( p(x|c) ) 近似为：
[
p(x|c) \approx \int p(x|z, c) p(z) dz
]
其中 ( p(z) ) 是先验分布（通常为正态分布 ( \mathcal{N}(0, I) )），( p(x|z, c) ) 由生成器 ( G(z, c) ) 参数化。

4.2 CGAN的目标函数推导

CGAN的对抗训练框架中，生成器 ( G ) 和判别器 ( D ) 进行极小极大博弈：
[
\min_G \max_D \mathbb{E}{(x,c) \sim p{\text{data}}} [\log D(x, c)] + \mathbb{E}_{(z,c) \sim p(z) \times p©} [\log (1 - D(G(z,c), c))]
]

• 判别器目标：最大化 ( \log D(x,c) + \log (1 - D(G(z,c),c)) )，即尽可能区分真实样本与生成样本；
• 生成器目标：最小化 ( \log (1 - D(G(z,c),c)) )（等价于最大化 ( \log D(G(z,c),c) )），即生成尽可能逼真的样本。

4.3 举例：条件控制的数学意义

假设我们要生成“数字3”的图像，条件 ( c=3 )（one-hot编码为 ( [0,0,0,1,0,0,0,0,0,0] )）。生成器 ( G(z, c=3) ) 的输出需满足 ( x \sim p(x|c=3) )，即图像像素分布集中在“3”的典型特征（如上下两个半圆、中间横线）。判别器 ( D(x, c=3) ) 需判断 ( x ) 是否既真实（属于MNIST分布）又与 ( c=3 ) 匹配（不是数字2或5）。

---

5. 项目实战：代码实际案例和详细解释说明

5.1 开发环境搭建

• 步骤1：安装Python 3.8+（推荐Anaconda）；
• 步骤2：安装PyTorch（根据CUDA版本选择，如 pip install torch torchvision --extra-index-url https://download.pytorch.org/whl/cu118）；
• 步骤3：安装依赖库：pip install matplotlib pandas tqdm；
• 步骤4：验证环境：运行 import torch; print(torch.cuda.is_available()) 确认GPU可用。

5.2 源代码详细实现和代码解读

前文3.2节已给出完整代码，此处重点解读关键模块：

5.2.1 生成器的条件嵌入（label_emb）

通过 nn.Embedding 将离散标签（如0-9）映射为连续向量（维度与噪声 ( z ) 相同），实现标签到潜在空间的语义转换。例如，标签3的嵌入向量应包含“3的形状特征”（如曲线、横线）的信息。

5.2.2 判别器的输入拼接（torch.cat）

将图像（展平为784维）与标签嵌入（784维）拼接为1568维向量，使判别器同时感知图像内容和条件信息。这种设计强制判别器学习“图像是否属于指定类别”的判断能力。

5.2.3 训练中的detach()操作

生成器训练时，gen_imgs.detach() 用于断开生成器与判别器的梯度连接，确保仅更新判别器参数（避免生成器梯度影响判别器训练）。

5.3 代码解读与分析

• 超参数选择：latent_dim=100 是平衡表达能力与计算成本的常用值；lr=0.0002 是GAN训练的经典学习率（Adam优化器的betas=(0.5, 0.999) 用于稳定训练）。
• 损失函数：BCELoss（二分类交叉熵）衡量判别器输出与真实标签（0或1）的差异，是GAN的标准选择。
• 生成样本保存：每轮训练后生成10个样本（对应标签0-9），通过save_image保存，方便观察模型是否学会按条件生成。

---

6. 实际应用场景

6.1 图文生成（Text-to-Image）

• 案例：DALL-E 2根据自然语言描述生成图像（如“一只戴太阳镜的熊猫在冲浪”）。
• 技术要点：将文本编码为条件 ( c )（通过CLIP等模型），输入扩散模型生成图像，条件信息控制图像的主体、风格、场景。

6.2 个性化内容定制

• 案例：游戏公司使用条件生成模型为玩家定制角色（如“生成一个穿红色盔甲、持长剑的精灵”）。
• 技术要点：条件 ( c ) 包含角色属性（职业、装备、颜色），生成器输出符合属性的3D模型或2D原画。

6.3 语音合成（Text-to-Speech）

• 案例：Google WaveNet根据文本和说话人身份生成语音（如“将这段文字用周杰伦的声音朗读”）。
• 技术要点：条件 ( c ) 包含文本嵌入和说话人ID嵌入，生成器输出语音波形，确保语义与音色对齐。

6.4 代码生成（Code Generation）

• 案例：GitHub Copilot根据注释或函数名生成代码（如“写一个计算斐波那契数列的Python函数”）。
• 技术要点：条件 ( c ) 是代码上下文或自然语言描述，生成器输出符合语义的代码片段。

---

7. 工具和资源推荐

7.1 学习资源推荐

7.1.1 书籍推荐

• 《Deep Learning》（Goodfellow等）：第20章详细讲解生成模型（包括GAN、VAE）。
• 《Generative Adversarial Networks》（Nishant Shukla）：聚焦GAN的理论与实践，包含CGAN的专章。
• 《Diffusion Models from Scratch》（Sam Witteveen）：最新扩散模型教程，涵盖条件扩散的实现。

7.1.2 在线课程

• Coursera《Deep Learning Specialization》（Andrew Ng）：第5课“序列模型”涉及生成式模型基础。
• Fast.ai《Practical Deep Learning for Coders》：实战导向，包含GAN和扩散模型的案例。
• Hugging Face Course：免费在线课程，覆盖Transformers、扩散模型的条件生成应用（链接）。

7.1.3 技术博客和网站

• OpenAI Blog：发布DALL-E、GPT等前沿模型的技术细节（链接）。
• Distill.pub：高质量可视化技术文章，如《GANs Explained》（链接）。
• Lil’Log：独立博客，深入讲解扩散模型原理（链接）。

7.2 开发工具框架推荐

7.2.1 IDE和编辑器

• PyCharm：专业Python IDE，支持代码调试、性能分析（适合模型开发）。
• VS Code：轻量编辑器，配合Jupyter扩展支持交互式开发（适合快速实验）。

7.2.2 调试和性能分析工具

• PyTorch Profiler：分析模型训练的时间/内存消耗（torch.profiler）。
• Weights & Biases（wandb）：可视化训练指标（损失、生成样本），支持条件生成的对比实验。

7.2.3 相关框架和库

• PyTorch Lightning：简化训练循环（如自动处理GPU分布式训练），适合快速迭代。
• Hugging Face Transformers：集成CLIP、Stable Diffusion等条件生成模型（pip install transformers diffusers）。
• TensorFlow Probability：支持概率编程，适合CVAE等需要显式概率建模的条件生成模型。

7.3 相关论文著作推荐

7.3.1 经典论文

• 《Conditional Generative Adversarial Nets》（Mirza & Osindero, 2014）：CGAN的原始论文。
• 《Auto-Encoding Variational Bayes》（Kingma & Welling, 2013）：VAE原理，条件版本可扩展为CVAE。
• 《Denoising Diffusion Probabilistic Models》（Ho et al., 2020）：扩散模型基础，后续条件扩散模型（如Stable Diffusion）的理论来源。

7.3.2 最新研究成果

• 《Hierarchical Text-Conditional Image Generation with CLIP Latents》（Ramesh et al., 2022）：DALL-E 2的技术论文，讲解文本条件生成的多阶段扩散方法。
• 《Scaling Diffusion Models to 10B Parameters》（Saharia et al., 2023）：大规模条件扩散模型的训练优化策略。

7.3.3 应用案例分析

• 《GANs for Game Asset Generation》（NVIDIA, 2021）：工业界使用条件GAN生成游戏3D模型的实践报告。
• 《Text-to-Speech Synthesis with Transformer Networks》（Google, 2018）：基于条件Transformer的语音合成案例。

---

8. 总结：未来发展趋势与挑战

8.1 未来趋势

• 多模态条件生成：融合文本、图像、语音等多模态条件，生成更复杂的内容（如交互式视频）。
• 细粒度控制：从“类别级条件”（如“生成猫”）到“属性级条件”（如“生成一只白色、短毛、戴项圈的猫”）。
• 实时生成：优化扩散模型的推理速度（如通过蒸馏、量化），支持实时应用（如虚拟试衣、游戏实时渲染）。

8.2 核心挑战

• 条件对齐（Condition Alignment）：如何确保生成内容与条件严格匹配（如避免“生成戴红帽子的猫”时帽子颜色错误）。
• 多样性与质量平衡：条件约束过强可能导致生成样本同质化（如所有“戴红帽子的猫”千篇一律）。
• 伦理与安全：条件生成可能被滥用（如伪造内容、深度伪造），需研究可控生成的“水印”“溯源”技术。

---

9. 附录：常见问题与解答

Q1：条件生成模型训练时，生成器不利用条件信息（生成样本与条件无关），如何解决？
A：可能原因是条件嵌入维度过低或融合方式不当。可尝试：

• 增加条件嵌入维度（如从100维提升到256维）；
• 改用更复杂的融合方式（如条件批归一化代替简单拼接）；
• 添加辅助分类损失（如在生成器中增加分类头，强制学习条件信息）。

Q2：CGAN训练不稳定，损失震荡严重，怎么办？
A：GAN训练不稳定是常见问题，可尝试：

• 使用更稳定的优化器（如SGD with momentum替换Adam）；
• 调整学习率（如降低到0.0001）；
• 引入梯度惩罚（如WGAN-GP的梯度约束）；
• 平衡生成器与判别器的能力（如让判别器更“弱”，生成器更“强”）。

Q3：如何评估条件生成模型的效果？
A：常用指标包括：

• FID（Frechet Inception Distance）：衡量生成样本与真实样本的分布差异（值越小越好）；
• 条件匹配准确率：用分类器评估生成样本与条件的匹配度（如用ResNet分类生成的MNIST图像，计算类别准确率）；
• 人工评估：邀请用户对生成样本的“相关性”“质量”打分。

---

10. 扩展阅读 & 参考资料

• 官方文档：PyTorch生成模型教程（链接）
• 开源项目：Stable Diffusion官方仓库（链接）
• 经典论文：CGAN原始论文、扩散模型原始论文
• 技术报告：OpenAI《DALL-E 2 Technical Report》（链接）