本文是对刘昕博士的《CNN的近期进展与实用技巧》的一个扩充性资料。
主要讨论CNN的发展，并且引用刘昕博士的思路，对CNN的发展作一个更加详细的介绍，将按下图的CNN发展史进行描述：

上图所示是刘昕博士总结的CNN结构演化的历史，起点是神经认知机模型，此时已经出现了卷积结构，经典的LeNet诞生于1998年。然而之后CNN的锋芒开始被SVM等手工设计的特征盖过。随着ReLU和dropout的提出，以及GPU和大数据带来的历史机遇，CNN在2012年迎来了历史突破–AlexNet.

CNN的演化路径可以总结为以下几个方向：

从LeNet到AlexNet
进化之路一：网络结构加深
进化之路二：加强卷积功能
进化之路三：从分类到检测
进化之路四：新增功能模块

本文将对CNN发展的四条路径中最具代表性的CNN模型结构进行讲解。

一切的开始( LeNet)

下图是广为流传LeNet的网络结构，麻雀虽小，但五脏俱全，卷积层、pooling层、全连接层，这些都是现代CNN网络的基本组件。

• 输入尺寸：32*32
• 卷积层：3个
• 降采样层：2个
• 全连接层：1个
• 输出：10个类别（数字0-9的概率）

因为LeNet可以说是CNN的开端，所以这里简单介绍一下各个组件的用途与意义。

Input (32*32)

输入图像Size为32*32。这要比mnist数据库中最大的字母(28*28)还大。这样做的目的是希望潜在的明显特征，如笔画断续、角点能够出现在最高层特征监测子感受野的中心。

C1, C3, C5 (卷积层)

卷积核在二维平面上平移，并且卷积核的每个元素与被卷积图像对应位置相乘，再求和。通过卷积核的不断移动，我们就有了一个新的图像，这个图像完全由卷积核在各个位置时的乘积求和的结果组成。
二维卷积在图像中的效果就是: 对图像的每个像素的邻域（邻域大小就是核的大小）加权求和得到该像素点的输出值。具体做法如下：

卷积运算一个重要的特点就是: 通过卷积运算，可以使原信号特征增强，并且降低噪音。
不同的卷积核能够提取到图像中的不同特征，这里有 在线demo，下面是不同卷积核得到的不同的feature map，

以C1层进行说明：C1层是一个卷积层，有6个卷积核（提取6种局部特征），核大小为5*5，能够输出6个特征图Feature Map，大小为28*28。C1有156个可训练参数（每个滤波器5*5=25个unit参数和一个bias参数，一共6个滤波器，共(5*5+1)*6 = 156个参数），共156 *(28*28) = 122,304个连接。

S2, S4 (pooling层)

S2, S4是下采样层，是为了降低网络训练参数及模型的过拟合程度。池化/采样的方式通常有以下两种：

Max-Pooling：选择Pooling窗口中的最大值作为采样值；
Mean-Pooling：将Pooling窗口中的所有值相加取平均，以平均值作为采样值；

S2层是6个14*14的feature map，map中的每一个单元于上一层的 2*2 领域相连接，所以，S2层是C1层的1/4。

F6 (全连接层)

F6是全连接层，类似MLP中的一个layer，共有84个神经元（为什么选这个数字？跟输出层有关），这84个神经元与C5层进行全连接，所以需要训练的参数是：(120+1)*84 = 10164. 如同经典神经网络，F6层计算输入向量和权重向量之间的点积，再加上一个偏置。然后将其传递给sigmoid函数产生单元i的一个状态。

Output (输出层)

输出层由欧式径向基函数（Euclidean Radial Basis Function）单元组成，每类一个单元，每个有84个输入。 换句话说，每个输出RBF单元计算输入向量和参数向量之间的欧式距离。输入离参数向量越远，RBF输出的越大。用概率术语来说，RBF输出可以被理解为F6层配置空间的高斯分布的负log-likelihood。给定一个输式，损失函数应能使得F6的配置与RBF参数向量（即模式的期望分类）足够接近。

王者回归(AlexNet)

AlexNet 可以说是具有历史意义的一个网络结构，可以说在AlexNet之前，深度学习已经沉寂了很久。历史的转折在2012年到来，AlexNet 在当年的ImageNet图像分类竞赛中，top-5错误率比上一年的冠军下降了十个百分点，而且远远超过当年的第二名。

AlexNet 之所以能够成功，深度学习之所以能够重回历史舞台，原因在于：

