深度学习（十二）稀疏自编码

最新推荐文章于 2023-09-20 09:20:37 发布

GarfieldEr007

最新推荐文章于 2023-09-20 09:20:37 发布

阅读量5.1k

点赞数 3

分类专栏： Deep Learning 文章标签：深度学习 Deep Learning 稀疏自编码自编码机

Deep Learning 专栏收录该内容

188 篇文章

订阅专栏

稀疏自编码

原文地址：http://blog.youkuaiyun.com/hjimce/article/details/49106869

作者：hjimce

一、相关理论

以前刚开始学CNN的时候，就是通过阅读theano的深度学习相关教程源码，对于CNN的整个过程才有了深入理解。之前虽然懂CNN的原理，但是对于其源码层的实现，到底要怎么搞，却有点模糊，之后学了theano的cnn教程后，才知道原来是利用了四维矩阵进行操作。

理解了theano的CNN实现之后，对四维矩阵有了深刻的印象，后来阅读caffe的源码的时候，数据结构blob我就把它理解为了四维矩阵。在这里把自己以前阅读theano的时候，对之前源码的标注贴一下，以供大家学习，源码来自于：http://deeplearning.net/tutorial/。学习这些源码，同时我们也可以熟悉theano的使用，好处多多。所以建议刚入门深度学习的，一定要好好学theano的深度学习教程，好好解读源码。

本篇博文主要讲解：《稀疏自编码》算法，及其theano实现，属于深度学习的基础知识，高手请绕道。众所周知，机器学习可以大体分为三大类：监督学习、非监督学习和半监督学习。自编码神经网络是一种无监督学习算法，其实如果我们已经对PCA降维、SVD简化，比较熟悉的话，那么你会发现其实稀疏自编跟它们差不多，一样的简单，一样的无聊……

开始前，我们需要知道什么叫无监督学习，说实话，一年前，我连这个都不懂，因为我本身不是学人工智能方向的、也不是计算机专业、信息专业的。以前虽然学过聚类算法，但是那都是自学，没有系统的进行相关理论的学习，故而也不知道其实聚类算法就是无监督学习。说的简单点吧，所谓的无监督学习，就是不需要标签数据，也就是不需要我们对数据做标注，然后才能进行训练，数据直接拿过来，就可以进行训练了。

自编码的网络结构如下：

既然自编码网络是无标签数据，是怎么进行训练的呢？自编码网络很有意思，网络的输入是X，输出也是X，这样就相当于不需要进行数据标注了，属于无监督学习。那么自编码有什么用呢？你觉得让一个网络，输入是input=x，输出output=x，这样有意思吗？

从上面自编码的网络结构图，可以看到一开始输入特征是x1……x6，有六个特征，然后隐藏层的神经元只有3个，最后又用这3个神经元，要使得网络的输出尽量接近x1……x6。这就相当于我们输入了一个6维的特征向量，我们先把它降维，降到3维，然后我们利用这三维的特征向量，进行重构原始的数据。这个跟PCA降维一模一样，只不过PCA是通过求解特征向量，进行降维，是一种线性的降维方式，而自编码可以利用神经网络进行降维，是一种非线性降维，当然自编码隐藏层可以很多个神经元，然后我们使用正则化约束项，进行稀疏约束。

这样好玩吗，有意思吗，把x送进网络中，结果啥也不干，这个便是我学习自编码的时候，最大的疑问了，因为我不知道让一个网络的输入是x，最后输出也是x，这样有什么意义？要解答上面的网络有什么用，我们得从深度学习说起，我们知道，在深度学习中，一般网络都有很多层，因为网络层数一多，训练网络采用的梯度下降，在低层网络会出现梯度弥散的现象，导致了深度网络一直不招人待见。直到2006年的3篇论文改变了这种状况，由Hinton提出了一种深层网络的训练方法，改变了人们对深度学习的态度。Hinton所提出的训练思想，整体过程如下；

1、网络各层参数预训练。我们在以前的神经网络中，参数的初始化都是用随机初始化方法，然而这种方法，对于深层网络，在低层中，参数很难被训练，于是Hinton提出了参数预训练，这个主要就是采用RBM、以及我们本篇博文要讲的自编码，对网络的每一层进行参数初始化。也就是我们这边要学的稀疏自编码就是为了对网络的每一层进行参数初始化，仅仅是为了获得初始的参数值而已。

