【动手学深度学习_李沐】笔记：(六）现代卷积神经⽹络

【六、现代卷积神经⽹络】

1. 深度卷积神经⽹络（AlexNet）

• 在 2012 年以前，神经⽹络往往被其他机器学习⽅法超越，如支持向量机（support vector machines）。而 AlexNet 在 2012 年 ImageNet 挑战赛中取得了轰动⼀时的成绩，在⽹络的最底层，模型学习到了⼀些类似于传统滤波器的特征抽取器。论文：[Krizhevsky et al., 2012] Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). Imagenet classification with deep convolutional neural networks. Advances in neural information processing systems (pp. 1097‒1105)
• AlexNet：8 层卷积神经⽹络，包括五个卷积层、两个全连接隐藏层和⼀个全连接输出层。ReLU 激活函数，计算更简单，不需要如 sigmoid 激活函数复杂的求幂运算，当使⽤不同的参数初始化⽅法时，训练模型更容易。当 sigmoid 激活函数的输出接近 0 或 1 时，梯度⼏乎为 0，反向传播⽆法继续更新⼀些模型参数。而 ReLU 激活函数在正区间的梯度总是 1。由于全连接层的输出数量是 LeNet 中的好⼏倍，因此使⽤ dropout 层来减轻过度拟合
• 输入1×1×224×224图像
  → 96×11×11 Conv，pad=0，s=4，n=(224-11+0)/4+1=54，96×54×54图像
  → 3×3 maxPool，stride=2，n=(54-3)/2+1=26，96×26×26图像
  → 256×5×5 Conv，pad=2，s=1，n=(26-5+2×2)/1+1=26，256×26×26图像
  → 3×3 maxPool，stride=2，n=(26-3)/2+1=12，256×12×12图像
  → 384×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，384×12×12图像
  → 384×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，384×12×12图像
  → 256×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，256×12×12图像
  → 3×3 maxPool，stride=2，n=(12-3)/2+1=5，256×5×5图像
  → 4096×1 Dense，权重4096×(256×5×5)，偏置4096×1
  → 4096×1 Dense，权重4096×4096，偏置4096×1
  → 1000×1 Dense，权重1000×4096，偏置1000×1，输出1000个类别
• 使⽤更小的学习率是因为⽹络更深更⼴、图像分辨率更高，训练卷积神经⽹络就更昂贵
  

2. 使用重复块的⽹络（VGG）

• 视觉⼏何组（visualgeometry Group，VGG）：不同的 VGG 模型可通过每个块中卷积层数量和输出通道数量的差异来定义，块的使⽤使⽹络定义简洁，使⽤块可有效设计复杂的⽹络。论⽂：[Simonyan & Zisserman, 2014] Simonyan, K., & Zisserman, A. (2014). Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556
• VGG：原始有 5 个卷积块，其中前两个块各有⼀个卷积层，后三个块各包含两个卷积层。第⼀个模块有 64 个输出通道，每个后续模块将输出通道数量翻倍，直到该数字达到 512。由于该⽹络使⽤ 8 个卷积层和 3 个全连接层，因此通常被称为** VGG-11**
• 输入1×1×224×224图像
  → 64×3×3 Conv，pad=1，s=1，n=(224-3+2×1)/1+1=224，64×224×224图像
  → 2×2 maxPool，stride=2，n=224/2=112，64×112×112图像
  → 128×3×3 Conv，pad=1，s=1，n=(112-3+2×1)/1+1=112，128×112×112图像
  → 2×2 maxPool，stride=2，n=112/2=56，128×56×56图像
  → 256×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，256×56×56图像
  → 256×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，256×56×56图像
  → 2×2 maxPool，stride=2，n=56/2=28，256×28×28图像
  → 512×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，512×28×28图像
  → 512×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，512×28×28图像
  → 2×2 maxPool，stride=2，n=28/2=14，512×14×14图像
  → 512×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，512×14×14图像
  → 512×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，512×14×14图像
  → 2×2 maxPool，stride=2，n=14/2=7，512×7×7图像
  → 4096×1 Dense，权重4096×(512×7×7)，偏置4096×1
  → 4096×1 Dense，权重4096×4096，偏置4096×1
  → 1000×1 Dense，权重1000×4096，偏置1000×1，输出1000个类别
  
  

3. 网络中的网络（NiN）

