深度生成模型对比：VAE、GAN、AR、Flow 与 Diffusion 原理及代码实战

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. 生成器的损失函数

生成器希望判别器误判生成样本为真（输出 1）。

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 核心概念

AR 模型基于序列数据，通过预测下一个元素的值来生成数据。给定序列 $x_1, ..., x_n$，模型学习条件概率 $P(x_t | x_{t-1}, ..., x_1)$。

Transformer 是 AR 的典型代表，利用注意力机制捕捉长程依赖。相比 RNN，它解决了梯度消失问题，更适合长序列。

3.2 训练过程

a. 核心思想：用历史预测未来

根据过去的输出预测未来的输出。例如语言模型中，根据'今天天气'预测下一个词。

b. Transformer 的损失计算

使用交叉熵监督预测。输入序列右移一位作为目标序列，模型对每个位置预测下一个词的概率分布。

c. 具体步骤

1. 嵌入与位置编码：将词转换为向量并添加位置信息。
2. 因果掩码：屏蔽未来信息，确保预测时只看过去。
3. 多头注意力：整合历史信息。
4. 输出层：映射到词表概率分布。
5. 计算损失：累加交叉熵。

3.3 代码实现（Transformer-AR）

这是一个基于 Pixel Transformer 的简化实现，将图像展平为序列进行生成。

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 核心概念

Flow 模型基于可逆变换，将简单分布（如正态分布）转换为复杂的数据分布。核心在于'可逆魔法'，既能变形也能恢复原状。

想象把一团橡皮泥捏成特定形状，同时保留随时恢复原状的能力。这使得 Flow 支持精确的概率密度估计。

4.2 训练过程

利用变量变换公式计算数据对数似然，优化雅可比行列式。损失函数通常是最小化负对数似然。

4.3 代码实现（Flow）

这里展示 RealNVP 结构的简化实现。

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 证明了只学均值就能获得很好的生成效果。

与传统编码器不同，扩散模型每个时间步输出特征图大小一致，且共享 U-Net 参数，类似 RNN 的循环结构。

U-Net 在一次完整前向传播中对应一个时间步。加入时间嵌入是为了告诉模型当前处于去噪的哪个阶段。

5.2 训练过程

损失函数核心是衡量'预测噪声'与'真实噪声'的差距，常用 MSE。

逻辑上，模型在正向过程中知道加了什么噪声，训练时 U-Net 预测噪声，损失函数要求预测值接近真实噪声。通过最小化损失，U-Net 学会分析带噪数据特征。

5.3 代码实现（Diffusion）

基于 UNet 的简化扩散模型实现。

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 在稳定性和多样性上表现优异，但计算成本较高。

未来趋势可能集中在混合架构融合（如 Diffusion-GAN）、轻量化部署以及物理约束嵌入等方面。理解这些模型的权衡，有助于在实际项目中选择合适的技术路径。