生成模型：变分自编码器-VAE

1.基本概念

1.1 概率

这里有：

1. x为真实图像，开源为数据集, 编码器将其编码为分布参数
2. $\hat{x}$为生成图像, 通过解码器获得
3. $\widehat{p(x)}$: 观测数据的分布, 即数据集所构成的经验分布
4. $p_{real}(x)$: 真实世界的数据分布，这个是最理想的情况
5. $p(x)$:生成模型的分布，目的是接近$p_{real}(x)$，避免过拟合到$\widehat{p(x)}$
6. $z\sim \mathcal{N}(\mu ,\sigma {)}^2$ :潜空间向量, 通常希望约束于正态分布
7. $p(z)$：先验分布，即假设分布，在 VAE 中通常假设为标准正态分布
8. $q_{\varphi }(z\mid x)$: 后验分布，是一种近似分布以逼近目标分布。依赖输入数据x，预测潜向量分布，即编码器
9. $p_{\theta }(x\mid z)$: 条件分布，通过z生成x，即解码器

KL散度, 衡量分布相似性：

• 当 $q_{\varphi }(z\mid x)=p(z)$, 散度为 0，表示两个分布完全一致。

• $q_{\varphi }(z\mid x)\ne p(z)$ 时，散度为正，值越大表示分布之间的差异越大。

KL 散度用于约束编码器生成的后验分布 $q_{\varphi }(z\mid x)$ 接近先验分布 $p(z)$

1.2 模型

VAE与普通自编码器区别如下：

• 普通自编码器（AE） 会直接将 x映射到一个固定的潜向量z
• 变分自编码器（VAE） 则通过学习概率分布的参数（均值 $\mu (x)$，方差 ${\sigma }^2(x)$ 来学习一个潜在分布$q_{\varphi }(x|z)$，

VAE训练一个自编码器, 目标是生成潜空间的分布参数，即潜向量z的均值和方差，而不是z本身。

因为学习的是一个分布参数，z具有随机性，即 x 和 z 不是一一对应的，是一对多的关系，

其设计原因分析如下：

1.数据分布复杂：真实世界中的非结构化数据分布是及其复杂且多样的。如果每个
x都严格映射到一个z,则潜在空间无法表达数据的多样性，数据映射的z存在随机性。

2.有助于模型泛化: 学习一个分布近似分布而不是固定映射。在生成任务中，随机采样z具有多样性，而不仅仅是直接复现训练数据, 适应未见过的数据。

2.方法

2.1 编码器-E

E将输入数据映射为潜在空间的概率分布参数： 均值 $\mu$ 与 方差${\sigma }^2$。

$\mu$ 和 ${\sigma }^2$ 分别代表潜空间向量的各元素均值和方差。

这里假定$q$是可以通过学习参数$\theta$学到，公式如下：

$\mathcal{N}(z;\mu (x),{\sigma }^2(x))$

表示z服从正态分布，其均值为 $\mu (x)$$

即$q_{\theta }$用编码器E来学习:

$E(x) = \mu(x), \sigma^2(x), z \sim ( \mu(x), \sigma^2(x)) $

2.2 解码器-D

D的目的是，输入潜向量 z，重构输入数据 x, 得到 $\hat{x}$

• 重参数化

由于分布输出的z是随机采样，存在不确定性，这里在送入D前重参数化:

$z=u+\sigma \cdot ϵ,ϵ\sim \mathcal{N}(0,1)$

即z是一个确定的函数，将随机性与模型参数$\mu ,\sigma$分离。

再送入解码器：

$\hat{x}=D(z)$

2.3 训练

VAE是将E和D作为一个整体训练（即整个自编码器）, 损失函数如下：

${\mathcal{L}}_{\text{VAE}}={\mathbb{E}}_{z\sim q_{\varphi }(z|x)}\left[-\log p_{\theta }(x|z)\right]+D_{\text{KL}}(q_{\varphi }(z|x)\parallel p(z))$

简化为:

${\mathcal{L}}_{\text{VAE}}$ = 重构损失 + KL散度

