2022年2022年卷积神经网络全面解析之代码详解 .pdf

《2022年2022年卷积神经网络全面解析之代码详解 .pdf》由会员分享，可在线阅读，更多相关《2022年2022年卷积神经网络全面解析之代码详解 .pdf（24页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、卷积神经网络全面解析之代码详解本文介绍多层感知机算法，特别是详细解读其代码实现，基于python theano ，代码来自 ：Convolutional Neural Networks (LeNet)。一、CNN 卷积神经网络原理简介要讲明白卷积神经网络， 估计得长篇大论，网上有很多博文已经写得很好了，所以本文就不重复了，如果你了解CNN ，那可以往下看，本文主要是详细地解读CNN 的实现代码。CNN 的最大特点就是稀疏连接（局部感受）和权值共享，如下面两图所示，左为稀疏连接，右为权值共享。稀疏连接和权值共享可以减少所要训练的参数，减少计算复杂度。至于 CNN 的结构，以经典的LeNet5来说

2、明：名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 1 页，共 24 页 - - - - - - - - - 这个图真是无处不在， 一谈 CNN ， 必说 LeNet5 ， 这图来自于这篇论文：Gradient-Based Learning Applied to Document Recognition，论文很长，第 7 页那里开始讲LeNet5这个结构，建议看看那部分。我这里简单说一下， LeNet5这张图从左到右，先是input ，这是输入层，即输入的图片。 input-laye

3、r到 C1 这部分就是一个卷积层（convolution运算），C1 到 S2 是一个子采样层 （pooling运算），关于卷积和子采样的具体过程可以参考下图：然后， S2 到 C3 又是卷积， C3 到 S4 又是子采样，可以发现，卷积和子采样都是成对出现的，卷积后面一般跟着子采样。S4 到 C5 之间是全连接的，这就相当于一个MLP 的隐含层了（如果你不清楚MLP，参考DeepLearning tutorial（3）MLP 多层感知机原理简介 + 代码详解）。C5 到 F6 同样是全连接，也是相当于一个MLP 的隐含层。最后从F6到输出 output，其实就是一个分类器，这一层就叫分类层。

4、ok ，CNN 的基本结构大概就是这样，由输入、卷积层、子采样层、全连接层、分类层、输出这些基本“ 构件” 组成，一般根据具体的应用或者名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 2 页，共 24 页 - - - - - - - - - 问题，去确定要多少卷积层和子采样层、采用什么分类器。当确定好了结构以后，如何求解层与层之间的连接参数？一般采用向前传播（FP）+ 向后传播（ BP）的方法来训练。具体可参考上面给出的链接。二、CNN 卷积神经网络代码详细解读（基于python+t

5、heano）代码来自于深度学习教程：Convolutional Neural Networks (LeNet)，这个代码实现的是一个简化了的LeNet5 ，具体如下：没有实现 location-specific gain and bias parameters用的是 maxpooling，而不是 average_pooling分类器用的是 softmax，LeNet5用的是 rbfLeNet5第二层并不是全连接的，本程序实现的是全连接另外，代码里将卷积层和子采用层合在一起，定义为“ LeNetConvPoolLayer“（卷积采样层），这好理解，因为它们总是成对出现。但是有个地方需要注意， 代

6、码中将卷积后的输出直接作为子采样层的输入，而没有加偏置b 再通过 sigmoid函数进行映射，即没有了下图中 fx 后面的 bx 以及 sigmoid映射，也即直接由fx 得到 Cx。最后，代码中第一个卷积层用的卷积核有20 个，第二个卷积层用50个，而不是上面那张LeNet5图中所示的 6 个和 16 个。了解了这些，下面看代码：（1）导入必要的模块名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 3 页，共 24 页 - - - - - - - - - import cPickle

7、 import gzip import os import sys import time import numpy import theano import theano.tensor as T from theano.tensor.signal import downsample from theano.tensor.nnet import conv （2）定义 CNN 的基本 构件CNN 的基本构件包括卷积采样层、隐含层、分类器，如下定义 LeNetConvPoolLayer （卷积 +采样层）见代码注释： 卷积+下采样合成一个层 LeNetConvPoolLayer rng: 随机数生

