五层全连接神经网络

⑴ 神经网络的全连接层

全连接层（fully connected layers，FC）在整个神经网络中起到“分类器”的作用。

如果说卷积层、池化层和激活函数层等操作是将原始数据映射到隐层特征空间的话，全连接层将学到的“分布式特征表示”映射到“样本标记空间”。

在实际使用中，全连接层可由卷积操作实现：对前层是全连接的全连接层可以转化为卷积核为1x1的卷积；而前层是卷积层的全连接层可以转化为卷积核为h*w的全局卷积，h和w分别为前层卷积结果的高和宽。

由于全连接层的参数冗余（仅全连接层参数就可占整个网络参数80%左右），有些性能优异的网络模型如ResNet和GoogLeNet等均用全局平均池化（global average pooling，GAP）取代全连接层，来融合学到的深度特征，最后仍用softmax等损失函数作为网络目标函数来指导学习过程。

⑵ 什么是全连接神经网络，怎么理解“全连接”

1、全连接神经网络解析：对n-1层和n层而言，n-1层的任意一个节点，都和第n层所有节点有连接。即第n层的每个节点在进行计算的时候，激活函数的输入是n-1层所有节点的加权。

2、全连接的神经网络示意图：

3、“全连接”是一种不错的模式，但是网络很大的时候，训练速度回很慢。部分连接就是认为的切断某两个节点直接的连接，这样训练时计算量大大减小。

⑶ CNN网络简介

卷积神经网络简介（Convolutional Neural Networks，简称CNN）

卷积神经网络是近年发展起来，并引起广泛重视的一种高效识别方法。20世纪60年代，Hubel和Wiesel在研究猫脑皮层中用于局部敏感和方向选择的神经元时发现其独特的网络结构可以有效地降低反馈神经网络的复杂性，继而提出了卷积神经网络（Convolutional

Neural

Networks-简称CNN）。现在，CNN已经成为众多科学领域的研究热点之一，特别是在模式分类领域，由于该网络避免了对图像的复杂前期预处理，可以直接输入原始图像，因而得到了更为广泛的应用。

K.Fukushima在1980年提出的新识别机是卷积神经网络的第一个实现网络。随后，更多的科研工作者对该网络进行了改进。其中，具有代表性的研究成果是Alexander和Taylor提出的“改进认知机”，该方法综合了各种改进方法的优点并避免了耗时的误差反向传播。

一般地，CNN的基本结构包括两层，其一为特征提取层，每个神经元的输入与前一层的局部接受域相连，并提取该局部的特征。一旦该局部特征被提取后，它与其它特征间的位置关系也随之确定下来；其二是特征映射层，网络的每个计算层由多个特征映射组成，每个特征映射是一个平面，平面上所有神经元的权值相等。特征映射结构采用影响函数核小的sigmoid函数作为卷积网络的激活函数，使得特征映射具有位移不变性。此外，由于一个映射面上的神经元共享权值，因而减少了网络自由参数的个数。卷积神经网络中的每一个卷积层都紧跟着一个用来求局部平均与二次提取的计算层，这种特有的两次特征提取结构减小了特征分辨率。

CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习，所以在使用CNN时，避免了显示的特征抽取，而隐式地从训练数据中进行学习；再者由于同一特征映射面上的神经元权值相同，所以网络可以并行学习，这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性，其布局更接近于实际的生物神经网络，权值共享降低了网络的复杂性，特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。

1. 神经网络

首先介绍神经网络，这一步的详细可以参考资源1。简要介绍下。神经网络的每个单元如下：

其对应的公式如下：

其中，该单元也可以被称作是Logistic回归模型。当将多个单元组合起来并具有分层结构时，就形成了神经网络模型。下图展示了一个具有一个隐含层的神经网络。

其对应的公式如下：

比较类似的，可以拓展到有2,3,4,5，…个隐含层。

神经网络的训练方法也同Logistic类似，不过由于其多层性，还需要利用链式求导法则对隐含层的节点进行求导，即梯度下降+链式求导法则，专业名称为反向传播。关于训练算法，本文暂不涉及。

2 卷积神经网络

在图像处理中，往往把图像表示为像素的向量，比如一个1000×1000的图像，可以表示为一个1000000的向量。在上一节中提到的神经网络中，如果隐含层数目与输入层一样，即也是1000000时，那么输入层到隐含层的参数数据为1000000×1000000=10^12，这样就太多了，基本没法训练。所以图像处理要想练成神经网络大法，必先减少参数加快速度。就跟辟邪剑谱似的，普通人练得很挫，一旦自宫后内力变强剑法变快，就变的很牛了。

2.1 局部感知

卷积神经网络有两种神器可以降低参数数目，第一种神器叫做局部感知野。一般认为人对外界的认知是从局部到全局的，而图像的空间联系也是局部的像素联系较为紧密，而距离较远的像素相关性则较弱。因而，每个神经元其实没有必要对全局图像进行感知，只需要对局部进行感知，然后在更高层将局部的信息综合起来就得到了全局的信息。网络部分连通的思想，也是受启发于生物学里面的视觉系统结构。视觉皮层的神经元就是局部接受信息的（即这些神经元只响应某些特定区域的刺激）。如下图所示：左图为全连接，右图为局部连接。

在上右图中，假如每个神经元只和10×10个像素值相连，那么权值数据为1000000×100个参数，减少为原来的千分之一。而那10×10个像素值对应的10×10个参数，其实就相当于卷积操作。

2.2 参数共享

但其实这样的话参数仍然过多，那么就启动第二级神器，即权值共享。在上面的局部连接中，每个神经元都对应100个参数，一共1000000个神经元，如果这1000000个神经元的100个参数都是相等的，那么参数数目就变为100了。

怎么理解权值共享呢？我们可以这100个参数（也就是卷积操作）看成是提取特征的方式，该方式与位置无关。这其中隐含的原理则是：图像的一部分的统计特性与其他部分是一样的。这也意味着我们在这一部分学习的特征也能用在另一部分上，所以对于这个图像上的所有位置，我们都能使用同样的学习特征。

更直观一些，当从一个大尺寸图像中随机选取一小块，比如说 8×8 作为样本，并且从这个小块样本中学习到了一些特征，这时我们可以把从这个

8×8 样本中学习到的特征作为探测器，应用到这个图像的任意地方中去。特别是，我们可以用从 8×8

样本中所学习到的特征跟原本的大尺寸图像作卷积，从而对这个大尺寸图像上的任一位置获得一个不同特征的激活值。

如下图所示，展示了一个33的卷积核在55的图像上做卷积的过程。每个卷积都是一种特征提取方式，就像一个筛子，将图像中符合条件（激活值越大越符合条件）的部分筛选出来。

