【CNN模型笔记（一）】Lenet-5模型+代码实现

LeNet神经网络由深度学习三巨头之一的Yan LeCun提出，他同时也是卷积神经网络 (CNN，Convolutional Neural Networks)之父。LeNet主要用来进行手写字符的识别与分类，并在美国的银行中投入了使用。LeNet的实现确立了CNN的结构，现在神经网络中的许多内容在LeNet的网络结构中都能看到，例如卷积层，Pooling层，ReLU层。虽然LeNet早在20世纪90年代就已经提出了，但由于当时缺乏大规模的训练数据，计算机硬件的性能也较低，因此LeNet神经网络在处理复杂问题时效果并不理想。虽然LeNet网络结构比较简单，但是刚好适合神经网络的入门学习。

---

Part1 相关理论

卷积的概念这个我想只要学过图像处理的人都懂的概念了，这个不解释。我们知道对于给定的一幅图像来说，给定一个卷积核，卷积就是根据卷积窗口，进行像素的加权求和。

卷积神经网络与我们之前所学到的图像的卷积的区别，我的理解是：我们之前学图像处理遇到卷积，一般来说，这个卷积核是已知的，比如各种边缘检测算子、高斯模糊等这些，都是已经知道卷积核，然后再与图像进行卷积运算。然而深度学习中的卷积神经网络卷积核是未知的，我们训练一个神经网络，就是要训练得出这些卷积核，而这些卷积核就相当于我们学单层感知器的时候的那些参数W，因此你可以把这些待学习的卷积核看成是神经网络的训练参数W。

2、池化

刚开始学习CNN的时候，看到这个词，好像高大上的样子，于是查了很多资料，理论一大堆，但是实践、算法实现却都没讲到，也不懂池化要怎么实现？其实所谓的池化，就是图片下采样。这个时候，你会发现CNN每一层的构建跟图像高斯金字塔的构建有点类似，因此你如果已经懂得了图像金字塔融合的相关算法，那么就变的容易理解了。在高斯金子塔构建中，每一层通过卷积，然后卷积后进行下采样，而CNN也是同样的过程。废话不多说，这里就讲一下，CNN的池化：

CNN的池化(图像下采样)方法很多：Mean pooling(均值采样)、Max pooling(最大值采样)、Overlapping (重叠采样)、L2 pooling(均方采样)、Local Contrast Normalization(归一化采样)、Stochasticpooling(随即采样)、Def-pooling(形变约束采样)。其中最经典的是最大池化，因此我就解释一下最大池化的实现：

原图片

为了简单起见，我用上面的图片作为例子，假设上面的图片大小是4*4的，如上图所示，然后图片中每个像素点的值是上面各个格子中的数值。然后我要对这张4*4的图片进行池化，池化的大小为(2,2)，跨步为2，那么采用最大池化也就是对上面4*4的图片进行分块，每个块的大小为2*2，然后统计每个块的最大值，作为下采样后图片的像素值，具体计算如下图所示：

也就是说我们最后得到下采样后的图片为：

这就是所谓的最大池化。当然以后你还会遇到各种池化方法，比如均值池化，也就是对每个块求取平均值作为下采样的新像素值。还有重叠采样的池化，我上面这个例子是没有重叠的采样的，也就是每个块之间没有相互重叠的部分，上面我说的跨步为2，就是为了使得分块都非重叠，等等，这些以后再跟大家解释池化常用方法。这里就先记住最大池化就好了，因为这个目前是最常用的。

3、feature maps 

这个单词国人把它翻译成特征图，挺起来很专业的名词。那么什么叫特征图呢？其实一张图片经过一个卷积核进行卷积运算，我们可以得到一张卷积后的结果图片，而这张图片就是特征图。在CNN中，我们要训练的卷积核并不是仅仅只有一个，这些卷积核用于提取特征，卷积核个数越多，提取的特征越多，理论上来说精度也会更高，然而卷积核一堆，意味着我们要训练的参数的个数越多。在LeNet-5经典结构中，第一层卷积核选择了6个，而在AlexNet中，第一层卷积核就选择了96个，具体多少个合适，还有待学习。

回到特征图概念，CNN的每一个卷积层我们都要人为的选取合适的卷积核个数，及卷积核大小。每个卷积核与图片进行卷积，就可以得到一张特征图了，比如LeNet-5经典结构中，第一层卷积核选择了6个，我们可以得到6个特征图，这些特征图也就是下一层网络的输入了。我们也可以把输入图片看成一张特征图，作为第一层网络的输入。

