Going deeper with convolutions-GoogLeNet（阅读）

本篇论文是针对ImageNet2014的比赛，论文中的方法是比赛的第一名，包括task1分类任务和task2检测任务。本文主要关注针对计算机视觉的高效深度神经网络结构，通过改进神经网络的结构达到不增加计算资源需求的前提下提高网络的深度，从而达到提高效果的目的。

目的：

提升深度神经网络的性能。

 

一般方法带来的问题：

增加网络的深度与宽度。

带来两个问题：

（1）参数增加，数据不足的情况容易导致过拟合

（2）计算资源要求高，而且在训练过程中会使得很多参数趋向于0，浪费计算资源。

 

解决方法：

使用稀疏连接替代稠密结构。

理论依据（Arora）：一个概率分布可以用一个大的稀疏的深度神经网络表示，最优的结构的构建通过分析上层的激活状态的统计相关性，并把输出高度相关的神经元聚合。这与生物学中Hebbian法则“有些神经元响应基本一致，即同时兴奋或抑制”一致。

存在问题：计算机的基础结构在遇到稀疏数据计算时会很不高效，使用稀疏矩阵会使得效率大大降低。

目标：设计一种既能利用稀疏性，又可以利用稠密计算的网络结构。

 

Inception 模型：

究竟模型中是怎样利用稀疏性的呢？我也说不清楚，但估计是在同一层利用了不同的核去对输入的feature进行卷积把，分散成几个小任务进行，然后再汇聚。如下图：

@2016/08/24  更新对稀疏性的理解

知乎上摘自 段石石的解答：

对的 channel的意思其实就是神经元的个数，这里降维的意思其实就是减少神经元的个数，比如原先的28*28*512 在1*1*256 之后 就是28*28*256（stride为1的情况）， 这样在整个网络结构这一层就降维了，原作者发现在没有1*1之前的参数空间存在很多稀疏的数据，这里降维之后，参数空间会更dense，这样就解决了文章说的痛点（也就是稀疏性增大计算困难的问题）

 

 

这是最原始的模型。可以看出，因为卷积并不一定就改变大小，而通道数目由于分散的连接最终会增加，这样很容易造成参数个数的指数级别的上升。论文中使用了NIN网络中提到的利用1*1卷积核降维的作用，在卷积层处理前，先对特征图层进行降维（注意是通道的降维(神经元的个数)，不是空间的降维），例如原本是M通道，降维到P通道后，在通过汇聚变成了M通道，这时参数的个数并没有随着深度的加深而指数级的增长，如下图：

 

 

这样做的合理性在于，Hebbin法则说的“有些神经元同时兴奋或抑制”，而在区域中同一节点对应的区域可能一样，认为它们是相关的，所以通过1*1的卷积核将它们聚合（信息压缩）后再卷积，符合Arora的理论。同时，注意到还有一个最大化池化层。

这样处理的好处是（1）深度增加，节点数目可控（2）出现多个尺度如3*3，1*1，5*5，7*7等。

 

GoogLeNet结构：

GoogLeNet网络有22层，最后一层使用了NIN网络中的全局平均池化层，但还是会加上FC层，再输入到softmax函数中。如下图：

 

在深度加深的情况下，在BP算法执行时可能会使得某些梯度为0，这会使得网络的收敛变慢。论文中使用的方法是增加两个输出层（Auxiliary Classifiers），这样一些权值更新的梯度就会来自于多个部分的叠加，加速了网络的收敛。但预测时会吧AC层去掉。

Abstract

网络结构称为Inception，名字的获得来自Network in Network。这个网络是一个分类和检测的网络。该网络最大的特点就是提升了计算资源的利用率。在网络需要的计算不变的前提下，通过工艺改进来提升网络的宽度和深度。最后基于Hebbian Principle和多尺寸处理的直觉来提高性能。GoogLeNet有22层。

Introduction

GoogLeNet 用了比"Imagenet classification with deep convolutional neural network"少12倍的参数，但正确率更高。本文最大的工作类似于R-CNN。因为算法的the ongoing traction of mobile和embedded计算，算法的效率变得很重要。

• Improve utilization of the computing resources inside the network, which is achieved by carefully crafted design and allows for increasing the depth and width of the network while keeping the computational budget constant.

• Architecture decisions are based on the Hebbian principle and the intuition of multi-scale processing.

• A 22 layers deep network is assessed in the competition.

Related Work

论文参考文献15使用不同尺度的Gabor过滤器来处理多尺度问题，同本文的Inception Model类似。GoogLeNet用了很多相同的层，共22层。Network in Network用来提高神经网络的power。本文用Network in Network有两方面用途，使用了很多1×1的卷积核，降低维度来降低计算瓶颈，也可以提高网络的深度和宽度。R-CNN将检测分成两部分：在浅层利用颜色、次像素组成等信息检测，再利用深层的CNN进行分类。

Motivation and High Level Considerations

网络更深更大，容易导致过拟合，且增加计算性能的消耗。其根本的解决办法是将全连接层变为稀疏链接层。对于非均衡的稀疏数据，现在的计算效率不高。"On two-dimensional sparse matrix partitioning: Models, methods, and a recipe"提出将多个稀疏矩阵合并成相关的稠密子矩阵来解决问题。

