5种生成模型（VAE、GAN、AR、Flow 和 Diffusion）的对比梳理 + 易懂讲解 + 代码实现

陈苏同学2025-03-27 14:47

目录

[1 变分自编码器（VAE）​](#1 变分自编码器（VAE）)

[1.1 概念](#1.1 概念)

[1.2 训练损失](#1.2 训练损失)

[1.3 VAE 的实现](#1.3 VAE 的实现)

[2 生成对抗网络（GAN）​](#2 生成对抗网络（GAN）)

[2.1 概念](#2.1 概念)

[2.2 训练损失](#2.2 训练损失)

[a. 判别器的损失函数](#a. 判别器的损失函数)

[b. 生成器的损失函数](#b. 生成器的损失函数)

[c. 对抗训练的动态过程](#c. 对抗训练的动态过程)

[2.3 GAN 的实现](#2.3 GAN 的实现)

[3 自回归模型（AR）](#3 自回归模型（AR）)

[3.1 概念](#3.1 概念)

[3.2 训练过程](#3.2 训练过程)

[a.核心思想: 用历史预测未来](#a.核心思想: 用历史预测未来)

[b. Transformer 的损失计算：交叉熵监督预测](#b. Transformer 的损失计算：交叉熵监督预测)

[c. 损失计算的具体步骤](#c. 损失计算的具体步骤)

[3.2 代码实现（Transformer-AR）​](#3.2 代码实现（Transformer-AR）)

[4 流模型（Flow）​](#4 流模型（Flow）)

[4.1 概念](#4.1 概念)

[4.2 训练过程](#4.2 训练过程)

[4.2 代码实现（Flow）](#4.2 代码实现（Flow）)

[5 扩散模型（Diffusion）​](#5 扩散模型（Diffusion）)

[5.1 概念](#5.1 概念)

[5.2 训练过程](#5.2 训练过程)

[5.2 代码实现（Diffusion）](#5.2 代码实现（Diffusion）)

[6 小结](#6 小结)

随着Sora、diffusion、GPT等模型的大火，深度生成模型又成为了大家的焦点。

深度生成模型是一类强大的机器学习工具，它可以从输入数据学习其潜在的分布，进而生成与训练数据相似的新的样本数据，它在计算机视觉、密度估计、自然语言和语音识别等领域得到成功应用, 并给无监督学习提供了良好的范式。

本文汇总了常用的深度学习模型，深入介绍其原理及应用：VAE （变分自编码器）、GAN （生成对抗网络）、AR （自回归模型 如 Transformer）、Flow （流模型）和 Diffusion（扩散模型）

模型 核心目标 原理 优点 缺点 应用场景
​VAE 学习潜在空间分布，编码器-解码器生成与训练数据相似的样本 基于变分推断，将输入数据映射到潜在空间的正态分布，解码器重构数据，优化重构误差与KL散度 训练稳定，支持潜在空间插值；生成样本多样化 生成图像模糊；KL散度约束可能导致信息丢失 数据填充、特征提取、图像修复
​GAN 通过生成器与判别器的对抗训练，生成与真实数据难分的样本 生成器从噪声生成假数据，判别器区分真假；两者通过零和博弈优化，最终达到纳什均衡 生成图像细节丰富；单步推理速度快 训练不稳定；生成多样性不足；需精细调参 艺术创作、风格迁移、图像超分辨率
​AR 自回归地生成序列数据，逐个预测下一个元素的概率分布 基于条件概率分解（如Transformer），自注意力机制捕捉长程依赖，逐像素/逐token生成数据 建模能力强，支持长序列生成；训练稳定 生成速度慢 (逐步采样)；高维数据计算成本高 文本生成、时序预测、图像生成
​Flow 可逆变换将简单分布转为复杂数据分布，实现精确概率密度估计 设计可逆神经网络层，利用变量变换公式计算数据对数似然，优化雅可比行列式。 支持精确密度估计；生成与重建可逆 高维数据下变换设计复杂；计算雅可比行列式开销大 语音合成、密度估计、图像生成
​Diffusion 通过逐步去噪过程从高斯噪声重建数据分布，生成高质量样本 正向扩散（逐步加噪）与逆向扩散（学习去噪）结合，基于马尔可夫链建模条件概率 生成质量最高；训练稳定 推理速度慢；显存占用高 高清图像生成、多模态/视频生成

1 变分自编码器（VAE）​

1.1 概念

VAE是在自编码器（A uto-E ncoder）的基础上，结合变分推断（V ariational Inference）和贝叶斯理论提出的一种深度生成模型。VAE 的目标是学习一个能够生成与训练数据相似样本的模型。它假设隐变量服从某种先验分布（如标准正态分布），并通过编码器将输入数据映射到隐变量的后验分布，再通过解码器将隐变量还原成生成样本。

补充

1. 先验分布的概念

假设我们要通过身高预测体重，贝叶斯理论会要求我们先对体重有一个 "初始认知"（比如平均体重 60kg，波动范围 ±10kg）。这个初始认知就是先验分布，它反映了我们在看到具体数据前对某个变量的信念

2. VAE 中的先验设计

在 VAE 中，隐变量（latent variable）z 被假设服从某种简单分布（通常是标准正态分布 N (0,1)）。这就像我们在做图像生成任务时，先假设所有图像的潜在特征（比如形状、颜色）都符合 "常见特征分布"

1.2 训练损失

VAE的训练损失函数包括 重构损失 （如均方误差）和 KL散度（衡量潜在分布与标准正态分布的差异）

损失函数：

  • 重构项：衡量解码器重建输入数据的能力（如均方误差或交叉熵）
  • KL散度项：约束潜在分布 q(z∣x) 与先验分布 p(z)（通常为标准正态分布）的相似性，平衡参数为 β（如 β-VAE）

优化目标：最大化证据下界（ELBO），同时保证潜在空间的结构化和连续性

补充

1. 损失函数的两大核心目标

VAE 的损失函数像一个 "双面裁判"，同时监督两个目标：

  • 重建能力："你生成的图片要和原图差不多！"（重构损失）
  • 规则意识："你不能乱想！生成规则要符合常识！"（KL 散度）

2. 重构损失：像照镜子的误差

  • 作用：确保解码器能把隐变量 z 还原成接近原图的样子。
  • 数学形式 ：
    • 图像任务常用均方误差（MSE）：计算每个像素点的误差平方和。
    • 文本任务常用交叉熵：衡量生成分布与真实分布的差异。

3. KL 散度：用规则约束想象力

  • 作用：强制隐变量 z 的分布接近先验（如正态分布）。
  • 数学意义 ：
    KL 散度 = 0 时，后验分布 q (z|x) 和先验 p (z) 完全一致；数值越大，说明模型越 "不守规矩"。

4. β-VAE：用旋钮调节规则强度

  • β 参数 ：像音量旋钮一样调节 KL 散度的权重。
    • β=0 时：完全不管规则，可能生成奇形怪状的样本（如猫的耳朵长在尾巴上）。
    • β 很大时：过于遵守规则，生成样本千篇一律（所有猫都长一个样）。

5. ELBO：为什么要同时优化这两个目标？

  • ELBO 公式 ：
    ELBO = 重构损失 - KL 散度
    （更准确的数学表达需要结合概率模型，但这里简化理解）
  • 核心逻辑 ：
    模型需要同时做到：
    1. 记住训练数据的特征（重构损失小）
    2. 把这些特征压缩到 "常识空间"（KL 散度小）
      这就像学习绘画时，既要准确临摹（重构），又要符合透视、比例等规则（KL 约束）。

详细介绍：

【VAE学习笔记】全面通透地理解VAE(Variational Auto Encoder)_vae架构-CSDN博客

1.3 VAE 的实现

python 复制代码 
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):
        # 编码：x → μ和logσ²
        h = self.encoder(x)
        mu, log_var = torch.chunk(h, 2, dim=1)  # 分割为均值和方差
        # 采样潜在变量z
        z = self.reparameterize(mu, log_var)
        # 解码：z → 重构x
        x_recon = self.decoder(z)
        return x_recon, mu, log_var

# 损失函数：重构损失 + KL散度
def loss_function(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()) # KL散度
    return recon_loss + kl_div

2 生成对抗网络（GAN）​

2.1 概念

GAN由两部分组成：生成器（Generator） 和 判别器（Discriminator）

  • 生成器的任务是生成尽可能接近真实数据的假数据
  • 判别器的任务是区分输入数据是真实数据还是生成器生成的假数据
  • 二者通过相互竞争与对抗 ，共同进化，最终生成器能够生成非常接近真实数据的样本

训练过程：

  1. 判别器接受真实数据和生成器生成的假数据，进行二分类训练，优化其判断真实或生成数据的能力

  2. 生成器 根据判别器的反馈，尝试生成更加真实的假数据以欺骗判别器

  3. 交替训练判别器和生成器，直到判别器无法区分真实和生成数据，或达到预设的训练轮数

2.2 训练损失

a. 判别器的损失函数

  • 判别器的目标是最大化正确判断的概率：
    • 真实样本：输出 1（正确识别为真）。
    • 生成样本：输出 0（正确识别为假）。
  • 数学表达：
  • 直观解释 ： 判别器的损失是两部分交叉熵的总和 ：
    1. 对真实样本判断错误的惩罚（希望 log D (x) 尽可能大，所以取负号）。
    2. 对生成样本判断错误的惩罚（希望 log (1-D (G (z))) 尽可能大，同样取负号）。

b. 生成器的损失函数

  • 生成器的目标是让判别器误判生成样本为真：
    • 生成样本：让判别器输出 1（即让 D (G (z)) 趋近于 1）。
  • 数学表达：
  • 直观解释： 生成器的损失是判别器误判生成样本的惩罚（希望 log D (G (z)) 尽可能大，所以取负号）。

c. 对抗训练的动态过程

  1. 第一轮训练：

    • 生成器随机生成低质量样本（如模糊的人脸）。
    • 判别器轻松识别真伪，损失很低（因为正确判断了大部分样本）。
    • 生成器的损失很高（因为判别器几乎都识别为假）。

  2. 第二轮训练：

    • 生成器改进造假技术（如生成更清晰的人脸）。
    • 判别器被 "迷惑"，损失上升（因为部分生成样本被误判为真）。
    • 生成器的损失下降（因为判别器误判增多）。

  3. 最终平衡：

    • 生成器能生成足以以假乱真的样本。
    • 判别器无法准确区分真伪，损失趋近于理论下限（交叉熵为 log (0.5)）。

为什么使用交叉熵作为损失？

  • 交叉熵的特性 ：
    它衡量两个概率分布的差异。当判别器对真实样本输出 1、生成样本输出 0 时，交叉熵为 0（理想状态）。
  • 对抗的本质 ：
    生成器希望让判别器的输出分布与 "全 1" 分布更接近（对生成样本），而判别器希望让输出分布与 "真实标签分布" 更接近（对真实样本为 1，生成样本为 0）。

2.3 GAN 的实现

python 复制代码 
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)  # 输出形状为(B, 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))，其中(t)表示序列的当前位置。AR模型可以通过循环神经网络（RNN） 或 Transformer 等结构实现。

如下以 Transformer 为例解析。

在深度学习的早期阶段，卷积神经网络（CNN）在图像识别和自然语言处理领域取得了显著的成功。然而，随着任务复杂度的增加，序列到序列（Seq2Seq）模型和循环神经网络（RNN）成为处理序列数据的常用方法。尽管RNN及其变体在某些任务上表现良好，但它们在处理长序列时容易遇到梯度消失和模型退化问题。为了解决这些问题，Transformer模型被提出。而后的GPT、Bert等大模型都是基于Transformer实现了卓越的性能！

3.2 训练过程

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

自回归模型的核心是根据过去的输出预测未来的输出。例如：

  • 语言模型：根据 "今天天气" 预测下一个词 "很" 或 "热"。
  • 时间序列预测：根据过去 10 天的股价预测第 11 天的股价。

Transformer 作为自回归模型： 它通过注意力机制捕捉序列中每个位置与之前所有位置的依赖关系，最终输出每个位置的预测概率分布。

b. Transformer 的损失计算：交叉熵监督预测

输入与输出的关系
  • 输入序列：例如句子 "我喜欢"。
  • 目标序列：将输入右移一位，得到 "喜欢天"（假设任务是补全句子）。
  • 模型目标：对每个位置，预测下一个词的概率分布。
损失函数的数学表达
  • 直观解释： 交叉熵损失衡量模型预测的概率分布与真实标签的差异。 例如：若真实词是 "天"，而模型预测 "天" 的概率为 0.8，则贡献的损失是 \(-\log(0.8) \approx 0.223\)。

c. 损失计算的具体步骤

  • (1) 嵌入与位置编码

    • 将输入词（如 "我""喜""欢"）转换为向量，并添加位置信息。

  • (2) 因果掩码（Causal Masking）

    • 在自注意力计算时，屏蔽未来信息。例如：预测 "欢" 时，只能看到 "我" 和 "喜"，看不到 "天"。

  • (3) 多头注意力与前馈网络

    • 通过注意力机制整合历史信息，生成每个位置的预测向量。

  • (4) 输出层与概率分布

    • 将预测向量映射到词表的概率分布（如 10000 个词的 softmax 输出）。

  • (5) 计算损失

    • 对比每个位置的预测概率与真实词的 one-hot 编码，累加交叉熵。

为什么使用交叉熵？

  • 分类问题的天然选择：每个位置的预测是多分类任务（选择词表中的一个词）

直观案例：生成句子 "我喜欢晴天"

  • 输入序列：["我", "喜", "欢"]
  • 目标序列：["喜", "欢", "晴"]
  • 损失计算 ：
    1. 预测第一个位置（"我"）的下一个词 "喜"，若正确则损失低
    2. 预测第二个位置（"喜"）的下一个词 "欢"，若正确则继续
    3. 预测第三个位置（"欢"）的下一个词 "晴"，若错误则贡献高损失

训练中的优化技巧

  • 掩码填充（Padding Mask）：忽略输入中的无效填充符号（如 "<pad>"）
  • 学习率调度：使用 warm-up 策略避免初始训练时的不稳定
  • 梯度裁剪：防止长序列反向传播时的梯度爆炸

与 VAE/GAN 损失的对比

模型 损失类型 监督方式
VAE 重构损失 + KL 散度 无监督（仅输入数据）
GAN 对抗损失（交叉熵 / 其他） 无监督（仅输入数据）
Transformer 交叉熵（自回归监督） 有监督（需目标序列）

详细解读： 注意力机制 → Transformer+位置编码(掩码softmax - 查询-键-值（Query-Key-Value，QKV）模式的理解)-CSDN博客

3.2 代码实现（Transformer-AR）​

python 复制代码 
class TransformerAR(nn.Module):
    """基于Transformer的自回归图像生成模型（Pixel Transformer）"""
    def __init__(self, vocab_size=256, embed_dim=128, num_heads=4, num_layers=3):
        super(TransformerAR, self).__init__()
        # 输入：图像展平为序列（如28x28 → 784像素）
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.positional_enc = nn.Parameter(torch.randn(784, embed_dim))  # 位置编码
        # Transformer编码器（仅解码模式）
        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形状：(B, seq_len) 每个位置是像素值（0-255）
        x = self.embedding(x) + self.positional_enc  # 嵌入 + 位置编码
        # 自注意力掩码（防止看到未来信息）
        mask = torch.triu(torch.ones(784, 784), diagonal=1).bool()
        # Transformer处理
        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 概念

算法原理：流模型是一种基于可逆变换的深度生成模型。它通过一系列可逆的变换，将简单分布（如均匀分布或正态分布）转换为复杂的数据分布。

核心思想：用 "可逆魔法" 转换分布 流模型就像一个 "数据变形大师"，它的核心是可逆变换。想象你有一团标准形状的橡皮泥（简单分布，如正态分布），通过一系列可逆向操作的手法（比如拉伸、折叠，但随时能恢复原状），把它捏成跟真实数据（如图像、语音）分布一样复杂的形状。这种 "既能变形，又能变回去" 的特性，就是流模型的关键 ------ 通过可逆函数，让简单分布 "流动" 成复杂数据分布。

**生成过程类比：**假设真实数据是 "猫咪图片" 的分布，流模型先从简单的正态分布中采样一个向量z（像随机选一块标准形状的橡皮泥），然后通过生成器G的一系列可逆变换（比如调整颜色、轮廓等操作），把z变成一张猫咪图片x。因为变换可逆，未来也能通过反向操作，从猫咪图片还原出最初的z。

4.2 训练过程

这里直接放豆包对图中损失函数的解读

4.2 代码实现（Flow）

python 复制代码 
class FlowModel(nn.Module):
    """基于RealNVP的可逆流模型"""
    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）
        x1, x2 = x.chunk(2, dim=1)
        # 计算缩放和偏移参数
        s = self.scale_net(x1)
        t = self.shift_net(x1)
        # 变换x2
        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(z, log_det):
    prior_logprob = -0.5 * (z ​** 2).sum(dim=1)  # 标准高斯先验
    return (-prior_logprob - log_det).mean()

5 扩散模型（Diffusion）​

5.1 概念

Diffusion Model（扩散模型）是一类深度生成模型，它的灵感来源于物理学中的扩散过程。与传统的生成模型（如VAE、GAN）不同，Diffusion Model通过模拟数据从随机噪声逐渐扩散到目标数据的过程来生成数据。这种模型在图像生成、文本生成和音频生成等领域都有出色的表现。

a. 核心思想：模拟 "破坏 - 修复" 的物理过程

  • 扩散模型的灵感来自物理扩散现象，比如墨水滴入水中逐渐扩散
  • 它把这个过程用在数据生成里，分两个阶段：
    • 正向扩散（破坏）：给干净数据（如图像）逐步加噪声，让数据从清晰变模糊，最后接近纯噪声（类似照片被雨水慢慢冲毁）
    • 反向扩散（修复）：从纯噪声出发，一步步去除噪声，恢复成清晰数据（类似修复老照片）通过学习这个过程，模型就能掌握数据的生成规律

b. 与其他模型的区别

  • 传统生成模型（如 VAE、GAN）直接学习生成数据，而扩散模型像 "数据侦探"，通过拆解 "数据如何被噪声破坏" 的过程，反向学会 "如何从噪声还原数据"，生成的内容往往更细腻真实

5.2 训练过程

声。

图中损失函数的核心是衡量 "预测噪声" 与 "真实噪声" 的差距，常用均方误差（MSE）：

  • 逻辑：在正向扩散中，模型知道每个时间步加了多少真实噪声。训练时，U-net 根据带噪样本预测噪声，损失函数要求预测值尽可能接近真实噪声。就像教孩子 "找不同"，每次对比预测结果和真实答案，错得越多，损失越大，模型就会调整参数减少错误。
  • 作用：通过最小化损失，U-net 学会分析带噪数据的特征，最终在反向扩散时，能用预测的噪声逐步还原出清晰数据。
    详细介绍：

超详细的扩散模型（Diffusion Models）原理+代码 - 知乎

5.2 代码实现（Diffusion）

python 复制代码 
class DiffusionModel(nn.Module):
    """基于UNet的扩散模型"""
    def __init__(self, image_size=28, channels=1):
        super(DiffusionModel, self).__init__()
        # 定义噪声预测网络（简化版UNet）
        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
        t = torch.randint(0, self.num_steps, (x0.size(0),))
        # 计算加噪后的xt
        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 小结

最后，简单回顾一下已经简单介绍过的5种常见的深度学习模型：

VAE （变分自编码器）、GAN （生成对抗网络）、AR （自回归模型 如 Transformer）、Flow （流模型）和 Diffusion（扩散模型）

我们可以看到不同模型的优缺点和适用场景：

  • VAE 和GAN是两种常用的深度生成模型，分别基于贝叶斯概率理论和对抗训练来生成样本
  • AR模型则适用于处理具有时序依赖关系的数据，如序列数据
  • Flow 模型和Diffusion模型在生成样本上具有较好的稳定性和多样性，但需要较高的计算成本

最后提供一些潜在的问题和方法：

研究方向 ​核心问题 ​技术路径 ​典型应用场景
​混合架构融合 单一模型难以兼顾生成质量与推理速度 • Diffusion-GAN混合（扩散模型生成质量+GAN推理速度） • VAE-Transformer（压缩编码+序列建模） • 流模型与自回归模型联立训练 • 高保真图像实时生成 • 长视频时序一致性优化
​轻量化 大模型部署资源消耗过高 • 知识蒸馏（教师-学生模型迁移） • 隐式神经表示（INR参数化生成） • 稀疏注意力机制与量化压缩 • 移动端AI绘图APP • 边缘计算设备实时生成
​物理约束嵌入 生成内容违反现实物理规律 • 刚体动力学方程约束（牛顿力学+生成器） • 流体力学PDE求解器集成 • 符号逻辑引导的潜在空间优化 • 科学模拟（气象/材料） • 机器人训练环境生成

部分参考：

数据派THU：必知！5大深度生成模型！

相关推荐
ai大模型木子8 分钟前
嵌入模型（Embedding Models）原理详解：从Word2Vec到BERT的技术演进
人工智能·自然语言处理·bert·embedding·word2vec·ai大模型·大模型资料
普if加的帕2 小时前
java Springboot使用扣子Coze实现实时音频对话智能客服
java·开发语言·人工智能·spring boot·实时音视频·智能客服
KoiC2 小时前
Dify接入RAGFlow无返回结果
人工智能·ai应用
lilye662 小时前
精益数据分析（20/126）：解析经典数据分析框架，助力创业增长
大数据·人工智能·数据分析
盈达科技3 小时前
盈达科技：登顶GEO优化全球制高点，以AICC定义AI时代内容智能优化新标杆
大数据·人工智能
安冬的码畜日常3 小时前
【AI 加持下的 Python 编程实战 2_10】DIY 拓展：从扫雷小游戏开发再探问题分解与 AI 代码调试能力（中）
开发语言·前端·人工智能·ai·扫雷游戏·ai辅助编程·辅助编程
古希腊掌管学习的神3 小时前
[LangGraph教程]LangGraph04——支持人机协作的聊天机器人
人工智能·语言模型·chatgpt·机器人·agent
FIT2CLOUD飞致云3 小时前
问答页面支持拖拽和复制粘贴文件，MaxKB企业级AI助手v1.10.6 LTS版本发布
人工智能·开源
起个破名想半天了3 小时前
计算机视觉cv入门之答题卡自动批阅
人工智能·opencv·计算机视觉
早睡早起吧3 小时前
目标检测篇---Fast R-CNN
人工智能·目标检测·计算机视觉·cnn
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06苍穹外卖面试总结07DeepSeek各版本说明与优缺点分析08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09RAG 实践- Ollama+RagFlow 部署本地知识库10yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）