AE & VAE

vae公式推导+源码

一、AE 自编码器

自编码器模型结构图

编码器网络可以将原始高维网络转换为潜在的低维代码

解码器网络可以从低维代码中恢复原始数据，并且可能具有越来越大的输出层

自编码器针对从代码重建数据进行了显式优化。一个好的中间表示不仅可以捕获潜在变量，而且有利于完整的解压缩过程。

变分编码器和自动编码器的区别就在于：传统自动编码器的隐变量$z$的分布是不知道的，因此我们无法采样得到新的$z$，也就无法通过解码器得到新的$x$。

AE的缺点：映射空间不连续，无规则，无界

VAE将每组数据编码为一个分布

二、AEs 正则自编码器

1. 去噪自编码器

在输入数据时加入噪声，强化特征提取能力

2. 稀疏自编码器

dropout

3. 对抗式自编码器

与GAN网络结合

三、VAE 变分自编码器

变分自编码器模型结构图

1. 数学知识

1.1 贝叶斯公式（Bayes Rule）

公式表述为：
$$p(z|x)=\frac{p(x,z)}{p(x)}=\frac{p(x|z)p(z)}{p(x)}\text{\hspace{1em}(1)}$$

1.2 KL散度

$K-L$ 散度又被称为相对熵（relative entropy），是对两个概率分布间差异的非对称性度量。

假设$p(x)$ ，$q(x)$是随机变量上的两个概率分布，

在离散随机变量的情况下，相对熵的定义为：
$$KL((p(x)||q(x)))=\sum p(x)\log \frac{p(x)}{q(x)}\text{\hspace{1em}(2)}$$
在连续随机变量的情况下，相对熵的定义为：
$$KL((p(x)||q(x)))=\int p(x)\log \frac{p(x)}{q(x)}dx\text{\hspace{1em}(3)}$$

1.3 EM算法

EM算法(期望最大算法)是一种迭代算法，用于含有隐变量的概率参数模型的最大似然估计或极大后验概率估计。具体思想如下：
EM算法的核心思想非常简单，分为两步：Expection-Step和Maximization-Step

E-Step主要通过观察数据和现有模型来估计参数，然后用这个估计的参数值来计算似然函数的期望值

M-Step是寻找似然函数最大化时对应的参数。由于算法会保证在每次迭代之后似然函数都会增加，所以函数最终会收敛。

公式表述为：
$$\ln p_{\theta }(x)=KL(q(z)||p_{\theta }(z|x))+\int q(z)\ln \frac{p_{\theta }(x,z)}{q(z)}dz\text{\hspace{1em}(4)}$$

$$=KL(q(z)||p_{\theta }(z|x))+L_{\theta }(q,x)$$

E-step:用来固定$\theta$，求 $q(z)$:
$$q_{t+1}(z)={\mathrm{argmax}}_q{L}_{{\theta }_t}(q,x)\text{\hspace{1em}(5)}$$

如果$p_{\theta }(z|x))$ 可以得出，则 $q(z)$ 就等于$p_{\theta }(z|x))$ ，如果不能得出，就利用变分推断近似估计 $q(z)$

M-step:用来固定 $q(z)$ ，求 $\theta$:

$${\theta }_{t+1}={\mathrm{argmax}}_{\theta }{L}_{\theta }(q_{t+1},x)\text{\hspace{1em}(6)}$$

1.4 变分推断

参数估计：根据样本中提供的相关信息，对总体分布中的未知参数$z$进行估值

使用贝叶斯估计对未知参数估值：
$$p(z|x)=\frac{p(x,z)}{p(x)}=\frac{p(x|z)p(z)}{p(x)}\text{\hspace{1em}(上述公式1)}$$
其中， $p(x|z)$ 为极大似然估计， $p(z)$ 为最大后验估计。然而贝叶斯估计中的分母 $p(x)$ 一般得不出结果，只能找一个与之相似的函数 $q(z) \approx p(z|x) $ 代替，并通过$K-L$散度求出函数间的近似程度。

目标函数：
$$\min KL((q(z)||p(z|x)))\text{\hspace{1em}(2)}$$
则：

​
$$KL((q(z)||p(z|x)))=\int q(z)\log \frac{q(z)}{p(z|x)}dz=\int q(z)\log \frac{q(z)}{p(x,z)}dz+\ln p(x)\text{\hspace{1em}(3)}$$

$$\ln p(x)=KL((q(z)||p(z|x)))+\int q(z)\log \frac{p(x,z)}{q(z)}dz=KL((q(z)||p(z|x)))+L(q)\text{\hspace{1em}(4)}$$

​