2.3 多卷积核

上面所述只有100个参数时，表明只有1个100*100的卷积核，显然，特征提取是不充分的，我们可以添加多个卷积核，比如32个卷积核，可以学习32种特征。在有多个卷积核时，如下图所示：

上图右，不同颜色表明不同的卷积核。每个卷积核都会将图像生成为另一幅图像。比如两个卷积核就可以将生成两幅图像，这两幅图像可以看做是一张图像的不同的通道。如下图所示，下图有个小错误，即将w1改为w0，w2改为w1即可。下文中仍以w1和w2称呼它们。

下图展示了在四个通道上的卷积操作，有两个卷积核，生成两个通道。其中需要注意的是，四个通道上每个通道对应一个卷积核，先将w2忽略，只看w1，那么在w1的某位置（i,j）处的值，是由四个通道上（i,j）处的卷积结果相加然后再取激活函数值得到的。

所以，在上图由4个通道卷积得到2个通道的过程中，参数的数目为4×2×2×2个，其中4表示4个通道，第一个2表示生成2个通道，最后的2×2表示卷积核大小。

2.4 Down-pooling

在通过卷积获得了特征 (features)

之后，下一步我们希望利用这些特征去做分类。理论上讲，人们可以用所有提取得到的特征去训练分类器，例如 softmax

分类器，但这样做面临计算量的挑战。例如：对于一个 96X96

像素的图像，假设我们已经学习得到了400个定义在8X8输入上的特征，每一个特征和图像卷积都会得到一个 (96 − 8 + 1) × (96 − 8+ 1) = 7921 维的卷积特征，由于有 400 个特征，所以每个样例 (example) 都会得到一个 892 × 400 =3,168,400 维的卷积特征向量。学习一个拥有超过 3 百万特征输入的分类器十分不便，并且容易出现过拟合 (over-fitting)。

为了解决这个问题，首先回忆一下，我们之所以决定使用卷积后的特征是因为图像具有一种“静态性”的属性，这也就意味着在一个图像区域有用的特征极有可能在另一个区域同样适用。因此，为了描述大的图像，一个很自然的想法就是对不同位置的特征进行聚合统计，例如，人们可以计算图像一个区域上的某个特定特征的平均值(或最大值)。这些概要统计特征不仅具有低得多的维度 (相比使用所有提取得到的特征)，同时还会改善结果(不容易过拟合)。这种聚合的操作就叫做池(pooling)，有时也称为平均池化或者最大池化 (取决于计算池化的方法)。

至此，卷积神经网络的基本结构和原理已经阐述完毕。

2.5 多层卷积

在实际应用中，往往使用多层卷积，然后再使用全连接层进行训练，多层卷积的目的是一层卷积学到的特征往往是局部的，层数越高，学到的特征就越全局化。

3 ImageNet-2010网络结构

ImageNetLSVRC是一个图片分类的比赛，其训练集包括127W+张图片，验证集有5W张图片，测试集有15W张图片。本文截取2010年AlexKrizhevsky的CNN结构进行说明，该结构在2010年取得冠军，top-5错误率为15.3%。值得一提的是，在今年的ImageNetLSVRC比赛中，取得冠军的GoogNet已经达到了top-5错误率6.67%。可见，深度学习的提升空间还很巨大。

下图即为Alex的CNN结构图。需要注意的是，该模型采用了2-GPU并行结构，即第1、2、4、5卷积层都是将模型参数分为2部分进行训练的。在这里，更进一步，并行结构分为数据并行与模型并行。数据并行是指在不同的GPU上，模型结构相同，但将训练数据进行切分，分别训练得到不同的模型，然后再将模型进行融合。而模型并行则是，将若干层的模型参数进行切分，不同的GPU上使用相同的数据进行训练，得到的结果直接连接作为下一层的输入。

上图模型的基本参数为：

输入：224×224大小的图片，3通道

第一层卷积：5×5大小的卷积核96个，每个GPU上48个。

第一层max-pooling：2×2的核。

第二层卷积：3×3卷积核256个，每个GPU上128个。

第二层max-pooling：2×2的核。

第三层卷积：与上一层是全连接，3*3的卷积核384个。分到两个GPU上个192个。

第四层卷积：3×3的卷积核384个，两个GPU各192个。该层与上一层连接没有经过pooling层。

第五层卷积：3×3的卷积核256个，两个GPU上个128个。

第五层max-pooling：2×2的核。

第一层全连接：4096维，将第五层max-pooling的输出连接成为一个一维向量，作为该层的输入。

第二层全连接：4096维

Softmax层：输出为1000，输出的每一维都是图片属于该类别的概率。

4 DeepID网络结构

DeepID网络结构是香港中文大学的Sun

Yi开发出来用来学习人脸特征的卷积神经网络。每张输入的人脸被表示为160维的向量，学习到的向量经过其他模型进行分类，在人脸验证试验上得到了97.45%的正确率，更进一步的，原作者改进了CNN，又得到了99.15%的正确率。

如下图所示，该结构与ImageNet的具体参数类似，所以只解释一下不同的部分吧。

上图中的结构，在最后只有一层全连接层，然后就是softmax层了。论文中就是以该全连接层作为图像的表示。在全连接层，以第四层卷积和第三层max-pooling的输出作为全连接层的输入，这样可以学习到局部的和全局的特征。

⑷ 卷积神经网络的 卷积层、激活层、池化层、全连接层

数据输入的是一张图片（输入层），CONV表示卷积层，RELU表示激励层，POOL表示池化层，Fc表示全连接层

全连接神经网络需要非常多的计算资源才能支撑它来做反向传播和前向传播，所以说全连接神经网络可以存储非常多的参数，如果你给它的样本如果没有达到它的量级的时候，它可以轻轻松松把你给他的样本全部都记下来，这会出现过拟合的情况。

所以我们应该把神经元和神经元之间的连接的权重个数降下来，但是降下来我们又不能保证它有较强的学习能力，所以这是一个纠结的地方，所以有一个方法就是 局部连接+权值共享 ，局部连接+权值共享不仅权重参数降下来了，而且学习能力并没有实质的降低，除此之外还有其它的好处，下来看一下，下面的这几张图片：

一个图像的不同表示方式

这几张图片描述的都是一个东西，但是有的大有的小，有的靠左边，有的靠右边，有的位置不同，但是我们构建的网络识别这些东西的时候应该是同一结果。为了能够达到这个目的，我们可以让图片的不同位置具有相同的权重（权值共享），也就是上面所有的图片，我们只需要在训练集中放一张，我们的神经网络就可以识别出上面所有的，这也是 权值共享 的好处。

而卷积神经网络就是局部连接+权值共享的神经网络。

