CNN卷积神经网络原理.docx

CNN卷积神经网络原理.docx

《CNN卷积神经网络原理.docx》由会员分享，可在线阅读，更多相关《CNN卷积神经网络原理.docx（34页珍藏版）》请在冰豆网上搜索。

CNN卷积神经网络原理

CNN卷积神经网络原理（总25页）

一、CNN卷积神经网络原理简介

本文主要是详细地解读CNN的实现代码。

如果你没学习过CNN，在此推荐周晓艺师兄的博文：

DeepLearning（深度学习）学习笔记整理系列之（七），以及UFLDL上的卷积特征提取、池化

CNN的最大特点就是稀疏连接（局部感受）和权值共享，如下面两图所示，左为稀疏连接，右为权值共享。

稀疏连接和权值共享可以减少所要训练的参数，减少计算复杂度。

至于CNN的结构，以经典的LeNet5来说明：

这个图真是无处不在，一谈CNN，必说LeNet5，这图来自于这篇论文：

Gradient-BasedLearningAppliedtoDocumentRecognition，论文很长，第7页那里开始讲LeNet5这个结构，建议看看那部分。

我这里简单说一下，LeNet5这张图从左到右，先是input，这是输入层，即输入的图片。

input-layer到C1这部分就是一个卷积层（convolution运算），C1到S2是一个子采样层（pooling运算），关于卷积和子采样的具体过程可以参考下图：

然后，S2到C3又是卷积，C3到S4又是子采样，可以发现，卷积和子采样都是成对出现的，卷积后面一般跟着子采样。

S4到C5之间是全连接的，这就相当于一个MLP的隐含层了（如果你不清楚MLP，参考《DeepLearningtutorial（3）MLP多层感知机原理简介+代码详解》）。

C5到F6同样是全连接，也是相当于一个MLP的隐含层。

最后从F6到输出output，其实就是一个分类器，这一层就叫分类层。

ok，CNN的基本结构大概就是这样，由输入、卷积层、子采样层、全连接层、分类层、输出这些基本“构件”组成，一般根据具体的应用或者问题，去确定要多少卷积层和子采样层、采用什么分类器。

当确定好了结构以后，如何求解层与层之间的连接参数？

一般采用向前传播（FP）+向后传播（BP）的方法来训练。

具体可参考上面给出的链接。

二、CNN卷积神经网络代码详细解读（基于python+theano）

代码来自于深度学习教程：

ConvolutionalNeuralNetworks（LeNet），这个代码实现的是一个简化了的LeNet5，具体如下：

没有实现location-specificgainandbiasparameters

用的是maxpooling，而不是average_pooling

分类器用的是softmax，LeNet5用的是rbf

LeNet5第二层并不是全连接的，本程序实现的是全连接

另外，代码里将卷积层和子采用层合在一起，定义为“LeNetConvPoolLayer“（卷积采样层），这好理解，因为它们总是成对出现。

但是有个地方需要注意，代码中将卷积后的输出直接作为子采样层的输入，而没有加偏置b再通过sigmoid函数进行映射，即没有了下图中fx后面的bx以及sigmoid映射，也即直接由fx得到Cx。

最后，代码中第一个卷积层用的卷积核有20个，第二个卷积层用50个，而不是上面那张LeNet5图中所示的6个和16个。

了解了这些，下面看代码：

（1）导入必要的模块

[python] viewplain copy

1.import cPickle  

2.import gzip  

3.import os  

4.import sys  

5.import time  

6.  

7.import numpy  

8.  

9.import theano  

10.import  as T  

11.from  import downsample  

12.from  import conv  

（2）定义CNN的基本"构件"

CNN的基本构件包括卷积采样层、隐含层、分类器，如下

定义LeNetConvPoolLayer（卷积+采样层）

见代码注释：

[python] viewplain copy

1.""" 

2.卷积+下采样合成一个层LeNetConvPoolLayer 

3.rng:

随机数生成器，用于初始化W 

4.input:

4维的向量， 

5.filter_shape:

（number of filters, num input feature maps,filter height, filter width） 

6.image_shape:

（batch size, num input feature maps,image height, image width） 

7.poolsize:

 （#rows, #cols） 

8."""  

9.class LeNetConvPoolLayer（object）:

10.    def __init__（self, rng, input, filter_shape, image_shape, poolsize=（2, 2））:

11.    

12.#assert condition，condition为True，则继续往下执行，condition为False，中断程序  

13.#image_shape[1]和filter_shape[1]都是num input feature maps，它们必须是一样的。

14.        assert image_shape[1] == filter_shape[1]  

15.         = input  

16.  

17.#每个隐层神经元（即像素）与上一层的连接数为num input feature maps * filter height * filter width。

18.#可以用（filter_shape[1:

]）来求得  

19.        fan_in = （filter_shape[1:

]）  

20.  

21.#lower layer上每个神经元获得的梯度来自于：

"num output feature maps * filter height * filter width" /pooling size  

