基于 NumPy 从零实现 Tiny-AlexNet 在 MNIST 数据集上的验证

Intro

2012 年，AlexNet 团队训练了一个大型深层卷积神经网络，用于将 ImageNet LSVRC-2010 数据集中的 120 万张高分辨率图像分类为 1,000 个类别。在测试集上，AlexNet 取得了 37.5% 的 Top-1 错误率和 17.0% 的 Top-5 错误率，显著刷新了当时的最佳成绩。

AlexNet 包含约 6,000 万个参数和 65 万个神经元，由五个卷积层和三个全连接层组成，部分卷积层后接最大池化层，最终通过 Softmax 层输出 1,000 个类别的预测结果。为提高训练效率，AlexNet 使用了非饱和激活函数 ReLU，并通过 GPU 高效实现卷积运算。为缓解全连接层的过拟合问题，模型还采用了当时新近提出的正则化方法 Dropout。

在随后举行的 ILSVRC-2012 竞赛中，AlexNet 的一个变体取得了 15.3% 的 Top-5 测试错误率，而排名第二的参赛作品为 26.2%。这一成果推动了深度卷积神经网络在图像识别领域的广泛应用。

作为神经网络初学者，我计划以学习和理解为主要目的，使用 NumPy 从零设计和实现一个参考 AlexNet 架构的卷积神经网络，并在 MNIST（Modified National Institute of Standards and Technology）数据集上进行验证。

考虑到学习效果、经济成本和训练时间，我将保留 AlexNet 的核心架构思想与网络拓扑，同时根据 MNIST 的数据规模和图像尺寸进行适配，设计一个轻量化的 Tiny-AlexNet。此外，对于已有成熟实践的实现细节，将酌情采用现代常用方案，如在仿射层、卷积层中使用 He 初始化。

开发与训练环境如下：

学习目标： 熟悉 AlexNet 的网络结构与前向传播、反向传播机制，学习 CNN 的核心原理，加深对卷积神经网络的理解。通过设计、验证、训练、评估，了解神经网络开发的基本流程。

训练成本预估： 原版 AlexNet 在 ILSVRC 数据集上训练时，每轮涉及大量浮点运算。2012 年，使用两块 GTX 580 GPU 训练 90 轮耗时近 6 天。若使用纯 Python/NumPy 在 CPU 上实现并训练原版模型，计算成本将显著增加。
相比之下，针对 MNIST 适配的 Tiny-AlexNet 大幅降低了计算量。

通过这种方式，可以在较低的计算与时间成本下，实践卷积网络的实现、反向传播与参数优化，并观察模型的训练过程和收敛表现。

Dataset

ILSVRC-2010 是 AlexNet 论文中主要使用的数据集版本之一。由于该版本提供了带标签的测试数据，研究人员可以直接评估模型的分类性能。

因为是以学习和复现为目的，因此选择小得多的 MNIST 数据集进行实验。MNIST 仅包含 28 × 28 的灰度图像，数据规模也远小于 ImageNet，直接照搬 AlexNet 的网络结构会导致模型容量与数据规模不匹配。

MNIST 数据集可从 Kaggle 下载。

MNIST 数据集包含以下文件：

MNIST 使用 IDX 二进制格式存储数据：

• ubyte：无符号单字节整数，即 uint8，取值范围为 0～255。
• idx1：存储一维数组，例如标签数据，形状为 (N,)。
• idx3：存储三维数组，例如图像集合，形状为 (N, H, W)。

原始数据只有训练集和测试集。为了便于调参，避免使用测试集参与模型选择，需要从训练集中划分出验证集。

我计划从原始训练集中抽取 10,000 张图像作为验证集，剩余 50,000 张作为训练集。考虑到 MNIST 数据规模较小，数据预处理阶段将直接把数据全部读入内存。

idx1

idx1 是 IDX 格式中用于存储一维数组的二进制格式，采用大端序。文件由两部分组成：8 字节的元数据头部（Header）和紧随其后的数据载荷（Payload）。

Header

1
2
3
4
5
6
7
8
9
10
11
12
13

魔数 Magic Number：0x00000801 = 2049

Byte 0: 0x00
Byte 1: 0x00
Byte 2: 0x08  # 数据类型：unsigned byte
Byte 3: 0x01  # 维度：1

元素总数 N：32 位无符号大端整数

Byte 4: 0x00
Byte 5: 0x00
Byte 6: 0xEA
Byte 7: 0x60  # N = 60,000