• 网络中的网络 (NiN)：在每个像素的通道上分别使⽤多层感知机，可视为 1×1 卷积层，或在每个像素位置上独⽴作⽤的全连接层。即将空间维度中的每个像素视为单个样本，将通道维度视为不同特征。论文：[Lin et al., 2013] Lin, M., Chen, Q., & Yan, S. (2013). Network in network. arXiv preprint arXiv:1312.4400
• NiN：分块以⼀个普通卷积层开始，后⾯是两个 1×1 卷积层，充当带有 ReLU激活函数的逐像素全连接层，允许更多的每像素⾮线性。NiN 和 AlexNet 的显著区别是取消了全连接层，使⽤⼀个 NiN块，输出通道数等于标签类别的数量，最后放⼀个全局平均池化层（global average pooling layer），⽣成⼀个多元逻辑向量。移除全连接层可减少过拟合，显著减少模型所需参数的数量，但增加了训练时间
• 输入1×1×224×224图像
  → 96×11×11 Conv，pad=0，s=4，n=(224-11+2×0)/4+1=54，96×54×54图像
  → 96×1×1 Conv，pad=0，s=1，n=(54-1+2×0)/1+1=54，96×54×54图像
  → 96×1×1 Conv，pad=0，s=1，n=(54-1+2×0)/1+1=54，96×54×54图像
  → 3×3 maxPool，stride=2，n=(54-3)/2+1=26，96×26×26图像
  → 256×5×5 Conv，pad=2，s=1，n=(26-5+2×2)/1+1=26，256×26×26图像
  → 256×1×1 Conv，pad=0，s=1，n=(26-1+2×0)/1+1=26，256×26×26图像
  → 256×1×1 Conv，pad=0，s=1，n=(26-1+2×0)/1+1=26，256×26×26图像
  → 3×3 maxPool，stride=2，n=(26-3)/2+1=12，256×12×12图像
  → 384×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，384×12×12图像
  → 384×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，384×12×12图像
  → 384×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，384×12×12图像
  → 3×3 maxPool，stride=2，n=(12-3)/2+1=5，384×5×5图像
  → 10×3×3 Conv，pad=1，s=1，n=(5-3+2×1)/1+1=5，10×5×5图像
  → 10×1×1 Conv，pad=0，s=1，n=(5-1+2×0)/1+1=5，10×5×5图像
  → 10×1×1 Conv，pad=0，s=1，n=(5-1+2×0)/1+1=5，10×5×5图像
  → GlobalAvePool，Flatten，10×1×1图像，输出10个类别
  
  

4. 含并行连结的⽹络（GoogLeNet）