现在我们对卷积神经网络有一个初步认识了，下面具体来讲解一下卷积神经网络，卷积神经网络依旧是层级结构，但层的功能和形式做了改变，卷积神经网络常用来处理图片数据，比如识别一辆汽车：

在图片输出到神经网络之前，常常先进行图像处理，有 三种 常见的图像的处理方式：

均值化和归一化

去相关和白化

图片有一个性质叫做局部关联性质，一个图片的像素点影响最大的是它周边的像素点，而距离这个像素点比较远的像素点二者之间关系不大。这个性质意味着每一个神经元我们不用处理全局的图片了（和上一层全连接），我们的每一个神经元只需要和上一层局部连接，相当于每一个神经元扫描一小区域，然后许多神经元（这些神经元权值共享）合起来就相当于扫描了全局，这样就构成一个特征图，n个特征图就提取了这个图片的n维特征，每个特征图是由很多神经元来完成的。

在卷积神经网络中，我们先选择一个局部区域（filter），用这个局部区域（filter）去扫描整张图片。 局部区域所圈起来的所有节点会被连接到下一层的 一个节点上 。我们拿灰度图（只有一维）来举例：

局部区域

图片是矩阵式的，将这些以矩阵排列的节点展成了向量。就能更好的看出来卷积层和输入层之间的连接，并不是全连接的，我们将上图中的红色方框称为filter，它是2*2的，这是它的尺寸，这不是固定的，我们可以指定它的尺寸。

我们可以看出来当前filter是2*2的小窗口，这个小窗口会将图片矩阵从左上角滑到右下角，每滑一次就会一下子圈起来四个，连接到下一层的一个神经元，然后产生四个权重，这四个权重(w1、w2、w3、w4)构成的矩阵就叫做卷积核。

卷积核是算法自己学习得到的，它会和上一层计算，比如，第二层的0节点的数值就是局部区域的线性组合（w1 0+w2 1+w3 4+w4 5），即被圈中节点的数值乘以对应的权重后相加。

卷积核计算

卷积操作

我们前面说过图片不用向量表示是为了保留图片平面结构的信息。 同样的，卷积后的输出若用上图的向量排列方式则丢失了平面结构信息。 所以我们依然用矩阵的方式排列它们，就得到了下图所展示的连接，每一个蓝色结点连接四个黄色的结点。

卷积层的连接方式

图片是一个矩阵然后卷积神经网络的下一层也是一个矩阵，我们用一个卷积核从图片矩阵左上角到右下角滑动，每滑动一次，当然被圈起来的神经元们就会连接下一层的一个神经元，形成参数矩阵这个就是卷积核，每次滑动虽然圈起来的神经元不同，连接下一层的神经元也不同，但是产生的参数矩阵确是一样的，这就是 权值共享 。

卷积核会和扫描的图片的那个局部矩阵作用产生一个值，比如第一次的时候，（w1 0+w2 1+w3 4+w4 5），所以，filter从左上到右下的这个过程中会得到一个矩阵（这就是下一层也是一个矩阵的原因），具体过程如下所示：

卷积计算过程

上图中左边是图矩阵，我们使用的filter的大小是3 3的，第一次滑动的时候，卷积核和图片矩阵作用（1 1+1 0+1 1+0 0+1 1+1 0+0 1+0 0+1 1）=4，会产生一个值，这个值就是右边矩阵的第一个值，filter滑动9次之后，会产生9个值，也就是说下一层有9个神经元，这9个神经元产生的值就构成了一个矩阵，这矩阵叫做特征图，表示image的某一维度的特征，当然具体哪一维度可能并不知道，可能是这个图像的颜色，也有可能是这个图像的轮廓等等。

单通道图片总结 ：以上就是单通道的图片的卷积处理，图片是一个矩阵，我们用指定大小的卷积核从左上角到右下角来滑动，每次滑动所圈起来的结点会和下一层的一个结点相连，连接之后就会形成局部连接，每一条连接都会产生权重，这些权重就是卷积核，所以每次滑动都会产生一个卷积核，因为权值共享，所以这些卷积核都是一样的。卷积核会不断和当时卷积核所圈起来的局部矩阵作用，每次产生的值就是下一层结点的值了，这样多次产生的值组合起来就是一个特征图，表示某一维度的特征。也就是从左上滑动到右下这一过程中会形成一个特征图矩阵（共享一个卷积核），再从左上滑动到右下又会形成另一个特征图矩阵（共享另一个卷积核），这些特征图都是表示特征的某一维度。

三个通道的图片如何进行卷积操作？

至此我们应该已经知道了单通道的灰度图是如何处理的，实际上我们的图片都是RGB的图像，有三个通道，那么此时图像是如何卷积的呢？

彩色图像

filter窗口滑的时候，我们只是从width和height的角度来滑动的，并没有考虑depth，所以每滑动一次实际上是产生一个卷积核，共享这一个卷积核，而现在depth=3了，所以每滑动一次实际上产生了具有三个通道的卷积核（它们分别作用于输入图片的蓝色、绿色、红色通道），卷积核的一个通道核蓝色的矩阵作用产生一个值，另一个和绿色的矩阵作用产生一个值，最后一个和红色的矩阵作用产生一个值，然后这些值加起来就是下一层结点的值，结果也是一个矩阵，也就是一张特征图。

三通道的计算过程

要想有多张特征图的话，我们可以再用新的卷积核来进行左上到右下的滑动，这样就会形成 新的特征图 。

三通道图片的卷积过程

也就是说增加一个卷积核，就会产生一个特征图，总的来说就是输入图片有多少通道，我们的卷积核就需要对应多少通道，而本层中卷积核有多少个，就会产生多少个特征图。这样卷积后输出可以作为新的输入送入另一个卷积层中处理，有几个特征图那么depth就是几，那么下一层的每一个特征图就得用相应的通道的卷积核来对应处理，这个逻辑要清楚，我们需要先了解一下 基本的概念：

卷积计算的公式

4x4的图片在边缘Zero padding一圈后，再用3x3的filter卷积后，得到的Feature Map尺寸依然是4x4不变。

填充

当然也可以使用5x5的filte和2的zero padding可以保持图片的原始尺寸，3x3的filter考虑到了像素与其距离为1以内的所有其他像素的关系，而5x5则是考虑像素与其距离为2以内的所有其他像素的关系。

规律： Feature Map的尺寸等于

(input_size + 2 * padding_size − filter_size)/stride+1

我们可以把卷积层的作用 总结一点： 卷积层其实就是在提取特征，卷积层中最重要的是卷积核（训练出来的），不同的卷积核可以探测特定的形状、颜色、对比度等，然后特征图保持了抓取后的空间结构，所以不同卷积核对应的特征图表示某一维度的特征，具体什么特征可能我们并不知道。特征图作为输入再被卷积的话，可以则可以由此探测到"更大"的形状概念，也就是说随着卷积神经网络层数的增加，特征提取的越来越具体化。