8、成器，用于初始化W input:4维的向量， theano.tensor.dtensor4 filter_shape:(number of filters, num input feature maps,filter height, filter width) image_shape:(batch size, num input feature maps,image height, image width) poolsize: (#rows, #cols) 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - -

9、 - - - - 第 4 页，共 24 页 - - - - - - - - - class LeNetConvPoolLayer(object): def _init_(self, rng, input, filter_shape, image_shape, poolsize=(2, 2): #assert condition，condition为 True，则继续往下执行， condition为 False ，中断程序#image_shape1 和 filter_shape1都是 num input feature maps，它们必须是一样的。 assert image_shape1 = f

10、ilter_shape1 self.input = input #每个隐层神经元（即像素）与上一层的连接数为num input feature maps * filter height * filter width。#可以用 numpy.prod(filter_shape1:)来求得 fan_in = numpy.prod(filter_shape1:) #lower layer上每个神经元获得的梯度来自于：num output feature maps * filter height * filter width /pooling size fan_out = (filter_shape0

11、* numpy.prod(filter_shape2:) / numpy.prod(poolsize) #以上求得 fan_in 、fan_out ，将它们代入公式，以此来随机初始化W,W 就是线性卷积核 W_bound = numpy.sqrt(6. / (fan_in + fan_out) self.W = theano.shared( numpy.asarray( 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 5 页，共 24 页 - - - - - - - - - rng.

12、uniform(low=-W_bound, high=W_bound, size=filter_shape), dtype=theano.config.floatX ), borrow=True ) # the bias is a 1D tensor - one bias per output feature map #偏置 b 是一维向量，每个输出图的特征图都对应一个偏置，#而输出的特征图的个数由filter个数决定，因此用 filter_shape0即 number of filters来初始化 b_values = numpy.zeros(filter_shape0,), dtype=t

13、heano.config.floatX) self.b = theano.shared(value=b_values, borrow=True) #将输入图像与 filter卷积， conv.conv2d 函数#卷积完没有加 b 再通过 sigmoid ，这里是一处简化。 conv_out = conv.conv2d( input=input, filters=self.W, filter_shape=filter_shape, image_shape=image_shape ) #maxpooling ，最大子采样过程 pooled_out = downsample.max_pool_2d(

14、 input=conv_out, 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 6 页，共 24 页 - - - - - - - - - ds=poolsize, ignore_border=True ) #加偏置，再通过 tanh 映射，得到卷积 +子采样层的最终输出#因为 b 是一维向量，这里用维度转换函数dimshuffle将其 reshape。比如 b 是(10,) ，#则 b.dimshuffle(x, 0, x, x)将其 reshape 为(1,10,1,1) sel

15、f.output = T.tanh(pooled_out + self.b.dimshuffle(x, 0, x, x) #卷积+采样层的参数 self.params = self.W, self.b 定义隐含层 HiddenLayer这个跟上一篇文章DeepLearning tutorial（3）MLP 多层感知机原理简介+ 代码详解中的 HiddenLayer是一致的，直接拿过来： 注释：这是定义隐藏层的类，首先明确：隐藏层的输入即input ，输出即隐藏层的神经元个数。输入层与隐藏层是全连接的。假设输入是 n_in 维的向量（也可以说时 n_in 个神经元） ，隐藏层有 n_out 个神

16、经元，则因为是全连接，一共有 n_in*n_out个权重，故 W大小时 (n_in,n_out),n_in行 n_out 列，每一列对应隐藏层的每一个神经元的连接权重。b 是偏置，隐藏层有n_out 个神经元，故 b 时 n_out 维向量。rng 即随机数生成器， numpy.random.RandomState，用于初始化 W 。名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 7 页，共 24 页 - - - - - - - - - input 训练模型所用到的所有输入，并不是M

17、LP 的输入层， MLP的输入层的神经元个数时 n_in ，而这里的参数 input 大小是（ n_example,n_in ）, 每一行一个样本，即每一行作为MLP的输入层。activation:激活函数 , 这里定义为函数 tanh class HiddenLayer(object): def _init_(self, rng, input, n_in, n_out, W=None, b=None, activation=T.tanh): self.input = input #类 HiddenLayer 的 input即所传递进来的input 注释：代码要兼容 GPU ，则必须使用 dt

18、ype=theano.config.floatX,并且定义为 theano.shared 另外， W的初始化有个规则：如果使用tanh 函数，则在-sqrt(6./(n_in+n_hidden)到 sqrt(6./(n_in+n_hidden)之间均匀抽取数值来初始化W ，若时 sigmoid 函数，则以上再乘4 倍。 #如果 W未初始化，则根据上述方法初始化。 #加入这个判断的原因是：有时候我们可以用训练好的参数来初始化W ，见我的上一篇文章。 if W is None: W_values = numpy.asarray( rng.uniform( low=-numpy.sqrt(6. /

19、(n_in + n_out), high=numpy.sqrt(6. / (n_in + n_out), size=(n_in, n_out) 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 8 页，共 24 页 - - - - - - - - - ), dtype=theano.config.floatX ) if activation = theano.tensor.nnet.sigmoid: W_values *= 4 W = theano.shared(value=W_val

20、ues, name=W, borrow=True) if b is None: b_values = numpy.zeros(n_out,), dtype=theano.config.floatX) b = theano.shared(value=b_values, name=b, borrow=True) #用上面定义的 W 、b 来初始化类 HiddenLayer 的 W 、b self.W = W self.b = b #隐含层的输出 lin_output = T.dot(input, self.W) + self.b self.output = ( lin_output if acti

21、vation is None else activation(lin_output) ) #隐含层的参数 self.params = self.W, self.b 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 9 页，共 24 页 - - - - - - - - - 定义分类器（Softmax 回归）采用 Softmax，这跟DeepLearning tutorial（1）Softmax回归原理简介+ 代码详解中的 LogisticRegression是一样的，直接拿过来： 定义分