---

Part2 Lenet模型

首先，我们给出LeNet-5卷积神经网络的整体框架：

特征映射：一幅图在经过卷积操作后得到结果称为feature map。

LeNet-5共有8层，包含输入层，每层都包含可训练参数；每个层有多个特征映射(Feature Map)，每个特征映射通过一种卷积核（或者叫滤波器）提取输入的一种特征，然后每个特征映射有多个神经元。C层代表的是卷积层，通过卷积操作，可以使原信号特征增强，并且降低噪音。 S层是一个降采样层，利用图像局部相关性的原理，对图像进行子抽样，可以减少数据处理量同时保留有用信息。

计算公式：输入图像的大小为nxn，卷积核的大小为mxm，步长为s， 为输入图像两端填补p个零（zero padding），那么卷积操作之后输出的大小为（n-m+2p）/s + 1。

 

1、INPUT层-输入层

首先是数据 INPUT 层，输入图像的尺寸统一归一化为32*32。

 

2、C1层-卷积层

输入图片：32*32

卷积核大小：5*5

卷积核种类：6

步长为：1

输出特征映射大小：28*28 （32-5+1）=28

神经元数量：28*28*6

可训练参数：（5*5+1) * 6（每个滤波器5*5=25个unit参数和一个bias参数，一共6个滤波器）

连接数：（5*5+1）*6*28*28=122304

详细说明：对输入图像进行第一次卷积运算（使用 6个大小为 5*5 的卷积核），得到6个28x28 的特征映射。我们再来看看需要多少个参数，卷积核的大小为5*5，总共就有6*（5*5+1）=156个参数，其中+1是表示一个卷积核有一个bias参数。对于卷积层C1，C1内的每个像素都与输入图像中的5*5个像素和1个bias有连接，所以总共有156*28*28=122304个连接（connection）。有122304个连接，但是我们只需要学习156个参数，主要是通过权值共享实现的。

 

3、S2层-池化层（降采样层-平均采样）

输入：28*28

采样区域：2*2

采样方式：平均池化，乘以一个可训练参数，再加上一个可训练偏置。结果通过sigmoid函数激活。

采样种类：6

步长为：2

输出特征映射的大小：14*14（28/2）

神经元数量：14*14*6

可训练参数：2*6（和的权+偏置）

连接数：（2*2+1）*6*14*14

S2中每个特征图的大小是C1中特征图大小的1/4。

详细说明：卷积之后紧接着就是池化运算，使用 2*2核进行池化，于是得到了S2，6个14*14的特征图（28/2=14）。S2汇聚层是对C1中的2*2区域内的像素求平均，乘以一个权值系数再加上一个偏置，然后将这个结果再做一次激活映射，于是每个池化之后的特征映射有两个训练参数，所以共有2x6=12个训练参数，但是有（2*2+1）x 14 x 14 x 6=5880个连接。

 

4、C3层-卷积层--（使用了复杂的局部连接）

输入：S2中所有6个或者几个特征映射的组合

卷积核大小：5*5

卷积核种类：16

步长为：1

输出特征映射的大小：10*10 (14-5+1) =10

C3中的每个特征映射是连接到S2中6个或者几个特征映射的组合，表示本层的特征映射是提取上一层特征映射的不同组合。

其中一个方式是：C3的前6个特征映射（feature map），把S2中3个相邻的特征映射子集为输入。接下来C3的6个特征映射以S2中4个相邻特征映射子集为输入。然后C3的3个特征映射以不相邻的4个特征映射子集为输入。最后一个将S2中所有特征图为输入。

则：可训练参数：6*(3*5*5+1)+6*(4*5*5+1)+3*(4*5*5+1)+1*(6*5*5+1)=1516

连接数：10*10*1516=151600

详细说明：第一次池化之后是第二次卷积，第二次卷积的输出是C3，16个10x10的特征映射，卷积核大小是 5*5. 我们知道S2 有6个 14*14 的特征映射，怎么从S2的6 个特征映射得到 C3的16个特征映射了？ 这里是通过对S2 特征映射的特殊组合计算得到的16个特征图。具体如下：

 

