自编码器（autoencoder）

这篇文章介绍了自编码器（autoencoder），分享给大家做个参考，收藏Python资料网收获更多编程知识

1.自编码器的由来

最初的自编码器是用来降维的，后来也逐渐用于去噪、生成任务。

2.自编码器的基本结构

自编码器（autoencoder）内部有一个隐藏层 h，可以产生编码（code）表示输入。该网络可以看作由两部分组成：一个由函数 $h=f(x)$ 表示的编码器和一个生成重构的解码器$r=g(h)$，整体结构如下图所示：

自编码器通过内部表示或编码 h 将输入 x 映射到输出（称为重构）r。自编码器具有两个组件：编码器 f （将 x 映射到 h）和解码器 g（将 h 映射到 r）。映射关系可以分别表示为 p e n c o d e r ( h ∣ x ) p_{encoder}(h|x) pencoder​(h∣x)、 p d e c o d e r ( r ∣ h ) p_{decoder}(r|h) pdecoder​(r∣h)。

3.自编码器的一些基本概念

3.1欠完备与过完备

①欠完备自编码器：h维度<x维度。
学习欠完备的表示将强制自编码器捕捉训练数据中最显著的特征。“学习欠完备的表示”意味着编码器被设计成只能生成比输入数据更简单、更压缩的表示。举一个简单的例子：
假设你有一堆猫和狗的图片。一个没有任何限制的自编码器可能会尝试记住每张图片的所有细节（毛色、背景等等）。但是，如果我们限制自编码器只能生成非常简化的表示，它就会被迫关注猫和狗最明显的特征，比如猫的尖耳朵和狗的长尾巴，而忽略背景和毛色等次要特征。

②过完备自编码器：h维度>=x维度。
过完备则与欠完备相反。“过完备”意味着编码器的表示空间非常大，能够容纳甚至超过输入数据中的所有信息。举一个简单的例子：
假设你有一堆猫和狗的图片。一个过完备自编码器可能会记住每张图片的所有细节，包括背景、毛色、姿态等等。这使得它在训练数据上表现非常好，但在遇到新的猫狗图片时，可能无法很好地识别出它们的共同特征。
在过完备的情况下，可能会出现编码器无法学习到有效信息的情况。这是因为：当编码维数与输入维数相等或更大时，自编码器的表示空间非常大，足以容纳输入数据中的所有信息。在这种情况下，甚至简单的线性编码器和解码器也可以直接将输入复制到输出，而不需要提取任何有用的特征。这意味着自编码器没有被迫去学习数据的分布特征，因为它可以简单地记住所有的数据。这种记忆机制使得模型在训练数据上表现很好，但在面对新数据时可能表现很差，因为它没有学到数据的内在模式或结构。

3.2自编码器的目的与损失函数

自编码器的目的是得到编码后的有效表示h，而这种目的是通过尝试将网络输入复制到输出来实现的。所以自编码器最简单的损失函数如下：
$loss=L(x,g(f(x)))$，其中L就表示一个函数，如L2范数。

3.3自编码器的正则化

3.2中提到自编码器是通过输入输出的loss来达到有效表示h的目的，而当过完备时，编码器又可能无法学习到有效的h。所以有了自编码器的正则化，使得过完备时网络仍能得到有效的h。举个例子：
比如在稀疏自编码器中，损失函数修改为$L(x,g(f(x)))+\Omega (h)$，针对h稀疏特性而增加了$\Omega (h)$部分。虽然引入稀疏性惩罚项 Ω(ℎ)会导致稀疏自编码器的复制动作变差，即重构误差可能增加，但这种修改能够迫使模型学习到更加有用的特征，提高模型在后续任务中的性能和泛化能力。这种权衡在实际应用中通常是有益的。

4.多种自编码器

自编码器可以分为以下几种：
下面介绍几种常见的自编码器。

4.1 传统自编码器（AE）

AE的网络结构如下：包含三层——输入层、隐藏层、输出层，每一层都是由若干个神经元组成的。

