深度生成模型概述
随着 Sora、Diffusion、GPT 等模型的发展，深度生成模型成为焦点。这类机器学习工具可从输入数据学习潜在分布，生成与训练数据相似的样本，广泛应用于计算机视觉、自然语言处理等领域。
| 模型 | 核心目标 | 原理 | 优点 | 缺点 | 应用场景 |
|---|---|---|---|---|---|
| VAE | 学习潜在空间分布，编码器 - 解码器生成样本 | 基于变分推断，将输入映射到潜在空间正态分布，优化重构误差与 KL 散度 | 训练稳定，支持潜在空间插值；生成多样化 | 生成图像模糊；KL 约束可能导致信息丢失 | 数据填充、特征提取、图像修复 |
| GAN | 通过生成器与判别器的对抗训练，生成难分样本 | 生成器从噪声生成假数据，判别器区分真假；零和博弈优化至纳什均衡 | 生成图像细节丰富；单步推理速度快 | 训练不稳定；多样性不足；需精细调参 | 艺术创作、风格迁移、图像超分辨率 |
| AR | 自回归地生成序列数据，逐个预测下一个元素概率 | 基于条件概率分解（如 Transformer），自注意力机制捕捉长程依赖 | 建模能力强，支持长序列生成；训练稳定 | 生成速度慢 (逐步采样)；高维数据计算成本高 | 文本生成、时序预测、图像生成 |
| Flow | 可逆变换将简单分布转为复杂数据分布，实现精确密度估计 | 设计可逆神经网络层，利用变量变换公式计算对数似然 | 支持精确密度估计；生成与重建可逆 | 高维数据下变换设计复杂；雅可比行列式开销大 | 语音合成、密度估计、图像生成 |
| Diffusion | 通过逐步去噪过程从高斯噪声重建数据分布 | 正向扩散（加噪）与逆向扩散（去噪）结合，基于马尔可夫链建模 | 生成质量最高；训练稳定 | 推理速度慢；显存占用高 | 高清图像生成、多模态/视频生成 |
1 变分自编码器（VAE）
1.1 概念
VAE 是在自编码器（Auto-Encoder）基础上，结合变分推断（Variational Inference）和贝叶斯理论提出的深度生成模型。目标是学习能够生成与训练数据相似样本的模型。假设隐变量服从某种先验分布（如标准正态分布），通过编码器将输入映射到隐变量的后验分布，再通过解码器还原生成样本。
1.2 训练损失
VAE 的训练损失函数包括重构损失（如均方误差）和 KL 散度（衡量潜在分布与标准正态分布的差异）。
损失函数：
- 重构项：衡量解码器重建输入数据的能力（如均方误差或交叉熵）
- KL 散度项：约束潜在分布 q(z|x) 与先验分布 p(z)（通常为标准正态分布）的相似性，平衡参数为 β（如 β-VAE）
优化目标：最大化证据下界（ELBO），同时保证潜在空间的结构化和连续性。
1.3 VAE 的实现
import torch
import torch.nn as nn
import torch.nn.functional as F
class VAE(nn.Module):
def __init__(self, input_dim=784, hidden_dim=400, latent_dim=20):
super(VAE, self).__init__()
# 编码器：输入 → 隐藏层 → 均值和方差
self.encoder = nn.Sequential(
nn.Linear(input_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, latent_dim * 2) # 输出均值和对数方差
)
# 解码器：潜在变量 → 隐藏层 → 重构输入
self.decoder = nn.Sequential(
nn.Linear(latent_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, input_dim),
nn.Sigmoid() # 输出像素值在 [0,1] 区间
)
def reparameterize(self, mu, log_var):
"""重参数化技巧：从 N(μ, σ²) 采样潜在变量 z"""
std = torch.exp(0.5 * log_var)
eps = torch.randn_like(std)
return mu + eps * std
def forward(self, x):
h = self.encoder(x)
mu, log_var = torch.chunk(h, 2, dim=1)
z = self.reparameterize(mu, log_var)
x_recon = self.decoder(z)
return x_recon, mu, log_var
def loss_function(self, x_recon, x, mu, log_var):
recon_loss = F.binary_cross_entropy(x_recon, x, reduction='sum')
kl_div = -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())
return recon_loss + kl_div
2 生成对抗网络（GAN）
2.1 概念
GAN 由两部分组成：生成器（Generator）和判别器（Discriminator）。
- 生成器的任务是生成尽可能接近真实数据的假数据。
- 判别器的任务是区分输入数据是真实数据还是生成器生成的假数据。
- 二者通过相互竞争与对抗，共同进化，最终生成器能够生成非常接近真实数据的样本。
训练过程：
- 判别器接受真实数据和生成器生成的假数据，进行二分类训练。
- 生成器根据判别器的反馈，尝试生成更加真实的假数据以欺骗判别器。
- 交替训练判别器和生成器，直到判别器无法区分真实和生成数据。
2.2 训练损失
a. 判别器的损失函数
- 判别器的目标是最大化正确判断的概率：真实样本输出 1，生成样本输出 0。
- 数学表达：
- 直观解释：判别器的损失是两部分交叉熵的总和，分别惩罚对真实样本和生成样本的判断错误。
b. 生成器的损失函数
- 生成器的目标是让判别器误判生成样本为真。
- 数学表达：
c. 对抗训练的动态过程
- 第一轮训练：生成器随机生成低质量样本，判别器轻松识别真伪。
- 第二轮训练：生成器改进造假技术，判别器被迷惑，损失上升。
- 最终平衡：生成器能生成足以以假乱真的样本，判别器无法准确区分真伪。
2.3 GAN 的实现
class Generator(nn.Module):
def __init__(self, noise_dim=100, output_dim=784):
super(Generator, self).__init__()
self.model = nn.Sequential(
nn.Linear(noise_dim, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
nn.Linear(512, output_dim),
nn.Tanh() # 输出范围 [-1,1]
)
def forward(self, z):
return self.model(z).view(-1, 1, 28, 28)
class Discriminator(nn.Module):
def __init__(self, input_dim=784):
super(Discriminator, self).__init__()
self.model = nn.Sequential(
nn.Linear(input_dim, 512),
nn.LeakyReLU(0.2),
nn.Linear(512, 256),
nn.LeakyReLU(0.2),
nn.Linear(256, 1),
nn.Sigmoid()
)
def forward(self, x):
x = x.view(-1, 784)
return self.model(x)
def train_gan():
G = Generator()
D = Discriminator()
criterion = nn.BCELoss()
for real_images, _ in dataloader:
real_labels = torch.ones(real_images.size(0), 1)
fake_labels = torch.zeros(real_images.size(0), 1)
# 训练判别器
real_loss = criterion(D(real_images), real_labels)
z = torch.randn(real_images.size(0), 100)
fake_images = G(z)
fake_loss = criterion(D(fake_images.detach()), fake_labels)
d_loss = real_loss + fake_loss
d_loss.backward()
optimizer_D.step()
# 训练生成器
g_loss = criterion(D(fake_images), real_labels)
g_loss.backward()
optimizer_G.step()
3 自回归模型（AR）
3.1 概念
自回归模型是一种基于序列数据的生成模型，通过预测序列中下一个元素的值来生成数据。给定序列 (x_1, x_2, ..., x_n)，模型学习条件概率分布 P(x_t | x_{t-1}, ..., x_1)。可通过 RNN 或 Transformer 实现。
Transformer 作为自回归模型的代表，通过注意力机制捕捉序列中每个位置与之前所有位置的依赖关系。GPT、Bert 等大模型均基于 Transformer 实现了卓越性能。
3.2 训练过程
a. 核心思想：用历史预测未来
自回归模型的核心是根据过去的输出预测未来的输出。例如语言模型根据上文预测下一个词。
b. Transformer 的损失计算：交叉熵监督预测
- 输入与输出的关系：输入序列右移一位得到目标序列，模型预测每个位置下一个词的概率分布。
- 损失函数的数学表达：
- 直观解释：交叉熵损失衡量模型预测的概率分布与真实标签的差异。
c. 损失计算的具体步骤
- 嵌入与位置编码：将输入转换为向量并添加位置信息。
- 因果掩码（Causal Masking）：屏蔽未来信息。
- 多头注意力与前馈网络：整合历史信息。
- 输出层与概率分布：映射到词表概率分布。
- 计算损失：对比预测概率与真实词 one-hot 编码。
3.2 代码实现（Transformer-AR）
class TransformerAR(nn.Module):
def __init__(self, vocab_size=256, embed_dim=128, num_heads=4, num_layers=3):
super(TransformerAR, self).__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.positional_enc = nn.Parameter(torch.randn(784, embed_dim))
encoder_layer = nn.TransformerEncoderLayer(
d_model=embed_dim, nhead=num_heads, dim_feedforward=512
)
self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
self.fc = nn.Linear(embed_dim, vocab_size)
def forward(self, x):
x = self.embedding(x) + self.positional_enc
mask = torch.triu(torch.ones(784, 784), diagonal=1).bool()
out = self.transformer(x, mask=mask)
logits = self.fc(out)
return logits
def generate(self, start_token, max_len=784):
generated = start_token
for _ in range(max_len):
logits = self(generated)
next_pixel = torch.multinomial(F.softmax(logits[:, -1, :], dim=-1), 1)
generated = torch.cat([generated, next_pixel], dim=1)
return generated
4 流模型（Flow）
4.1 概念
流模型是一种基于可逆变换的深度生成模型。通过一系列可逆的变换，将简单分布（如正态分布）转换为复杂的数据分布。核心思想是用'可逆魔法'转换分布，既能变形又能变回去。
4.2 训练过程
4.2 代码实现（Flow）
class FlowModel(nn.Module):
def __init__(self, input_dim=784, hidden_dim=512):
super(FlowModel, self).__init__()
self.scale_net = nn.Sequential(
nn.Linear(input_dim//2, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, input_dim//2)
)
self.shift_net = nn.Sequential(
nn.Linear(input_dim//2, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, input_dim//2)
)
def forward(self, x):
x1, x2 = x.chunk(2, dim=1)
s = self.scale_net(x1)
t = self.shift_net(x1)
z2 = x2 * torch.exp(s) + t
z = torch.cat([x1, z2], dim=1)
log_det = s.sum(dim=1)
return z, log_det
def inverse(self, z):
z1, z2 = z.chunk(2, dim=1)
s = self.scale_net(z1)
t = self.shift_net(z1)
x2 = (z2 - t) * torch.exp(-s)
x = torch.cat([z1, x2], dim=1)
return x
def flow_loss(self, z, log_det):
prior_logprob = -0.5 * (z ** 2).sum(dim=1)
return (-prior_logprob - log_det).mean()
5 扩散模型（Diffusion）
5.1 概念
Diffusion Model 是一类深度生成模型，灵感来源于物理学中的扩散过程。通过模拟数据从随机噪声逐渐扩散到目标数据的过程来生成数据。DDPM [NeurIPS 2020] 证明了不用像 VAE 那样学方差，只学个均值，就能有很好的图像生成效果。
与传统编码器 - 解码器结构不同，扩散模型每个时间步输出的特征图大小一致，且每个时间步都用同一套 U-Net 共享参数。
5.2 训练过程
图中损失函数的核心是衡量'预测噪声'与'真实噪声'的差距，常用均方误差（MSE）。训练时，U-net 根据带噪样本预测噪声，损失函数要求预测值尽可能接近真实噪声。
5.2 代码实现（Diffusion）
class DiffusionModel(nn.Module):
def __init__(self, image_size=28, channels=1):
super(DiffusionModel, self).__init__()
self.net = nn.Sequential(
nn.Conv2d(channels, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(),
nn.Conv2d(64, channels, 3, padding=1)
)
self.num_steps = 1000
self.betas = torch.linspace(1e-4, 0.02, self.num_steps)
self.alphas = 1 - self.betas
self.alpha_bars = torch.cumprod(self.alphas, dim=0)
def forward(self, x, t):
return self.net(x)
def train_step(self, x0):
t = torch.randint(0, self.num_steps, (x0.size(0),))
sqrt_alpha_bar = torch.sqrt(self.alpha_bars[t]).view(-1, 1, 1, 1)
sqrt_one_minus_alpha_bar = torch.sqrt(1 - self.alpha_bars[t]).view(-1, 1, 1, 1)
epsilon = torch.randn_like(x0)
xt = sqrt_alpha_bar * x0 + sqrt_one_minus_alpha_bar * epsilon
epsilon_pred = self(xt, t)
loss = F.mse_loss(epsilon_pred, epsilon)
return loss
def sample(self, num_samples=16):
xt = torch.randn(num_samples, 1, 28, 28)
for t in reversed(range(self.num_steps)):
epsilon_pred = self(xt, t)
xt = (xt - self.betas[t] * epsilon_pred) / torch.sqrt(self.alphas[t])
if t > 0:
xt += torch.sqrt(self.betas[t]) * torch.randn_like(xt)
return xt
6 小结
本文回顾了 VAE、GAN、AR、Flow 和 Diffusion 五种常见的深度学习模型。
- VAE和GAN是两种常用的深度生成模型，分别基于贝叶斯概率理论和对抗训练。
- AR模型适用于处理具有时序依赖关系的数据。
- Flow模型和Diffusion模型在生成样本上具有较好的稳定性和多样性，但需要较高的计算成本。
潜在研究方向包括混合架构融合、轻量化部署以及物理约束嵌入等。