因为 $\ln p(x)$是与$z$无关的常量，并不改变，所以要求的目标函数$\min KL((q(z)||p(z|x)))$ 相当于$\max L(q)$ ，而变分贝叶斯学习可以通过 $q(z)$ 的迭代实现 $L(q)$ 的最大化，即$ELBO$变分下界，则：
$$\max L(q)=\int q(z)\log p(x,z)dz-\int q(z)\log q(z)dz\text{\hspace{1em}(5)}$$
平均场理论：变分分布$q(z)$可以因式分解为$M$个互不相交的部分
$$q(z)=\prod _{i=I}^M{q}_i\text{\hspace{1em}(6)}$$
则：

$$ELBO=\max L(q)=\int q(z)\log \frac{p(x,z)}{q(z)}dz\text{\hspace{1em}(7)}$$

$$={\int }_z\prod _{i=1}^M{q}_i[\log p(x,z)-\log \prod _{k=1}^M{q}_k]dz$$

$$={\int }_z{q}_j[\prod _{i\ne j}^M{q}_i\log p(x,z)]dz-{\int }_z\prod _{i=0}^M{q}_i\sum _{k=1}^M\log q_{k}dz$$

分别对➖左右进行计算
$$Left={\int }_z{q}_j[\prod _{i\ne j}^M{q}_i\log p(x,z)]dz\text{\hspace{1em}(8)}$$

$$={\int }_{z_j}{q}_j[{\int }_{z_{i\ne j}}\prod _{i\ne j}{q}_i\log p(x,z)d{z}_{i\ne j}]d{z}_j$$

$$={\int }_{z_j}{q}_j{\mathbb{E}}_{i\ne j}[\log p(x,z)]d{z}_j$$

$$Right={\int }_z\prod _{i=0}^M{q}_i\sum _{k=1}^M\log q_{k}dz+C1\text{\hspace{1em}(9)}$$

$$={\int }_{z_j}{q}_j\log q_{j}d{z}_j\prod _{i\ne j}{\int }_{z_i}{q}_{i}d{z}_i+C1$$

$$={\int }_{z_j}{q}_j\log q_{j}d{z}_j+C1$$

其中：$C1=-{\int }_z{\prod }_{i=0}^M{q}_i\sum i\ne j\log q_{j}dz$

同时，令$\log \tilde{p}(x,z_j)={\mathbb{E}}_{i\ne j}[\log p(x,z)]+C2$ ($C2$用于归一化，等式左边对一个概率取对数，因此需要保证概率的性质)

则$ELBO$最终化为：
$$ELBO={\int }_{z_j}{q}_j{\mathbb{E}}_{i\ne j}[\log p(x,z)]d{z}_j-{\int }_{z_j}{q}_j\log q_{j}d{z}_j-C1\text{\hspace{1em}(10)}$$

$$={\int }_{z_j}{q}_j\log \frac{\tilde{p}(x,z_j)}{q_j}d{z}_j+C3$$

$$=-KL(q_j||\tilde{p}(x,z_j))+C3$$

则当$q_j\to \tilde{p}(x,z_j)$时，$ELBO$最大，即$L(q)$取最大值
$$\log q_j(z_j)=\log \tilde{p}(x,z_j)\text{\hspace{1em}(11)}$$

$$={\mathbb{E}}_{i\ne j}[\log p(x,z)]+C2$$

则：
$$q_j(z_j)=\exp ({\mathbb{E}}_{i\ne j}[\log p(x,z)]+C2)\text{\hspace{1em}(12)}$$

$${\int }_{z_j}{q}_j(z_j)d{z}_j=\exp (C2){\int }_{z_j}\exp ({\mathbb{E}}_{i\ne j}[\log p(x,z)])d{z}_j$$

可以求出：
$$C2=\log \frac{1}{{\int }_{z_j}\exp ({\mathbb{E}}_{i\ne j}[\log p(x,z)])d{z}_j}\text{\hspace{1em}(13)}$$
返回带入公式12，得出：
$$q_j(z_j)=\frac{\exp ({\mathbb{E}}_{i\ne j}[\log p(x,z)])}{{\int }_{z_j}\exp ({\mathbb{E}}_{i\ne j}[\log p(x,z)])d{z}_j}\text{\hspace{1em}(14)}$$

2. 公式推导

参数	含义	数学表示	含义
$x$	观测数据	$q_{\varphi }(z|x)/q_{\varphi }z$	使用变分参数 $\varphi$ 来近似真实后验 $p_{\theta }(z|x)$
$z$	隐变量	$p_{\theta }(z|x)$	给定数据 $x$ 后隐变量 $z$ 的真实后验分布
$\varphi$	变分参数(近似后验分布的参数)	$p_{\theta }(x,z)$	生成数据 $x$ 和隐变量 $z$ 的联合概率分布
$\theta$	生成模型的参数	$p_{\theta }(x|z)$	给定隐变量 $z$ 后数据 $x$ 的条件概率分布

