VAE模型及pytorch实现

本文介绍: VAE（变分自编码器）是一种生成模型，结合了自编码器和概率图模型的思想。它通过学习数据的潜在分布，可以生成新的数据样本。VAE通过将输入数据映射到潜在空间中的分布，并在训练过程中最大化数据与潜在变量之间的条件概率来实现。其关键思想在于编码器将输入数据编码成潜在分布的参数，解码器则从这个分布中采样生成新的数据。这种生成方式不仅能够生成新的数据，还能够在潜在空间中进行插值和操作，提供了强大的特征学习和数据生成能力

σ11e−2σ12(x−μ1)2d x=2σ22σ12+μ12−2μ1μ2+μ22=2σ22σ12+(μ1−μ2)2

对上述式子进行汇总：

(

)

∥

(

)

log

⁡

−

(

−

)

(

−

log

⁡

−

)

begin{align e d} mathrm{KL}left(math cal{N}left(mu _{1}, sig m a _{1}^{2}right) | math cal{N}left(mu _{2}, sig ma_{2}^{2}right)right) &=log{frac{sig ma_2}{sig ma_1}-frac{1}{2}+frac{sig ma_1^2+(mu_1-mu_2)^2}{2sig ma_2^2}} \&=frac{1}{2}(sigma_1^2+mu_1^2-log^{sigma_1^2}-1) end{align e d}

$KL (N (μ_{1}, σ_{1}^{2}) ∥ N (μ_{2}, σ_{2}^{2})) = lo g \frac{σ _{2}}{σ _{1}} - \frac{1}{2} + \frac{σ _{1}^{2} + ( μ _{1} - μ _{2} ) ^{2}}{2 σ _{2}^{2}} = \frac{1}{2} (σ_{1}^{2} + μ_{1}^{2} - lo g^{σ_{1}^{2}} - 1)$

代码 部分

损失 函数

通过上述推导，我们知道了需要最小化散度，然后最大化那个均值。所以可以得到如下的损失函数。

    def loss_fn(recon_x, x, mean, log_var):
        BCE = torch.nn.functional.binary_cross_entropy(
            recon_x.view(-1, 28*28), x.view(-1, 28*28), reduction='sum')
        KLD = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())

        return (BCE + KLD) / x.size(0)

Encode r 部分

class Encoder(nn.Module):
    def __init__(self, layer_sizes, latent_size):
        super(Encoder, self).__init__()
        self.MLP = nn.Sequential()
        for i, (in_size, out_size) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
            self.MLP.add_module(name="L{:d}".format(i), module=nn.Linear(in_size, out_size))
            self.MLP.add_module(name="A{:d}".format(i), module=nn.ReLU())

        # 首先对图像特征进行一些变换处理，然后将其展开成一维向量，然后通过全连接层得到均值和方差
        self.linear_means = nn.Linear(layer_sizes[-1], latent_size)
        self.linear_log_var = nn.Linear(layer_sizes[-1], latent_size)

    def forward(self, x):
        x = self.MLP(x)

        means = self.linear_means(x)
        log_vars = self.linear_log_var(x)

        return means, log_vars

Decode r 部分

class Decoder(nn.Module):
    def __init__(self, layer_sizes, latent_size):
        super(Decoder, self).__init__()
        self.MLP = nn.Sequential()
        input_size = latent_size
        
        for i, (in_size, out_size) in enumerate(zip([input_size] + layer_sizes[:-1], layer_sizes)):
            self.MLP.add_module(
                name="L{:d}".format(i), module=nn.Linear(in_size, out_size))
            if i + 1 < len(layer_sizes):
                self.MLP.add_module(name="A{:d}".format(i), module=nn.ReLU())
            else:
                self.MLP.add_module(name="sigmoid", module=nn.Sigmoid())

    def forward(self, z):
        #对输入的z进行全接连操作，最后输出一个重构的x
        x = self.MLP(z)
        return x

VAE整体 架构

class VAE(nn.Module):
    def __init__(self, encoder_layer_sizes, latent_size, decoder_layer_sizes):
        super(VAE, self).__init__()
        self.latent_size = latent_size
        self.encoder = Encoder(encoder_layer_sizes, latent_size)
        self.decoder = Decoder(decoder_layer_sizes, latent_size)

    def forward(self, x):
        if x.dim() &gt; 2:
            x = x.view(-1, 28 * 28)
        means, log_var = self.encoder(x)
        z = self.reparameterize(means, log_var)
        recon_x = self.decoder(z)
        return recon_x, means, log_var, z

    def reparameterize(self, mu, log_var):
        """
        用于对encoder部分输出的均值方差进行重参数化，采样得到隐式表示部分z
        :param mu:
        :param log_var:
        :return:
        """
        std = torch.exp(0.5 * log_var)
        eps = torch.randn_like(std)
        return mu + eps * std

    def inference(self, z):
        recon_x = self.decoder(z)
        return recon_x