Payload

从偏移 0x08（第 8 字节）开始，依次存储 N 个标签，每个标签占 1 字节。

1
2
3
4
5

Byte 8  : 第 0 个样本的标签（如 0x05，代表数字 5）
Byte 9  : 第 1 个样本的标签（如 0x00，代表数字 0）
Byte 10 : 第 2 个样本的标签（如 0x04，代表数字 4）
...
Byte (7 + N) : 第 N-1 个样本的标签

因此，idx1 文件的总大小为：

idx3

idx3 是 IDX 格式中用于存储三维数组的二进制格式，同样采用大端序。文件由两部分组成：16 字节的元数据头部和紧随其后的数据载荷。

Header

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

魔数 Magic Number：0x00000803 = 2051

Byte 0: 0x00
Byte 1: 0x00
Byte 2: 0x08  # 数据类型：unsigned byte
Byte 3: 0x03  # 维度：3

样本总数 N：32 位无符号大端整数

Byte 4: 0x00
Byte 5: 0x00
Byte 6: 0xEA
Byte 7: 0x60  # N = 60,000（训练集）

图像高度 H：32 位无符号大端整数

Byte 8:  0x00
Byte 9:  0x00
Byte 10: 0x00
Byte 11: 0x1C  # H = 28

图像宽度 W：32 位无符号大端整数

Byte 12: 0x00
Byte 13: 0x00
Byte 14: 0x00
Byte 15: 0x1C  # W = 28

其中，测试集的样本数为 10,000，即 N = 0x00002710。

Payload

从偏移 0x10（第 16 字节）开始，连续存储所有图像的像素值。每个像素占 1 字节，类型为 uint8，取值范围为 0～255。像素按行优先排列。

1
2
3
4
5
6
7
8

Byte 16                  : 第 0 张图像，第 0 行第 0 列像素
Byte 17                  : 第 0 张图像，第 0 行第 1 列像素
...
Byte (16 + 28*28 - 1)    : 第 0 张图像，第 27 行第 27 列像素

Byte (16 + 28*28)        : 第 1 张图像，第 0 行第 0 列像素
...
Byte (15 + N*H*W)        : 第 N-1 张图像的最后一个像素

因此，idx3 文件的总大小为：

数据预处理

读取原始图像后，需要将数据转换为适合后续卷积神经网络计算的形式。不同数据集的图像尺寸、通道数和像素值范围可能不同，因此预处理方式也需要根据数据特点选择。

AlexNet 论文使用的 ImageNet 图像尺寸各不相同。作者首先将图像的短边缩放至像素，再从中心裁剪出 () 的区域，并减去训练集的平均像素值。

训练时，AlexNet 还使用了数据增强：从 () 的图像中随机裁剪 () 的区域，并进行随机水平翻转和 RGB PCA 颜色扰动。通过为同一张图像生成不同的训练样本，这些方法有助于减少过拟合。

补充：RGB PCA 颜色扰动

PCA，即主成分分析，是一种分析数据变化方向的方法。它通常先对数据进行中心化，再计算协方差矩阵，求出其特征向量和特征值。特征向量给出一组相互正交的方向，特征值表示数据在对应方向上的方差大小。

PCA 常用于降维，即选择方差较大的几个方向，将原始数据投影到这些方向张成的低维空间中（这样原数据的差别在新的投影空间中被放大）。AlexNet 则用 PCA 来生成颜色扰动，并没有降维。

具体来说，作者将 ImageNet 训练集中每个像素的 RGB 值视为一个三维向量，计算这些向量的 () 协方差矩阵，得到三个主成分方向及其对应的特征值。然后，沿三个方向分别生成随机扰动并相加，得到一个 RGB 偏移量：

其中，() 是第 () 个主成分方向，() 是对应的特征值，() 是随机采样的系数。同一张训练图像的所有像素加上相同的 RGB 偏移量；当这张图像再次用于训练时，重新采样扰动。

这种方法利用了训练集中 RGB 通道的变化关系，产生类似光照强度和颜色变化的效果。它基于「适度改变光照通常不会改变图像中物体的类别。通过在训练中引入这些变化，模型有机会学到对光照变化更稳健的特征。」

很厉害的技巧！

考虑到 MNIST 的数据特点，本例不采用上述缩放、裁剪、均值中心化和 RGB 颜色扰动，而是保留 MNIST 原始的 28 × 28 图像尺寸，并将像素值归一化到 [0.0, 1.0]。