上面的网络可以表示为
①编码：输入层+隐藏层
h = f ( x ) = f ( W 1 X + b 1 ) h = f (x) = f (W_1X + b_1) h=f(x)=f(W1​X+b1​)。 W 1 W_1 W1​表示神经元的权重， b 1 b_1 b1​表示神经元的偏置。
②解码：隐藏层+输出层
X d = g ( x ) = g ( W 2 h + b 2 ) X^d = g(x) = g(W_2h + b_2) Xd=g(x)=g(W2​h+b2​)。
③损失函数
用$\theta$表示网络的权重和偏置参数，则损失函数为：
J A E ( θ ) = J ( X , X d ) = − ∑ i = 1 n ( x i log ⁡ ( x i d ) + ( 1 − x i ) log ⁡ ( 1 − x i d ) ) J_{AE}(\theta)=J(X,X^{d})=-\sum_{i=1}^{n}(x_{i}\log(x_{i}^{d})+(1-x_{i})\log(1-x_{i}^{d})) JAE​(θ)=J(X,Xd)=−∑i=1n​(xi​log(xid​)+(1−xi​)log(1−xid​))
采用梯度下降法即可进行训练。
此外，为了控制权重降低的程度，防止自编码器的过拟合，将在上述损失函数中加入正则化项(也称重量衰减项)，变为正则化自编码器。
J R e A E ( θ ) = J ( X , X d ) + λ ∥ W ∥ 2 2 J_{\mathrm{ReAE}}(\theta)=J(X,X^{d})+\lambda\parallel W\parallel_{2}^{2} JReAE​(θ)=J(X,Xd)+λ∥W∥22​
通过约束网络权重从而间接使得隐藏层神经元稀疏，提高了整个自编码器模型的泛化性。

4.2 去噪自编码器（DAE）

DAE的网络结构如下，AE的目的是求h，但它没有使用h的真实值来训练，所以是无监督的。而DAE的目的是使得网络能够进行去噪，目的是求X，但它用到了X真实值做loss，所以他是监督学习。

DAE的动机是主动给X加噪，使得网络带有去噪的能力。但是在每次网络训练之前，人为地在干净的输入信号中加入噪声，增加了模型的处理时间。而且，如果加入过多的噪声，会导致输入样本的严重失真，从而降低算法的性能。

4.3稀疏自编码器（SAE）

稀疏自编码器利用了X的先验信息，这个先验信息就是X的稀疏度。它的网络结构和AE没有什么区别，但是损失函数变了，添加了一项KL散度，是编码后h的稀疏度和真实稀疏度之间的散度。其中$\beta$是控制稀疏惩罚的系数，为0~1.
J S A E ( θ ) = J ( X , X d ) + β ∑ j = 1 t K L ( ρ ∥ ρ ^ j ) J_{SAE}(\theta)=J(X,X^d)+\beta\sum_{j=1}^tKL(\rho\parallel\hat{\rho}_j) JSAE​(θ)=J(X,Xd)+β∑j=1t​KL(ρ∥ρ^​j​)
首先定义每个隐藏单元$j$的平均激活值 ρ ^ j : \hat{\rho}_j: ρ^​j​:
ρ ^ j = 1 n ∑ i = 1 n h j ( x i ) \hat{\rho}_j=\frac{1}{n}\sum_{i=1}^nh_j{(x_i)} ρ^​j​=n1​i=1∑n​hj​(xi​)
其中，$n$是训练样本数量， h j ( x i ) h_j{(x_i)} hj​(xi​)是第$i$个样本对于隐藏单元$j$的激活值。
然后定义目标稀疏度$\rho$,这是希望隐藏单元的平均激活值。例如，如果$\rho$较小(如0.05),则希望大多数隐藏单元在任何给定时间都不活跃。
最后，将稀疏惩罚项加入到损失函数中，使用KL散度来衡量目标稀疏度和实际稀疏度之间的差异：
K L ( ρ ∣ ∣ ρ ^ j ) = ρ log ⁡ ρ ρ ^ j + ( 1 − ρ ) log ⁡ 1 − ρ 1 − ρ ^ j \mathrm{KL}(\rho||\hat{\rho}_j)=\rho\log\frac{\rho}{\hat{\rho}_j}+(1-\rho)\log\frac{1-\rho}{1-\hat{\rho}_j} KL(ρ∣∣ρ^​j​)=ρlogρ^​j​ρ​+(1−ρ)log1−ρ^​j​1−ρ​
稀疏惩罚项的总和是所有隐藏单元的KL散度之和：
∑ j = 1 t K L ( ρ ∣ ∣ ρ j ^ ) \sum_{j=1}^{t}\mathrm{KL}(\rho||\hat{\rho_j}) j=1∑t​KL(ρ∣∣ρj​^​)
KL散度是描述两个分布之间差异的指标，KL散度越小，分布越接近，具体公式如下：
K L ( ρ ∥ ρ ^ j ) = ρ log ⁡ ρ ρ ^ j + ( 1 − ρ ) log ⁡ 1 − ρ 1 − ρ ^ j KL(\rho\parallel\hat{\rho}_j)=\rho\log\frac{\rho}{\hat{\rho}_j}+(1-\rho)\log\frac{1-\rho}{1-\hat{\rho}_j} KL(ρ∥ρ^​j​)=ρlogρ^​j​ρ​+(1−ρ)log1−ρ^​j​1−ρ​

