StackAutoEncoder堆栈自编码器

1.AutoEncoder自编码网络

经典自编码模型
自编码模型
损失函数

2.StackAutoEncoder堆栈自编码网络

StackAutoEncoder
第L层自编码学习
两阶段：
1、无监督逐层贪婪预训练，layer-wise unsuperwised pre-training （较深网络直接训练会梯度消失或梯度爆炸，在训练第L层时,冻结第1~(L-1)层的参数。每个隐藏层的参数都只是局部最优的。）
比如说我们要训练一个n−>m−>k结构的网络，实际上我们是先训练网络n−>m−>n，得到n−>m的变换，然后再训练m−>k−>m网络，得到m−>k的变换。最终堆叠成SAE，即为n−>m−>k的结果。
2、全局训练，微调
只保留每一自编码层的分析阶段的参数，直接丢弃合成阶段的参数。把保留的参数当做最后网络的初始化参数，然后使用带标签的数据使用传统的神经网络的训练方法进行参数的微调即可。
image.png

3.StackAutoEncoder举例说明

第一层AE

首先，用原始输入x(k)训练第一个稀疏自编码器，得学习得到原始输入的一阶特征表示h(1)(k)。

第一层AE

第二层AE

把原始数据输入到上述训练好的稀疏自编码器中，对于每一个输入x(k)都可以得到它对应的一阶特征表示h(1)(k)。
然后再用这些一阶特征作为另一个稀疏自编码器的输入，使用它们来学习二阶特征h(2)(k)。

第二层AE

第三层-分类器

再把一阶特征输入到刚训练好的第二层稀疏自编码器中，得到每个h(1)(k)对应的二阶特征激活值h(2)(k)。接下来的，可以把这些二阶特征作为softmax分类器的输入，训练得到一个能将二阶特征映射到标签的模型。如下图：

第三层-分类器

组合

最后，将这三层结合起来构建一个包含两个隐藏层和一个最终softmax分类器层的堆叠自编码网络。最终模型如下图：

组合

4.代码实现

for epoch_index in range(epoch):
    # 冻结当前层之前的所有层的参数  --第0层没有前置层
    if layer != 0:
        for index in range(layer):
            layers_list[index].lock_grad()
            layers_list[index].is_training_layer = False  # 除了冻结参数,也要设置冻结层的输出返回方式, 见下方解析

    for batch_index, (train_data, _) in enumerate(train_loader):
        # 生成输入数据
        if torch.cuda.is_available():
            train_data = train_data.cuda()  # 注意Tensor放到GPU上的操作方式,和model不同
        out = train_data.view(train_data.size(0), -1)

        # 对前(layer-1)冻结了的层进行前向计算
        if layer != 0:
            for l in range(layer):
                out = layers_list[l](out)
        # 训练第layer层
        pred = layers_list[layer](out)
        optimizer.zero_grad()
        loss = criterion(pred, out)
        sum_loss += loss
        loss.backward()
        optimizer.step()

其中每一层隐藏层都需要定义一个单独的输出方式,分别用于进行逐层和训练和全局的训练:

class AutoEncoderLayer(torch.nn.Module):
    """
    fully-connected linear layers for stacked autoencoders.
    This module can automatically be trained when training each layer is enabled
    Yes, this is much like the simplest auto-encoder
    """

    def __init__(self, input_dim=None, output_dim=None, SelfTraining=False):
        super(AutoEncoderLayer, self).__init__()
        # if input_dim is None or output_dim is None:
        #     raise ValueError
        self.in_features = input_dim
        self.out_features = output_dim
        self.is_training_self = SelfTraining  # 指示是否进行逐层预训练,还是训练整个网络
        self.encoder = torch.nn.Sequential(
            torch.nn.Linear(self.in_features, self.out_features, bias=True),
            torch.nn.Sigmoid()  # 统一使用Sigmoid激活
        )
        self.decoder = torch.nn.Sequential(  # 此处decoder不使用encoder的转置; 使用Sigmoid进行激活.
            torch.nn.Linear(self.out_features, self.in_features, bias=True),
            torch.nn.Sigmoid()
        )

    def forward(self, x):
        out = self.encoder(x)
        if self.is_training_self:  # 当逐层训练时,需要输出self.decoder的计算结果,作为一个输出层; 
            return self.decoder(out)
        else:
            return out

    def lock_grad(self):
        for param in self.parameters():
            param.requires_grad = False

    def acquire_grad(self):
        for param in self.parameters():
            param.requires_grad = True

5.分析

为什么逐层预训练的SAE有不错的效果？一个直观的解释是，预训练好的网络在一定程度上拟合了训练数据的结构，这使得整个网络的初始值是在一个合适的状态，便于有监督阶段加快迭代收敛。当然，有不少研究提出了很好的初始化策略，再加上现在常用的dropout、ReLU，直接去训练一个深层网络已经不是问题。
得除了AE和SAE这种逐层预训练的方式外，还有另外一条类似的主线，即限制玻尔兹曼机（RBM）与深度信念网络（DBN）。