1. 非线性激活函数：ReLU
2. 防止过拟合的方法：Dropout，Data augmentation
3. 大数据训练：百万级ImageNet图像数据
4. 其他：GPU实现，LRN归一化层的使用

下面简单介绍一下AlexNet的一些细节：

Data augmentation

有一种观点认为神经网络是靠数据喂出来的，若增加训练数据，则能够提升算法的准确率，因为这样可以避免过拟合，而避免了过拟合你就可以增大你的网络结构了。当训练数据有限的时候，可以通过一些变换来从已有的训练数据集中生成一些新的数据，来扩大训练数据的size。

其中，最简单、通用的图像数据变形的方式:

1. 从原始图像（256,256）中，随机的crop出一些图像（224,224）。【平移变换，crop】
2. 水平翻转图像。【反射变换，flip】
3. 给图像增加一些随机的光照。【光照、彩色变换，color jittering】

AlexNet 训练的时候，在data augmentation上处理的很好：

• 随机crop。训练时候，对于256＊256的图片进行随机crop到224＊224，然后允许水平翻转，那么相当与将样本倍增到((256-224)^2)*2=2048。
• 测试时候，对左上、右上、左下、右下、中间做了5次crop，然后翻转，共10个crop，之后对结果求平均。作者说，不做随机crop，大网络基本都过拟合(under substantial overfitting)。
• 对RGB空间做PCA，然后对主成分做一个(0, 0.1)的高斯扰动。结果让错误率又下降了1%。

ReLU 激活函数

Sigmoid 是常用的非线性的激活函数，它能够把输入的连续实值“压缩”到0和1之间。特别的，如果是非常大的负数，那么输出就是0；如果是非常大的正数，输出就是1.

但是它有一些致命的 缺点：

• Sigmoids saturate and kill gradients. sigmoid 有一个非常致命的缺点，当输入非常大或者非常小的时候，会有饱和现象，这些神经元的梯度是接近于0的。如果你的初始值很大的话，梯度在反向传播的时候因为需要乘上一个sigmoid 的导数，所以会使得梯度越来越小，这会导致网络变的很难学习。
• Sigmoid 的 output 不是0均值. 这是不可取的，因为这会导致后一层的神经元将得到上一层输出的非0均值的信号作为输入。 产生的一个结果就是：如果数据进入神经元的时候是正的(e.g. x>0 elementwise in f=wTx+b)，那么 w计算出的梯度也会始终都是正的。 当然了，如果你是按batch去训练，那么那个batch可能得到不同的信号，所以这个问题还是可以缓解一下的。因此，非0均值这个问题虽然会产生一些不好的影响，不过跟上面提到的 kill gradients 问题相比还是要好很多的。

ReLU 的数学表达式如下：

![][01]
[01]:http://latex.codecogs.com/png.latex?f(x)%20=%20max(0,%20x)

很显然，从图左可以看出，输入信号<0时，输出都是0，>0的情况下，输出等于输入。w是二维的情况下，使用ReLU之后的效果如下：

Alex用ReLU代替了Sigmoid，发现使用 ReLU 得到的SGD的收敛速度会比 sigmoid/tanh 快很多。

主要是因为它是linear，而且 non-saturating（因为ReLU的导数始终是1），相比于 sigmoid/tanh，ReLU 只需要一个阈值就可以得到激活值，而不用去算一大堆复杂的运算。

关于激活函数更多内容，可以参考文章：神经网络-激活函数面面观。

Dropout

结合预先训练好的许多不同模型，来进行预测是一种非常成功的减少测试误差的方式（Ensemble）。但因为每个模型的训练都需要花了好几天时间，因此这种做法对于大型神经网络来说太过昂贵。

然而，AlexNet 提出了一个非常有效的模型组合版本，它在训练中只需要花费两倍于单模型的时间。这种技术叫做Dropout，它做的就是以0.5的概率，将每个隐层神经元的输出设置为零。以这种方式“dropped out”的神经元既不参与前向传播，也不参与反向传播。

所以每次输入一个样本，就相当于该神经网络就尝试了一个新的结构，但是所有这些结构之间共享权重。因为神经元不能依赖于其他特定神经元而存在，所以这种技术降低了神经元复杂的互适应关系。

正因如此，网络需要被迫学习更为鲁棒的特征，这些特征在结合其他神经元的一些不同随机子集时有用。在测试时，我们将所有神经元的输出都仅仅只乘以0.5，对于获取指数级dropout网络产生的预测分布的几何平均值，这是一个合理的近似方法。