4.4 收缩自编码器（CAE）

这里的收缩指的是在学习过程中对隐藏层表示进行收缩，使得隐藏层表示对输入数据的小变化不敏感，从而增强模型的鲁棒性和特征提取能力。
使得隐藏层表示对输入数据的小变化不敏感？也就是说X变化，h不变或变化很小，如果这种关系用导数关系来表示，h对X的一阶导应该越小越好，所以有如下损失函数，同样通过系数$\lambda$来控制收缩。
J C A E ( θ ) = J ( X , X d ) + λ ∥ J f ( x ) ∥ F 2 J_{CAE}(\theta)=J(X,X^d)+\lambda\parallel J_f(x)\parallel_F^2 JCAE​(θ)=J(X,Xd)+λ∥Jf​(x)∥F2​
其中， ∥ J f ( x ) ∥ F 2 = ∑ j = 1 t ∑ i = 1 n ( ∂ h j ( x ) ∂ x i ) 2 \parallel J_f(x)\parallel_F^2=\sum_{j=1}^t\sum_{i=1}^n(\frac{\partial h_j(x)}{\partial x_i})^2 ∥Jf​(x)∥F2​=∑j=1t​∑i=1n​(∂xi​∂hj​(x)​)2， J f ( x ) J_f(x) Jf​(x)是雅可比矩阵（Jacobian Matrix），雅可比矩阵是向量值函数对其输入向量的偏导数组成的矩阵。
Tips:①这里可以看到，如果CAE的编码是线性的，那么CAE就和正则化自编码器没有区别了，因为线性的一阶导就是权重参数。
②CAE和DAE都对带噪数据有鲁棒性，CAE是对提取的特征有鲁棒性；DAE是对输出的去噪数据有鲁棒性。

4.5 卷积自编码器（CoAE）

卷积自编码器使用卷积层和池化层处理二维或三维数据，保留空间结构并减少参数数量，而普通自编码器使用全连接层处理一维向量数据，参数数量较多且不保留数据的空间结构。二维空间结构信息对图像来说十分重要，用AE时，需要把图像变为一维向量输入网络，这就破坏了图像的二维空间信息。

从上图可以看出，网络的输入输出都是二维的图像，其损失函数如下：
J C o A E ( θ ) = J ( X , X d ) + λ ∥ W ∥ 2 2 J_{CoAE}(\theta)=J(X,X^d)+\lambda\parallel W\parallel_2^2 JCoAE​(θ)=J(X,Xd)+λ∥W∥22​

4.6 变分自编码器（VAE）

关于变分自编码器，知乎上的这篇文章写的很好。首先说明变分自编码器的总体意义：VAE是在自编码器基础上结合了变分贝叶斯推断的方法，旨在学习数据的隐含结构，并能够生成新的、类似于训练数据的样本。可以说VAE的主要目的是生成新的数据。VAE通过显式地建模潜在变量的概率分布，使得潜在空间结构更加明确和可解释，最终能生成新样本。这在生成对抗网络（GAN）出现之前是一个重要的进展。
下面介绍VAE的主要做法：
VAE的整体网络结构简图如下：

针对一个输入 x i x_i xi​（比如一个样本就是一张图像），网络结构如下（下图中的 μ i ′ \mu_{i}^{\prime} μi′​就是输出的 X d X^d Xd）：