22.        fan_out = （filter_shape[0] * （filter_shape[2:

]） /  

23.                   （poolsize））  

24.                     

25.#以上求得fan_in、fan_out ，将它们代入公式，以此来随机初始化W,W就是线性卷积核  

26.        W_bound = （6. / （fan_in + fan_out））  

27.         = （  

28.            （  

29.                （low=-W_bound, high=W_bound, size=filter_shape）,  

30.                dtype=  

31.            ）,  

32.            borrow=True  

33.        ）  

34.  

35.# the bias is a 1D tensor -- one bias per output feature map  

36.#偏置b是一维向量，每个输出图的特征图都对应一个偏置，  

37.#而输出的特征图的个数由filter个数决定，因此用filter_shape[0]即number of filters来初始化  

38.        b_values = （（filter_shape[0],）, dtype=  

39.         = （value=b_values, borrow=True）  

40.  

41.#将输入图像与filter卷积，函数  

42.#卷积完没有加b再通过sigmoid，这里是一处简化。

43.        conv_out = （  

44.            input=input,  

45.            filters=,  

46.            filter_shape=filter_shape,  

47.            image_shape=image_shape  

48.        ）  

49.  

50.#maxpooling，最大子采样过程  

51.        pooled_out = （  

52.            input=conv_out,  

53.            ds=poolsize,  

54.            ignore_border=True  

55.        ）  

56.  

57.#加偏置，再通过tanh映射，得到卷积+子采样层的最终输出  

58.#因为b是一维向量，这里用维度转换函数dimshuffle将其reshape。

比如b是（10,），  

59.#则（'x', 0, 'x', 'x'））将其reshape为（1,10,1,1）  

60.         = （pooled_out + 'x', 0, 'x', 'x'））  

61.#卷积+采样层的参数  

62.         = [, ]  

定义隐含层HiddenLayer

这个跟上一篇文章《 DeepLearningtutorial（3）MLP多层感知机原理简介+代码详解》中的HiddenLayer是一致的，直接拿过来：

[python] viewplain copy

1.""" 

2.注释：

3.这是定义隐藏层的类，首先明确：

隐藏层的输入即input，输出即隐藏层的神经元个数。

输入层与隐藏层是全连接的。

4.假设输入是n_in维的向量（也可以说时n_in个神经元），隐藏层有n_out个神经元，则因为是全连接， 

5.一共有n_in*n_out个权重，故W大小时（n_in,n_out）,n_in行n_out列，每一列对应隐藏层的每一个神经元的连接权重。

6.b是偏置，隐藏层有n_out个神经元，故b时n_out维向量。

7.rng即随机数生成器，，用于初始化W。

8.input训练模型所用到的所有输入，并不是MLP的输入层，MLP的输入层的神经元个数时n_in，而这里的参数input大小是（n_example,n_in）,每一行一个样本，即每一行作为MLP的输入层。

9.activation:

激活函数,这里定义为函数tanh 

10."""  

11.class HiddenLayer（object）:

12.    def __init__（self, rng, input, n_in, n_out, W=None, b=None,  

13.                 activation=:

14.          = input   #类HiddenLayer的input即所传递进来的input  

15.  

16.         """ 

17.         注释：

18.         代码要兼容GPU，则必须使用 dtype=并且定义为 

19.         另外，W的初始化有个规则：

如果使用tanh函数，则在-sqrt（6./（n_in+n_hidden））到sqrt（6./（n_in+n_hidden））之间均匀 

20.         抽取数值来初始化W，若时sigmoid函数，则以上再乘4倍。

21.         """  

22.         #如果W未初始化，则根据上述方法初始化。

23.         #加入这个判断的原因是：

有时候我们可以用训练好的参数来初始化W，见我的上一篇文章。

24.         if W is None:

25.            W_values = （  

26.                （  

27.                    low=（6. / （n_in + n_out））,  

28.                    high=（6. / （n_in + n_out））,  

29.                    size=（n_in, n_out）  

30.                ）,  

31.                dtype=  

32.            ）  

33.            if activation ==   

34.                W_values *= 4  

35.            W = （value=W_values, name='W', borrow=True）  

36.  

37.         if b is None:

38.            b_values = （（n_out,）, dtype=  

39.            b = （value=b_values, name='b', borrow=True）  

40.  

41.         #用上面定义的W、b来初始化类HiddenLayer的W、b  

42.          = W  

43.          = b  

44.  

45.        #隐含层的输出  

46.         lin_output = （input,  +   

47.          = （  

48.            lin_output if activation is None  

49.            else activation（lin_output）  

50.         ）  

51.  

52.        #隐含层的参数  

53.          = [, ]  

定义分类器（Softmax回归）

采用Softmax，这跟《DeepLearningtutorial

（1）Softmax回归原理简介+代码详解》中的LogisticRegression是一样的，直接拿过来：

[python] viewplain copy