• 本文提出的网络结构为Inception，得名于论文参考文献12（network in network）。
• Recent trend of CNN is to increase the number of layers and layer size, while using dropout to address the problem of overfitting。
• 论文参考文献15使用不同尺度的Gabor过滤器来处理多尺度问题，同本文的Inception Model类似。
• 本文借鉴参考论文12，使用了很多1×1的卷积核。卷积核在本文中的作用主要在于降维，以此来去除计算瓶颈。
• Detection task’s leading approach is Regions with Convolutional Neural Networks(R-CNN) (参考文献6)。该方法分为两步：
  • First utilize low-level cues such as color and superpixel consistency for potential object proposals in a category-agnostic fashion.
  • Then use CNN classifiers to identity object categories at those locations.

Motivation and High level considerations

3.1. Drawback of increasing CNN size directly:

• More prone to overfitting.
• Dramatically increase use of computational resources. (for example, if most weights end up to be close to zero, then lots of computations is wasted.)

3.2. How to solve it?

• The fundamental way would be by ultimately moving from fully connected to sparsely connected architectures.
• 论文的参考文献2表明，考虑到统计相关性，一个稀疏网络结构可以重新构建出最优结构。并产生了Hebbian principle——neurons that fire together, wire together。
• 从更底层考虑，现在的硬件在非一致稀疏数据结构上的计算非常不高效，尤其在这些数据上使用已经为密集矩阵优化过的库时。原来自论文参考文献9以来，都会使用随机稀疏的网络结构来打破对称性，提高学习率。但论文参考文献11中又重新使用全连接的结构，以图利用密集计算的高效性。
• 所以，现在的问题是有没有一种方法，既能保有网络结构的稀疏性，又能利用密集矩阵的高计算性能。论文提出了一种Inception Module，可以达到此等效果。

Architectural Details

Inception主要的思想就是如何找出最优的局部稀疏结构并将其覆盖为近似的稠密的组件。"Provable bounds for learningsome deep representations"提出一个层与层的结构，在结构的最后一层进行相关性统计，将高相关性的聚集到一起。这些簇构成下一层的单元，与上一层的单元连接。假设前面层的每个单元对应输入图像的某些区域，这些单元被滤波器进行分组。低层（接近input层）的单元集中在某些局部区域，意味着在最终会得到在单个区域的大量群，他们能在下一层通过1*1卷积覆盖"Network in network"。然而也可以通过一个簇覆盖更大的空间来减小簇的数量。为了避免patch-alignment问题，现在滤波器大小限制在1*1，3*3和5*5（主要是为了方便也非必要）。在pooling层添加一个备用的pooling路径可以增强效率。Inception模块都堆在其他Inception模块的上面,上述模块一个巨大的问题就是，即使是一个合适数量的卷积，也会因为大量的滤波而变得特别expensive。经过pooling层输出的合并，最终可能会导致数量级增大不可避免。处理效率不高导致计算崩溃。

第二种方法：在需要大量计算的地方进行慎重的降维。压缩信息以聚合。1*1卷积不仅用来降维，还用来修正线性特性。

如何发现最优结构呢？ 较低的层次对应着图像的某个区域，使用1×1的卷积核仍然对应这个区域，使用3×3的卷积核，可以得到更大的区域对应。因而设计如图(a)。

为了降维，使用1×1的核进行降维，设计如图(b)。降维能够起效主要得益于embedding技术的发展，即使较低的维度仍然可以包含很多信息。

在Filter concatenation层将1×1/3×3/5×5的卷积结果连接起来。如此设计的好处在于防止了层数增多带来的计算资源的爆炸性需求。从而使网络的宽度和深度均可扩大。使用了Inception层的结构可以有2-3×的加速。

GoogLeNet

#3*3 reduce代表3*3卷积前1*1滤波器的个数。所有的reduction/projection层都利用了修正线性激活。网络包含22层带参数层和5层不含参数的pooling层。总共有约100层。分类前的pooling是基于[12]，只是我们利用了不同的线性层。有利于精细的调节网络，但不期望它有多出色。从全连接层move到下采样会将Top1准确率提高0.6%，但是dropout仍然需要。GoogLeNet通过减少1*1的卷积核数量来降维。对于参数计算不是很清楚，（7x7+1）x64=3200？为什么是2700？哪位网友知道，留个言，非常感谢。

在浅层网络来说，相对中间的网络产生的特征非常有辨识力。在这些层中增加一些额外的分类器，能个增加BP的梯度信号和提供额外的正则化。这些分类器将小德卷积网络放在4a和4b的输出上。在训练过程中，损失会根据权重叠加，而在测试时丢弃。

Inception结构

目前最直接提升DNN效果的方法是increasing their size，这里的size包括depth和width两方面。在有足够的labeled training data 时这种方法是最简单以及稳妥的方法来获得一个高质量的模型。但是往往实际中大的网络会有更多的参数，当training data数量很少时，很容易出现overfitting，并且大的网络需要的计算资源也是更多。这是需要将fully connected改变成sparsely connected：

 

 

1x1大小卷积最主要的作用是dimension reduction，否则会限制网络的大小，1x1卷积核的应用允许从depth和width上都增大网络，而不会带来大量计算的负担。