具体公式推导参考上面的那篇博客，下面是对博客推导思想的简单总结：

为了更好理解，还是直接博客的代码吧：

# -*- coding: utf-8 -*-

"""
Created on January 28, 2021

@author: Siqi Miao
"""

import os
from tqdm import tqdm
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

import torch
import torch.nn as nn

from torchvision import transforms
from torchvision.utils import save_image
from torchvision.datasets import MNIST


class VAE(nn.Module):

    def __init__(self, in_features, latent_size, y_size=0):
        super(VAE, self).__init__()

        self.latent_size = latent_size

        self.encoder_forward = nn.Sequential(
            nn.Linear(in_features + y_size, in_features),
            nn.LeakyReLU(),
            nn.Linear(in_features, in_features),
            nn.LeakyReLU(),
            nn.Linear(in_features, self.latent_size * 2)  # latent_size表示潜变量的个数，每一个变量有均值和方差两个数值
        )

        self.decoder_forward = nn.Sequential(
            nn.Linear(self.latent_size + y_size, in_features), # 解码器输入的时候只需要输入编码器输出的潜在变量的均值
            nn.LeakyReLU(),
            nn.Linear(in_features, in_features),
            nn.LeakyReLU(),
            nn.Linear(in_features, in_features),
            nn.Sigmoid()
        )

    def encoder(self, X):
        out = self.encoder_forward(X)
        mu = out[:, :self.latent_size] # 前latent_size个数据是均值
        log_var = out[:, self.latent_size:] # 后latent_size个数据是log(方差)
        return mu, log_var

    def decoder(self, z):
        mu_prime = self.decoder_forward(z)
        return mu_prime

    def reparameterization(self, mu, log_var):  # Reparameterization Trick
        epsilon = torch.randn_like(log_var) # 产生和log_var维度一样的高斯分布数据
        z = mu + epsilon * torch.sqrt(log_var.exp()) # log_var.exp()=var，sqrt(var)就是sigema
        return z

    def loss(self, X, mu_prime, mu, log_var): # mu_prime编码器的输出；mu潜变量的均值，也就是潜变量的值了；log_var潜变量的log(方差)
        # reconstruction_loss = F.mse_loss(mu_prime, X, reduction='mean') is wrong!
        #print(mu_prime.shape) # [1024,784]
        #print(mu.shape) # [1024,64]
        #print(log_var.shape) # [1024,64]
        # torch.square 是一个用于计算张量中每个元素的平方的函数。这个函数返回一个新的张量，其中包含原始张量中每个元素的平方值
        reconstruction_loss = torch.mean(torch.square(X - mu_prime).sum(dim=1)) # sum(dim=1)表示对列求和，torch.mean就相当于是对1024个样本求均值了，也就是公式里的1/n

        latent_loss = torch.mean(0.5 * (log_var.exp() + torch.square(mu) - log_var).sum(dim=1)) # sum(dim=1)表示对潜变量求和，torch.mean相当于是对1024个样本求均值
        return reconstruction_loss + latent_loss

    def forward(self, X, *args, **kwargs):
        mu, log_var = self.encoder(X)
        z = self.reparameterization(mu, log_var)
        mu_prime = self.decoder(z)
        return mu_prime, mu, log_var


class CVAE(VAE): # 继承VAE类，所以可以使用VAE的编码和解码器

    def __init__(self, in_features, latent_size, y_size):
        super(CVAE, self).__init__(in_features, latent_size, y_size)

    def forward(self, X, y=None, *args, **kwargs):
        y = y.to(next(self.parameters()).device)
        #print(y.shape) # [1024]
        X_given_Y = torch.cat((X, y.unsqueeze(1)), dim=1) 
        #print(X_given_Y.shape) # [1024,785]
        
        mu, log_var = self.encoder(X_given_Y)
        z = self.reparameterization(mu, log_var)
        z_given_Y = torch.cat((z, y.unsqueeze(1)), dim=1)

        mu_prime_given_Y = self.decoder(z_given_Y)
        return mu_prime_given_Y, mu, log_var