激励层的作用可以理解为把卷积层的结果做 非线性映射 。

激励层

上图中的f表示激励函数，常用的激励函数几下几种：

常用的激励函数

我们先来看一下激励函数Sigmoid导数最小为0，最大为1/4，

激励函数Sigmoid

Tanh激活函数：和sigmoid相似，它会关于x轴上下对应，不至于朝某一方面偏向

Tanh激活函数

ReLU激活函数（修正线性单元)：收敛快，求梯度快，但较脆弱，左边的梯度为0

ReLU激活函数

Leaky ReLU激活函数：不会饱和或者挂掉，计算也很快，但是计算量比较大

Leaky ReLU激活函数

一些激励函数的使用技巧 ：一般不要用sigmoid，首先试RELU，因为快，但要小心点，如果RELU失效，请用Leaky ReLU，某些情况下tanh倒是有不错的结果。

这就是卷积神经网络的激励层，它就是将卷积层的线性计算的结果进行了非线性映射。可以从下面的图中理解。它展示的是将非线性操作应用到一个特征图中。这里的输出特征图也可以看作是"修正"过的特征图。如下所示：

非线性操作

池化层：降低了各个特征图的维度，但可以保持大分重要的信息。池化层夹在连续的卷积层中间，压缩数据和参数的量，减小过拟合，池化层并没有参数，它只不过是把上层给它的结果做了一个下采样（数据压缩）。下采样有 两种 常用的方式：

Max pooling ：选取最大的，我们定义一个空间邻域（比如，2x2 的窗口），并从窗口内的修正特征图中取出最大的元素，最大池化被证明效果更好一些。

Average pooling ：平均的，我们定义一个空间邻域（比如，2x2 的窗口），并从窗口内的修正特征图算出平均值

Max pooling

我们要注意一点的是：pooling在不同的depth上是分开执行的，也就是depth=5的话，pooling进行5次，产生5个池化后的矩阵，池化不需要参数控制。池化操作是分开应用到各个特征图的，我们可以从五个输入图中得到五个输出图。

池化操作

无论是max pool还是average pool都有分信息被舍弃，那么部分信息被舍弃后会损坏识别结果吗？

因为卷积后的Feature Map中有对于识别物体不必要的冗余信息，我们下采样就是为了去掉这些冗余信息，所以并不会损坏识别结果。

我们来看一下卷积之后的冗余信息是怎么产生的？

我们知道卷积核就是为了找到特定维度的信息，比如说某个形状，但是图像中并不会任何地方都出现这个形状，但卷积核在卷积过程中没有出现特定形状的图片位置卷积也会产生一个值，但是这个值的意义就不是很大了，所以我们使用池化层的作用，将这个值去掉的话，自然也不会损害识别结果了。

比如下图中，假如卷积核探测"横折"这个形状。 卷积后得到3x3的Feature Map中，真正有用的就是数字为3的那个节点，其余数值对于这个任务而言都是无关的。 所以用3x3的Max pooling后，并没有对"横折"的探测产生影响。 试想在这里例子中如果不使用Max pooling，而让网络自己去学习。 网络也会去学习与Max pooling近似效果的权重。因为是近似效果，增加了更多的参数的代价，却还不如直接进行最大池化处理。

最大池化处理

在全连接层中所有神经元都有权重连接，通常全连接层在卷积神经网络尾部。当前面卷积层抓取到足以用来识别图片的特征后，接下来的就是如何进行分类。 通常卷积网络的最后会将末端得到的长方体平摊成一个长长的向量，并送入全连接层配合输出层进行分类。比如，在下面图中我们进行的图像分类为四分类问题，所以卷积神经网络的输出层就会有四个神经元。

四分类问题

我们从卷积神经网络的输入层、卷积层、激活层、池化层以及全连接层来讲解卷积神经网络，我们可以认为全连接层之间的在做特征提取，而全连接层在做分类，这就是卷积神经网络的核心。

⑸ 卷积神经网络（CNN）基础

在七月初七情人节，牛郎织女相见的一天，我终于学习了CNN（来自CS231n），感觉感触良多，所以赶快记下来，别忘了，最后祝大家情人节快乐5555555.正题开始!

CNN一共有卷积层（CONV）、ReLU层（ReLU）、池化层（Pooling）、全连接层（FC（Full Connection））下面是各个层的详细解释。

卷积，尤其是图像的卷积，需要一个滤波器，用滤波器对整个图像进行遍历，我们假设有一个32*32*3的原始图像A，滤波器的尺寸为5*5*3，用w表示，滤波器中的数据就是CNN的参数的一部分，那么在使用滤波器w对A进行滤波的话，可以用下面的式子表示：

其中x为原始图像的5*5*3的一部分，b是偏置项置为1。在对A进行滤波之后，产生的是一个28*28*1的数据。那么假设我们存在6个滤波器，这六个滤波器之间彼此是独立的，也就是他们内部的数据是不同的且没有相关性的。可以理解为一个滤波器查找整幅图像的垂直边缘，一个查找水平边缘，一个查找红色，一个查找黑色这样。那么我就可以产生6个28*28*1的数据，将它们组合到一起就可以产生28*28*6的数据，这就是卷积层主要做的工作。

CNN可以看作一系列的卷积层和ReLU层对原始数据结构进行处理的神经网络，处理的过程可以用下面这幅图表示

特别要注意的是滤波器的深度一定要与上一层传来的数据的深度相同，就像上图的第二个卷积层在处理传来的28*28*6的数据时要使用5*5*6的滤波器.

滤波器在图像上不断移动对图像滤波，自然存在步长的问题，在上面我们举的例子都是步长为1的情况，如果步长为3的话，32*32*3的图像经过5*5*3的滤波器卷积得到的大小是（32-5）/3+1=10， 注：步长不能为2因为（32-5）/2+1=14.5是小数。

所以当图像大小是N，滤波器尺寸为F时，步长S，那么卷积后大小为（N-F）/S+1

我们从上面的图中可以看到图像的长和宽在逐渐的减小，在经过超过5层之后极可能只剩下1*1的空间尺度，这样是十分不好的，而且也不利于我们接下来的计算，所以我们想让卷积层处理完之后图像在空间尺度上大小不变，所以我们引入了pad the border的操作。pad其实就是在图像周围补0，扩大图像的尺寸，使得卷积后图像大小不变。在CNN中，主要存在4个超参数，滤波器个数K，滤波器大小F，pad大小P和步长S，其中P是整数，当P=1时，对原始数据的操作如图所示：