在Inception中1x1考虑到local region，3x3和5x5则考虑到spatially spread out clusters。所以在lower的层中主要是local信息，所以1x1的output number要多一些，但在higher的层中往往捕捉的是features of higher abstraction，所以在higher layer中3x3和5x5的比例应该增大。

但在这种naïve Inception中有一个跟严重的问题是：经过结构以后的卷积output number增加太多，这样就导致只经过几个stage就会出现computation blow up问题。因为pooling只能改变mapping的大小，而不改变output num，所以当使用naïve Inception时需要concatenate三个卷积的输出以及pooling的输出，所以当上一层的channel较大时，输出的output number会更大。并且5x5的卷积即使在output number适中时，当channel极大时，计算量也是巨大的。

上述问题引出了带有dimension reduction的Inception结构：这种方法源于即使一个低维度的embedding也能包含一个相对大的image patch的很多信息。但embedding压缩过于稠密，但需要这种结构的稀疏性，所以在耗费计算量的3x3和5x5卷积之前使用1x1 reduction减少卷积输入的channel。在使用reduction后同时使用ReLU一方面降维减少输入channel数量，另一方面增强非线性。

 

上述的结构主要有两个优点：一是可以再每个stage增加units的数量，仅为即使output number多了，在下一个stage时也会通过dimension reduction去减少channel数，所以不会出现计算爆炸的情况。二是这种结构满足了在不同的scale下处理视觉信号然后聚集在一起输入到下一个阶段以至于可以继续从多scales下提取特征。

GoogLeNet（22层）

 

所有的卷积包括Inception都使用ReLU，训练图像大小为224x224，RGB三通道，减均值。“#3x3 reduce”和“#5x5 reduce”表示1x1 reduction layer的数量。“pool proj”表示max-pooling后1x1 projection layer的数量。在网络中，并没有完全使用Inception，一开始的三层使用的是原始的卷积，这样是出于技术的原因（memory efficiency during training），但不是必须。

网络中的最后使用的是average pooling，而不是全连接，结果发现可以提高0.6%，但使用dropout是必要的，使用linear线性层是为了方便fine-tuning模型。

另外，发现在网络中间层产生的特征很有判别性，所以在中间层添加辅助分类器（auxiliary classifiers）希望在较浅的层中获得具有判别性的分类器，为反传过程增强梯度并且增强正则化。在训练过程中这些损失都会加权计入总损失（0.3），详细的结构见论文。

Training Methodology

训练采用随机梯度下降，冲量momentum：0.9，固定学习率8 epochs减小4%。训练策略一直在变化，参考文章Some improvements on deep convolutional neural network based image classification。

在测试中使用提升准确率的技巧

1. 集成方法：训练了7个相同结构的GoogLeNet模型，初始化方法，学习率调整策略相同，图像采用（patch）以及随机输入的顺序不相同。
2. aggressive cropping方法：ILSVRC中使用的很多图是矩形，非正方形。将图像resize成4种scales，使得最短的边分别为256，288，320和352，然后从左、中、右分别截取方形square图像（如果是肖像图像，则分为上、中、下），然后对于每个square图像从4个角及中心截取224x224 square images，并把原square图像resize成224x224，在对上面5种做镜像变换。所以这样一幅图像可以得到4x3x6x2=144个crops。参考：Imagenet classification with deep convolutional neural networks
3. multiple crops的softmax概率取平均效果最好。

Training Methodology

利用"Large scale distributed deep networks"提供的分布式机器学习系统和数据平行。用数个高端GPU，一周达到收敛。利用"On the importance of initialization and momentum in deep learning"异步随机梯度下降，0.9动量，学习率每八个周期下降4%。最后用"Acceleration of stochastic approximation by averaging"来创建最后用来测试的模型。

采样变化很大。"Some improvements on deep convolutional neural network based imageclassification"的光度扭曲有助于对付过拟合。还进行了随机插入。

ILSVRC 2014 Classification Challenge Setup and Results

①训练了7个网络，只是采样方法和随机输入图像不同，取综合值。

②将图像的短边缩放成4中：256,288,320,352。取图像的上中下块。每块取四个角、中间的224*224和将其缩放到224*224以及它们的镜像。结果是4*3*6*2=144，即每个图像采样144块输入图。但可能实际生产中不能应用。

③maxpooling和在分类器平均，最后的结果都不如简单的平均好。

ILSVRC 2014 Detection Challenge Setup and Results

方法与R-CNN很像，但增加了Inception模块。结合了用multi-box 的方法和Selective Search来提高定位框的召回率。这让从Selective Search得到的结果减半。再加上200个的方法，总共占60%，可以将覆盖率从92%提高到93%。上述方法可以将准确率相对单一模型提高1%。在分类区域的时候利用6个卷积网络科将准确率从40%提高到43.9%。

最后GoogLeNet最好，比去年大了接近一倍。GoogLeNet在单模型的情况下，只比最好的低0.3%，但那个用了3个模型，而GoogLeNet在多模型的情况下结果好得多。

Experiments Setup and Results

