卷积神经网络原理.docx
《卷积神经网络原理.docx》由会员分享，可在线阅读，更多相关《卷积神经网络原理.docx（34页珍藏版）》请在冰豆网上搜索。
卷积神经网络原理
一、CNN卷积神经网络原理简介
本文主要是详细地解读CNN的实现代码。
如果你没学习过CNN，在此推荐周晓艺师兄的博文：
，以及UFLDL上的、
CNN的最大特点就是稀疏连接（局部感受）和权值共享，如下面两图所示，左为稀疏连接，右为权值共享。
稀疏连接和权值共享可以减少所要训练的参数，减少计算复杂度。
至于CNN的结构，以经典的LeNet5来说明：
这个图真是无处不在，一谈CNN，必说LeNet5，这图来自于这篇论文：
，论文很长，第7页那里开始讲LeNet5这个结构，建议看看那部分。
我这里简单说一下，LeNet5这张图从左到右，先是input，这是输入层，即输入的图片。
input-layer到C1这部分就是一个卷积层（convolution运算），C1到S2是一个子采样层（pooling运算），关于卷积和子采样的具体过程可以参考下图：
然后，S2到C3又是卷积，C3到S4又是子采样，可以发现，卷积和子采样都是成对出现的，卷积后面一般跟着子采样。
S4到C5之间是全连接的，这就相当于一个MLP的隐含层了（如果你不清楚MLP，参考《》）。
C5到F6同样是全连接，也是相当于一个MLP的隐含层。
最后从F6到输出output，其实就是一个分类器，这一层就叫分类层。
ok，CNN的基本结构大概就是这样，由输入、卷积层、子采样层、全连接层、分类层、输出这些基本“构件”组成，一般根据具体的应用或者问题，去确定要多少卷积层和子采样层、采用什么分类器。
当确定好了结构以后，如何求解层与层之间的连接参数？
一般采用向前传播（FP）+向后传播（BP）的方法来训练。
具体可参考上面给出的链接。
二、CNN卷积神经网络代码详细解读（基于python+theano）
代码来自于深度学习教程：
，这个代码实现的是一个简化了的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]
1.importcPickle
2.importgzip
3.importos
4.importsys
5.importtime
6.importnumpy
7.importtheano
8.importtheano.tensorasT
9.fromimportdownsample
10.fromimportconv
（2）定义CNN的基本"构件"
CNN的基本构件包括卷积采样层、隐含层、分类器，如下
∙定义LeNetConvPoolLayer（卷积+采样层）
见代码注释：
[python]
1."""
2.
3.卷积+下采样合成一个层LeNetConvPoolLayer
4.
5.rng:
随机数生成器，用于初始化W
6.
7.?
8.filter_shape:
（numberoffilters,numinputfeaturemaps,filterheight,filterwidth）
9.image_shape:
（batchsize,numinputfeaturemaps,imageheight,imagewidth）
10.poolsize:
（#rows,#cols）
11."""
12.
13.classLeNetConvPoolLayer（object）:
14.def__init__（self,rng,input,filter_shape,image_shape,poolsize=（2,
15.2））:
16.#assert?
condition，condition为True，则继续往下执行，condition为False，中断程序
17.#image_shape[1]和filter_shape[1]都是numinputfeaturemaps，它们必须是一样的。
18.assertimage_shape[1]==filter_shape[1]
19.self.input=input
20.#每个隐层神经元（即像素）与上一层的连接数为numinputfeaturemaps*filterheight*filterwidth。
21.#可以用numpy.prod（filter_shape[1:
]）来求得
22.
23.fan_in=numpy.prod（filter_shape[1:
]）
24.#lowerlayer上每个神经元获得的梯度来自于：
"numoutputfeaturemaps*filterheight*filterwidth"/poolingsize
25.fan_out=（filter_shape[0]*numpy.prod（filter_shape[
26.2:
]）/
27.numpy.prod（poolsize））
28.#以上求得fan_in、fan_out，将它们代入公式，以此来随机初始化W,W就是线性卷积核
29.W_bound=numpy.sqrt（6./（fan_in+fan_out））
30.self.W=theano.shared（
31.numpy.asarray（
32.rng.uniform（low=-W_bound,high=W_bound,size=filter_shape）,
33.
34.）,
35.borrow=True
36.）
37.
38.#thebiasisa1Dtensor--onebiasperoutputfeaturemap
39.#偏置b是一维向量，每个输出图的特征图都对应一个偏置，
40.
41.#而输出的特征图的个数由filter个数决定，因此用filter_shape[0]即numberoffilters来初始化
42.b_values=numpy.zeros（（filter_shape[0
43.self.b=theano.shared（value=b_values,borrow=True）
44.#将输入图像与filter卷积，conv.conv2d函数
45.
46.#卷积完没有加b再通过sigmoid，这里是一处简化。
47.
48.conv_out=conv.conv2d（
49.input=input,
50.filters=self.W,
51.filter_shape=filter_shape,
52.image_shape=image_shape
53.）
54.
55.#maxpooling，最大子采样过程
56.
57.pooled_out=downsample.max_pool_2d（
58.input=conv_out,
59.ds=poolsize,
60.ignore_border=True
61.）
62.
63.#加偏置，再通过tanh映射，得到卷积+子采样层的最终输出
64.
65.#因为b是一维向量，这里用维度转换函数dimshuffle将其reshape。
比如b是（10,），
66.
67.#则b.dimshuffle（'x',0,'x','x'））将其reshape为（1,10,1,1）
68.self.output=T.tanh（pooled_out+self.b.dimshuffle（'x',
69.0,
70.'x',
71.'x'））
72.#卷积+采样层的参数
73.
74.self.params=[self.W,
75.self.b]
∙定义隐含层HiddenLayer
这个跟上一篇文章《》中的HiddenLayer是一致的，直接拿过来：
[python]
1."""
2.
3.注释：
4.
5.这是定义隐藏层的类，首先明确：
隐藏层的输入即input，输出即隐藏层的神经元个数。
输入层与隐藏层是全连接的。
6.
7.假设输入是n_in维的向量（也可以说时n_in个神经元），隐藏层有n_out个神经元，则因为是全连接，
8.
9.一共有n_in*n_out个权重，故W大小时（n_in,n_out）,n_in行n_out列，每一列对应隐藏层的每一个神经元的连接权重。
10.
11.b是偏置，隐藏层有n_out个神经元，故b时n_out维向量。
12.
13.?
14.input训练模型所用到的所有输入，并不是MLP的输入层，MLP的输入层的神经元个数时n_in，而这里的参数input大小是（n_example,n_in）,每一行一个样本，即每一行作为MLP的输入层。
15.
16.activation:
激活函数,这里定义为函数tanh
17.
18."""
19.
20.classHiddenLayer（object）:
21.def__init__（self,rng,input,n_in,n_out,W=None,
22.b=None,
23.activation=T.tanh）:
24.self.input=input#类HiddenLayer的input即所传递进来的input
25."""
26.注释：
27.?
28.另外，W的初始化有个规则：
如果使用tanh函数，则在-sqrt（6./（n_in+n_hidden））到sqrt（6./（n_in+n_hidden））之间均匀
29.抽取数值来初始化W，若时sigmoid函数，则以上再乘4倍。
30."""
31.#如果W未初始化，则根据上述方法初始化。
32.#加入这个判断的原因是：
有时候我们可以用训练好的参数来初始化W，见我的上一篇文章。
33.ifWisNone:
34.W_values=numpy.asarray（
35.rng.uniform（
36.low=-numpy.sqrt（6./（n_in+n_out））,
37.high=numpy.sqrt（6./（n_in+n_out））,
38.size=（n_in,n_out）
39.）,
40.
41.）
42.
43.if
44.W_values*=4
45.W=theano.shared（value=W_values,name='W',
46.borrow=True）
47.ifbisNone:
48.
49.b=theano.shared（value=b_values,name='b',
50.borrow=True）
51.#用上面定义的W、b来初始化类HiddenLayer的W、b
52.self.W=W
53.self.b=b
54.#隐含层的输出
55.lin_output=T.dot（input,self.W）+self.b?
56.
57.self.output=（
58.lin_outputifactivationisNone
59.elseactivation（lin_output）
60.）
61.
62.#隐含层的参数
63.self.params=[self.W,
64.self.b]
∙定义分类器（Softmax回归）
采用Softmax，这跟《》中的LogisticRegression是一样的，直接拿过来：
[python]
1."""
2.
3.定义分类层LogisticRegression，也即Softmax回归
4.
5.在deeplearning?
tutorial中，直接将LogisticRegression视为Softmax，
6.而我们所认识的二类别的逻辑回归就是当n_out=2时的LogisticRegression
7.
8."""
9.
10.#参数说明：
11.
12.#input，大小就是（n_example,n_in），其中n_example是一个batch的大小，
13.
14.#因为我们训练时用的是Minibatch?
SGD，因此input这样定义
15.#n_in,即上一层（隐含层）的输出
16.
17.#n_out,输出的类别数?
18.classLogisticRegression（object）:
19.def__init__（self,input,n_in,n_out）:
20.#W大小是n_in行n_out列，b为n_out维向量。
即：
每个输出对应W的一列以及b的一个元素。
21.self.W=theano.shared（
22.value=numpy.zeros（
23.（n_in,n_out）,
24.
25.）,
26.name='W',
27.borrow=True
28.）
29.
30.self.b=theano.shared（
31.value=numpy.zeros（
32.（n_out,）,
33.
34.）,
35.name='b',
36.borrow=True
37.）
38.
39.#input是（n_example,n_in），W是（n_in,n_out）,点乘得到（n_example,n_out），加上偏置b，
40.
41.
42.#故p_y_given_x每一行代表每一个样本被估计为各类别的概率?
43.#PS：
b是n_out维向量，与（n_example,n_out）矩阵相加，内部其实是先复制n_example个b，
44.
45.#然后（n_example,n_out）矩阵的每一行都加b
46.
47.selfself.W）+self.b）
48.#argmax返回最大值下标，因为本例数据集是MNIST，下标刚好就是类别。
axis=1表示按行操作。
49.
50.self.y_pred=T.argmax（self.p_y_given_x,
51.axis=1）
52.#params，LogisticRegression的参数?
53.self.params=[self.W,
54.self.b]
到这里，CNN的基本”构件“都有了，下面要用这些”构件“组装成LeNet5（当然，是简化的，上面已经说了），具体来说，就是组装成：
LeNet5=input+LeNetConvPoolLayer_1+LeNetConvPoolLayer_2+HiddenLayer+LogisticRegression+output。
然后将其应用于MNIST数据集，用BP算法去解这个模型，得到最优的参数。
（3）加载MNIST数据集（）
[python]
1."""
2.
3.加载MNIST数据集load_data（）
4.
5."""
6.
7.defload_data（dataset）:
8.#
9.dataset是数据集的路径，程序首先检测该路径下有没有MNIST数据集，没有的话就下载MNIST数据集
10.#这一部分就不解释了，与softmax回归算法无关。
11.
12.ifdata_dir==""andnot
13.#Checkifdatasetisinthedatadirectory.
14.
15.0],
16.
17."..",
18."data",
19.dataset
20.）
21.
22.ifordata_file==:
23.dataset=new_path
24.if（notanddata_file==:
25.importurllib
26.origin=（
27.
28.）
29.
30.print'Downloadingdatafrom%s'%origin
31.urllib.urlretrieve（origin,dataset）
32.print'...loadingdata'
33.
34.
35.#主要用到python里的gzip.open（）函数,以及?
cPickle.load（）。
36.#‘rb’表示以二进制可读的方式打开文件
37.
38.f=gzip.open（dataset,'rb'）
39.train_set,valid_set,test_set=cPickle.load（f）
40.f.close（）
41.#将数据设置成sharedvariables，主要时为了GPU加速，只有sharedvariables才能存到GPUmemory中
42.#GPU里数据类型只能是float。
而data_y是类别，所以最后又转换为int返回
43.
44.defshared_dataset（data_xy,borrow=True）:
45.data_x,data_y=data_xy
46.shared_x=theano.shared（numpy.asarray（data_x,
47.
48.borrow=borrow）
49.shared_y=theano.shared（numpy.asarray（data_y,
50.
51.borrow=borrow）
52.returnshared_x,T.cast（shared_y,'int32'）
53.test_set_x,test_set_y=shared_dataset（test_set）
54.valid_set_x,valid_set_y=shared_dataset（valid_set）
55.train_set_x,train_set_y=shared_dataset（train_set）
56.rval=[（train_set_x,train_set_y）,（valid_set_x,valid_set_y）,
57.（test_set_x,test_set_y）]
58.returnrval
（4）实现LeNet5并测试
[python]
1."""
2.
3.实现LeNet5
4.
5.LeNet5有两个卷积层，第一个卷积层有20个卷积核，第二个卷积层有50个卷积核
6.
7."""
8.
9.defevaluate_lenet5（learning_rate=0.1,
10.n_epochs=200,
11.dataset=,
12.nkerns=[20,
13.50],
14.batch_size=500）:
15."""
16.
17.learning_rate:
学习速率，随机梯度前的系数。
18.n_epochs训练步数，每一步都会遍历所有batch，即所有样本
19.batch_size,这里设置为500，即每遍历完500个样本，才计算梯度并更新参数
20.nkerns=[20,50],每一个LeNetConvPoolLayer卷积核的个数，第一个LeNetConvPoolLayer有
21.20个卷积核，第二个有50个
22."""
23.23455）
24.
25.#加载数据
26.datasets=load_data（dataset）
27.train_set_x,train_set_y=datasets[0]
28.valid_set_x,valid_set_y=datasets[1]
29.test_set_x,test_set_y=datasets[2]
30.#
31.计算batch的个数
32.n_train_batches=train_set_x.get_value（borrow=True）.shape[0]
33.n_valid_batches=valid_set_x.get_value（borrow=True）.shape[0]
34.n_test_batches=test_set_x.get_value（borrow=True）.shape[0]
35.n_train_batches/=batch_size
36.n_valid_batches/=batch_size
37.n_test_batches/=batch_size
38.#定义几个变量，index表示batch下标，x表示输入的训练数据，y对应其标签
39.index=T.lscalar（）
40.x=T.matrix（'x'）
41.y=T.ivector（'y'）
42.######################
43.#BUILDACTUALMODEL#
44.######################
45.print'...buildingthemodel'
46.#我们加载进来的batch大小的数据是（batch_size,28*28），但是LeNetConvPoolLayer的输入是四维的，所以要reshape
47.layer0_input=x.reshape（（batch_size,1,
48.28,
49.28））
50.#layer0即第一个LeNetConvPoolLayer层
51.#输入的单张图片（28,28），经过conv得到（28-5+1,28-5+1）=（24,24），
52.#经过maxpooling得到（24/2,24/2）=（12,12）
53.#因为每个batch有batch_size张图，第一个LeNetConvPoolLayer层有nkerns[0]个卷积核，
54.
55.#故layer0输出为（batch_size,nkerns[0],12,12）
56.layer0=LeNetConvPoolLayer（
57.rng,
58.input=layer0_input,
59.image_shape=（batch_size,1,
60.28,
61.28）,
62.filter_shape=（nkerns[0],
63.1,
64.5,
65.5）,
66.poolsize=（2,
67.2）
68.）
69.
70.#layer1即第二个LeNetConvPoolLayer层
71.
72.#输入是layer0的输出，每张特征图为（12,12）,经过conv得到（12-5+1,12-5+1）=（8,8）,
73.#经过maxpooling得到（8/2,8/2）=（4,4）
74.#因为每个batch有batch_size张图（特征图），第二个LeNetConvPoolLayer层有nkerns[1]个卷积核
75.
76.#，故layer1输出为（batch_size,nkerns[1],4,4）
77.layer1=LeNetConvPoolLayer（
78.rng,
79.input=layer0.output,
80.image_shape=（batch_size,nkerns[0],
81.12,
82.12）,#输入nkerns[0]张特征图，即layer0输出nkerns[0]张特征图
83.filter_shape=（nkerns[1],
84.nkerns[0],
85.5,
8
升级会员 