那么在pad操作后卷积后的图像大小为：（N-F+2*P）/S+1
而要想让卷积层处理后图像空间尺度不变，P的值可以设为P=（F-1）/2

卷积层输入W ₁ *H ₁ *D ₁ 大小的数据，输出W ₂ *H ₂ *D ₂ 的数据，此时的卷积层共有4个超参数：
K：滤波器个数
P：pad属性值
S：滤波器每次移动的步长
F：滤波器尺寸
此时输出的大小可以用输入和超参计算得到：
W ₂ =（W ₁ -F+2P）/S+1
H ₂ =（H ₁ -F+2P）/S+1
D ₂ =D ₁

1*1的滤波器也是有意义的，它在深度方向做卷积，例如1*1*64的滤波器对56*56*64的数据卷积得到56*56的数据

F通常是奇数，这样可以综合考虑上下左右四个方向的数据。

卷积层从神经元的角度看待可以有两个性质： 参数共享和局域连接 。对待一个滤波器，例如5*5*3的一个滤波器，对32*32*3的数据卷积得到28*28的数据，可以看作存在28*28个神经元，每个对原图像5*5*3的区域进行计算，这28*28个神经元由于使用同一个滤波器，所以参数相同，我们称这一特性为 参数共享 。

针对不同的滤波器，我们可以看到他们会看到同一区域的图像，相当于在深度方向存在多个神经元，他们看着相同区域叫做 局域连接

参数共享减少了参数的数量，防止了过拟合
局域连接为查找不同特征更丰富的表现图像提供了可能。
卷积就像是对原图像的另一种表达。

激活函数，对于每一个维度经过ReLU函数输出即可。不改变数据的空间尺度。

通过pad操作，输出图像在控件上并没有变化，但是深度发生了变化，越来越庞大的数据给计算带来了困难，也出现了冗余的特征，所以需要进行池化操作，池化不改变深度，只改变长宽，主要有最大值和均值两种方法，一般的池化滤波器大小F为2步长为2，对于最大值池化可以用下面的图像清晰的表示：

卷积层输入W ₁ *H ₁ *D ₁ 大小的数据，输出W ₂ *H ₂ *D ₂ 的数据，此时的卷积层共有2个超参数：
S：滤波器每次移动的步长
F：滤波器尺寸
此时输出的大小可以用输入和超参计算得到：
W ₂ =（W ₁ -F）/S+1
H ₂ =（H ₁ -F）/S+1
D ₂ =D ₁

将最后一层（CONV、ReLU或Pool）处理后的数据输入全连接层，对于W ₂ *H ₂ *D ₂ 数据，我们将其展成1*1*W ₂ *H ₂ *D ₂ 大小的数据，输入层共有W ₂ *H ₂ *D ₂ 个神经元，最后根据问题确定输出层的规模，输出层可以用softmax表示。也就是说，全连接层就是一个常见的BP神经网络。而这个网络也是参数最多的部分，是接下来想要去掉的部分。完整的神经网络可以用下面的图表示：

[(CONV-ReLU)*N-POOL?]*M-(FC-RELU)*K,SoftMax

1.更小的滤波器与更深的网络
2.只有CONV层而去掉池化与全链接

最早的CNN，用于识别邮编，结构为：
CONV-POOL-CONV-POOL-CONV-FC
滤波器大小5*5，步长为1，池化层2*2，步长为2

2012年由于GPU技术所限，原始AlexNet为两个GPU分开计算，这里介绍合起来的结构。

输入图像为227*227*3

1.首次使用ReLU
2.使用Norm layers，现在已经抛弃，因为效果不大
3.数据经过预处理（例如大小变化，颜色变化等）
4.失活比率0.5
5.batch size 128
6.SGD Momentum 参数0.9（SGD和Momentum见我的其他文章）
7.学习速率 0.01，准确率不在提升时减少10倍，1-2次后达到收敛
8.L2权重减少0.0005
9.错误率15.4%

改进自AlexNet，主要改变：
1.CONV1的滤波器从11*11步长S=4改为7*7步长为2.
2.CONV3,4,5滤波器数量有384，384，256改为512，1024，512（滤波器数量为2的n次幂有利于计算机计算可以提高效率）
错误率：14.8%后继续改进至11.2%

当前最好的最易用的CNN网络，所有卷积层滤波器的大小均为3*3，步长为1，pad=1，池化层为2*2的最大值池化，S=2。

主要参数来自全连接层，这也是想要去掉FC的原因。

具有高度的统一性和线性的组合，易于理解，十分方便有VGG-16，VGG-19等多种结构。
错误率7.3%

完全移除FC层，参数只有500万，使用Inception模块（不太理解，有时间继续看）
准确率6.67%

准确率3.6%
拥有极深的网络结构，且越深准确率越高。是传统CNN不具备的特点，传统CNN并非越深越准确。需要训练时间较长但是快于VGG

1.每个卷积层使用Batch Normalization
2.Xavier/2初始化
3.SGD+Momentum（0.9）
4.Learning rate:0.1,准确率不变减小10倍（因为Batch Normalization所以比AlexNet大）
5.mini-batch size 256
6.Weight decay of 0.00001
7.不适用失活（因为Batch Normalization）

具体的梯度过程学完ResNet再说吧。

⑹ LeNet神经网络

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

LeNet的神经网络结构图如下：

LeNet网络的执行流程图如下：

接下来我们来具体的一层层的分析LeNet的网络结构。首先要了解图像（输入数据）的表示。在LeNet网络中，输入图像是手写字符，图像的表示形式为二维数据矩阵，如下念老图所示：

LeNet网络除去输入输出层总共有六层网络。第一层是卷积层（C1层），卷积核的大小为 5*5 ，卷积核数量为 6 个，输入图像的大小为 32*32 ，因此输入数据在进行第一层卷积之后，输出结果为大小为 28*28 ，数量为 6 个的feature map。卷积操作如下面两幅图所示：

卷积操作的过程可描述为：卷积核在图像上滑动，滑动步长为1（即每次移动一格，水平方向从左到右，到最右边之后再从最左边开始，向下移动一格，重复从左到右滑动），当卷积核与图像的一个局部块重合时进行卷积运行，卷积计算方式为图像块对应位置的数与卷积核对应位置的数相乘，然后将所有相乘结果相加即为feature map的值， 相乘累加之后的结果位于卷积核中心点的位置 ，因此如果是 3*3 的卷积核，feature map比原图像在水平和垂直方向上分别减少两行（上下各一行）和两列（左右各一列），因此上面图像原图为 5*5 ，卷积核为 3*3 ，卷积结果大小为 3*3 ，即 (5-2)*(5-2) ，如果卷积核为 5*5 ，则卷积结果大小为 (5-4)*(5-4) 。上图中的卷积核为：