• Trained 7 versions of same GoogLeNet model, performed ensembel prediction with them. These models are trained with the same initialization, but differ in sampling methodologies and the random order in which they see input images.
• Testing: resize the image to 4 scales where the shorter dim is 256,288,320,352. Take the left, right, center square of these resized images, then take the 4 corners and the center 224×224 crop and the square resize 224×224, and their mirror version. Namely, 4×3×6×2=144 crops per image.
• Softmax probabilities are averaged over multiple crops and over all individual classifiers to obtain the final prediction. Simple averaged is the best.结果如下：

图 4 performance of the competition

图 5 performance of fusions of Models

caffe的实现和原来论文的模型是有不同的：

不是用重新点亮数据增加训练;
不是用尺度或纵横比数据增加训练;
使用“xavier”初始化权重，而不是“gaussian”;
quick_solver.prototxt使用不同于原始solver.prototxt的学习速率衰减策略，允许更快的训练（60个纪元和250个纪元）;
捆绑模型是使用quick_solver.prototxt的迭代2,400,000个快照（60个纪元）

但是准确度还是达到了顶1精度68.7％（31.3％误差）和前5精度88.9％（11.1％误差）

我们来分析一下这个模型的层次关系：

原始数据，输入为224 * 224 * 3

第一层卷积层conv1，pad是3,64个特征，7 * 7步长为2，输出特征为112 * 112 * 64，然后进行relu，经过pool1（红色的最大池）进行pooling 3 * 3的核，步长为2，[（112 - 3 + 1）/ 2] +1 = 56特征为56 * 56 * 64，然后进行norm 

第二层卷积层conv2，pad是1,3 * 3,192个特征，输出为56 * 56 * 192，然后进行relu，进行norm，经过pool2进行pooling，3 * 3的核，步长为2输出为28 * 28 * 192然后进行split分成四个支线

 

1. 设置pool2 / 3x3_s2  
2. I0319 23：50：37.405478 5765 net.cpp：103]顶部形状：10 192 28 28（1505280）  
3. I0319 23：50：37.405484 5765 net.cpp：113]数据需要内存：174612480  
4. I0319 23：50：37.405495 5765 net.cpp：67]创建图层pool2 / 3x3_s2_pool2 / 3x3_s2_0_split  
5. I0319 23：50：37.405503 5765 net.cpp：394] pool2 / 3x3_s2_pool2 / 3x3_s2_0_split  < - pool2 / 3x3_s2  
6. I0319 23：50：37.405515 5765 net.cpp：356] pool2 / 3x3_s2_pool2 / 3x3_s2_0_split - > pool2 / 3x3_s2_pool2 / 3x3_s2_0_split_0  
7. I0319 23：50：37.405531 5765 net.cpp：356] pool2 / 3x3_s2_pool2 / 3x3_s2_0_split - > pool2 / 3x3_s2_pool2 / 3x3_s2_0_split_1  
8. I0319 23：50：37.405545 5765 net.cpp：356] pool2 / 3x3_s2_pool2 / 3x3_s2_0_split - > pool2 / 3x3_s2_pool2 / 3x3_s2_0_split_2  
9. 池03/23×20  
10. I0319 23：50：37.405567 5765 net.cpp：96]设置pool2 / 3x3_s2_pool2 / 3x3_s2_0_split  
11. I0319 23：50：37.405577 5765 net.cpp：103]顶部形状：10 192 28 28（1505280）  
12. I0319 23：50：37.405582 5765 net.cpp：103]顶部形状：10 192 28 28（1505280）  
13. I0319 23：50：37.405587 5765 net.cpp：103]顶部形状：10 192 28 28（1505280）  
14. I0319 23：50：37.405592 5765 net.cpp：103]顶部形状：10 192 28 28（1505280）  
15. I0319 23：50：37.405597 5765 net.cpp：113]数据所需的内存：198696960  
16. I0319 23：50：37.405611 5765 net.cpp：67]创建层初始_3a / 1x1 ^ M  

第三层开始时候模块，这个的思想受到使用不同尺度的Gabor过滤器来处理多尺度问题，inception module采用不同尺度的卷积核来处理问题.3a包含四个支线：

 

1：64个1 * 1的卷积核（之后进行RULE计算）变成28 * 28 * 64

2：96个1 * 1的卷积核作为3 * 3卷积核之前的减少，变成28 * 28 * 96，进行relu计算后，再进行128个3 * 3的卷积， 28 * 28 * 128

3:16个1 * 1的卷积核作为5 * 5卷积核之前的减少，变成28 * 28 * 16，进行relu计算后，再进行32个5 * 5的卷积，变成28 * 28 * 32

4：池层，3 * 3的核，垫为1，输出还是28 * 28 * 192，然后进行32个1 * 1的卷积，变成28 * 28 * 32。

将四个结果进行连接，输出为28 * 28 * 256

 

 

 

 

然后将3a的结果又分成四条支线，开始建立3b的开始模块

3b 

 

1：128个1 * 1的卷积核（之后进行RULE计算）变成28 * 28 * 128

2：128个1 * 1的卷积核作为3 * 3卷积核之前的减少，变成28 * 28 * 128，再进行192个3 * 3的卷积，垫为1，28 * 28 * 192 ，进行relu计算