C3的前6个特征映射（feature map）（对应上图第一个红框的6列）与S2层相连的3个特征映射相连接（上图第一个红框），后面6个特征映射与S2层相连的4个特征映射相连接（上图第二个红框），后面3个特征映射与S2层部分不相连的4个特征映射相连接，最后一个与S2层的所有特征映射相连。卷积核大小依然为5*5，所以总共有6*(3*5*5+1)+6*(4*5*5+1)+3*(4*5*5+1)+1*(6*5*5+1)=1516个参数。而图像大小为10*10，所以共有151600个连接。

C3与S2中前3个图相连的卷积结构如下图所示：

 

上图对应的参数为 3*5*5+1，一共进行6次卷积得到6个特征图，所以有6*（3*5*5+1）参数。 为什么采用上述这样的组合了？论文中说有两个原因：1）减少参数，2）这种不对称的组合连接的方式有利于提取多种组合特征。

5、S4层-池化层（降采样层）

输入：10*10

采样区域：2*2

采样方式：平均池化，一个参数，再加上一个偏置。结果通过sigmoid函数激活。

采样种类：16

步长为：2

输出特征映射大小：5*5（10/2）

神经元数量：5*5*16=400

可训练参数：2*16=32（和的权+偏置）

连接数：16*（2*2+1）*5*5=2000

S4中每个特征图的大小是C3中特征图大小的1/4

详细说明：S4是池化层，窗口大小仍然是2*2，共计16个特征映射，C3层的16个10x10的图分别进行以2x2为单位的池化得到16个5x5的特征映射。这一层有2x16共32个训练参数，5x5x5x16=2000个连接。连接的方式与S2层类似。

 

6、C5层-卷积层

输入：S4层的全部16个单元特征映射（与 S4全相连）

卷积核大小：5*5

卷积核种类：120*16

输出特征映射的大小：1*1（5-5+1）

步长为：1

可训练参数/连接：120*（16*5*5+1）=48120

详细说明：C5层是一个卷积层。由于S4层的16个图的大小为5x5，与卷积核的大小相同，所以卷积后形成的图的大小为1x1。这里形成120个卷积结果。每个都与上一层的16个图相连。所以共有(5x5x16+1)x120 = 48120个参数，同样有48120个连接。C5层的网络结构如下：

 

7、F6层-全连接层

输入：C5的120维向量

计算方式：计算输入向量和权重向量之间的点积，再加上一个偏置，结果通过sigmoid函数输出。

可训练参数:84*(120+1)=10164

详细说明：6层是全连接层。F6层有84个节点，对应于一个7x12的比特图，-1表示白色，1表示黑色，这样每个符号的比特图的黑白色就对应于一个编码。该层的训练参数和连接数是(120 + 1)x84=10164。ASCII编码图如下：

 

F6层的连接方式如下：

 

 

8、Output层-全连接层

Output层也是全连接层，共有10个节点，分别代表数字0到9，且如果节点i的值为0，则网络识别的结果是数字i。采用的是径向基函数（RBF）的网络连接方式。假设x是上一层的输入，y是RBF的输出，则RBF输出的计算方式是：

 

上式的值由的比特图编码确定，从0到9，取值从0到7*12-1。RBF输出的值越接近于0，则越接近于的ASCII编码图，表示当前网络输入的识别结果是字符。该层有84x10=840个参数和连接。

 

上图是LeNet-5识别数字3的过程。

 

四、总结

LeNet-5是一种用于手写体字符识别的卷积神经网络。

卷积神经网络能够很好的利用图像的结构信息。

卷积层的参数较少，这也是由卷积层的主要特性即局部连接和共享权重所决定。

 

五、代码实现

首先你要知道mnist.pkl.gz这个库给我们的图片的大小是28*28的，因此我们可以第一步选择5*5的卷积核进行卷积得到24*24，同时我们希望C1层得到20张特征图，等等，具体的代码实现如下;

import os  
import sys  
import timeit  
  
import numpy  
  
import theano  
import theano.tensor as T  
from theano.tensor.signal import downsample  
from theano.tensor.nnet import conv  
  
from logistic_sgd import LogisticRegression, load_data  
from mlp import HiddenLayer  
  
