28.AutoEncoder

回顾：CNN处理位置相关性，RNN在时间维度上共享权值，还分析了RNN存在的问题：梯度爆炸和梯度离散。
增强学习Reinforcement learning
与外界进行交互，例如游戏。
监督学习supervised learning
无监督学习unsupervised learning/predict learning
为什么需要无监督学习

AutoEncoder

重建自己：输入和输出的维度一样，最中间有一个neck，可用于升维或者降维

重建图片-输入图像

AutoEncoder的变种

denoising encoder、dropout encoder和adversarial encoder

当dropout为0时，loss是最低的，但accuracy可能不是最高的，因为此时可能发生overfitting，导致模型也记住了一些噪声。

从分布图中可以看到，encoder h的分布不属于常见的一些分布，但是我们希望它的均值为0，方差是某个特定的数，这样在做generation时，可以更好的控制y轴值h的变化，使h在-1到1内满足某种分布。
但是假如在这个范围内，我们重建的图片和原来一样或者不满足某种分布：

前半部分：
在∅网络下，xi在z下的概率最大，loss最小。
z是来自于pθ网络，在给定xi得到的z的概率，在该分布下，我们要求在∅网络下，xi在z下的概率最大的情况，此时最接近于真实分布。这就是重建xi。
也可以理解为使得(x ̅i-xi )的值最小。
后半部分：
KL（p q）是指pq函数重叠的面积，p与q越接近，重叠面积越大，kl就越小。

KL（p，q）的意思是使p接近于q。

对于autoencoder，是x→h→x ̅，每个关系都是一一对应的。对于variaional autoencoder，h属于q(h)分布，对于x是用一个分布表示的，从q(h)分布中取一个分布的样本，赋值为一个h或者z，然后根据z重建出x ̅，取得样本具有随机性。
sample的过程是不可微的。

z=μ+σ⊙ε
Reparameterization trick：解决sample不能微分的问题

AutoEncoder实战

实现autoencoder重建minst

ae

import torch
from torch import nn

class AE(nn.Module):
    def __init__(self):
        super(AE, self).__init__()


        #[b,784]=>[b,20]
        self.encoder=nn.Sequential(
            nn.Linear(784,256),
            nn.ReLU(),
            nn.Linear(256,64),
            nn.ReLU(),
            nn.Linear(64,20),
            nn.ReLU()
        )
        #[b,20]=>[b,784]
        self.decoder=nn.Sequential(
            nn.Linear(20,64),
            nn.ReLU(),
            nn.Linear(64,256),
            nn.ReLU(),
            nn.Linear(256,784),
            nn.Sigmoid()
        )

    def forward(self,x):
        '''

        :param x: [b,1,28,28]
        :return:[]
        '''
        batchsz=x.size(0)
        #flatten
        x=x.view(batchsz,784)
        #encoder
        x=self.encoder(x)
        #decoder
        x=self.decoder(x)
        #reshpe
        x=x.view(batchsz,1,28,28)

        return x

vae

import numpy as np
import torch
from torch import nn

class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()

        #[b,784]=>[]
        #u:[b,10]
        #sigma:[b,10]
        self.encoder=nn.Sequential(
            nn.Linear(784,256),
            nn.ReLU(),
            nn.Linear(256,64),
            nn.ReLU(),
            nn.Linear(64,20),
            nn.ReLU()
        )
        self.decoder=nn.Sequential(
            nn.Linear(10,64),
            nn.ReLU(),
            nn.Linear(64,256),
            nn.ReLU(),
            nn.Linear(256,784),
            nn.Sigmoid()
        )

    def forward(self,x):
        '''

        :param x:
        :return:
        '''
        batchsz=x.size(0)
        x=x.view(batchsz,784)
        #encoder
        #[b,20],including mean and sigma
        h_=self.encoder(x)
        #[b,20]=>[b,10]and [b,10]
        mu,sigma=h_.chunk(2,dim=1)
        #reparametrize trick,epison~N(0,1)
        h=mu+sigma*torch.rand_like(sigma)

        #decoder
        x_hat=self.decoder(h)
        x_hat=x_hat.view(batchsz,1,28,28)
        #KL
        kld=0.5*torch.sum(
            torch.pow(mu,2)+
            torch.pow(sigma,2)-
            torch.log(1e-8+torch.pow(sigma,2))-1
        )/(batchsz*28*28)


        return x_hat,kld