22、类层 LogisticRegression，也即 Softmax 回归在 deeplearning tutorial中，直接将 LogisticRegression视为 Softmax，而我们所认识的二类别的逻辑回归就是当n_out=2 时的 LogisticRegression #参数说明：#input ，大小就是 (n_example,n_in)，其中 n_example 是一个 batch 的大小，#因为我们训练时用的是Minibatch SGD ，因此 input 这样定义#n_in, 即上一层 (隐含层 ) 的输出#n_out, 输出的类别数class LogisticRegress

23、ion(object): def _init_(self, input, n_in, n_out): #W大小是 n_in 行 n_out 列，b 为 n_out 维向量。即：每个输出对应W的一列以及 b 的一个元素。 self.W = theano.shared( value=numpy.zeros( (n_in, n_out), dtype=theano.config.floatX ), name=W, borrow=True 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 10

24、 页，共 24 页 - - - - - - - - - ) self.b = theano.shared( value=numpy.zeros( (n_out,), dtype=theano.config.floatX ), name=b, borrow=True ) #input 是(n_example,n_in)， W是 （n_in,n_out ） , 点乘得到 (n_example,n_out) ，加上偏置 b，#再作为 T.nnet.softmax的输入，得到 p_y_given_x #故 p_y_given_x 每一行代表每一个样本被估计为各类别的概率#PS ：b 是 n_out 维

25、向量，与 (n_example,n_out) 矩阵相加，内部其实是先复制n_example 个 b，#然后(n_example,n_out) 矩阵的每一行都加b self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b) #argmax返回最大值下标， 因为本例数据集是MNIST ， 下标刚好就是类别。 axis=1表示按行操作。 self.y_pred = T.argmax(self.p_y_given_x, axis=1) #params，LogisticRegression的参数 self.params = self.

26、W, self.b 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 11 页，共 24 页 - - - - - - - - - 到这里， CNN 的基本 ” 构件 “ 都有了，下面要用这些 ” 构件“ 组装成LeNet5 （当然， 是简化的， 上面已经说了） ，具体来说， 就是组装成：LeNet5=input+LeNetConvPoolLayer_1+LeNetConvPoolLayer_2+HiddenLayer+LogisticRegression+output。然后将其应用于M

27、NIST 数据集，用 BP 算法去解这个模型，得到最优的参数。（3）加载 MNIST数据集（ mnist.pkl.gz） 加载 MNIST数据集 load_data() def load_data(dataset): # dataset是数据集的路径，程序首先检测该路径下有没有MNIST数据集，没有的话就下载 MNIST数据集 #这一部分就不解释了，与softmax 回归算法无关。 data_dir, data_file = os.path.split(dataset) if data_dir = and not os.path.isfile(dataset): # Check if data