#卷积神经网络的一层，包含：卷积+下采样两个步骤  
#算法的过程是：卷积-》下采样-》激活函数  
class LeNetConvPoolLayer(object):  
  
    #image_shape是输入数据的相关参数设置  filter_shape本层的相关参数设置  
    def __init__(self, rng, input, filter_shape, image_shape, poolsize=(2, 2)):  
        """ 
        :type rng: numpy.random.RandomState 
        :param rng: a random number generator used to initialize weights 
 
        3、input: 输入特征图数据，也就是n幅特征图片 
 
        4、参数 filter_shape: (number of filters, num input feature maps, 
                              filter height, filter width) 
        num of filters：是卷积核的个数，有多少个卷积核，那么本层的out feature maps的个数 
        也将生成多少个。num input feature maps：输入特征图的个数。 
        然后接着filter height, filter width是卷积核的宽高，比如5*5,9*9…… 
        filter_shape是列表，因此我们可以用filter_shape[0]获取卷积核个数 
 
        5、参数 image_shape: (batch size, num input feature maps, 
                             image height, image width)， 
         batch size：批量训练样本个数 ，num input feature maps：输入特征图的个数 
         image height, image width分别是输入的feature map图片的大小。 
         image_shape是一个列表类型，所以可以直接用索引，访问上面的4个参数，索引下标从 
         0~3。比如image_shape[2]=image_heigth  image_shape[3]=num input feature maps 
 
        6、参数 poolsize: 池化下采样的的块大小，一般为(2,2) 
        """  
  
        assert image_shape[1] == filter_shape[1]#判断输入特征图的个数是否一致，如果不一致是错误的  
        self.input = input  
  
        # fan_in=num input feature maps *filter height*filter width   
        #numpy.prod(x)函数为计算x各个元素的乘积  
        #也就是说fan_in就相当于每个即将输出的feature  map所需要链接参数权值的个数  
        fan_in = numpy.prod(filter_shape[1:])  
        # fan_out=num output feature maps * filter height * filter width  
        fan_out = (filter_shape[0] * numpy.prod(filter_shape[2:]) /  
                   numpy.prod(poolsize))  
        # 把参数初始化到[-a,a]之间的数，其中a=sqrt(6./(fan_in + fan_out)),然后参数采用均匀采样  
        #权值需要多少个？卷积核个数*输入特征图个数*卷积核宽*卷积核高？这样没有包含采样层的链接权值个数  
        W_bound = numpy.sqrt(6. / (fan_in + fan_out))  
        self.W = theano.shared(  
            numpy.asarray(  
                rng.uniform(low=-W_bound, high=W_bound, size=filter_shape),  
                dtype=theano.config.floatX  
            ),  
            borrow=True  
        )  
  
        # b为偏置，是一维的向量。每个输出特征图i对应一个偏置参数b[i]  
        #,因此下面初始化b的个数就是特征图的个数filter_shape[0]  
        b_values = numpy.zeros((filter_shape[0],), dtype=theano.config.floatX)  
        self.b = theano.shared(value=b_values, borrow=True)  
  
        # 卷积层操作，函数conv.conv2d的第一个参数为输入的特征图，第二个参数为随机出事化的卷积核参数  
        #第三个参数为卷积核的相关属性，输入特征图的相关属性  
        conv_out = conv.conv2d(  
            input=input,  
            filters=self.W,  
            filter_shape=filter_shape,  
            image_shape=image_shape  
        )  
  
        # 池化操作，最大池化  
        pooled_out = downsample.max_pool_2d(  
            input=conv_out,  
            ds=poolsize,  
            ignore_border=True  
        )  
        #激励函数，也就是说是先经过卷积核再池化后，然后在进行非线性映射  
        # add the bias term. Since the bias is a vector (1D array), we first  
        # reshape it to a tensor of shape (1, n_filters, 1, 1). Each bias will  
        # thus be broadcasted across mini-batches and feature map  
        # width & height  
        self.output = T.tanh(pooled_out + self.b.dimshuffle('x', 0, 'x', 'x'))  
  
        # 保存参数  
        self.params = [self.W, self.b]  
        self.input = input  
  
