整理CNN卷积神经网络原理.docx

整理CNN卷积神经网络原理.docx

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

整理CNN卷积神经网络原理

CNN卷积神经网络原理

编辑整理：

尊敬的读者朋友们：

这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（CNN卷积神经网络原理）的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。

本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为CNN卷积神经网络原理的全部内容。

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

http：

//blog。

csdn。

net/u012162613/article/details/43225445

本文主要是详细地解读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 theano。

tensor as T  

11.from theano.tensor。

signal import downsample  

12.from theano。

tensor.nnet import conv  

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

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

∙定义LeNetConvPoolLayer（卷积+采样层）

见代码注释:

［python] viewplain copy

1.”"" 

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

3.rng：

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

4.input:

4维的向量，theano。

tensor.dtensor4 

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.        self。

input = input  

16.  

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

18.＃可以用numpy。

prod（filter_shape［1：

]）来求得  

19.        fan_in = numpy.prod（filter_shape[1:

]）  

20.  

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

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

22.        fan_out = （filter_shape[0］ * numpy。

prod（filter_shape[2：

］） /  

23.                   numpy.prod（poolsize））  

24.                     

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

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

27.        self.W = theano.shared（  

28.            numpy.asarray（  

29.                rng。

uniform（low=—W_bound, high=W_bound, size=filter_shape），  

30.                dtype=theano.config。

floatX  

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 = numpy.zeros（（filter_shape［0］，）， dtype=theano。

config。

floatX）  

39.        self.b = theano.shared（value=b_values， borrow=True）  

40.  

41.#将输入图像与filter卷积，conv。

conv2d函数  

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

43.        conv_out = conv.conv2d（  

44.            input=input,  

45.            filters=self.W,  

46.            filter_shape=filter_shape,  

47.            image_shape=image_shape  

48.        ）  

49.  

50.＃maxpooling,最大子采样过程  

51.        pooled_out = downsample。

max_pool_2d（  

52.            input=conv_out,  

53.            ds=poolsize，  

54.            ignore_border=True  

55.        ）  

56.  

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

58.＃因为b是一维向量,这里用维度转换函数dimshuffle将其reshape.比如b是（10,），  

59.＃则b.dimshuffle（’x’， 0, ’x'， 'x'））将其reshape为（1，10，1，1）  

60.        self.output = T.tanh（pooled_out + self。

b.dimshuffle（’x’， 0, ’x’, 'x'））  

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

62.        self.params = ［self.W， self。

b]  

∙定义隐含层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即随机数生成器，numpy.random.RandomState，用于初始化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=T。

tanh）:

14.         self。

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

15.  

16.         "”" 

17.         注释：

18.         代码要兼容GPU,则必须使用 dtype=theano.config。

floatX，并且定义为theano.shared 

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 = numpy。

asarray（  

26.                rng。

uniform（  

27.                    low=-numpy。

sqrt（6。

 / （n_in + n_out）），  

28.                    high=numpy。

sqrt（6. / （n_in + n_out）），  

29.                    size=（n_in, n_out）  

30.                ）,  

31.                dtype=theano.config。

floatX  

32.            ）  

33.            if activation == theano。

tensor.nnet.sigmoid：

34.                W_values ＊= 4  

35.            W = theano.shared（value=W_values， name=’W’, borrow=True）  

36.  

37.         if b is None:

38.            b_values = numpy.zeros（（n_out,）, dtype=theano。

config.floatX）  

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

40.  

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

42.         self。

W = W  

43.         self.b = b  

44.  

45.        ＃隐含层的输出  

46.         lin_output = T.dot（input， self。

W） + self。

b  

47.         self。

output = （  

48.            lin_output if activation is None  

49.            else activation（lin_output）  

50.         ）  

51.  

52.        ＃隐含层的参数  

53.         self。

params = ［self.W， self。

b］  

∙定义分类器（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.        self.W = theano。

shared（  

16.            value=numpy。

zeros（  

17.                （n_in, n_out），  

18.                dtype=theano.config。

floatX  

19.            ）,  

20.            name='W',  

21.            borrow=True  

22.        ）  

23.  

24.        self.b = theano.shared（  

25.            value=numpy。

zeros（  

26.                （n_out,）,  

27.                dtype=theano.config。

floatX  

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.＃再作为T。

nnet。

softmax的输入,得到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.        self。

p_y_given_x = T。

nnet.softmax（T.dot（input, self.W） + self。

b）  

39.  

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

axis=1表示按行操作。

41.        self.y_pred = T。

argmax（self。

p_y_given_x， axis=1）  

42.  

43.#params，LogisticRegression的参数       

44.        self。

params = ［self.W， self。

b]  

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

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

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

（3）加载MNIST数据集（mnist。

pkl.gz）

[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 = os。

path。

split（dataset）  

8.    if data_dir == "” and not os。

path.isfile（dataset）:

9.        ＃ Check if dataset is in the data directory。

10.        new_path = os.path。

join（  

11.            os。

path.split（__file__）［0］，  

12.            "。

。

”,  

13.            "data”,  

14.            dataset  

15.        ）  

16.        if os。

path。

isfile（new_path） or data_file == 'mnist。

pkl。

gz'：

17.            dataset = new_path  

18.  

19.    if （not os.path。

isfile（dataset）） and data_file == 'mnist.pkl.gz’：

20.        import urllib  

21.        origin = （  

22.            ’http：

//www。

iro.umontreal.ca/~lisa/deep/data/mnist/mnist。

pkl.gz’  

23.        ）  

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

25.        urllib。

urlretrieve（origin, dataset）  

26.  

27.    print '... loading data’  

28.#以上是检测并下载数据集mnist.pkl。

gz，不是本文重点。

下面才是l