由于神经网络层与层的结构是通过连接来实现的，因此输入层与第一个卷积层的连接数量应为 (32-2-2)*(32-2-2)*(5*5+1)*6= 28*28*156 =122304 。

卷积的作用主要是：通过卷积运算，可以使原信号特征增强，并且降低噪音。在图像上卷积之后主要是减少图像噪声，提取图像的特征。例如sobel算子就是一种卷积运算，主要是提友喊取图像的边缘特征。卷积网络能很好地适应图像的平移不变性：例如稍稍移动一幅猫的图像，它仍然是一幅猫的图像。卷积操作保留了图像块之间的空间信息，进行卷积操作的图像块之间的相对位置关系没有改变。图像在不同卷积仔告升核上进行卷积之后的效果图如下：

图像在LeNet网络上进行第一层卷积之后，结果为大小为 28*28 ，数量为 6 个的feature map。LeNet网络的第二层为pooling层（S2层），也称为下采样。在图像处理中，下采样之后，图像的大小会变为原来的 1/4 ，即水平方向和垂直方向上图像大小分别减半。Pooling有多种，这里主要介绍两种，max-pooling和average-pooling。max-pooling即为从四个元素中选取一个最大的来表示这四个元素，average-pooling则用四个元素的平均值来表示这四个元素。Pooling示意图如下：

在LeNet在进行第二层Pooling运算后，输出结果为 14*14 的 6 个feature map。其连接数为 (2*2+1) * 14 * 14 *6 = 5880 。Pooling层的主要作用就是减少数据，降低数据纬度的同时保留最重要的信息。在数据减少后，可以减少神经网络的纬度和计算量，可以防止参数太多过拟合。LeNet在这一层是将四个元素相加，然后乘以参数w再加上偏置b，然后计算sigmoid值。

LeNet第三层（C3层）也是卷积层，卷积核大小仍为 5*5 ，不过卷积核的数量变为 16 个。第三层的输入为 14*14 的 6 个feature map，卷积核大小为 5*5 ，因此卷积之后输出的feature map大小为 10*10 ，由于卷积核有 16 个，因此希望输出的feature map也为 16 个，但由于输入有 6 个feature map，因此需要进行额外的处理。输入的 6 个feature map与输出的 16 个feature map的关系图如下：

如上图所示，第一个卷积核处理前三幅输入的feature map，得出一个新的feature map。

上一层卷积运算之后，结果为大小为 10*10 的 16 个feature map，因此在第四层（S4层）进行pooling运算之后，输出结果为 16 个大小为 5*5 的feature map。与S2层进行同样的操作。

LeNet第五层是卷积层(C5层)，卷积核数目为120个，大小为 5*5 ，由于第四层输出的feature map大小为 5*5 ，因此第五层也可以看成全连接层，输出为120个大小为 1*1 的feature map。

LeNet第六层是全连接层（F6层），有84个神经元（84与输出层的设计有关），与C5层全连接。

LeNet神经网络结构在Caffe中的配置文件如下：

参考资料：

1. https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/

⑺ CNN之Lenet5

LeNet诞生于 1994 年，是最早的卷积神经网络之一，并且推动了深度学习领域的发展。

LeNet-5是Yann LeCun等人在多次研究后提出的最终卷积神经网络结构，主要用于手写数字识别

LeNet5的网络结构如下所示：

LeNet-5包含七层，不包括输入，每一层都包含可训练参数（权重），当时使用的输入数据是32*32像素的图像。下面逐层介绍LeNet-5的结构，并且，卷积层将用Cx表示，子采样层则被标记为Sx，全连接层被标记为Fx，其中x是层索引。

该层使用了6个卷积核，每个卷积核的大小为5×5，这样就得到了6个feature map（特征图）。

每个卷积核（5×5）与原始的输入图像（32×32）进行卷积，这样得到的feature map（特征图）大小为（32-5+1）×（32-5+1）= 28×28

卷积核与输入图像按卷积核大小逐个区域进行匹配计算，匹配后原始输入图像的尺寸将变小，因为边缘部分卷积核无法越出界，只能匹配一次，匹配计算后的尺寸变为Cr×Cc=（Ir-Kr+1）×（Ic-Kc+1），其中Cr、Cc，Ir、Ic，Kr、Kc分别表示卷积后结果图像、输入图像、卷积核的行列大小。

由于参数（权值）共享的原因，对于同个卷积核每个神经元均使用相同的参数，因此，参数个数为（5×5+1）×6= 156，其中5×5为卷积核参数，1为偏置参数

卷积后的图像大小为28×28，因此每个特征图有28×28个神经元，每个卷积核参数为（5×5+1）×6，因此，该层的连接数为（5×5+1）×6×28×28=122304

这一层主要是做池化或者特征映射（特征降维），池化单元为2×2，因此，6个特征图的大小经池化后即变为14×14。池化单元之间没有重叠，在池化区域内进行聚合统计后得到新的特征值，因此经2×2池化后，每两行两列重新算出一个特征值出来，相当于图像大小减半，因此卷积后的28×28图像经2×2池化后就变为14×14。

这一层的计算过程是：2×2 单元里的值相加，然后再乘以训练参数w，再加上一个偏置参数b（每一个特征图共享相同的w和b)，然后取sigmoid值（S函数：0-1区间），作为对应的该单元的值。卷积操作与池化的示意图如下：

S2层由于每个特征图都共享相同的w和b这两个参数，因此需要2×6=12个参数

下采样之后的图像大小为14×14，因此S2层的每个特征图有14×14个神经元，每个池化单元连接数为2×2+1（1为偏置量），因此，该层的连接数为（2×2+1）×14×14×6 = 5880

C3层有16个卷积核，卷积模板大小为5×5。

与C1层的分析类似，C3层的特征图大小为（14-5+1）×（14-5+1）= 10×10

需要注意的是，C3与S2并不是全连接而是部分连接，有些是C3连接到S2三层、有些四层、甚至达到6层，通过这种方式提取更多特征，连接的规则如下表所示：

例如第一列表示C3层的第0个特征图（feature map）只跟S2层的第0、1和2这三个feature maps相连接，计算过程为：用3个卷积模板分别与S2层的3个feature maps进行卷积，然后将卷积的结果相加求和，再加上一个偏置，再取sigmoid得出卷积后对应的feature map了。其它列也是类似（有些是3个卷积模板，有些是4个，有些是6个）。因此，C3层的参数数目为（5×5×3+1）×6 +（5×5×4+1）×9 +5×5×6+1 = 1516

卷积后的特征图大小为10×10，参数数量为1516，因此连接数为1516×10×10= 151600