• GoogLeNet 及其系列是 ImageNet 最有效的模型之⼀，以较低的计算复杂度提供类似的测试精度。论文中解决了什么样⼤小的卷积核最合适的问题，有时使⽤不同⼤小的卷积核组合是有利的。论文：[Szegedy et al., 2015] Szegedy, C., Liu, W., Jia, Y., Sermanet, P., Reed, S., Anguelov, D., …Rabinovich, A. (2015). Going deeper with convolutions. Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 1‒9)
• GoogLeNet：基本卷积块称为 Inception 块（Inception block），由四条并行路径组成，通过不同窗口形状的卷积层和最⼤池化层（降低维度）并⾏抽取信息，使⽤** 1×1 卷积层减少每像素级别上的通道维数从而降低模型复杂度。这四条路径使⽤合适的填充使输⼊与输出的⾼和宽⼀致，最后将每条线路的输出在通道维度上连结，构成 Inception 块的输出。在 Inception 块中，通常调整的超参数是每层输出通道的数量，将 Inception 块与其他层串联，Inception 块的通道数分配之⽐通过⼤量实验得来。使⽤ 9 个Inception 块和全局平均池化层**，全局平均池化层避免最后使⽤全连接层
• 输入1×1×96×96图像
  → 64×7×7 Conv，pad=3，s=2，n=(96-7+2×3)/2+1=48，64×48×48图像
  → 3×3 maxPool，pad=1，stride=2，n=(48-3+2×1)/2+1=24，64×24×24图像
  → 64×1×1 Conv，pad=0，s=1，n=(24-1+2×0)/1+1=24，64×24×24图像
  → 192×3×3 Conv，pad=1，s=1，n=(24-3+2×1)/1+1=24，192×24×24图像
  → 3×3 maxPool，pad=1，stride=2，n=(24-3+2×1)/2+1=12，192×12×12图像
  → 64×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，64×12×12图像
  → 96×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，96×12×12图像
  → 128×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，128×12×12图像
  → 16×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，16×12×12图像
  → 32×5×5 Conv，pad=2，s=1，n=(12-5+2×2)/1+1=12，32×12×12图像
  → 3×3 maxPool，pad=1，stride=1，n=(12-3+2×1)/1+1=12，32×12×12图像
  → 32×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，32×12×12图像
  → 128×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，128×12×12图像
  → 128×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，128×12×12图像
  → 192×3×3 Conv，pad=1，s=1，n=(12-3+2×1)/1+1=12，192×12×12图像
  → 32×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，32×12×12图像
  → 96×5×5 Conv，pad=2，s=1，n=(12-5+2×2)/1+1=12，96×12×12图像
  → 3×3 maxPool，pad=1，stride=1，n=(12-3+2×1)/1+1=12，96×12×12图像
  → 64×1×1 Conv，pad=0，s=1，n=(12-1+2×0)/1+1=12，64×12×12图像
  → 3×3 maxPool，pad=1，stride=2，n=(12-3+2×1)/2+1=6，480×6×6（128 + 192 + 96 + 64）
  → 192×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，192×6×6图像
  → 96×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，96×6×6图像
  → 208×3×3 Conv，pad=1，s=1，n=(6-3+2×1)/1+1=6，208×6×6图像
  → 16×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，16×6×6图像
  → 48×5×5 Conv，pad=2，s=1，n=(6-5+2×2)/1+1=6，48×6×6图像
  → 3×3 maxPool，pad=1，stride=1，n=(6-3+2×1)/1+1=6，48×6×6图像
  → 64×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，64×6×6图像
  → 160×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，160×6×6图像
  → 112×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，112×6×6图像
  → 224×3×3 Conv，pad=1，s=1，n=(6-3+2×1)/1+1=6，224×6×6图像
  → 24×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，24×6×6图像
  → 64×5×5 Conv，pad=2，s=1，n=(6-5+2×2)/1+1=6，64×6×6图像
  → 3×3 maxPool，pad=1，stride=1，n=(6-3+2×1)/1+1=6，64×6×6图像
  → 64×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，64×6×6图像
  → 128×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，128×6×6图像
  → 128×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，128×6×6图像
  → 256×3×3 Conv，pad=1，s=1，n=(6-3+2×1)/1+1=6，256×6×6图像
  → 24×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，24×6×6图像
  → 64×5×5 Conv，pad=2，s=1，n=(6-5+2×2)/1+1=6，64×6×6图像
  → 3×3 maxPool，pad=1，stride=1，n=(6-3+2×1)/1+1=6，64×6×6图像
  → 64×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，64×6×6图像
  → 112×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，112×6×6图像
  → 144×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，144×6×6图像
  → 288×3×3 Conv，pad=1，s=1，n=(6-3+2×1)/1+1=6，288×6×6图像
  → 32×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，32×6×6图像
  → 64×5×5 Conv，pad=2，s=1，n=(6-5+2×2)/1+1=6，64×6×6图像
  → 3×3 maxPool，pad=1，stride=1，n=(6-3+2×1)/1+1=6，64×6×6图像
  → 64×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，64×6×6图像
  → 256×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，256×6×6图像
  → 160×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，160×6×6图像
  → 320×3×3 Conv，pad=1，s=1，n=(6-3+2×1)/1+1=6，320×6×6图像
  → 32×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，32×6×6图像
  → 128×5×5 Conv，pad=2，s=1，n=(6-5+2×2)/1+1=6，128×6×6图像
  → 3×3 maxPool，pad=1，stride=1，n=(6-3+2×1)/1+1=6，128×6×6图像
  → 128×1×1 Conv，pad=0，s=1，n=(6-1+2×0)/1+1=6，128×6×6图像
  → 3×3 maxPool，pad=1，stride=2，n=(6-3+2×1)/2+1=6，832×3×3（256 + 320 + 128 + 128）
  → 256×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，256×3×3图像
  → 160×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，160×3×3图像
  → 320×3×3 Conv，pad=1，s=1，n=(3-3+2×1)/1+1=3，320×3×3图像
  → 32×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，32×3×3图像
  → 128×5×5 Conv，pad=2，s=1，n=(3-5+2×2)/1+1=3，128×3×3图像
  → 3×3 maxPool，pad=1，stride=1，n=(3-3+2×1)/1+1=3，128×3×3图像
  → 128×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，128×3×3图像
  → 384×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，384×3×3图像
  → 192×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，192×3×3图像
  → 384×3×3 Conv，pad=1，s=1，n=(3-3+2×1)/1+1=3，384×3×3图像
  → 48×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，48×3×3图像
  → 128×5×5 Conv，pad=2，s=1，n=(3-5+2×2)/1+1=3，128×3×3图像
  → 3×3 maxPool，pad=1，stride=1，n=(3-3+2×1)/1+1=3，128×3×3图像
  → 128×1×1 Conv，pad=0，s=1，n=(3-1+2×0)/1+1=3，128×3×3图像
  → GlobalAvePool，Dense，10×1×1图像，输出10个类别
  
  