在变分自编码器（VAE）的推导过程中，我们使用变分推断来近似真实后验分布，并且通过优化目标函数来学习生成模型的参数。

推导过程

1. 目标：最大化数据的对数似然

   变分自编码器的目标是最大化观测数据 $x$ 的对数似然，即：
   $$\log p_{\theta }(x)\text{\hspace{1em}(1)}$$
   由于计算 $p_{\theta }(x)$ 直接计算非常困难，我们通过引入隐变量 $z$ 和变分推断来简化。

2. 引入隐变量

   根据隐变量的定义，我们可以将对数似然分解为：
   $$\log p_{\theta }(x)=\log {\int }_z{p}_{\theta }(x,z)dz\text{\hspace{1em}(2)}$$

3. 应用变分下界（ELBO）

   为了优化这个目标，我们引入变分分布 $q_{\varphi }(z|x)$ 来近似真实后验分布 $p_{\theta }(z|x)$。通过引入变分分布，我们可以使用变分下界（Evidence Lower Bound, ELBO）来逼近对数似然。ELBO 的推导如下：
   $$\log p_{\theta }(x)=\log {\int }_z{p}_{\theta }(x,z)dz\text{\hspace{1em}(3)}$$
   引入变分分布 $q_{\varphi }(z|x)$：
   $$\log p_{\theta }(x)=\log {\int }_z\frac{q_{\varphi }(z|x)}{q_{\varphi }(z|x)}{p}_{\theta }(x,z)dz\text{\hspace{1em}(4)}$$

   使用对数的变换性质：
   $$\log p_{\theta }(x)=\log \left[{\int }_z{q}_{\varphi }(z|x)\frac{p_{\theta }(x,z)}{q_{\varphi }(z|x)}dz\right]$$

   应用对数-期望的变换：
   $$\log p_{\theta }(x)\ge {\mathbb{E}}_{q_{\varphi }(z|x)}\left[\log p_{\theta }(x,z)-\log q_{\varphi }(z|x)\right]\text{\hspace{1em}(5)}$$

   这个期望值被称为变分下界（ELBO）：
   $$\text{ELBO}={\mathbb{E}}_{q_{\varphi }(z|x)}\left[\log p_{\theta }(x,z)-\log q_{\varphi }(z|x)\right]\text{\hspace{1em}(6)}$$
   其中：
   $$\text{ELBO}={\mathbb{E}}_{q_{\varphi }(z|x)}\left[\log p_{\theta }(x|z)\right]-\text{KL}(q_{\varphi }(z|x)||p_{\theta }(z))\text{\hspace{1em}(7)}$$
   这里，KL 散度（Kullback-Leibler divergence）是：
   $$\text{KL}(q_{\varphi }(z|x)||p_{\theta }(z))={\int }_z{q}_{\varphi }(z|x)\log \frac{q_{\varphi }(z|x)}{p_{\theta }(z)}dz\text{\hspace{1em}(8)}$$

4. 优化目标

   最终的目标是最大化 ELBO，从而间接最大化对数似然。通过优化变分参数 $\varphi$ 和生成参数 $\theta$，使得 ELBO 最大化，即可获得最优的模型参数。

5. 总结

   • 近似后验 $q_{\varphi }(z|x)$：通过变分推断来近似真实后验。
   • 真实后验 $p_{\theta }(z|x)$：目标是通过优化得到近似。
   • 生成模型 $p_{\theta }(x,z)$：模型定义生成数据的过程。
   • 条件概率分布 $p_{\theta }(x|z)$：表示给定隐变量 $z$ 的情况下数据 $x$ 的分布。

VAE 的关键在于利用 ELBO 来进行模型优化，通过最大化 ELBO 来逼近真实对数似然，从而获得高效的生成模型。

3. 代码实现

以下为基于pytorch的代码实现：
vae.py

import torch
from torch import nn
import torch.nn.functional as F