• 调整张量形状：将原始图像数组从扩展为。对于 MNIST，输入通道数为 1，因此最终形状为。
• 归一化：将像素值从 uint8 转换为 float32，并除以 255，使其映射到区间。

数据集划分

总之，我们完成数据读取与预处理后，将原始训练集划分为训练集和验证集，并保留原始测试集用于最终评估。

Architecture

原版 AlexNet 的架构图如下。由于 2012 年使用的 NVIDIA GTX 580 单卡显存仅有 3 GB，无法轻松容纳整个模型及训练过程中产生的中间数据，因此论文中采用了双 GPU 并行的设计。

论文中的架构图存在排版截断，我重新绘制了一份结构图：

双 GPU 与单流架构

原版 AlexNet 的双 GPU 设计主要出于当时的硬件限制。

• 显存需求：模型包含约 6,000 万个参数，训练时还需要保存前向传播产生的中间激活值及反向传播所需的数据，显存占用较高。
• 分治策略：将部分网络计算分配到两张 GPU 上，每张 GPU 负责部分卷积核和特征图计算，并在指定层进行跨 GPU 通信。

这体现了根据各层的特性，合理拆分任务并行计算突破硬件资源限制的思路。

对于我们的 Tiny-AlexNet，模型规模较小，没有必要实现双 GPU 并行。因此，为降低实现复杂度，我们会将网络合并为单一计算流。

未来面对更大规模的模型时，可进一步学习数据并行、模型并行等分布式训练方法。

激活函数

Alex 团队通过实验确认，使用 ReLU 的网络训练错误率下降得更快。最终，AlexNet 选择 ReLU 作为激活函数。

ReLU 定义为：

其导数为：

相较于 Sigmoid、Tanh 等饱和激活函数，ReLU 在正半轴上的导数恒为 1，有助于缓解梯度消失问题。

我们同样会采用 ReLU。

局部响应归一化（LRN）

AlexNet 使用了局部响应归一化（Local Response Normalization，LRN），其设计灵感来源于生物学中的侧抑制机制。

对于输入特征图上位置的第个通道，LRN 的计算形式为：

其中：

• 、：输入与输出特征图的数值。
• ：特征图的总通道数。
• ：参与归一化的邻近通道范围。
• ：控制归一化行为的超参数。

LRN 在局部通道范围内，根据相邻通道的响应强度调整当前通道的输出。较大的邻近响应会增大归一化分母，从而抑制当前响应。

不过，LRN 并不是现代 CNN 的必需组件。后续网络研究表明，在很多架构中，移除 LRN 并不会降低模型性能。

考虑到 LRN 不是很常用，并且会显著增加前向和反向传播的代码实现、计算复杂度，因此 Tiny-AlexNet 不使用 LRN。

补充：AlexNet 论文中的 LRN 在通道边界处直接截断邻域，没有像循环数组那样首尾回绕。（论文中给出的 LRN 计算公式的分母的求和上下界中的和将索引限制在到之间）

池化层

AlexNet 采用了重叠最大池化（Overlapping Max Pooling）。

传统的最大池化通常使用步幅，相邻窗口互不重叠。

AlexNet 则在相关池化层中使用：

窗口大小为，每次移动 2 个像素，因此相邻窗口在空间上重叠 1 个像素。

举个例子：

1
2

窗口 1：[x0, x1, x2]
窗口 2：        [x2, x3, x4]

此时同时属于两个池化窗口。

AlexNet 论文指出，重叠池化相较于非重叠池化略微降低了分类错误率，并且在实验中表现出一定的抗过拟合优势。

We generally observe during training that models with overlapping pooling find it slightly more difficult to overfit.

重叠池化的反向传播

最大池化的反向传播会将梯度传递给前向传播时选中的最大值位置。

假设同时是两个池化窗口的最大值，分别对应输出和。

根据链式法则：

由于两个窗口都依赖于，其梯度贡献必须累加。

因此，在实现 MaxPool 的反向传播时，需要使用 dx[idx] += dout，累加来自多个窗口的梯度。

Dropout

Dropout 是 AlexNet 用于缓解全连接层过拟合的重要技术。

Without dropout, our network exhibits substantial overfitting.

其原理是在训练阶段，以一定概率随机将部分神经元的输出置零，使网络不能过度依赖特定神经元，从而学习更具鲁棒性的特征。