1.""" 

2.定义分类层LogisticRegression，也即Softmax回归 

3.在deeplearning tutorial中，直接将LogisticRegression视为Softmax， 

4.而我们所认识的二类别的逻辑回归就是当n_out=2时的LogisticRegression 

5."""  

6.#参数说明：

7.#input，大小就是（n_example,n_in），其中n_example是一个batch的大小，  

8.#因为我们训练时用的是Minibatch SGD，因此input这样定义  

9.#n_in,即上一层（隐含层）的输出  

10.#n_out,输出的类别数   

11.class LogisticRegression（object）:

12.    def __init__（self, input, n_in, n_out）:

13.  

14.#W大小是n_in行n_out列，b为n_out维向量。

即：

每个输出对应W的一列以及b的一个元素。

15.         = （  

16.            value=（  

17.                （n_in, n_out）,  

18.                dtype=  

19.            ）,  

20.            name='W',  

21.            borrow=True  

22.        ）  

23.  

24.         = （  

25.            value=（  

26.                （n_out,）,  

27.                dtype=  

28.            ）,  

29.            name='b',  

30.            borrow=True  

31.        ）  

32.  

33.#input是（n_example,n_in），W是（n_in,n_out）,点乘得到（n_example,n_out），加上偏置b，  

34.#再作为的输入，得到p_y_given_x  

35.#故p_y_given_x每一行代表每一个样本被估计为各类别的概率      

36.#PS：

b是n_out维向量，与（n_example,n_out）矩阵相加，内部其实是先复制n_example个b，  

37.#然后（n_example,n_out）矩阵的每一行都加b  

38.         =   +   

39.  

40.#argmax返回最大值下标，因为本例数据集是MNIST，下标刚好就是类别。

axis=1表示按行操作。

41.         = , axis=1）  

42.  

43.#params，LogisticRegression的参数       

44.         = [, ]  

到这里，CNN的基本”构件“都有了，下面要用这些”构件“组装成LeNet5（当然，是简化的，上面已经说了），具体来说，就是组装成：

LeNet5=input+LeNetConvPoolLayer_1+LeNetConvPoolLayer_2+HiddenLayer+LogisticRegression+output。

然后将其应用于MNIST数据集，用BP算法去解这个模型，得到最优的参数。

（3）加载MNIST数据集（）

[python] viewplain copy

1.""" 

2.加载MNIST数据集load_data（） 

3."""  

4.def load_data（dataset）:

5.    # dataset是数据集的路径，程序首先检测该路径下有没有MNIST数据集，没有的话就下载MNIST数据集  

6.    #这一部分就不解释了，与softmax回归算法无关。

7.    data_dir, data_file =   

8.    if data_dir == "" and not   

9.        # Check if dataset is in the data directory.  

10.        new_path =   

11.              

12.            "..",  

13.            "data",  

14.            dataset  

15.        ）  

16.        if  or data_file == '':

17.            dataset = new_path  

18.  

19.    if （not  and data_file == '':

20.        import urllib  

21.        origin = （  

22.            ''  

23.        ）  

24.        print 'Downloading data from %s' % origin  

25.        （origin, dataset）  

26.  

27.    print '... loading data'  

28.#以上是检测并下载数据集，不是本文重点。

下面才是load_data的开始  

29.      

30.#从""里加载train_set, valid_set, test_set，它们都是包括label的  

31.#主要用到python里的（）函数,以及 （）。

32.#‘rb’表示以二进制可读的方式打开文件  

33.    f = （dataset, 'rb'）  

34.    train_set, valid_set, test_set = （f）  

35.    （）  

36.     

37.  

38.#将数据设置成shared variables，主要时为了GPU加速，只有shared variables才能存到GPU memory中  

39.#GPU里数据类型只能是float。

而data_y是类别，所以最后又转换为int返回  

40.    def shared_dataset（data_xy, borrow=True）:

41.        data_x, data_y = data_xy  

42.        shared_x = （data_x,  

43.                                               dtype=  

44.                                 borrow=borrow）  

45.        shared_y = （data_y,  

46.                                               dtype=  

47.                                 borrow=borrow）  

48.        return shared_x, （shared_y, 'int32'）  

49.  

50.  

51.    test_set_x, test_set_y = shared_dataset（test_set）  

52.    valid_set_x, valid_set_y = shared_dataset（valid_set）  

53.    train_set_x, train_set_y = shared_dataset（train_set）  

54.  

55.    rval = [（train_set_x, train_set_y）, （valid_set_x, valid_set_y）,  

56.            （test_set_x, test_set_y）]  

57.    return rval  

（4）实现LeNet5并测试

[python] viewplain copy

1.""" 

2.实现LeNet5 

3.LeNet5有两个卷积层，第一个卷积层有20个卷积核，第二个卷积层有50个卷积核 

4."""  

5.def evaluate_lenet5（learning_rate=, n_epochs=200,  

6.                    dataset='',  

7.                    nkerns=[20, 50], batch_size=500）:

8.    """