class VAE(nn.Module):

    def __init__(self):
        super(VAE, self).__init__()

        # 编码器所用的结构
        self.fc1 = nn.Linear(784, 200)
        self.fc2_mu = nn.Linear(200, 20) # 用于生成高斯分布的均值
        self.fc2_log_std = nn.Linear(200, 20) # 用于生成高斯分布的方差，且为方便计算默认方差是经过log函数处理的。

        # 解码器所用的结构
        self.fc3 = nn.Linear(20, 200)
        self.fc4 = nn.Linear(200, 784)

    def encoder(self, x):
        h1 = F.relu(self.fc1(x))
        mu = self.fc2_mu(h1)  # 生成均值
        logvar = self.fc2_log_std(h1) # 生成经过log处理的方差
        return mu, logvar

    def decoder(self, z):
        h3 = F.relu(self.fc3(z))
        recon = torch.sigmoid(self.fc4(h3)) # 之所以用sigmoid是因为本例用到的图像默认像素值为0-1之间。
        return recon

    def reparametrize(self, mu, logvar):
        var = torch.exp(logvar)  # 因为生成的方差是经过log处理的，所以真正要用到方差的时候要再把它经过exp处理一下。
        eps = torch.randn_like(var) # 在标准正态分布中采样
        z = mu + eps * var  # 获得抽取的z
        return z

    def forward(self, x):
        mu, logvar = self.encoder(x)
        z = self.reparametrize(mu, logvar)
        recon = self.decoder(z)
        return recon, mu, logvar # 返回重构的图，均值，log后的方差

    def loss_function(self, recon, x, mu, logvar):
        recon_loss = F.mse_loss(recon, x, reduction="sum") 
        kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
        loss = recon_loss + kl_loss
        return loss

vae_main.py

import torch
from torch import optim
from torch.autograd import Variable
from torch.utils.data import DataLoader
import torch.nn.functional as F
from torchvision import transforms
from torchvision.utils import save_image
from torchvision.datasets import MNIST
import os
import datetime
from vae import VAE

if not os.path.exists('./vae_img'):
    os.mkdir('./vae_img')

def to_img(x):
    x = x.clamp(0, 1)  # torch.clamp(input,min,max) 把输入的张量加紧到指定区间内
    x = x.view(x.size(0), 1, 28, 28)  # batch，channel,w,h
    return x


num_epochs = 300
batch_size = 128

img_transform = transforms.Compose([
    transforms.ToTensor()
    # transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
])

dataset = MNIST('./data', transform=img_transform, download=True)
datalodader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

start_time = datetime.datetime.now()
model = VAE()
if torch.cuda.is_available():
    print('cuda is ok!')
    model = model.to('cuda')
else:
    print('cuda is no!')

# loss_function = VAE.loss_function
optimizer = optim.Adam(model.parameters(), lr=1e-4)

for epoch in range(num_epochs):
    model.train()
    train_loss = 0
    for batch_idx, data in enumerate(datalodader):
        img, _ = data
        img = img.view(img.size(0), -1)  # 把图像拉平
        img = Variable(
            img)  # tensor不能求导，variable能（其包含三个参数，data：存tensor数据，grad：保留data的梯度，grad_fn：指向function对象，用于反向传播的梯度计算）但我印象中好像tensor可以求梯度 见13讲
        img = (img.cuda() if torch.cuda.is_available() else img)
        optimizer.zero_grad()
        recon_batch, mu, logvar = model(img)

        # 计算损失函数
        recon_loss = F.mse_loss(recon_batch, img, reduction="sum")  # use "mean" may have a bad effect on gradients
        kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
        # kl_loss = torch.sum(kl_loss)
        loss = recon_loss + kl_loss

        # loss = VAE.loss_function(recon_batch, img, mu, logvar)
        loss.backward()
        train_loss += loss.item()
        optimizer.step()
        # if batch_idx % 100 == 0:
        #     end_time = datetime.datetime.now()
        #     print('Train Epoch: {} [{}/{}({:.0f}%]   Loss:{:.6f} time:{:.2f}s'.format(
        #         epoch,
        #         batch_idx * len(img),
        #         len(datalodader.dataset),
        #         (batch_idx * len(img)) / (len(datalodader.dataset)),
        #         loss.item() / len(img),
        #         (end_time - start_time).seconds
        #     ))
    print('====> Epoch: {} Average loss: {:.4f}'.format(
        epoch, train_loss / len(datalodader.dataset)
    ))

    if epoch % 2 == 0:
        # 生成图像
        if torch.cuda.is_available():
            device = 'cuda'
        else:
            device = 'cpu'
        z = torch.randn(batch_size, 20).to(device)
        out = model.decoder(z).view(-1, 1, 28, 28)
        # print(out)
        # print(type(out))
        save_image(out, './vae_img/sample-{}.png'.format(epoch))

        # 重构图像
        # recon_batch = model.encoder(img).to(device)
        save = to_img(recon_batch.cpu().data)
        # print(save)
        # print(type(save))
        save_image(save, './vae_img/image_{}.png'.format(epoch))

torch.save(model.state_dict(), './vae_weight/vae.pth')

实现结果如下：
image.png（原生） 对比 sample.png（生成）