AlexNet 在前两个全连接隐藏层中使用了 Dropout，丢弃概率为。

Dropout 的计算

假设下一层神经元的输入为：

其中是上一层的激活值。

在 AlexNet Dropout 方案中，训练阶段为每个神经元独立采样一个二值掩码：

当时：

因此，训练阶段的输出为：

如果推理阶段关闭 Dropout，直接使用全部神经元，则：

如何处理训练与推理阶段的差异？

在 AlexNet Dropout 方案中，推理阶段将相关激活值乘以保留概率，以匹配训练阶段的期望。

当时：

一个简单的理解是：训练时候随机丢掉了一半的能量，推理的时候全部的神经元都要激活，所以能量会是训练阶段的两倍，所以推理的时候相关激活值乘以 0.5 以降低到相同能量大小。

实际上这样是不严谨的，。当偏置时，不能简单地认为二者始终恰好相差两倍

现代实现中更常见的是 Inverted Dropout：训练阶段对保留的激活值除以保留概率，推理阶段则不需要额外缩放。

其训练阶段的输出为：

因为考虑到要验证 AlexNet Dropout 是否能显著降低过拟合，所以 Tiny-AlexNet 将同样在 FC6 和 FC7 后使用 AlexNet Dropout，丢弃概率均为。后续会通过对比有无 Dropout 的实验，观察其对训练误差、验证误差和过拟合的影响。

最优化方法

AlexNet 使用带动量的随机梯度下降法（SGDM），并结合权重衰减。

论文采用的主要参数为：

• Batch Size：128
• Momentum：0.9
• Weight Decay：0.0005
• 初始学习率：0.01

其更新形式可以写为：

其中：

：参数更新的迭代索引。
：动量变量。
：当前参数。
：学习率。
：当前 Mini-batch 上的平均梯度。

权重衰减项用于限制权重的增长，动量项则利用历史更新方向改善优化过程。

AlexNet 还采用了人工调整学习率的策略：当验证错误率在当前学习率下不再改善时，将学习率缩小为原来的十分之一。

我们将尝试对比以下三种经典的优化器：

• SGD：随机梯度下降。
• SGDM：带动量的随机梯度下降。
• Adam：结合一阶、二阶梯度矩估计的自适应优化方法。

初始化参数

AlexNet 论文采用均值为 0、标准差为 0.01 的高斯分布初始化权重，并根据网络层的位置设置不同的偏置。

We initialized the weights in each layer from a zero-mean Gaussian distribution with standard deviation 0.01. We initialized the neuron biases in the second, fourth, and fifth convolutional layers, as well as in the fully-connected hidden layers, with the constant 1.

当时，He 初始化尚未提出。现代 CNN 则常采用 He 初始化，以便更好地适配 ReLU 激活函数。

对于 ReLU 网络，He 初始化的典型形式为：

其中（扇入） 表示每个输出单元对应的输入连接数。

对于卷积层：

对于仿射层：

我们将采用 He 初始化，并将偏置初始化为 0。

学习率

AlexNet 使用统一的初始学习率，并根据验证集错误率的变化手动调整。

当验证错误率停止改善时，将学习率缩小为原来的十分之一。AlexNet 论文中初始的学习率为 0.01，训练结束前共缩小了三次。

Tiny-AlexNet 架构

Tiny-AlexNet 保留原版 AlexNet 的 8 层骨架，即 5 个卷积层和 3 个全连接层，同时根据 MNIST 的输入尺寸、类别数量和计算资源缩减网络规模。

整体结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Input
  ↓
Conv1 → ReLU → MaxPool1
  ↓
Conv2 → ReLU → MaxPool2
  ↓
Conv3 → ReLU
  ↓
Conv4 → ReLU
  ↓
Conv5 → ReLU → MaxPool3
  ↓
Flatten
  ↓
FC6 → ReLU → Dropout
  ↓
FC7 → ReLU → Dropout
  ↓
FC8
  ↓
SoftmaxWithLoss

其中，FC8 输出 10 个类别的 Logits，随后由 SoftmaxWithLoss 计算分类损失。

输入尺寸与 Conv1

MNIST 的原始输入形状为：

其中：

• ：Batch Size。
• ：灰度图像只有一个通道。
• ：图像的高和宽。

二维卷积的输出尺寸为：

为了保留浅层特征的空间分辨率，Conv1 采用卷积核、步幅和填充。

卷积核尺寸必须为奇数，因为卷积是要在中心点输出一个高精度的加权特征响应，必须有中心像素。