多GPU训练

单个GTX 580 GPU只有3GB内存，这限制了在其上训练的网络的最大规模。因此他们将网络分布在两个GPU上。 目前的GPU特别适合跨GPU并行化，因为它们能够直接从另一个GPU的内存中读出和写入，不需要通过主机内存。

他们采用的并行方案是：在每个GPU中放置一半核（或神经元），还有一个额外的技巧：GPU间的通讯只在某些层进行。

例如，第3层的核需要从第2层中所有核映射输入。然而，第4层的核只需要从第3层中位于同一GPU的那些核映射输入。

Local Responce Normalization

一句话概括：本质上，这个层也是为了防止激活函数的饱和的。

个人理解原理是通过正则化让激活函数的输入靠近“碗”的中间(避免饱和)，从而获得比较大的导数值。

所以从功能上说，跟ReLU是重复的。

不过作者说，从试验结果看，LRN操作可以提高网络的泛化能力，将错误率降低了大约1个百分点。

AlexNet 优势在于：网络增大（5个卷积层+3个全连接层+1个softmax层），同时解决过拟合（dropout，data augmentation，LRN），并且利用多GPU加速计算

网络结构

在imagenet上的图像分类challenge上Alex提出的alexnet网络结构模型赢得了2012届的冠军。要研究CNN类型DL网络模型在图像分类上的应用，就逃不开研究alexnet，这是CNN在图像分类上的经典模型（DL火起来之后）。在DL开源实现caffe的model样例中，它也给出了alexnet的复现，具体网络配置文件如下：
https://github.com/BVLC/caffe/blob/master/models/bvlc_reference_caffenet/train_val.prototxt

接下来将一步步对该网络配置结构中各个层进行详细的解读（训练阶段）：

1. conv1阶段DFD（data flow diagram）：

2. conv2阶段DFD（data flow diagram）：

3. conv3阶段DFD（data flow diagram）：

4. conv4阶段DFD（data flow diagram）：

5. conv5阶段DFD（data flow diagram）：

6. fc6阶段DFD（data flow diagram）：

7. fc7阶段DFD（data flow diagram）：

8. fc8阶段DFD（data flow diagram）：

各种layer的operation更多解释可以参考http://caffe.berkeleyvision.org/tutorial/layers.html
从计算该模型的数据流过程中，该模型参数大概5kw+。

caffe的输出中也有包含这块的内容日志，详情如下：