与S2的分析类似，池化单元大小为2×2，因此，该层与C3一样共有16个特征图，每个特征图的大小为5×5。

与S2的计算类似，所需要参数个数为16×2 = 32

连接数为（2×2+1）×5×5×16 = 2000

该层有120个卷积核，每个卷积核的大小仍为5×5，因此有120个特征图。由于S4层的大小为5×5，而该层的卷积核大小也是5×5，因此特征图大小为（5-5+1）×（5-5+1）= 1×1。这样该层就刚好变成了全连接，这只是巧合，如果原始输入的图像比较大，则该层就不是全连接了。

与前面的分析类似，本层的参数数目为120×（5×5×16+1） = 48120

由于该层的特征图大小刚好为1×1，因此连接数为48120×1×1=48120

F6层有84个单元，之所以选这个数字的原因是来自于输出层的设计，对应于一个7×12的比特图，如下图所示，-1表示白色，1表示黑色，这样每个符号的比特图的黑白色就对应于一个编码。

该层有84个特征图，特征图大小与C5一样都是1×1，与C5层全连接。

由于是全连接，参数数量为（120+1）×84=10164。跟经典神经网络一样，F6层计算输入向量和权重向量之间的点积，再加上一个偏置，然后将其传递给sigmoid函数得出结果。

由于是全连接，连接数与参数数量一样，也是10164。

Output层也是全连接层，共有10个节点，分别代表数字0到9。如果第i个节点的值为0，则表示网络识别的结果是数字i。

该层采用径向基函数（RBF）的网络连接方式，假设x是上一层的输入，y是RBF的输出，则RBF输出的计算方式是：

上式中的Wij的值由i的比特图编码确定，i从0到9，j取值从0到7×12-1。RBF输出的值越接近于0，表示当前网络输入的识别结果与字符i越接近。

由于是全连接，参数个数为84×10=840

由于是全连接，连接数与参数个数一样，也是840

from skimage import io,transform

import os

import glob

import numpy as np

import tensorflow as tf

#将所有的图片重新设置尺寸为32*32

w = 32

h = 32

c = 1

#mnist数据集中训练数据和测试数据保存地址

train_path = "E:/data/datasets/mnist/train/"

test_path = "E:/data/datasets/mnist/test/"

#读取图片及其标签函数

'''os.listdir()返回指定的文件夹包含的文件或文件夹的名字,存放于一个列表中;os.path.isdir()判断某一路径是否为目录

enumerate()将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，数据下标和相应数据'''

def read_image(path):

    label_dir = [path+x for x in os.listdir(path) if os.path.isdir(path+x)]

    images = []

    labels = []

    for index,folder in enumerate(label_dir):

        for img in glob.glob(folder+'/*.png'):

            print("reading the image:%s"%img)

            image = io.imread(img)

            image = transform.resize(image,(w,h,c))

            images.append(image)

            labels.append(index)

    return np.asarray(images,dtype=np.float32),np.asarray(labels,dtype=np.int32)

#读取训练数据及测试数据           

train_data,train_label = read_image(train_path)

test_data,test_label = read_image(test_path)

#打乱训练数据及测试数据  np.arange()返回一个有终点和起点的固定步长的排列,

train_image_num = len(train_data)

train_image_index = np.arange(train_image_num) ##起始点0，结束点train_image_num，步长1，返回类型array，一维

np.random.shuffle(train_image_index)

train_data = train_data[train_image_index]

train_label = train_label[train_image_index]

test_image_num = len(test_data)

test_image_index = np.arange(test_image_num)

np.random.shuffle(test_image_index)

test_data = test_data[test_image_index]

test_label = test_label[test_image_index]

#搭建CNN 此函数可以理解为形参，用于定义过程，在执行的时候再赋具体的值,形参名X，y_

x = tf.placeholder(tf.float32,[None,w,h,c],name='x')

y_ = tf.placeholder(tf.int32,[None],name='y_')