28、set is in the data directory. new_path = os.path.join( os.path.split(_file_)0, ., data, dataset ) if os.path.isfile(new_path) or data_file = mnist.pkl.gz: 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 12 页，共 24 页 - - - - - - - - - dataset = new_path if (not os.path.

29、isfile(dataset) and data_file = mnist.pkl.gz: import urllib origin = ( http:/www.iro.umontreal.ca/lisa/deep/data/mnist/mnist.pkl.gz ) print Downloading data from %s % origin urllib.urlretrieve(origin, dataset) print . loading data #以上是检测并下载数据集mnist.pkl.gz，不是本文重点。下面才是load_data的开始#从mnist.pkl.gz里加载 tra

30、in_set, valid_set, test_set，它们都是包括label的#主要用到 python 里的 gzip.open()函数 , 以及 cPickle.load()。#rb表示以二进制可读的方式打开文件 f = gzip.open(dataset, rb) train_set, valid_set, test_set = cPickle.load(f) f.close() #将数据设置成shared variables，主要时为了GPU加速，只有shared variables才能存到 GPU memory中#GPU里数据类型只能是float。而 data_y 是类别，所以最后又

31、转换为int返回 def shared_dataset(data_xy, borrow=True): data_x, data_y = data_xy shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 13 页，共

32、 24 页 - - - - - - - - - dtype=theano.config.floatX), borrow=borrow) return shared_x, T.cast(shared_y, int32) test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = (train_set_x, train_set_y),

33、(valid_set_x, valid_set_y), (test_set_x, test_set_y) return rval （4）实现 LeNet5并测试 实现 LeNet5 LeNet5 有两个卷积层，第一个卷积层有20 个卷积核，第二个卷积层有50 个卷积核 def evaluate_lenet5(learning_rate=0.1, n_epochs=200, dataset=mnist.pkl.gz, nkerns=20, 50, batch_size=500): learning_rate:学习速率，随机梯度前的系数。 n_epochs 训练步数，每一步都会遍历所有batch

34、，即所有样本 batch_size,这里设置为 500，即每遍历完 500 个样本，才计算梯度并更新参数名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 14 页，共 24 页 - - - - - - - - - nkerns=20, 50,每一个 LeNetConvPoolLayer 卷积核的个数，第一个LeNetConvPoolLayer 有 20 个卷积核，第二个有50个 rng = numpy.random.RandomState(23455) #加载数据 datasets =

35、 load_data(dataset) train_set_x, train_set_y = datasets0 valid_set_x, valid_set_y = datasets1 test_set_x, test_set_y = datasets2 # 计算 batch 的个数 n_train_batches = train_set_x.get_value(borrow=True).shape0 n_valid_batches = valid_set_x.get_value(borrow=True).shape0 n_test_batches = test_set_x.get_valu

36、e(borrow=True).shape0 n_train_batches /= batch_size n_valid_batches /= batch_size n_test_batches /= batch_size #定义几个变量， index 表示 batch 下标，x 表示输入的训练数据， y 对应其标签 index = T.lscalar() x = T.matrix(x) y = T.ivector(y) 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 15 页，共 2

37、4 页 - - - - - - - - - # # BUILD ACTUAL MODEL # # print . building the model #我们加载进来的 batch 大小的数据是 (batch_size, 28 * 28)，但是LeNetConvPoolLayer 的输入是四维的，所以要reshape layer0_input = x.reshape(batch_size, 1, 28, 28) # layer0即第一个 LeNetConvPoolLayer 层#输入的单张图片 (28,28) ，经过 conv 得到(28-5+1 , 28-5+1) = (24, 24)，#经

38、过 maxpooling 得到(24/2, 24/2) = (12, 12) #因为每个 batch 有 batch_size张图，第一个 LeNetConvPoolLayer 层有nkerns0 个卷积核，#故 layer0 输出为 (batch_size, nkerns0, 12, 12) layer0 = LeNetConvPoolLayer( rng, input=layer0_input, image_shape=(batch_size, 1, 28, 28), filter_shape=(nkerns0, 1, 5, 5), poolsize=(2, 2) ) #layer1 即第

39、二个 LeNetConvPoolLayer 层名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 16 页，共 24 页 - - - - - - - - - #输入是 layer0 的输出， 每张特征图为 (12,12),经过 conv 得到(12-5+1, 12-5+1) = (8, 8), #经过 maxpooling 得到(8/2, 8/2) = (4, 4) #因为每个 batch 有 batch_size张图（特征图），第二个LeNetConvPoolLayer层有 nkern

40、s1 个卷积核#，故 layer1 输出为 (batch_size, nkerns1, 4, 4) layer1 = LeNetConvPoolLayer( rng, input=layer0.output, image_shape=(batch_size, nkerns0, 12, 12),#输入 nkerns0 张特征图，即 layer0 输出 nkerns0 张特征图 filter_shape=(nkerns1, nkerns0, 5, 5), poolsize=(2, 2) ) #前面定义好了两个LeNetConvPoolLayer（layer0 和 layer1 ），layer1后面