#测试函数  
def evaluate_lenet5(learning_rate=0.1, n_epochs=200,  
                    dataset='mnist.pkl.gz',  
                    nkerns=[20, 50], batch_size=500):  
    """ Demonstrates lenet on MNIST dataset 
 
 
    :learning_rate: 梯度下降法的学习率 
 
    :n_epochs: 最大迭代次数 
 
    :type dataset: string 
    :param dataset: path to the dataset used for training /testing (MNIST here) 
 
    :nkerns: 每个卷积层的卷积核个数，第一层卷积核个数为 nkerns[0]=20,第二层卷积核个数 
    为50个 
    """  
  
    rng = numpy.random.RandomState(23455)  
  
    datasets = load_data(dataset)#加载训练数据，训练数据包含三个部分  
  
    train_set_x, train_set_y = datasets[0]#训练数据  
    valid_set_x, valid_set_y = datasets[1]#验证数据  
    test_set_x, test_set_y = datasets[2]#测试数据  
  
    # 计算批量训练可以分多少批数据进行训练，这个只要是知道批量训练的人都知道  
    n_train_batches = train_set_x.get_value(borrow=True).shape[0]#训练数据个数  
    n_valid_batches = valid_set_x.get_value(borrow=True).shape[0]  
    n_test_batches = test_set_x.get_value(borrow=True).shape[0]  
    n_train_batches /= batch_size#批数  
    n_valid_batches /= batch_size  
    n_test_batches /= batch_size  
  
    # allocate symbolic variables for the data  
    index = T.lscalar()  # index to a [mini]batch  
  
    # start-snippet-1  
    x = T.matrix('x')   # the data is presented as rasterized images  
    y = T.ivector('y')  # the labels are presented as 1D vector of  
                        # [int] labels  
  
  
    # Reshape matrix of rasterized images of shape (batch_size, 28 * 28)  
    # to a 4D tensor, compatible with our LeNetConvPoolLayer  
    # (28, 28) is the size of MNIST images.  
    layer0_input = x.reshape((batch_size, 1, 28, 28))  
  
    '''''构建第一层网络： 
    image_shape：输入大小为28*28的特征图，batch_size个训练数据，每个训练数据有1个特征图 
    filter_shape：卷积核个数为nkernes[0]=20，因此本层每个训练样本即将生成20个特征图 
    经过卷积操作，图片大小变为(28-5+1 , 28-5+1) = (24, 24) 
    经过池化操作，图片大小变为 (24/2, 24/2) = (12, 12) 
    最后生成的本层image_shape为(batch_size, nkerns[0], 12, 12)'''  
    layer0 = LeNetConvPoolLayer(  
        rng,  
        input=layer0_input,  
        image_shape=(batch_size, 1, 28, 28),  
        filter_shape=(nkerns[0], 1, 5, 5),  
        poolsize=(2, 2)  
    )  
  
    '''''构建第二层网络：输入batch_size个训练图片，经过第一层的卷积后，每个训练图片有nkernes[0]个特征图，每个特征图 
    大小为12*12 
    经过卷积后，图片大小变为(12-5+1, 12-5+1) = (8, 8) 
    经过池化后，图片大小变为(8/2, 8/2) = (4, 4) 
    最后生成的本层的image_shape为(batch_size, nkerns[1], 4, 4)'''  
    layer1 = LeNetConvPoolLayer(  
        rng,  
        input=layer0.output,  
        image_shape=(batch_size, nkerns[0], 12, 12),  
        filter_shape=(nkerns[1], nkerns[0], 5, 5),  
        poolsize=(2, 2)  
    )  
  
    # the HiddenLayer being fully-connected, it operates on 2D matrices of  
    # shape (batch_size, num_pixels) (i.e matrix of rasterized images).  
    # This will generate a matrix of shape (batch_size, nkerns[1] * 4 * 4),  
    # or (500, 50 * 4 * 4) = (500, 800) with the default values.  
    layer2_input = layer1.output.flatten(2)  
  
    '''''全链接：输入layer2_input是一个二维的矩阵，第一维表示样本，第二维表示上面经过卷积下采样后 
    每个样本所得到的神经元，也就是每个样本的特征，HiddenLayer类是一个单层网络结构 
    下面的layer2把神经元个数由800个压缩映射为500个'''  
    layer2 = HiddenLayer(  
        rng,  
        input=layer2_input,  
        n_in=nkerns[1] * 4 * 4,  
        n_out=500,  
        activation=T.tanh  
    )  
  
    # 最后一层：逻辑回归层分类判别，把500个神经元，压缩映射成10个神经元，分别对应于手写字体的0~9  
    layer3 = LogisticRegression(input=layer2.output, n_in=500, n_out=10)  
  
    # the cost we minimize during training is the NLL of the model  
    cost = layer3.negative_log_likelihood(y)  
  
    # create a function to compute the mistakes that are made by the model  
    test_model = theano.function(  
        [index],  
        layer3.errors(y),  
        givens={  
            x: test_set_x[index * batch_size: (index + 1) * batch_size],  
            y: test_set_y[index * batch_size: (index + 1) * batch_size]  
        }  
    )  
  
    validate_model = theano.function(  
        [index],  
        layer3.errors(y),  
        givens={  
            x: valid_set_x[index * batch_size: (index + 1) * batch_size],  
            y: valid_set_y[index * batch_size: (index + 1) * batch_size]  
        }  
    )  
  
    #把所有的参数放在同一个列表里，可直接使用列表相加  
    params = layer3.params + layer2.params + layer1.params + layer0.params  
  
    #梯度求导  
    grads = T.grad(cost, params)  
  
    # train_model is a function that updates the model parameters by  
    # SGD Since this model has many parameters, it would be tedious to  
    # manually create an update rule for each model parameter. We thus  
    # create the updates list by automatically looping over all  
    # (params[i], grads[i]) pairs.  
    updates = [  
        (param_i, param_i - learning_rate * grad_i)  
        for param_i, grad_i in zip(params, grads)  
    ]  
  
    train_model = theano.function(  
        [index],  
        cost,  
        updates=updates,  
        givens={  
            x: train_set_x[index * batch_size: (index + 1) * batch_size],  
            y: train_set_y[index * batch_size: (index + 1) * batch_size]  
        }  
    )  
    # end-snippet-1  
  
    ###############  
    # TRAIN MODEL #  
    ###############  
    print '... training'  
    # early-stopping parameters  
    patience = 10000  # look as this many examples regardless  
    patience_increase = 2  # wait this much longer when a new best is  
                           # found  
    improvement_threshold = 0.995  # a relative improvement of this much is  
                                   # considered significant  
    validation_frequency = min(n_train_batches, patience / 2)  
                                  # go through this many  
                                  # minibatche before checking the network  
                                  # on the validation set; in this case we  
                                  # check every epoch  
  
    best_validation_loss = numpy.inf  
    best_iter = 0  
    test_score = 0.  
    start_time = timeit.default_timer()  
  
    epoch = 0  
    done_looping = False  
  
    while (epoch < n_epochs) and (not done_looping):  
        epoch = epoch + 1  
        for minibatch_index in xrange(n_train_batches):#每一批训练数据  
  
            cost_ij = train_model(minibatch_index)  
            iter = (epoch - 1) * n_train_batches + minibatch_index  
            if (iter + 1) % validation_frequency == 0:  
  
                # compute zero-one loss on validation set  
                validation_losses = [validate_model(i) for i  
                                     in xrange(n_valid_batches)]  
                this_validation_loss = numpy.mean(validation_losses)  
                print('epoch %i, minibatch %i/%i, validation error %f %%' %  
                      (epoch, minibatch_index + 1, n_train_batches,  
                       this_validation_loss * 100.))  
  
                # if we got the best validation score until now  
                if this_validation_loss < best_validation_loss:  
  
                    #improve patience if loss improvement is good enough  
                    if this_validation_loss < best_validation_loss *  \  
                       improvement_threshold:  
                        patience = max(patience, iter * patience_increase)  
  
                    # save best validation score and iteration number  
                    best_validation_loss = this_validation_loss  
                    best_iter = iter  
  
                    # test it on the test set  
                    test_losses = [  
                        test_model(i)  
                        for i in xrange(n_test_batches)  
                    ]  
                    test_score = numpy.mean(test_losses)  
                    print(('     epoch %i, minibatch %i/%i, test error of '  
                           'best model %f %%') %  
                          (epoch, minibatch_index + 1, n_train_batches,  
                           test_score * 100.))  
  
            if patience <= iter:  
                done_looping = True  
                break  
  
    end_time = timeit.default_timer()  
    print('Optimization complete.')  
    print('Best validation score of %f %% obtained at iteration %i, '  
          'with test performance %f %%' %  
          (best_validation_loss * 100., best_iter + 1, test_score * 100.))  
    print >> sys.stderr, ('The code for file ' +  
                          os.path.split(__file__)[1] +  
                          ' ran for %.2fm' % ((end_time - start_time) / 60.))  
  
if __name__ == '__main__':  
    evaluate_lenet5()  
  
  
def experiment(state, channel):  
    evaluate_lenet5(state.learning_rate, dataset=state.dataset) 

---

【参考】

http://www.deeplearning.net/tutorial/lenet.html#lenet（官方源码实现[英]）

https://blog.csdn.net/yangyang688/article/details/82884336（讲解）

https://blog.csdn.net/yangyang688/article/details/82800022（实现）

https://www.cnblogs.com/muyangshaonian/p/9650486.html