因此：

同理，。

如果只看卷积输出，形状将变为：

接下来应该考虑 MaxPool1，若在池化层降采样为原来的一半，那么可取，要重叠池化那么只能比大，比如。但是代入发现不是整数（即无法顺利池化）。

重新考虑 Conv1，令、按照惯例取，尝试代入公式反推、。即，由只能取、，发现、无解。

考虑非对称 Padding，给 MNIST 边缘填充一圈零，即输入，若 Conv1 不变，将输出，在 MaxPool1(,,) 输出，尺寸确实对接成功了，但是同样的情景又出现了：Conv1 处理的输入也是偶数尺寸，输出会是偶数尺寸。后续还有卷积池化层，同样的情况只会导致我们又遇到相同的问题，所以不考虑这种方式。

考虑裁剪 MNIST 边缘，Conv1(,,) 输出， MaxPool1(,,) 输出是奇数了，问题不会再出现了。

即我们选择在进入网络时裁剪图像的最末一行和最末一列：

因此，实际输入为：

那么重新推导 Conv1：

Conv1 使用 16 个卷积核：

经过 Conv1 后：

输出形状为：

MaxPool1

AlexNet 使用重叠池化，典型配置为窗口、步幅 2。

对于当前的特征图：

因此：

Conv2 与 MaxPool2

Conv2 使用 64 个卷积核：

采用卷积核、步幅 1、填充 1，保持空间尺寸不变：

接着进行、步幅 2 的最大池化：

因此：

Conv3 与 Conv4

Conv3 将通道数增加到 128：

采用、步幅 1、填充 1，输出形状为：

Conv4 保持 128 个通道：

同样采用、步幅 1、填充 1，因此：

Conv5 与 MaxPool3

Conv5 将通道数从 128 降至 64：

经过卷积和 ReLU 后，输出为：

最后使用、步幅 2 的最大池化：

因此：

注：为适配较小特征图，MaxPool3 使用非重叠池化

Flatten 与全连接层

经过最后一个池化层后，特征图形状为：

Flatten 将每个样本的通道与空间维度展平：

因此：

接着依次通过三个全连接层。

FC6：

经过 ReLU 和 Dropout 后，形状保持不变。

FC7：

同样经过 ReLU 和 Dropout。

FC8：

最终输出：

即每个样本对应 10 个 Logits 得分。

SoftmaxWithLoss 根据 Logits 和真实标签计算交叉熵损失。若采用 Batch 平均损失，最终输出标量 Loss。

完整架构

参数量

最后，对 Tiny-AlexNet 所有可学习参数进行核算：

Tiny-AlexNet 共包含约 52.1 万个可学习参数，约为原版 AlexNet 6,000 万个参数的。

模型参数规模显著缩小，更适合在 NumPy 和 CPU 环境下进行实现。

Operators

Flatten

Flatten 的意义是什么？

将四维张量拍扁成二维矩阵，便于输入到 Affine。

前向传播

将输入张量的后三个维度合并为一个维度，保留批量维度。

同时，记录输入张量的原始形状，以便反向传播时恢复：

反向传播

由于 Flatten 只改变张量的形状，不会改变每个元素对应的梯度数值。

因此，反向传播时，只需要将恢复为输入张量的原始形状：

其中

实现

1
2
3
4
5
6
7
8
9
10
11
12

class Flatten:
    def __init__(self):
        self.orig_shape = None

    def forward(self, x):
        self.orig_shape = x.shape
        out = x.reshape(x.shape[0], -1)
        return out

    def backward(self, dout):
        dx = dout.reshape(*self.orig_shape)
        return dx

Affine

Affine 的意义是什么？

通过可学习的权重矩阵和偏置，对输入特征进行仿射变换，生成新的特征表示。

类比 Logistic 回归，Affine 可以构建超平面，作为线性分类的决策边界。

前向传播

反向传播

其中：

又，，

其中：

又，，

其中：

又，，
由于在前向传播中偏置广播到了每一个样本上，根据反向传播规则，对的梯度需要将批量维度（）上的梯度进行累加求和：

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b
        self.x = None
        self.dW = None
        self.db = None

    def forward(self, x):
        self.x = x
        out = x @ self.W + self.b
        return out

    def backward(self, dout):
        dx = dout @ self.W.T
        self.dW = self.x.T @ dout
        self.db = np.sum(dout, axis=0)
        return dx