5. 批量归⼀化

• 批量归⼀化（batch normalization）能够训练 100 层以上的⽹络，每次迭代中⾸先归⼀化输⼊，通过减去基于小批量处理的均值并除以标准差，再应⽤⽐例系数和⽐例偏移。批量归⼀化将每⼀层主动居中，并重新调整为给定的平均值和⼤小，减小变化幅度。批量归⼀化利⽤小批量的均值和标准差，不断调整神经⽹络的中间输出，使整个神经⽹络各层的中间输出值更加稳定。论文：[Ioffe & Szegedy, 2015] Ioffe, S., & Szegedy, C. (2015). Batch normalization: accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167.
• ⽤ x∈B 表⽰来⾃小批量 B 的输⼊，批量归⼀化 BN 根据以下表达式转换x：
  

µB 是样本均值，σB 是样本标准差，标准化后⽣成小批量均值为 0、⽅差为 1。拉伸参数（scale）γ和偏移参数（shift）β 的维度与x相同。⽅差中添加小常量 ϵ > 0，确保分母不为零

• 全连接层：将批量归⼀化层置于全连接层的仿射变换和激活函数之间。设全连接层输⼊ u、权重参数 W、偏置参数 b、激活函数 ϕ ，批量归⼀化运算符 BN，输出计算如下：
  

• 卷积层：在卷积层后和⾮线性激活函数前应⽤批量归⼀化。对通道的每个输出执⾏批量归⼀化，每个通道都有⾃⼰的拉伸和偏移参数。收集所有空间位置的值，在给定通道内应⽤相同的均值和⽅差，以便在每个空间位置对值进⾏归⼀化

• 批量归⼀化在全连接层和卷积层的使⽤略有不同，在训练模式和预测模式下计算不同

6. 残差⽹络（ResNet）

• ResNet 的基础结构是残差块（residual block），输⼊通过跨层数据线路更快向前传播。残差块（residual blocks）赢得 2015 年 ImageNet ⼤规模视觉识别挑战赛，将加权运算（如仿射）的权重和偏置参数设成 0，f(x) 即为恒等映射。实际中，当理想映射 f(x) 接近恒等映射时，残差映射易于捕捉恒等映射的细微波动，更容易学习同⼀函数
  
  

• 残差块：有** 2 个相同输出通道数的 3×3 卷积层**，每个卷积层后接⼀个批量归⼀化层和 ReLU 激活函数，通过跨层数据通路将输⼊直接加在 ReLU 激活函数前，但要求 2 个卷积层的输出与输⼊形状⼀样才可以相加。如果改变通道数，需引⼊ 1×1 卷积层

• ResNet：使⽤** 4 个残差块模块，每个模块使⽤若⼲个同样输出通道数的残差块，第⼀个模块的通道数同输⼊通道数⼀致。每个模块有 4 个卷积层**（不包括恒等映射的 1×1 卷积层），加上第⼀个 7×7 卷积层和最后⼀个全连接层，共有 18 层，也称为 ResNet-18。更深如含 152 层的 ResNet-152。相比 GoogLeNet，ResNet 结构更简单