I0721 10:38:15.326920  4692 net.cpp:125] Top shape: 256 3 227 227 (39574272)  
I0721 10:38:15.326971  4692 net.cpp:125] Top shape: 256 1 1 1 (256)  
I0721 10:38:15.326982  4692 net.cpp:156] data does not need backward computation.  
I0721 10:38:15.327003  4692 net.cpp:74] Creating Layer conv1  
I0721 10:38:15.327011  4692 net.cpp:84] conv1 <- data  
I0721 10:38:15.327033  4692 net.cpp:110] conv1 -> conv1  
I0721 10:38:16.721956  4692 net.cpp:125] Top shape: 256 96 55 55 (74342400)  
I0721 10:38:16.722030  4692 net.cpp:151] conv1 needs backward computation.  
I0721 10:38:16.722059  4692 net.cpp:74] Creating Layer relu1  
I0721 10:38:16.722070  4692 net.cpp:84] relu1 <- conv1  
I0721 10:38:16.722082  4692 net.cpp:98] relu1 -> conv1 (in-place)  
I0721 10:38:16.722096  4692 net.cpp:125] Top shape: 256 96 55 55 (74342400)  
I0721 10:38:16.722105  4692 net.cpp:151] relu1 needs backward computation.  
I0721 10:38:16.722116  4692 net.cpp:74] Creating Layer pool1  
I0721 10:38:16.722125  4692 net.cpp:84] pool1 <- conv1  
I0721 10:38:16.722133  4692 net.cpp:110] pool1 -> pool1  
I0721 10:38:16.722167  4692 net.cpp:125] Top shape: 256 96 27 27 (17915904)  
I0721 10:38:16.722187  4692 net.cpp:151] pool1 needs backward computation.  
I0721 10:38:16.722205  4692 net.cpp:74] Creating Layer norm1  
I0721 10:38:16.722221  4692 net.cpp:84] norm1 <- pool1  
I0721 10:38:16.722234  4692 net.cpp:110] norm1 -> norm1  
I0721 10:38:16.722251  4692 net.cpp:125] Top shape: 256 96 27 27 (17915904)  
I0721 10:38:16.722260  4692 net.cpp:151] norm1 needs backward computation.  
I0721 10:38:16.722272  4692 net.cpp:74] Creating Layer conv2  
I0721 10:38:16.722280  4692 net.cpp:84] conv2 <- norm1  
I0721 10:38:16.722290  4692 net.cpp:110] conv2 -> conv2  
I0721 10:38:16.725225  4692 net.cpp:125] Top shape: 256 256 27 27 (47775744)  
I0721 10:38:16.725242  4692 net.cpp:151] conv2 needs backward computation.  
I0721 10:38:16.725253  4692 net.cpp:74] Creating Layer relu2  
I0721 10:38:16.725261  4692 net.cpp:84] relu2 <- conv2  
I0721 10:38:16.725270  4692 net.cpp:98] relu2 -> conv2 (in-place)  
I0721 10:38:16.725280  4692 net.cpp:125] Top shape: 256 256 27 27 (47775744)  
I0721 10:38:16.725288  4692 net.cpp:151] relu2 needs backward computation.  
I0721 10:38:16.725298  4692 net.cpp:74] Creating Layer pool2  
I0721 10:38:16.725307  4692 net.cpp:84] pool2 <- conv2  
I0721 10:38:16.725317  4692 net.cpp:110] pool2 -> pool2  
I0721 10:38:16.725329  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)  
I0721 10:38:16.725338  4692 net.cpp:151] pool2 needs backward computation.  
I0721 10:38:16.725358  4692 net.cpp:74] Creating Layer norm2  
I0721 10:38:16.725368  4692 net.cpp:84] norm2 <- pool2  
I0721 10:38:16.725378  4692 net.cpp:110] norm2 -> norm2  
I0721 10:38:16.725389  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)  
I0721 10:38:16.725399  4692 net.cpp:151] norm2 needs backward computation.  
I0721 10:38:16.725409  4692 net.cpp:74] Creating Layer conv3  
I0721 10:38:16.725419  4692 net.cpp:84] conv3 <- norm2  
I0721 10:38:16.725427  4692 net.cpp:110] conv3 -> conv3  
I0721 10:38:16.735193  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)  
I0721 10:38:16.735213  4692 net.cpp:151] conv3 needs backward computation.  
I0721 10:38:16.735224  4692 net.cpp:74] Creating Layer relu3  
I0721 10:38:16.735234  4692 net.cpp:84] relu3 <- conv3  
I0721 10:38:16.735242  4692 net.cpp:98] relu3 -> conv3 (in-place)  
I0721 10:38:16.735250  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)  
I0721 10:38:16.735258  4692 net.cpp:151] relu3 needs backward computation.  
I0721 10:38:16.735302  4692 net.cpp:74] Creating Layer conv4  
I0721 10:38:16.735312  4692 net.cpp:84] conv4 <- conv3  
I0721 10:38:16.735321  4692 net.cpp:110] conv4 -> conv4  
I0721 10:38:16.743952  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)  
I0721 10:38:16.743988  4692 net.cpp:151] conv4 needs backward computation.  
I0721 10:38:16.744000  4692 net.cpp:74] Creating Layer relu4  
I0721 10:38:16.744010  4692 net.cpp:84] relu4 <- conv4  
I0721 10:38:16.744020  4692 net.cpp:98] relu4 -> conv4 (in-place)  
I0721 10:38:16.744030  4692 net.cpp:125] Top shape: 256 384 13 13 (16613376)  
I0721 10:38:16.744038  4692 net.cpp:151] relu4 needs backward computation.  
I0721 10:38:16.744050  4692 net.cpp:74] Creating Layer conv5  
I0721 10:38:16.744057  4692 net.cpp:84] conv5 <- conv4  
I0721 10:38:16.744067  4692 net.cpp:110] conv5 -> conv5  
I0721 10:38:16.748935  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)  
I0721 10:38:16.748955  4692 net.cpp:151] conv5 needs backward computation.  
I0721 10:38:16.748965  4692 net.cpp:74] Creating Layer relu5  
I0721 10:38:16.748975  4692 net.cpp:84] relu5 <- conv5  
I0721 10:38:16.748983  4692 net.cpp:98] relu5 -> conv5 (in-place)  
I0721 10:38:16.748998  4692 net.cpp:125] Top shape: 256 256 13 13 (11075584)  
I0721 10:38:16.749011  4692 net.cpp:151] relu5 needs backward computation.  
I0721 10:38:16.749022  4692 net.cpp:74] Creating Layer pool5  
I0721 10:38:16.749030  4692 net.cpp:84] pool5 <- conv5  
I0721 10:38:16.749039  4692 net.cpp:110] pool5 -> pool5  
I0721 10:38:16.749050  4692 net.cpp:125] Top shape: 256 256 6 6 (2359296)  
I0721 10:38:16.749058  4692 net.cpp:151] pool5 needs backward computation.  
I0721 10:38:16.749074  4692 net.cpp:74] Creating Layer fc6  
I0721 10:38:16.749083  4692 net.cpp:84] fc6 <- pool5  
I0721 10:38:16.749091  4692 net.cpp:110] fc6 -> fc6  
I0721 10:38:17.160079  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.160148  4692 net.cpp:151] fc6 needs backward computation.  
I0721 10:38:17.160166  4692 net.cpp:74] Creating Layer relu6  
I0721 10:38:17.160177  4692 net.cpp:84] relu6 <- fc6  
I0721 10:38:17.160190  4692 net.cpp:98] relu6 -> fc6 (in-place)  
I0721 10:38:17.160202  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.160212  4692 net.cpp:151] relu6 needs backward computation.  
I0721 10:38:17.160222  4692 net.cpp:74] Creating Layer drop6  
I0721 10:38:17.160230  4692 net.cpp:84] drop6 <- fc6  
I0721 10:38:17.160238  4692 net.cpp:98] drop6 -> fc6 (in-place)  
I0721 10:38:17.160258  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.160265  4692 net.cpp:151] drop6 needs backward computation.  
I0721 10:38:17.160277  4692 net.cpp:74] Creating Layer fc7  
I0721 10:38:17.160286  4692 net.cpp:84] fc7 <- fc6  
I0721 10:38:17.160295  4692 net.cpp:110] fc7 -> fc7  
I0721 10:38:17.342094  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.342157  4692 net.cpp:151] fc7 needs backward computation.  
I0721 10:38:17.342175  4692 net.cpp:74] Creating Layer relu7  
I0721 10:38:17.342185  4692 net.cpp:84] relu7 <- fc7  
I0721 10:38:17.342198  4692 net.cpp:98] relu7 -> fc7 (in-place)  
I0721 10:38:17.342208  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.342217  4692 net.cpp:151] relu7 needs backward computation.  
I0721 10:38:17.342228  4692 net.cpp:74] Creating Layer drop7  
I0721 10:38:17.342236  4692 net.cpp:84] drop7 <- fc7  
I0721 10:38:17.342245  4692 net.cpp:98] drop7 -> fc7 (in-place)  
I0721 10:38:17.342254  4692 net.cpp:125] Top shape: 256 4096 1 1 (1048576)  
I0721 10:38:17.342262  4692 net.cpp:151] drop7 needs backward computation.  
I0721 10:38:17.342274  4692 net.cpp:74] Creating Layer fc8  
I0721 10:38:17.342283  4692 net.cpp:84] fc8 <- fc7  
I0721 10:38:17.342291  4692 net.cpp:110] fc8 -> fc8  
I0721 10:38:17.343199  4692 net.cpp:125] Top shape: 256 22 1 1 (5632)  
I0721 10:38:17.343214  4692 net.cpp:151] fc8 needs backward computation.  
I0721 10:38:17.343231  4692 net.cpp:74] Creating Layer loss  
I0721 10:38:17.343240  4692 net.cpp:84] loss <- fc8  
I0721 10:38:17.343250  4692 net.cpp:84] loss <- label  
I0721 10:38:17.343264  4692 net.cpp:151] loss needs backward computation.  
I0721 10:38:17.343305  4692 net.cpp:173] Collecting Learning Rate and Weight Decay.  
I0721 10:38:17.343327  4692 net.cpp:166] Network initialization done.  
I0721 10:38:17.343335  4692 net.cpp:167] Memory required for Data 1073760256  

Refenence

[1] 【卷积神经网络-进化史】从LeNet到AlexNet - csdn 仙道菜
[2] http://m.blog.csdn.net/article/details?id=51440344
[3] [caffe]深度学习之图像分类模型AlexNet解读

（转载请注明出处，谢谢！）