def train(model, optimizer, data_loader, device, name='VAE'):
    model.train()

    total_loss = 0
    pbar = tqdm(data_loader)
    for X, y in pbar:
        #print(X.shape) # [1024,1,28,28]
        #print(y.shape) # [1024]
        batch_size = X.shape[0]
        X = X.view(batch_size, -1).to(device)
        #print(X.shape) # [1024,784]
        model.zero_grad() #将模型中所有参数的梯度缓存清零。在进行反向传播计算梯度之前，必须先将之前计算的梯度清零。这是因为在 PyTorch 中，梯度是累积的。

        if name == 'VAE':
            mu_prime, mu, log_var = model(X)
        else:
            mu_prime, mu, log_var = model(X, y)

        loss = model.loss(X.view(batch_size, -1), mu_prime, mu, log_var)
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        pbar.set_description('Loss: {loss:.4f}'.format(loss=loss.item()))

    return total_loss / len(data_loader)


@torch.no_grad()
def save_res(vae, cvae, data, latent_size, device):
    num_classes = len(data.classes)

    # raw samples from dataset
    out = [] # 用于存储每个类别的图像
    for i in range(num_classes): 
        # 提取类别为 i 的图像
        img = data.data[torch.where(data.targets == i)[0][:num_classes]]
        out.append(img)
    out = torch.stack(out).transpose(0, 1).reshape(-1, 1, 28, 28) # 将图像堆叠在一起，并转置维度以便于保存
    save_image(out.float(), './img/raw_samples.png', nrow=num_classes, normalize=True) # 100张图像

    # samples generated by vanilla VAE
    z = torch.randn(num_classes ** 2, latent_size).to(device)
    # print(z.shape) # [100,64]
    out = vae.decoder(z)
    save_image(out.view(-1, 1, 28, 28), './img/vae_samples.png', nrow=num_classes)

    # sample generated by CVAE
    z = torch.randn(num_classes ** 2, latent_size).to(device)
    y = torch.arange(num_classes).repeat(num_classes).to(device)
    z_given_Y = torch.cat((z, y.unsqueeze(1)), dim=1)
    out = cvae.decoder(z_given_Y)
    save_image(out.view(-1, 1, 28, 28), './img/cvae_samples.png', nrow=num_classes)


def main():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    device = torch.device(device)

    batch_size = 256 * 4
    epochs = 50
    latent_size = 64
    in_features = 28 * 28
    lr = 0.001

    data = MNIST('./dataset/', download=True, transform=transforms.ToTensor())
    data_loader = torch.utils.data.DataLoader(data, batch_size=batch_size, shuffle=True)

    # train VAE
    vae = VAE(in_features, latent_size).to(device)
    optimizer = torch.optim.AdamW(vae.parameters(), lr=lr)

    print('Start Training VAE...')
    for epoch in range(1, 1 + epochs):
        loss = train(vae, optimizer, data_loader, device, name='VAE')
        print("Epochs: {epoch}, AvgLoss: {loss:.4f}".format(epoch=epoch, loss=loss))
    print('Training for VAE has been done.')

    # train VCAE
    cvae = CVAE(in_features, latent_size, y_size=1).to(device)
    optimizer = torch.optim.AdamW(cvae.parameters(), lr=lr)

    print('Start Training CVAE...')
    for epoch in range(1, 1 + epochs):
        loss = train(cvae, optimizer, data_loader, device, name='CVAE')
        print("Epochs: {epoch}, AvgLoss: {loss:.4f}".format(epoch=epoch, loss=loss))
    print('Training for CVAE has been done.')

    save_res(vae, cvae, data, latent_size, device)


if __name__ == '__main__':
    main()

VAE的变种：条件变分自编码器（CVAE）
传统的VAE可以近似地生成输入数据，但不能定向地生成特定类型的数据。为解决这一问题，将数据x和x的部分标签( y )输入到CVAE的编码器部分。这样就会生成指定类别的数据。CVAE的结构与VAE相似，因此CVAE的计算方法和优化方法与VAE一致。由于在输入中存在一些标签Y，CVAE成为一种半监督学习形式。
参考资料：
[1]《Deep Learning》
[2] Li P, Pei Y, Li J. A comprehensive survey on design and application of autoencoder in deep learning[J]. Applied Soft Computing, 2023, 138: 110176.
[3] https://zhuanlan.zhihu.com/p/348498294

版权声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！