3:32个1 * 1的卷积核作为5 * 5卷积核之前的减少，变成28 * 28 * 32，进行relu计算后，再进行96个5 * 5的卷积，变成28 * 28 * 96

4：池层，3 * 3的核，垫为1，输出还是28 * 28 * 256，然后进行64个1 * 1的卷积，变成28 * 28 * 64。

 

将四个结果进行连接，输出为28 * 28 * 480

同理依次推算，数据变化如下表：

 

一部分输出结果如下：

I0319 22：27：51.257917 5080 net.cpp：208]这个网络产生输出故障

 

1. I0319 22：27：51.258116 5080 net.cpp：467]收集学习率和体重衰减。  
2. I0319 22：27：51.258162 5080 net.cpp：219]网络初始化完成。  
3. I0319 22：27：51.258167 5080 net.cpp：220]数据所需的内存：545512320  
4. I0319 22：27：51.345417 5080 net.cpp：702]忽略源层数据  
5. I0319 22：27：51.345443 5080 net.cpp：702]忽略源层label_data_1_split  
6. I0319 22：27：51.345448 5080 net.cpp：705]复制源层conv1 / 7x7_s2  
7. I0319 22：27：51.345542 5080 net.cpp：705]复制源层conv1 / relu_7x7  
8. I0319 22：27：51.345548 5080 net.cpp：705]复制源层pool1 / 3x3_s2  
9. I0319 22：27：51.345553 5080 net.cpp：705]复制源层pool1 / norm1  
10. I0319 22：27：51.345558 5080 net.cpp：705]复制源层conv2 / 3x3_reduce  
11. I0319 22：27：51.345600 5080 net.cpp：705]复制源层conv2 / relu_3x3_reduce  
12. I0319 22：27：51.345607 5080 net.cpp：705]复制源层conv2 / 3x3  
13. I0319 22：27：51.346571 5080 net.cpp：705]复制源层conv2 / relu_3x3  
14. I0319 22：27：51.346580 5080 net.cpp：705]复制源层conv2 / norm2  
15. I0319 22：27：51.346585 5080 net.cpp：705]复制源层pool2 / 3x3_s2  
16. I0319 22：27：51.346590 5080 net.cpp：705]复制源层pool2 / 3x3_s2_pool2 / 3x3_s2_0_split  
17. I0319 22：27：51.346595 5080 net.cpp：705]复制源层inception_3a / 1x1  
18. I0319 22：27：51.346706 5080 net.cpp：705]复制源层inception_3a / relu_1x1  
19. I0319 22：27：51.346712 5080 net.cpp：705]复制源层inception_3a / 3x3_reduce  
20. I0319 22：27：51.346879 5080 net.cpp：705]复制源层inception_3a / relu_3x3_reduce  
21. I0319 22：27：51.346885 5080 net.cpp：705]复制源层inception_3a / 3x3  
22. I0319 22：27：51.347844 5080 net.cpp：705]复制源层inception_3a / relu_3x3  
23. I0319 22：27：51.347851 5080 net.cpp：705]复制源层inception_3a / 5x5_reduce  
24. I0319 22：27：51.347885 5080 net.cpp：705]复制源层inception_3a / relu_5x5_reduce  
25. I0319 22：27：51.347892 5080 net.cpp：705]复制源层inception_3a / 5x5  
26. I0319 22：27：51.348008 5080 net.cpp：705]复制源层inception_3a / relu_5x5  
27. I0319 22：27：51.348014 5080 net.cpp：705]复制源层inception_3a / pool  
28. I0319 22：27：51.348019 5080 net.cpp：705]复制源层inception_3a / pool_proj  
29. I0319 22：27：51.348080 5080 net.cpp：705]复制源层inception_3a / relu_pool_proj  
30. I0319 22：27：51.348085 5080 net.cpp：705]复制源层inception_3a / output  
31. I0319 22：27：51.348091 5080 net.cpp：705]复制源层inception_3a / output_inception_3a / output_0_split  
32. I0319 22：27：51.348096 5080 net.cpp：705]复制源层inception_3b / 1x1  
33. I0319 22：27：51.348398 5080 net.cpp：705]复制源层inception_3b / relu_1x1  
34. I0319 22：27：51.348405 5080 net.cpp：705]复制源层inception_3b / 3x3_reduce  
35. I0319 22：27：51.348700 5080 net.cpp：705]复制源层inception_3b / relu_3x3_reduce  
36. I0319 22：27：51.348707 5080 net.cpp：705]复制源层inception_3b / 3x3  
37. I0319 22：27：51.350611 5080 net.cpp：705]复制源层inception_3b / relu_3x3  
38. I0319 22：27：51.350620 5080 net.cpp：705]复制源层inception_3b / 5x5_reduce  
39. I0319 22：27：51.350699 5080 net.cpp：705]复制源层inception_3b / relu_5x5_reduce  
40. I0319 22：27：51.350705 5080 net.cpp：705]复制源层inception_3b / 5x5  
41. I0319 22：27：51.351372 5080 net.cpp：705]复制源层inception_3b / relu_5x5  
42. I0319 22：27：51.351378 5080 net.cpp：705]复制源层inception_3b / pool  
43. I0319 22：27：51.351384 5080 net.cpp：705]复制源层inception_3b / pool_proj  
44. I0319 22：27：51.351546 5080 net.cpp：705]复制源层inception_3b / relu_pool_proj  
45. I0319 22：27：51.351552 5080 net.cpp：705]复制源层inception_3b / output  
46. I0319 22：27：51.351558 5080 net.cpp：705]复制源层pool3 / 3x3_s2  
47. I0319 22：27：51.351563 5080 net.cpp：705]复制源层pool3 / 3x3_s2_pool3 / 3x3_s2_0_split  
48. I0319 22：27：51.351569 5080 net.cpp：705]复制源层inception_4a / 1x1  
49. I0319 22：27：51.352367 5080 net.cpp：705]复制源层inception_4a / relu_1x1  
50. I0319 22：27：51.352375 5080 net.cpp：705]复制源层inception_4a / 3x3_reduce  
51. I0319 22：27：51.352782 5080 net.cpp：705]复制源层inception_4a / relu_3x3_reduce  
52. I0319 22：27：51.352789 5080 net.cpp：705]复制源层inception_4a / 3x3  
53. I0319 22：27：51.354333 5080 net.cpp：705]复制源层inception_4a / relu_3x3  
54. I0319 22：27：51.354341 5080 net.cpp：705]复制源层inception_4a / 5x5_reduce  
55. I0319 22：27：51.354420 5080 net.cpp：705]复制源层inception_4a / relu_5x5_reduce  
56. I0319 22：27：51.354429 5080 net.cpp：705]复制源层inception_4a / 5x5  
57. I0319 22：27：51.354601 5080 net.cpp：705]复制源层inception_4a / relu_5x5  
58. I0319 22：27：51.354609 5080 net.cpp：705]复制源层inception_4a / pool  
59. I0319 22：27：51.354614 5080 net.cpp：705]复制源层inception_4a / pool_proj  
60. I0319 22：27：51.354887 5080 net.cpp：705]复制源图层inception_4a / relu_pool_proj  
61. I0319 22：27：51.354894 5080 net.cpp：705]复制源层inception_4a / output  
62. I0319 22：27：51.354900 5080 net.cpp：705]复制源层inception_4a / output_inception_4a / output_0_split  
63. I0319 22：27：51.354910 5080 net.cpp：702]忽略源层loss1 / ave_pool  
64. I0319 22：27：51.354918 5080 net.cpp：702]忽略源层丢失1 / conv  
65. I0319 22：27：51.354923 5080 net.cpp：702]忽略源层loss1 / relu_conv  
66. I0319 22：27：51.354930 5080 net.cpp：702]忽略源层loss1 / fc  
67. I0319 22：27：51.354936 5080 net.cpp：702]忽略源层loss1 / relu_fc  
68. I0319 22：27：51.354943 5080 net.cpp：702]忽略源层loss1 / drop_fc  
69. I0319 22：27：51.354950 5080 net.cpp：702]忽略源层损失1 /分类器  
70. I0319 22：27：51.354956 5080 net.cpp：702]忽略源层损失1 /损失  
71. I0319 22：27：51.354962 5080 net.cpp：705]复制源层inception_4b / 1x1  
72. I0319 22：27：51.355681 5080 net.cpp：705]复制源层inception_4b / relu_1x1  
73. I0319 22：27：51.355690 5080 net.cpp：705]复制源层inception_4b / 3x3_reduce  
74. I0319 22：27：51.356190 5080 net.cpp：705]复制源层inception_4b / relu_3x3_reduce  
75. I0319 22：27：51.356199 5080 net.cpp：705]复制源层inception_4b / 3x3  
76. I0319 22：27：51.358134 5080 net.cpp：705]复制源层inception_4b / relu_3x3  
77. I0319 22：27：51.358144 5080 net.cpp：705]复制源层inception_4b / 5x5_reduce  
78. I0319 22：27：51.358256 5080 net.cpp：705]复制源层inception_4b / relu_5x5_reduce  
79. I0319 22：27：51.358263 5080 net.cpp：705]复制源层inception_4b / 5x5  
80. I0319 22：27：51.358608 5080 net.cpp：705]复制源层inception_4b / relu_5x5  
81. I0319 22：27：51.358616 5080 net.cpp：705]复制源层inception_4b / pool  
82. I0319 22：27：51.358623 5080 net.cpp：705]复制源层inception_4b / pool_proj  
83. I0319 22：27：51.358917 5080 net.cpp：705]复制源层inception_4b / relu_pool_proj  
84. I0319 22：27：51.358925 5080 net.cpp：705]复制源层inception_4b / output  
85. I0319 22：27：51.358932 5080 net.cpp：705]复制源层inception_4b / output_inception_4b / output_0_split  
86. I0319 22：27：51.358937 5080 net.cpp：705]复制源层inception_4c / 1x1  
87. I0319 22：27：51.359519 5080 net.cpp：705]复制源层inception_4c / relu_1x1  
88. I0319 22：27：51.359526 5080 net.cpp：705]复制源层inception_4c / 3x3_reduce  
89. I0319 22：27：51.360097 5080 net.cpp：705]复制源层inception_4c / relu_3x3_reduce  
90. I0319 22：27：51.360105 5080 net.cpp：705]复制源层inception_4c / 3x3  
91. I0319 22：27：51.362634 5080 net.cpp：705]复制源层inception_4c / relu_3x3  
92. I0319 22：27：51.362643 5080 net.cpp：705]复制源层inception_4c / 5x5_reduce  
93. I0319 22：27：51.362757 5080 net.cpp：705]复制源层inception_4c / relu_5x5_reduce  
94. I0319 22：27：51.362764 5080 net.cpp：705]复制源层inception_4c / 5x5  
95. I0319 22：27：51.363106 5080 net.cpp：705]复制源层inception_4c / relu_5x5  
96. I0319 22：27：51.363114 5080 net.cpp：705]复制源层inception_4c / pool  
97. I0319 22：27：51.363121 5080 net.cpp：705]复制源层inception_4c / pool_proj  
98. I0319 22：27：51.363415 5080 net.cpp：705]复制源层inception_4c / relu_pool_proj  
99. I0319 22：27：51.363423 5080 net.cpp：705]复制源层inception_4c / output  
100. I0319 22：27：51.363430 5080 net.cpp：705]复制源层inception_4c / output_inception_4c / output_0_split  
101. I0319 22：27：51.363436 5080 net.cpp：705]复制源层inception_4d / 1x1  
102. I0319 22：27：51.363937 5080 net.cpp：705]复制源层inception_4d / relu_1x1  
103. I0319 22：27：51.363945 5080 net.cpp：705]复制源层inception_4d / 3x3_reduce  
104. I0319 22：27：51.364591 5080 net.cpp：705]复制源层inception_4d / relu_3x3_reduce  
105. I0319 22：27：51.364600 5080 net.cpp：705]复制源层inception_4d / 3x3  
106. I0319 22：27：51.367797 5080 net.cpp：705]复制源层inception_4d / relu_3x3  
107. I0319 22：27：51.367806 5080 net.cpp：705]复制源层inception_4d / 5x5_reduce  
108. I0319 22：27：51.367959 5080 net.cpp：705]复制源层inception_4d / relu_5x5_reduce  
109. I0319 22：27：51.367966 5080 net.cpp：705]复制源层inception_4d / 5x5  
110. I0319 22：27：51.368420 5080 net.cpp：705]复制源层inception_4d / relu_5x5  
111. I0319 22：27：51.368428 5080 net.cpp：705]复制源层inception_4d / pool  
112. I0319 22：27：51.368435 5080 net.cpp：705]复制源层inception_4d / pool_proj  
113. I0319 22：27：51.368726 5080 net.cpp：705]复制源层inception_4d / relu_pool_proj  
114. I0319 22：27：51.368733 5080 net.cpp：705]复制源层inception_4d / output  
115. I0319 22：27：51.368739 5080 net.cpp：705]复制源层inception_4d / output_inception_4d / output_0_split  
116. I0319 22：27：51.368748 5080 net.cpp：702]忽略源层loss2 / ave_pool  
117. I0319 22：27：51.368755 5080 net.cpp：702]忽略源层丢失2 / conv  
118. I0319 22：27：51.368762 5080 net.cpp：702]忽略源层loss2 / relu_conv  
119. I0319 22：27：51.368768 5080 net.cpp：702]忽略源层损耗2 / fc  
120. I0319 22：27：51.368774 5080 net.cpp：702]忽略源层loss2 / relu_fc  
121. I0319 22：27：51.368780 5080 net.cpp：702]忽略源层loss2 / drop_fc  
122. I0319 22：27：51.368788 5080 net.cpp：702]忽略源层丢失2 /分类器  
123. I0319 22：27：51.368794 5080 net.cpp：702]忽略源层损失2 /损失  
124. I0319 22：27：51.368800 5080 net.cpp：705]复制源层inception_4e / 1x1  
125. I0319 22：27：51.369971 5080 net.cpp：705]复制源层inception_4e / relu_1x1  
126. I0319 22：27：51.369981 5080 net.cpp：705]复制源层inception_4e / 3x3_reduce  
127. I0319 22：27：51.370717 5080 net.cpp：705]复制源层inception_4e / relu_3x3_reduce  
128. I0319 22：27：51.370725 5080 net.cpp：705]复制源层inception_4e / 3x3  
129. I0319 22：27：51.374668 5080 net.cpp：705]复制源层inception_4e / relu_3x3  
130. I0319 22：27：51.374678 5080 net.cpp：705]复制源层inception_4e / 5x5_reduce  
131. I0319 22：27：51.374831 5080 net.cpp：705]复制源层inception_4e / relu_5x5_reduce  
132. I0319 22：27：51.374840 5080 net.cpp：705]复制源层inception_4e / 5x5  
133. I0319 22：27：51.375728 5080 net.cpp：705]复制源层inception_4e / relu_5x5  
134. I0319 22：27：51.375737 5080 net.cpp：705]复制源层inception_4e / pool  
135. I0319 22：27：51.375744 5080 net.cpp：705]复制源层inception_4e / pool_proj  
136. I0319 22：27：51.376332 5080 net.cpp：705]复制源层inception_4e / relu_pool_proj  
137. I0319 22：27：51.376340 5080 net.cpp：705]复制源层inception_4e / output  
138. I0319 22：27：51.376346 5080 net.cpp：705]复制源层pool4 / 3x3_s2  
139. I0319 22：27：51.376353 5080 net.cpp：705]复制源层pool4 / 3x3_s2_pool4 / 3x3_s2_0_split  
140. I0319 22：27：51.376359 5080 net.cpp：705]复制源层inception_5a / 1x1  
141. I0319 22：27：51.378186 5080 net.cpp：705]复制源层inception_5a / relu_1x1  
142. I0319 22：27：51.378196 5080 net.cpp：705]复制源层inception_5a / 3x3_reduce  
143. I0319 22：27：51.379343 5080 net.cpp：705]复制源层inception_5a / relu_3x3_reduce  
144. I0319 22：27：51.379353 5080 net.cpp：705]复制源层inception_5a / 3x3  
145. I0319 22：27：51.383293 5080 net.cpp：705]复制源层inception_5a / relu_3x3  
146. I0319 22：27：51.383303 5080 net.cpp：705]复制源层inception_5a / 5x5_reduce  
147. I0319 22：27：51.383548 5080 net.cpp：705]复制源层inception_5a / relu_5x5_reduce  
148. I0319 22：27：51.383558 5080 net.cpp：705]复制源层inception_5a / 5x5  
149. I0319 22：27：51.384449 5080 net.cpp：705]复制源层inception_5a / relu_5x5  
150. I0319 22：27：51.384459 5080 net.cpp：705]复制源层inception_5a / pool  
151. I0319 22：27：51.384465 5080 net.cpp：705]复制源层inception_5a / pool_proj  
152. I0319 22：27：51.385397 5080 net.cpp：705]复制源层inception_5a / relu_pool_proj  
153. I0319 22：27：51.385406 5080 net.cpp：705]复制源层inception_5a / output  
154. I0319 22：27：51.385414 5080 net.cpp：705]复制源层inception_5a / output_inception_5a / output_0_split  
155. I0319 22：27：51.385421 5080 net.cpp：705]复制源层inception_5b / 1x1  
156. I0319 22：27：51.388157 5080 net.cpp：705]复制源层inception_5b / relu_1x1  
157. I0319 22：27：51.388166 5080 net.cpp：705]复制源层inception_5b / 3x3_reduce  
158. I0319 22：27：51.389539 5080 net.cpp：705]复制源层inception_5b / relu_3x3_reduce  
159. I0319 22：27：51.389549 5080 net.cpp：705]复制源层inception_5b / 3x3  
160. I0319 22：27：51.395212 5080 net.cpp：705]复制源层inception_5b / relu_3x3  
161. I0319 22：27：51.395225 5080 net.cpp：705]复制源层inception_5b / 5x5_reduce  
162. I0319 22：27：51.395584 5080 net.cpp：705]复制源层inception_5b / relu_5x5_reduce  
163. I0319 22：27：51.395594 5080 net.cpp：705]复制源层inception_5b / 5x5  
164. I0319 22：27：51.396921 5080 net.cpp：705]复制源层inception_5b / relu_5x5  
165. I0319 22：27：51.396931 5080 net.cpp：705]复制源层inception_5b / pool  
166. I0319 22：27：51.396939 5080 net.cpp：705]复制源层inception_5b / pool_proj  
167. I0319 22：27：51.397862 5080 net.cpp：705]复制源层inception_5b / relu_pool_proj  
168. I0319 22：27：51.397871 5080 net.cpp：705]复制源层inception_5b / output  
169. I0319 22：27：51.397879 5080 net.cpp：705]复制源层pool5 / 7x7_s1  
170. I0319 22：27：51.397886 5080 net.cpp：705]复制源层pool5 / drop_7x7_s1  
171. I0319 22：27：51.397893 5080 net.cpp：705]复制源层loss3 /分类器  
172. I0319 22：27：51.406652 5080 net.cpp：702]忽略源层loss3 / loss3  

 