41、接layer2 ，这是一个全连接层，相当于MLP里面的隐含层#故可以用 MLP中定义的 HiddenLayer 来初始化 layer2 ， layer2的输入是二维的(batch_size, num_pixels) ，#故要将上层中同一张图经不同卷积核卷积出来的特征图合并为一维向量，#也就是将 layer1 的输出 (batch_size, nkerns1, 4, 4)flatten为(batch_size, nkerns1*4*4)=(500，800), 作为 layer2 的输入。#(500，800)表示有 500 个样本，每一行代表一个样本。layer2 的输出大小是(batch_siz

42、e,n_out)=(500,500) layer2_input = layer1.output.flatten(2) layer2 = HiddenLayer( rng, 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 17 页，共 24 页 - - - - - - - - - input=layer2_input, n_in=nkerns1 * 4 * 4, n_out=500, activation=T.tanh ) #最后一层 layer3 是分类层，用的是逻辑回归中定义的Lo

43、gisticRegression，#layer3 的输入是 layer2 的输出 (500,500) ，layer3 的输出就是(batch_size,n_out)=(500,10) layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10) #代价函数 NLL cost = layer3.negative_log_likelihood(y) # test_model 计算测试误差， x、y 根据给定的 index 具体化，然后调用 layer3 ，#layer3 又会逐层地调用layer2 、layer1 、lay

44、er0 ，故 test_model 其实就是整个 CNN 结构，#test_model 的输入是 x、y，输出是 layer3.errors(y)的输出，即误差。 test_model = theano.function( index, layer3.errors(y), givens= x: test_set_xindex * batch_size: (index + 1) * batch_size, y: test_set_yindex * batch_size: (index + 1) * batch_size ) 名师资料总结 - - -精品资料欢迎下载 - - - - - - - -

45、 - - - - - - - - - - 名师精心整理 - - - - - - - 第 18 页，共 24 页 - - - - - - - - - #validate_model ，验证模型，分析同上。 validate_model = theano.function( index, layer3.errors(y), givens= x: valid_set_xindex * batch_size: (index + 1) * batch_size, y: valid_set_yindex * batch_size: (index + 1) * batch_size ) #下面是 train

46、_model ，涉及到优化算法即SGD ，需要计算梯度、更新参数 #参数集 params = layer3.params + layer2.params + layer1.params + layer0.params #对各个参数的梯度 grads = T.grad(cost, params) #因为参数太多，在updates 规则里面一个一个具体地写出来是很麻烦的，所以下面用了一个 for.in.,自动生成规则对 (param_i, param_i - learning_rate * grad_i) updates = (param_i, param_i - learning_rate *

47、grad_i) for param_i, grad_i in zip(params, grads) 名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 19 页，共 24 页 - - - - - - - - - #train_model ，代码分析同 test_model 。train_model里比 test_model 、validation_model多出 updates 规则 train_model = theano.function( index, cost, updates=

48、updates, givens= x: train_set_xindex * batch_size: (index + 1) * batch_size, y: train_set_yindex * batch_size: (index + 1) * batch_size ) # # 开始训练 # # print . training patience = 10000 patience_increase = 2 improvement_threshold = 0.995 validation_frequency = min(n_train_batches, patience / 2) # 这样设

49、置 validation_frequency可以保证每一次 epoch都会在验证集上测试。 best_validation_loss = numpy.inf #最好的验证集上的 loss ，最好即最小名师资料总结 - - -精品资料欢迎下载 - - - - - - - - - - - - - - - - - - 名师精心整理 - - - - - - - 第 20 页，共 24 页 - - - - - - - - - best_iter = 0 #最好的迭代次数，以 batch 为单位。比如 best_iter=10000，说明在训练完第10000个 batch 时，达到best_validat

50、ion_loss test_score = 0. start_time = time.clock() epoch = 0 done_looping = False #下面就是训练过程了， while 循环控制的时步数epoch，一个 epoch 会遍历所有的 batch ，即所有的图片。#for 循环是遍历一个个batch ，一次一个 batch 地训练。 for 循环体里会用train_model(minibatch_index)去训练模型，#train_model里面的 updatas 会更新各个参数。#for 循环里面会累加训练过的batch 数 iter ， 当 iter是 valid