• 输入1×1×224×224图像
  → 64×7×7 Conv，pad=3，s=2，n=(224-7+2×3)/2+1=112，64×112×112图像
  → BatchNorm、Relu，64×112×112图像
  → 3×3 maxPool，pad=1，s=2，n=(112-3+2×1)/2+1=56，64×56×56图像
  → 64×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，64×56×56图像
  → 64×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，64×56×56图像
  → 64×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，64×56×56图像
  → 64×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，64×56×56图像
  → 128×3×3 Conv，pad=1，s=2，n=(56-3+2×1)/2+1=28，128×28×28图像
  → 128×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，128×28×28图像
  → 128×1×1 Conv，pad=0，s=2，n=(56-1+2×0)/2+1=28，128×28×28图像
  → 128×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，128×28×28图像
  → 128×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，128×28×28图像
  → 256×3×3 Conv，pad=1，s=2，n=(28-3+2×1)/2+1=14，256×14×14图像
  → 256×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，256×14×14图像
  → 256×1×1 Conv，pad=0，s=2，n=(28-1+2×0)/2+1=14，256×14×14图像
  → 256×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，256×14×14图像
  → 256×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，256×14×14图像
  → 512×3×3 Conv，pad=1，s=2，n=(14-3+2×1)/2+1=7，512×7×7图像
  → 512×3×3 Conv，pad=1，s=1，n=(7-3+2×1)/1+1=7，512×7×7图像
  → 512×1×1 Conv，pad=0，s=2，n=(14-1+2×0)/2+1=7，512×7×7图像
  → 512×3×3 Conv，pad=1，s=1，n=(7-3+2×1)/1+1=7，512×7×7图像
  → 512×3×3 Conv，pad=1，s=1，n=(7-3+2×1)/1+1=7，512×7×7图像
  → GlobalAvePool，512×1×1图像，Dense，输出10个类别
  

7. 稠密连接⽹络（DenseNet）

• DenseNet是 ResNet 的逻辑扩展，DenseNet 输出是连接而不是如 ResNet 的简单相加。计算成本高，但效果更好。论文：[Huang et al., 2017] Huang, G., Liu, Z., Van Der Maaten, L., & Weinberger, K. Q. (2017). Densely connected convolutional networks. Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 4700‒4708)
  
  

• 应⽤复杂的函数序列后，执⾏ x 到展开式的映射，结合到多层感知机中减少特征数量：
  

• DenseNet：由稠密块（dense block）和过渡层（transition layer）构成。前者定义如何连接输⼊和输出，后者控制通道数量不会太复杂。使⽤ 4 个稠密块，⼀个稠密块由多个卷积块组成，每个卷积块使⽤相同数量的输出通道。前向传播将每个卷积块的输⼊和输出在通道维上连结，卷积块的通道数控制了输出通道数相对于输⼊通道数的增⻓，也称为增⻓率（growth rate）。由于每个稠密块都会带来通道数的增加，使⽤过多则会过于复杂化模型，过渡层通过 1×1 卷积层减小通道数，并使⽤步幅为 2 的平均池化层减半⾼和宽，从而降低模型复杂度。输出通道数=输入通道数+增长率*稠密块数

• 输入1×1×224×224图像
  → 64×7×7 Conv，pad=3，s=2，n=(224-7+2×3)/2+1=112，64×112×112图像
  → BatchNorm、Relu，64×112×112图像
  → 3×3 maxPool，pad=1，s=2，n=(112-3+2×1)/2+1=56，64×56×56图像
  → BatchNorm、Relu，64×56×56图像
  → 32×3×3 Conv，pad=1，s=1，n=(56-3+2×1)/1+1=56，192×56×56图像（64+32×4）
  → BatchNorm、Relu，192×56×56图像
  → 96×1×1 Conv，pad=0，s=1，n=(56-1+2×0)/1+1=56，96×56×56图像
  → 2×2 maxPool，pad=0，s=2，n=(56-2+2×0)/2+1=28，96×28×28图像
  → BatchNorm、Relu，96×28×28图像
  → 56×3×3 Conv，pad=1，s=1，n=(28-3+2×1)/1+1=28，224×28×28图像（96+32×4）
  → BatchNorm、Relu，224×28×28图像
  → 112×1×1 Conv，pad=0，s=1，n=(28-1+2×0)/1+1=28，112×28×28图像
  → 2×2 maxPool，pad=0，s=2，n=(28-2+2×0)/2+1=14，112×14×14图像
  → BatchNorm、Relu，112×14×14图像
  → 240×3×3 Conv，pad=1，s=1，n=(14-3+2×1)/1+1=14，240×14×14图像（112+32×4）
  → BatchNorm、Relu，240×14×14图像
  → 120×1×1 Conv，pad=0，s=1，n=(14-1+2×0)/1+1=14，120×14×14图像
  → 2×2 maxPool，pad=0，s=2，n=(14-2+2×0)/2+1=7，120×7×7图像
  → BatchNorm、Relu，120×7×7图像
  → 248×3×3 Conv，pad=1，s=1，n=(7-3+2×1)/1+1=7，248×7×7图像 （120+32×4）
  → BatchNorm、Relu，248×7×7图像
  → GlobalAvePool，248×1×1图像，Dense，输出10个类别