def inference(input_tensor,train,regularizer):

    #第一层：卷积层，过滤器的尺寸为5×5，深度为6,不使用全0补充，步长为1。

    #尺寸变化：32×32×1->28×28×6

    '''参数的初始化：tf.truncated_normal_initializer()或者简写为tf.TruncatedNormal()、tf.RandomNormal() 去掉_initializer,大写首字母即可

生成截断正态分布的随机数，这个初始化方法好像在tf中用得比较多mean=0.0, stddev=1.0 正态分布

http://www.mamicode.com/info-detail-1835147.html'''

    with tf.variable_scope('layer1-conv1'):

        conv1_weights = tf.get_variable('weight',[5,5,c,6],initializer=tf.truncated_normal_initializer(stddev=0.1))

        conv1_biases = tf.get_variable('bias',[6],initializer=tf.constant_initializer(0.0))

        conv1 = tf.nn.conv2d(input_tensor,conv1_weights,strides=[1,1,1,1],padding='VALID')

        relu1 = tf.nn.relu(tf.nn.bias_add(conv1,conv1_biases))

    #第二层：池化层，过滤器的尺寸为2×2，使用全0补充，步长为2。

    #尺寸变化：28×28×6->14×14×6

    with tf.name_scope('layer2-pool1'):

        pool1 = tf.nn.max_pool(relu1,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

    #第三层：卷积层，过滤器的尺寸为5×5，深度为16,不使用全0补充，步长为1。

    #尺寸变化：14×14×6->10×10×16

    with tf.variable_scope('layer3-conv2'):

        conv2_weights = tf.get_variable('weight',[5,5,6,16],initializer=tf.truncated_normal_initializer(stddev=0.1))

        conv2_biases = tf.get_variable('bias',[16],initializer=tf.constant_initializer(0.0))

        conv2 = tf.nn.conv2d(pool1,conv2_weights,strides=[1,1,1,1],padding='VALID')

        relu2 = tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))

    #第四层：池化层，过滤器的尺寸为2×2，使用全0补充，步长为2。

    #尺寸变化：10×10×6->5×5×16

    with tf.variable_scope('layer4-pool2'):

        pool2 = tf.nn.max_pool(relu2,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

    #将第四层池化层的输出转化为第五层全连接层的输入格式。第四层的输出为5×5×16的矩阵，然而第五层全连接层需要的输入格式

    #为向量，所以我们需要把代表每张图片的尺寸为5×5×16的矩阵拉直成一个长度为5×5×16的向量。

    #举例说，每次训练64张图片，那么第四层池化层的输出的size为(64,5,5,16),拉直为向量，nodes=5×5×16=400,尺寸size变为(64,400)

    pool_shape = pool2.get_shape().as_list()

    nodes = pool_shape[1]*pool_shape[2]*pool_shape[3]

    reshaped = tf.reshape(pool2,[-1,nodes])

    #第五层：全连接层，nodes=5×5×16=400，400->120的全连接

    #尺寸变化：比如一组训练样本为64，那么尺寸变化为64×400->64×120

    #训练时，引入dropout，dropout在训练时会随机将部分节点的输出改为0，dropout可以避免过拟合问题。

    #这和模型越简单越不容易过拟合思想一致，和正则化限制权重的大小，使得模型不能任意拟合训练数据中的随机噪声，以此达到避免过拟合思想一致。

    #本文最后训练时没有采用dropout，dropout项传入参数设置成了False，因为训练和测试写在了一起没有分离，不过大家可以尝试。

    '''tf.matmul()这个函数是专门矩阵或者tensor乘法，而不是矩阵元素对应元素相乘

    tf.multiply（）两个矩阵中对应元素各自相乘

    tf.nn.dropout(x, keep_prob):TensorFlow里面为了防止或减轻过拟合而使用的函数，它一般用在全连接层，

    x：指输入;keep_prob: 设置神经元被选中的概率,使输入tensor中某些元素变为0，其它没变0的元素变为原来的1/keep_prob大小,可以想象下，比如某些元素弃用

    在初始化时keep_prob是一个占位符,keep_prob = tf.placeholder(tf.float32).

    tensorflow在run时设置keep_prob具体的值，例如keep_prob: 0.5,train的时候才是dropout起作用的时候

    keep_prob: A scalar Tensor with the same type as x. The probability that each element is kept.'''

    with tf.variable_scope('layer5-fc1'):

        fc1_weights = tf.get_variable('weight',[nodes,120],initializer=tf.truncated_normal_initializer(stddev=0.1))

        if regularizer != None:

            tf.add_to_collection('losses',regularizer(fc1_weights))

        fc1_biases = tf.get_variable('bias',[120],initializer=tf.constant_initializer(0.1))

        fc1 = tf.nn.relu(tf.matmul(reshaped,fc1_weights) + fc1_biases)

        if train:

            fc1 = tf.nn.dropout(fc1,0.5)

    #第六层：全连接层，120->84的全连接

    #尺寸变化：比如一组训练样本为64，那么尺寸变化为64×120->64×84

    '''tf.add_to_collection：把变量放入一个集合，把很多变量变成一个列表

    tf.get_collection：从一个结合中取出全部变量，是一个列表

    tf.add_n：把一个列表的东西都依次加起来'''

    with tf.variable_scope('layer6-fc2'):

        fc2_weights = tf.get_variable('weight',[120,84],initializer=tf.truncated_normal_initializer(stddev=0.1))

        if regularizer != None:

            tf.add_to_collection('losses',regularizer(fc2_weights))

        fc2_biases = tf.get_variable('bias',[84],initializer=tf.truncated_normal_initializer(stddev=0.1))

        fc2 = tf.nn.relu(tf.matmul(fc1,fc2_weights) + fc2_biases)

        if train:

            fc2 = tf.nn.dropout(fc2,0.5)

    #第七层：全连接层（近似表示），84->10的全连接

    #尺寸变化：比如一组训练样本为64，那么尺寸变化为64×84->64×10。最后，64×10的矩阵经过softmax之后就得出了64张图片分类于每种数字的概率，

    #即得到最后的分类结果。

    with tf.variable_scope('layer7-fc3'):

        fc3_weights = tf.get_variable('weight',[84,10],initializer=tf.truncated_normal_initializer(stddev=0.1))

        if regularizer != None:

            tf.add_to_collection('losses',regularizer(fc3_weights))

        fc3_biases = tf.get_variable('bias',[10],initializer=tf.truncated_normal_initializer(stddev=0.1))

        logit = tf.matmul(fc2,fc3_weights) + fc3_biases

    return logit

#正则化，交叉熵，平均交叉熵，损失函数，最小化损失函数，预测和实际equal比较，tf.equal函数会得到True或False，

#accuracy首先将tf.equal比较得到的布尔值转为float型，即True转为1.，False转为0，最后求平均值，即一组样本的正确率。

#比如：一组5个样本，tf.equal比较为[True False True False False],转化为float型为[1. 0 1. 0 0],准确率为2./5=40%。

'''规则化可以帮助防止过度配合，提高模型的适用性。（让模型无法完美匹配所有的训练项。）（使用规则来使用尽量少的变量去拟合数据）

规则化就是说给需要训练的目标函数加上一些规则（限制），让他们不要自我膨胀。

TensorFlow会将L2的正则化损失值除以2使得求导得到的结果更加简洁

如tf.contrib.layers.apply_regularization/l1_regularizer/l2_regularizer/sum_regularizer

https://blog.csdn.net/liushui94/article/details/73481112

sparse_softmax_cross_entropy_with_logits()是将softmax和cross_entropy放在一起计算

https://blog.csdn.net/ZJRN1027/article/details/80199248'''

regularizer = tf.contrib.layers.l2_regularizer(0.001)

y = inference(x,False,regularizer)

cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=y_)

cross_entropy_mean = tf.rece_mean(cross_entropy)

loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))

train_op = tf.train.AdamOptimizer(0.001).minimize(loss)

correct_prediction = tf.equal(tf.cast(tf.argmax(y,1),tf.int32),y_)

accuracy = tf.rece_mean(tf.cast(correct_prediction,tf.float32))

#每次获取batch_size个样本进行训练或测试

def get_batch(data,label,batch_size):

    for start_index in range(0,len(data)-batch_size+1,batch_size):

        slice_index = slice(start_index,start_index+batch_size)

        yield data[slice_index],label[slice_index]

#创建Session会话

with tf.Session() as sess:

    #初始化所有变量(权值，偏置等)

    sess.run(tf.global_variables_initializer())

    #将所有样本训练10次，每次训练中以64个为一组训练完所有样本。

    #train_num可以设置大一些。

    train_num = 10

    batch_size = 64

    for i in range(train_num):

        train_loss,train_acc,batch_num = 0, 0, 0

        for train_data_batch,train_label_batch in get_batch(train_data,train_label,batch_size):

            _,err,acc = sess.run([train_op,loss,accuracy],feed_dict={x:train_data_batch,y_:train_label_batch})

            train_loss+=err;train_acc+=acc;batch_num+=1

        print("train loss:",train_loss/batch_num)

        print("train acc:",train_acc/batch_num)

        test_loss,test_acc,batch_num = 0, 0, 0

        for test_data_batch,test_label_batch in get_batch(test_data,test_label,batch_size):

            err,acc = sess.run([loss,accuracy],feed_dict={x:test_data_batch,y_:test_label_batch})

            test_loss+=err;test_acc+=acc;batch_num+=1

        print("test loss:",test_loss/batch_num)

        print("test acc:",test_acc/batch_num)