2.3.1 重构损失

表示在潜向量z按照近似后验分布 $q_{\varphi }(z\mid x)$采样时，模型重构数据$\hat{x}$的对数似然期望值:

$-{\mathbb{E}}_{z\sim q_{\varphi }(z\mid x)}\left[\log p_{\theta }(x\mid z)\right]$

这里加了负号，即最大化重构概率转为损失值最小化。

直观理解：

1.编码器$q_{\varphi }(z|x)$为每个输入数据x提供一组潜向量z的分布参数。

2.解码器$p_\theta(x|z)尝试根据z重构原始数据x。

3.对${\log }_{\theta }(x|z)$取期望值，是对不同z的采样重构结果进行平均。

如果解码器能很好地重构x,${\log }_{\theta }(x|z)$值就大，相反就小。

• 如果是二值像素, 即0 和 1。可以用交叉熵，即BCE（Binary Cross Entropy）

即判断像素值接近 0 还是接近 1：

$\text{BCE}=-\frac{1}{N}{\sum }_{i=1}^N\left[x_i\log ({\hat{x}}_i)+(1-x_i)\log (1-{\hat{x}}_i)\right]$

• 如果是[0,255],或者归一化为[0,1],[-1,1]的像素，可以用MSE

$\text{MSE}=\frac{1}{N}{\sum }_{i=1}^N(x_i-{\hat{x}}_i{)}^2$

2.3.2 KL散度

KL 散度的定义：

$D_{\text{KL}}(q_{\varphi }(z|x)\parallel p(z))={\mathbb{E}}_{q_{\varphi }(z|x)}\left[\log \frac{q_{\varphi }(z|x)}{p(z)}\right]$

展开：

$D_{\text{KL}}={\mathbb{E}}_{z\sim q_{\varphi }(z|x)}\left[-\log p_{\theta }(x|z)+\log \frac{q_{\varphi }(z|x)}{p(z)}\right]$

进一步分解为：

$D_{\text{KL}}=-\frac{1}{2}{\sum }_{i=1}^d\left(1+\log {\sigma }_i^2-{\mu }_i^2-{\sigma }_i^2\right)$

3.代码实现

训练VAE生成手写数字。

3.1 参数设置

• 模型：极简的7层全连接自编码器（E-4层， D-3层）

• 数据集：pytorch自带的mnist手写数据集，每个样本像素为单通道 [28,28]

• epoch: 50次

• batch-size：64

• learing-rate：1e-3 或 5e-4

3.2 代码概述

• 导入必要的库

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

• 编码器：将输入数据映射为潜在变量 z 的均值 $\mu$ 和方差 ${\sigma }^2$
• 解码器：从潜在变量 z 重构原始数据

class VAE(nn.Module):
    def __init__(self, input_dim, latent_dim):
        super(VAE, self).__init__()
        # 编码器
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU()
        )
        self.fc_mu = nn.Linear(256, latent_dim)  # 均值
        self.fc_logvar = nn.Linear(256, latent_dim)  # 对数方差

        # 解码器
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, input_dim),
            nn.Sigmoid()  # 用 Sigmoid 将输出值压缩到 [0, 1]
        )

    def reparameterize(self, mu, logvar):
        """使用重参数化技巧生成潜在变量 z"""
        std = torch.exp(0.5 * logvar)  # 标准差
        eps = torch.randn_like(std)    # 标准正态分布的随机噪声
        return mu + eps * std

    def forward(self, x):
        # 编码
        h = self.encoder(x)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)

        # 重参数化
        z = self.reparameterize(mu, logvar)

        # 解码
        recon_x = self.decoder(z)
        return recon_x, mu, logvar

• 损失函数

def vae_loss(recon_x, x, mu, logvar):
    # 重构误差（BCE）
    recon_loss = nn.functional.binary_cross_entropy(recon_x, x, reduction='sum')

    # KL 散度
    kl_div = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())

    return recon_loss + kl_div

• 数据加载和超参数设置