2、在一个时间里，一个层次的无监督训练，接着之前训练的层次。在每一层学习到的表示作为下一层的输入，对每层网络的进行训练初始化。

3、用有监督训练来调整所有层。

OK，我们回到本篇文章的主题，从上面的解释中，我们知道稀疏自编码仅仅只是为了获得参数的初始值而已。而其实我们上面的网络结构图，仅仅只是为了获取深度学习中，各层网络的初始参数值而已，一般我们训练完上后，就会把重构输出层去掉，只留下隐藏层与输入层的参数。而这些参数值，将作为本层网络，与上层网络的一个连接参数初始值。

二、源码实现

下面还是把theano的相关代码实现，贴一下：

[python]view plaincopy 
   
 <span style="font-family:Arial;">import os  
 import sys  
 import timeit  
   
 import numpy  
   
 import theano  
 import theano.tensor as T  
   
   
 from logistic_sgd import load_data  
 from utils import tile_raster_images  
   
 try:  
     import PIL.Image as Image  
 except ImportError:  
     import Image  
   
 '''''代码编写参考文献：Contractive Auto-Encoder class 
 这篇文献主要是提出一个约束正则项 
 整个总计算过程，参考文献的公式：7'''  
 class cA(object):  
   
     def __init__(self, numpy_rng, input=None, n_visible=784, n_hidden=100,  
                  n_batchsize=1, W=None, bhid=None, bvis=None):  
         """ 
         input:输入训练数据数据， input与n_batchsize是对应的，input中有n_batchsize个样本 
         input每一行代表一个样本，共有n_batchsize个样本 
  
         n_visible:可见层神经元的个数 
  
         n_hidden: 隐藏层神经元个数 
  
         n_batchsize:批量训练，每批数据的个数 
  
         W:输入当隐藏层的全连接权值矩阵，因为使用了tied weight 所以从隐藏到输入的权值 
         矩阵为:W.transpose() 
  
         bhid:从输入到隐藏层的偏置单元 
  
         bvis:从隐藏层的偏置单元 
         """  
         self.n_visible = n_visible  
         self.n_hidden = n_hidden  
         self.n_batchsize = n_batchsize  
         # 如果没有输入W，则在类里面进行初始化  
         if not W:  
             '''''W 采用[-a,a]的均匀采样方法进行初始化，因为后面采用s函数，所以 
            a=4*sqrt(6./(n_visible+n_hidden)) ,矩阵类型theano.config.floatX  
            这样才能保证在GPU上运行'''  
             initial_W = numpy.asarray(  
                 numpy_rng.uniform(  
                     low=-4 * numpy.sqrt(6. / (n_hidden + n_visible)),  
                     high=4 * numpy.sqrt(6. / (n_hidden + n_visible)),  
                     size=(n_visible, n_hidden)  
                 ),  
                 dtype=theano.config.floatX  
             )  
             W = theano.shared(value=initial_W, name='W', borrow=True)  
   
         if not bvis:  
             bvis = theano.shared(value=numpy.zeros(n_visible,  
                                                    dtype=theano.config.floatX),  
                                  borrow=True)  
   
         if not bhid:  
             bhid = theano.shared(value=numpy.zeros(n_hidden,  
                                                    dtype=theano.config.floatX),  
                                  name='b',  
                                  borrow=True)  
   
         self.W = W  
         # 输入到隐藏的偏置单元  
         self.b = bhid  
         # 隐藏到输出的偏置单元  
         self.b_prime = bvis  
         # 使用了tied weights, 所以 W_prime 是 W 的转置  
         self.W_prime = self.W.T  
   
         # 如果没有给定input，那么创建一个  
         if input is None:  
             self.x = T.dmatrix(name='input')  
         else:  
             self.x = input  
   
         self.params = [self.W, self.b, self.b_prime]  
     #1、输入层到隐藏层  
     def get_hidden_values(self, input):  
         return T.nnet.sigmoid(T.dot(input, self.W) + self.b)  
     #2、隐藏层到输出层。重建结果 x' = s(W' h  + b') ，因为文献使用了tied weigth，所以  
     #W'等于W的转置，这个可以百度搜索：自编码，tied weight等关键词  
     def get_reconstructed_input(self, hidden):  
         return T.nnet.sigmoid(T.dot(hidden, self.W_prime) + self.b_prime)  
     #计算 J_i = h_i (1 - h_i) * W_i        
     def get_jacobian(self, hidden, W):  
         return T.reshape(hidden * (1 - hidden),(self.n_batchsize, 1, self.n_hidden))*T.reshape(W, (1, self.n_visible, self.n_hidden))  
   
     #权值更新函数  
     def get_cost_updates(self, contraction_level, learning_rate):  
         y = self.get_hidden_values(self.x)#输入-》隐藏  
         z = self.get_reconstructed_input(y)#隐藏-》输出  
         J = self.get_jacobian(y, self.W)#y*(1-y)*W  
         #文献Contractive Auto-Encoders:公式4损失函数计算公式  
         self.L_rec = - T.sum(self.x * T.log(z) +(1 - self.x) * T.log(1 - z),axis=1)  
   
         # 因为J是由n_batchsize*n_hidden计算而来，有n_batchsize个样本，所以要求取样本平均值  
         self.L_jacob = T.sum(J ** 2) / self.n_batchsize  
           
         #整个惩罚函数  
         cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)  
   
         #对参数求导  
         gparams = T.grad(cost, self.params)  
         #梯度下降法更新参数  
         updates = []  
         for param, gparam in zip(self.params, gparams):  
             updates.append((param, param - learning_rate * gparam))  
   
         return (cost, updates)  
   
 #测试验证上面的类是否正确  
 def test_cA(learning_rate=0.01, training_epochs=20,  
             dataset='mnist.pkl.gz',  
             batch_size=10, output_folder='cA_plots', contraction_level=.1):  
     """ 
     learning_rate:梯度下降法的学习率 
  
     training_epochs: 最大迭代次数 
      
     contraction_level：为正则项的权重 
  
     """  
     #datasets[0]为训练集，datasets[1]为验证集，datasets[2]为测试集  
     datasets = load_data(dataset)  
     train_set_x, train_set_y = datasets[0]  
   
     # 批量下降法，训练的批数  
     n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size  
   
     # allocate symbolic variables for the data  
     index = T.lscalar()    # 每一批训练数据的索引  
     x = T.matrix('x')  # 每一批训练数据  
   
     if not os.path.isdir(output_folder):  
         os.makedirs(output_folder)  
     os.chdir(output_folder)  
   
   
     rng = numpy.random.RandomState(123)  
   
     ca = cA(numpy_rng=rng, input=x,  
             n_visible=28 * 28, n_hidden=500, n_batchsize=batch_size)  
   
     cost, updates = ca.get_cost_updates(contraction_level=contraction_level,  
                                         learning_rate=learning_rate)  
     #每一批，训练更新函数，输入参数index  
     train_ca = theano.function(  
         [index],  
         [T.mean(ca.L_rec), ca.L_jacob],  
         updates=updates,  
         givens={  
             x: train_set_x[index * batch_size: (index + 1) * batch_size]  
         }  
     )  
   
     start_time = timeit.default_timer()  
   
     ############  
     # TRAINING #  
     ############  
   
     # go through training epochs  
     for epoch in xrange(training_epochs):  
         # go through trainng set  
         c = []  
         for batch_index in xrange(n_train_batches):  
             c.append(train_ca(batch_index))  
   
         c_array = numpy.vstack(c)  
         print 'Training epoch %d, reconstruction cost ' % epoch, numpy.mean(  
             c_array[0]), ' jacobian norm ', numpy.mean(numpy.sqrt(c_array[1]))  
   
     end_time = timeit.default_timer()  
   
     training_time = (end_time - start_time)  
   
     print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] +  
                           ' ran for %.2fm' % ((training_time) / 60.))  
     image = Image.fromarray(tile_raster_images(  
         X=ca.W.get_value(borrow=True).T,  
         img_shape=(28, 28), tile_shape=(10, 10),  
         tile_spacing=(1, 1)))  
   
     image.save('cae_filters.png')  
   
     os.chdir('../')  
   
   
 if __name__ == '__main__':  
     test_cA()</span>  