材料集合：

http://deeplearning.net/2014/09/19/googles-entry-to-imagenet-2014-challenge/

 

[1] Imagenet 2014 LSVRC结果， http : //karpathy.github.io/2014/09/02/what-i-learned-from-competing-against-a-convnet-on-imagenet/，最后检索：19 -09-2014。

[2] Christian Szegedy，Wei Liu，Yangqing Jia，Pierre Sermanet，Scott Reed，Dragomir Anguelov，Dumitru Erhan，Vincent Vanhoucke，Andrew Rabinovich，Going Deeper with Convolutions，Arxiv链接：http :  //arxiv.org/abs/1409.4842。

[3] GoogLeNet演示， http ://image-net.org/challenges/LSVRC/2014/slides/GoogLeNet.pptx，最后检索的：19-09.2014。

[4]我从竞争对手的网络上学到的东西， http://karpathy.github.io/2014/09/02/what-i-learned-from-competing-against-a-convnet-on-imagenet /最后检索日期：19-09-2014。

[5] Girshick，Ross，et al。“丰富的特征层次结构，用于精确的对象检测和语义分割。” arXiv preprint arXiv：1311.2524  （2013）。

8. Reference

[1]. Szegedy C, Liu W, Jia Y, et al. Going deeper with convolutions[J]. arXiv preprint arXiv:1409.4842, 2014.