# 超参数
latent_dim = 20  # 潜在空间维度
input_dim = 28 * 28  # MNIST 图像大小
batch_size = 64
epochs = 50
lr = 0.001

# 数据加载器
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

• 训练 VAE, 先初始化模型和优化器

vae = VAE(input_dim=input_dim, latent_dim=latent_dim).to('cuda')
optimizer = optim.Adam(vae.parameters(), lr=lr)

for epoch in range(epochs):
    vae.train()
    total_loss = 0

    for images, _ in dataloader:
        # 预处理数据
        images = images.view(-1, input_dim).to('cuda')

        # 前向传播
        recon_images, mu, logvar = vae(images)

        # 计算损失
        loss = vae_loss(recon_images, images, mu, logvar)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item()

    print(f"Epoch [{epoch+1}/{epochs}] Loss: {total_loss / len(dataloader.dataset):.4f}")

• 生成新样本时，只需要随机从潜在空间中采样z，然后通过解码器生成数据：

vae.eval()
with torch.no_grad():
    # 从标准正态分布采样
    z = torch.randn(256, latent_dim).to('cuda')  # 16x16 = 256 个样本
    generated_images = vae.decoder(z).view(-1, 1, 32, 32).cpu()

    # 创建 16x16 的网格
    grid = torchvision.utils.make_grid(generated_images, nrow=16, normalize=True)

    # 保存生成的图像为文件
    torchvision.utils.save_image(grid, 'generated_images.png', normalize=True)

    # 显示图像
    plt.imshow(grid.permute(1, 2, 0))
    plt.axis('off')  # 去除坐标轴
    plt.show()

4.实验结果

4.1 损失函数

损失函数值有效下降,在数据集迭代34次（ep33）后下降约一半：

4.2 最终效果

• epoch-1:

• epoch-12:

• epoch-33:

5.概率相关补充

5.1 条件概率-贝叶斯定理

$p(x,z)=p(x|z)p(z)$

$p(z\mid x)=\frac{p(x,z)}{p(x)}=\frac{p(x\mid z)p(z)}{p(x)}$

5.2 KL散度函数：

$D_{KL}(q(z|x)\parallel p(z))={\mathbb{E}}_{q(z|x)}\left[\log \frac{p(z)}{q(z|x)}\right]=\int q(z|x)\log \frac{q(z|x)}{p(z)}dz={\sum }_{z}q(z|x)\log \frac{q(z|x)}{p(z)}$

KL衡量一个分布相对于另一个分布的信息损失或“距离”，是一个正数：

证明可利用：

$\log x\le x-1,\forall x>0$

给log内分数上负号，颠倒分子分母，则：

${\sum }_{z}q(z|x)\log \frac{p(z)}{q(z|x)}\le {\sum }_z-\frac{p(z)}{q(z|x)}<0$

5.3 概率密度函数:

$p(z)\sim \mathcal{N}(0,1)$:

$p(z)=\frac{1}{(2\pi {)}^{d/2}}\exp \left(-\frac{1}{2}{\sum }_{i=1}^d{z}_i^2\right)$

注：d是维度

$p(z)\sim \mathcal{N}(\mu ,\sigma )$:

$q(z|x)=\frac{1}{(2\pi {)}^{d/2}|\Sigma {|}^{1/2}}\exp \left(-\frac{1}{2}{\sum }_{i=1}^d\frac{(z_i-{\mu }_i{)}^2}{{\sigma }_i^2}\right);\Sigma =diag({\sigma }_1^2,...,{\sigma }_d^2)$

也可以写成这样：

$q(z|x)=\frac{1}{(2\pi {)}^{d/2}{\sigma }_1{\sigma }_2\cdots {\sigma }_d}\exp \left(-\frac{1}{2}{\sum }_{i=1}^d\frac{(z_i-{\mu }_i{)}^2}{{\sigma }_i^2}\right)$

Ref

• Auto-Encoding Variational Bayes / Variational autoencoder
• https://arxiv.org/abs/1312.6114
• https://www.zhihu.com/question/579890053/answer/38625999761

本文全部代码：

• https://github.com/disanda/GM.git