TensorFlow实现LeNet训练MNIST：卷积神经网络入门实战全流程

1. 项目概述

如果要选一个模型作为深度学习入门的第一课，我大概率会选LeNet。这个1998年提出的经典卷积神经网络，在今天看来结构简单得有点“朴素”，但它恰好是把卷积、池化、全连接这些核心概念串起来的最小完整闭环。用TensorFlow把它实现一遍，不仅能把卷积神经网络的原理彻底吃透，还能顺带把TensorFlow的建模流程、训练套路、调试方法全部过一遍。这篇文章就把我从零搭建LeNet并训练MNIST手写数字识别的完整过程拆开讲清楚，包括每一步的参数是怎么算出来的、踩过的坑、以及实测下来的一些心得，希望能给正在入门深度学习的你一个可以直接抄作业的参考。

我默认读者已经有Python基础，装好了TensorFlow环境，但不要求你有任何深度学习理论背景。整个项目只需要一个CPU就能跑完，代码量不大，训练时间也不长，非常适合作为第一个完整的深度学习实战项目。你会在动手的过程中建立起对神经网络训练全流程的直觉：数据预处理为什么要这么做、卷积层到底在干什么、学习率为什么不能随便设、loss降不下去的时候该往哪个方向查。这些东西光看书是学不会的，必须亲手跑一遍才有体感。

2. 整体设计与思路拆解

2.1 为什么选LeNet作为入门项目

LeNet-5是深度学习史上第一个真正意义上的卷积神经网络，由深度学习领域的先驱杨立昆在1998年提出，最初是为了解决手写支票数字识别的问题。它奠定了现代卷积神经网络的基本范式：卷积层提取特征、池化层降维、全连接层做分类。今天那些动辄上百层的ResNet、EfficientNet，本质上都是在LeNet这个骨架上不断做扩展和优化。

对于初学者来说，LeNet有两个不可替代的优势。第一是结构足够小，整个网络只有几万个参数，在现代硬件上训练一个MNIST数据集只需要几分钟，迭代试错的成本极低。不像现在的大模型，训一次要几小时甚至几天，调参的反馈周期太长，新手很难建立起“改了参数会发生什么”的直觉。第二是它包含了所有必须理解的核心概念，卷积的通道数变化、特征图的尺寸变化、全连接层的展平操作、softmax分类头的设计，每一个细节都能在这个小网络里找到具体的例子。

从工程角度看，MNIST数据集本身也非常友好。每张图片只有28x28像素，单通道灰度图，总共10个类别（数字0到9），训练集6万张、测试集1万张。这个规模和复杂度对应的是“说明白一个原理”的定位，而不是“证明一个模型多强大”的定位。换句话说，LeNet加上MNIST，是深度学习中“Hello World”级别的组合。

2.2 技术选型背后的考量

TensorFlow实现LeNet有好几条路线：可以用Keras的Sequential API一行一行堆模型，也可以用Functional API构建更灵活的模型结构，还可以用自定义训练循环。我这次选的是Sequential API加常规的model.fit()训练方式，原因很简单：对入门项目来说，这套组合最少代码、最不容易出错，而且可以把注意力完全集中在理解网络本身。

很多教程喜欢用低级API手写反向传播来教原理，但我觉得这个阶段的重点应该是建立对网络结构的基本认知。等用高级API跑通了整个流程之后，再去看底层的张量操作会清晰得多。当然，我也没有完全依赖Keras封装——有几处关键代码我会拆开写，比如损失函数的计算过程、评估指标的统计方式，这样你对每一步在做什么是有感知的，而不是一路调包到底。

此外，我会在训练前做数据标准化和One-Hot编码。这是两个很小的细节，却直接影响训练效果和结果读法。后面我会详细解释。

2.3 网络结构逐层拆解：每个参数都不是瞎填的

LeNet-5的原始结构是：卷积层1 -> 池化层1 -> 卷积层2 -> 池化层2 -> 展平 -> 全连接层1 -> 全连接层2 -> softmax输出。5层结构、约6万个参数，在今天看来就是一个“微型”网络。我下面把每一层的作用和参数设计的逻辑讲清楚，这是整个项目理解的关键部分。

第一个卷积层的设计是“6个卷积核，每个大小5x5，步长1，padding='valid'”。输入是28x28x1的灰度图像，经过这一层后输出尺寸变为24x24x6。那个“24”怎么来的？公式很简单：输出尺寸 = (输入尺寸 - 卷积核尺寸 + 2×padding) / 步长 + 1，代入就是(28-5)/1+1=24。这层的作用是提取图像的局部特征，比如边缘、拐角、明暗突变等底层视觉模式。为什么不直接用全连接层？因为一张28x28的图像展平后有784个像素，如果全连接的话参数数量会快速增长，而且会完全丢失像素之间的空间位置关系。卷积层用一个滑动窗口在图像上移动，每次只看一个局部区域，这样既大幅减少参数量，又天然保留了局部空间结构。

第一个池化层用的是“2x2最大池化，步长2”。它的作用非常直白：降采样，把特征图的尺寸从24x24缩小到12x12。为什么用最大池化而不是平均池化？经验上最大池化能保留更突出的特征响应，对边缘和纹理这类判别性信息都有比较好的保持效果。池化没有可学习参数，纯粹是做空间上的压缩，同时扩大后续层的感受野，让网络在更宏观的尺度上观察特征。

第二个卷积层把通道数从6增加到16，卷积核仍然是5x5。输入是12x12x6，经过这一层后输出尺寸是8x8x16。通道数增加的原因在于：第一层卷积提取的是底层的边缘和纹理，第二层需要在这些初级特征的基础上组合出更抽象的模式，比如数字的笔画结构、弧线片段等。特征层次越高，需要的通道数往往越多——这几乎是所有卷积神经网络设计的通用规律。

第二个池化层同样用2x2最大池化，把8x8特征图压缩到4x4。到这里，原始28x28的图像已经被浓缩成了16个4x4的特征图，一共16×4×4=256个数值。你可以把这一堆数值理解为“原始图像经过层层加工后提炼出的特征向量”。接下来要做的，是让全连接网络在这个高维特征表达上做分类决策。

展平操作就是把16张4x4的特征图拉直成256个连续的值，它没有任何计算逻辑，纯粹是维度变换。后面的第一个全连接层把256维映射到120维，第二个全连接层把120维映射到84维，最后一层是输出层：84维映射到10维。输出层的10个数分别对应数字0到9的预测得分，再做softmax转换成概率。为什么中间全连接层要选120和84这两个数？纯粹是设计者拍脑袋定的，没有理论依据。实践中你改成128和64效果也差不多，扩宽一点或者收窄一点并不会显著影响最终准确率。我在实际测试中试过128和64，最终精度差异在0.1%以内，所以这里不必纠结——跟着原版走一遍，之后再按自己的理解去调整。

2.4 激活函数选型的变化

原始LeNet用的激活函数是sigmoid或tanh，但我在实现中选择全部用ReLU。原因很简单：ReLU计算量小、梯度消失问题比sigmoid轻微得多，训练收敛速度明显更快。原先的LeNet在MNIST上要迭代很多轮才能收敛，换上ReLU之后通常十来个epoch就到98%以上的准确率了。这在今天的实践里已经是标准操作——深度学习框架的默认认知都是配合ReLU族激活函数使用的。

最后一个细节是在全连接层之后加Dropout正则化，随机丢弃一部分神经元来防止过拟合。原版LeNet没有这个结构，但训练时我观察到仅仅两个全连接层仍然会出现训练损失持续下降、验证损失停止甚至反弹的情况，这就是过拟合的典型症状。加一个Dropout层，比例设为0.5，能有效缓解这个问题。这部分属于“合理改良”，后面实测数据会证明它的效果。

3. 核心细节解析与实操要点

3.1 数据准备：MNIST的处理细节

MNIST数据集的获取在TensorFlow里已经非常简单，一行代码就能下载加载：

from tensorflow.keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data()

但下载完之后，数据不能直接扔给网络训练，中间有三件事必须做：标准化、形状变换、One-Hot编码。这三件事每件都有它存在的理由，我一个个说。

标准化：MNIST图像像素值的范围是0到255，如果直接原样输入神经网络，数值量级偏大。神经网络训练时，输入值过大或分布差异过大会让梯度更新不稳定，收敛速度变慢。标准做法是把每个像素值除以255，把范围压缩到0到1之间。更讲究一点还可以做均值方差标准化，让数据分布变成均值0方差1。不过对于MNIST这种简单任务，除以255已经足够了。

x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 # 转成四维张量，格式为 [样本数, 高度, 宽度, 通道数] x_train = x_train.reshape(-1, 28, 28, 1) x_test = x_test.reshape(-1, 28, 28, 1)

形状变换：TensorFlow的卷积层要求输入是四维张量，顺序是（样本数，高，宽，通道数），即NHWC格式。MNIST原始数据是（样本数，28，28），缺少通道这一维，所以要手动加一个维度。灰度图通道数是1，如果是RGB彩色图就是3。初学者最容易在这一步出问题，报错信息通常是“expected ndim=4, found ndim=3”，看到这个报错就知道是形状没对上。

One-Hot编码：MNIST的标签是0到9的整数，比如一张图片的标签是“3”。但网络输出的10维向量表示的是“这张图属于每一类的概率”。要让两者能直接计算loss，就得把整数标签也变成10维向量：标签“3”变成[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]，这叫One-Hot编码，也叫独热编码。

num_classes = 10 y_train = tf.keras.utils.to_categorical(y_train, num_classes) y_test = tf.keras.utils.to_categorical(y_test, num_classes)

注意：to_categorical会把标签自动转成float32类型，方便之后直接参与交叉熵计算。这里的num_classes必须和模型输出层的神经元数量一致，否则训练时维度不匹配直接报错。

3.2 数据增强：MNIST需不需要？

图像分类任务里数据增强几乎已经成了标配操作，旋转、平移、缩放，一招接一招地防止模型过拟合。但MNIST这个特定数据集，我实测下来的结论是：基本不需要。原因在于MNIST本身已经是一个“规规矩矩”的数据集，数字都是居中、尺度统一、背景干净。模型只要能提取到笔画特征，基本就能学好。而真正在真实场景中遇到的手写数字，可能是歪的、糊的、有大有小、还带各种噪声。如果你希望模型更有泛化能力，可以考虑做一个微小的随机旋转或平移：

datagen = tf.keras.preprocessing.image.ImageDataGenerator( rotation_range=10, width_shift_range=0.1, height_shift_range=0.1, zoom_range=0.1 )

这里每个人可以根据需要自行决定。做数据增强会增加训练时间，而收益在MNIST上并不算明显。如果后面想挑战更复杂的数据集，那个阶段再去系统性地学习数据增强策略也不急。入门阶段先把最基本的主流程跑通，避免一次承担过多变量。

3.3 模型搭建：把网络结构翻译成代码

下面是我最终使用的完整模型结构，每一层都有注释说明，方便对照上面的设计思路来看代码。

import tensorflow as tf from tensorflow.keras import layers, models def build_lenet5(): model = models.Sequential([ # 第一层卷积：6个5x5卷积核，输入28x28x1，输出24x24x6 layers.Conv2D(6, kernel_size=(5, 5), activation='relu', input_shape=(28, 28, 1)), # 第一层池化：2x2最大池化，步长2，输出12x12x6 layers.MaxPooling2D(pool_size=(2, 2), strides=2), # 第二层卷积：16个5x5卷积核，输出8x8x16 layers.Conv2D(16, kernel_size=(5, 5), activation='relu'), # 第二层池化：2x2最大池化，输出4x4x16 layers.MaxPooling2D(pool_size=(2, 2), strides=2), # 展平：把4x4x16拉直成256维向量 layers.Flatten(), # 全连接层1：256 -> 120，ReLU激活 layers.Dense(120, activation='relu'), # 随机失活50%的神经元，防止过拟合 layers.Dropout(0.5), # 全连接层2：120 -> 84，ReLU激活 layers.Dense(84, activation='relu'), # 输出层：84 -> 10，对应10个数字类别 layers.Dense(10, activation='softmax') ]) return model model = build_lenet5() model.summary()

运行model.summary()会打印出每层输出形状和参数量。第一次看的同学可能对这个表格有点懵，这里解释一下怎么读。以第一个卷积层为例，它有6个5x5卷积核，另外每个卷积核还有一个偏置项，所以参数量是6×5×5+6=156。这些参数会在训练过程中不断被更新。整张summary表往下看一下就知道网络总共有多少参数，LeNet-5大概6万出头。这个“6万”是个很直观的数字——对一个现代神经网络来说，这个参数量可以说相当轻量了。

几个容易踩坑的点提醒一下。input_shape参数只写在第一层，因为后面的层可以根据前面的输出自动推断形状。Flatten层的存在是必需的，因为全连接层只能接收二维输入（样本数，特征数），而卷积池化的输出是四维的，必须展平才能对接。最后输出层的激活函数用的是softmax，因为这是多分类任务，需要得到每一类的概率分布。

3.4 损失函数与评估指标的选择逻辑

模型编译时，最核心的两个选择是损失函数和优化器。

model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'] )

损失函数选的是categorical_crossentropy，它对应的是“多分类 + 标签是One-Hot编码”的设定。这里有个小知识点值得展开：还有一个sparse_categorical_crossentropy，它适用于标签还是整数而不是One-Hot向量的情况。两者数学本质完全一样，只是输入格式不同。我第一次用TensorFlow时在这里栽过跟头：模型输出10维、标签是整数，代码对不上，直到把标签改成One-Hot才顺利跑通。现在熟练之后自定义训练时就喜欢用sparse版本，因为省去一步预处理，但如果你是第一次跑这个流程，直接用categorical_crossentropy配合上面的to_categorical编码，逻辑上更直白。

提示：交叉熵的计算公式为 -Σ y_i log(p_i)，其中y是真实标签的One-Hot向量，p是模型预测的概率分布。当预测概率和真实标签完全一致时loss为0，差异越大loss越大。与均方误差相比，交叉熵在分类任务中收敛更快、更容易达到高精度——因为分类的输出是概率分布，用概率分布之间的差异做损失更自然。

评估指标选了accuracy，也就是预测的类别（概率最大的那个位置）和真实类别一致的占比。训练过程中每个epoch结束，都会输出训练集上的loss和accuracy，以及验证集上的对应指标。

3.5 训练策略与Batch Size的权衡

训练阶段最关键的几个超参数是：batch size、epochs、优化器选择。我的选择是batch size=128，epochs=10到15，优化器用Adam。

Batch size的意思是每次迭代从训练集里抽多少张图片来计算梯度。每次迭代用128张图片的梯度做一个平均，然后更新一次网络参数。这个值不是越大越好，也不是越小越好。太大，单次迭代计算量大且容易陷入尖锐极小点，泛化能力反而可能下降；太小，梯度估计的噪声大，收敛不稳定。128对MNIST来说是一个久经考验的稳妥选择——整个训练集6万张，除以128大约是469次迭代完成一个epoch，速度很快。

学习率设置为0.001，这是Adam优化器的默认值，实测下来对MNIST足够好用。注意，这里“好用”是指从随机初始化开始训练时能稳定收敛。如果试过学习率设成0.01，准确率会掉不少，甚至出现loss震荡。我后面在问题排查部分会详细说这个观察。

4. 实操过程与核心环节实现

4.1 完整训练流程与日志解读

把前面所有代码整合在一起，就是一个可以直接运行的完整脚本：

import tensorflow as tf from tensorflow.keras.datasets import mnist from tensorflow.keras import layers, models # 1. 数据加载与预处理 (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 x_train = x_train.reshape(-1, 28, 28, 1) x_test = x_test.reshape(-1, 28, 28, 1) num_classes = 10 y_train = tf.keras.utils.to_categorical(y_train, num_classes) y_test = tf.keras.utils.to_categorical(y_test, num_classes) # 2. 从训练集中切出一部分作为验证集 from tensorflow.keras.datasets import mnist val_split = 0.1 split_idx = int(len(x_train) * (1 - val_split)) x_train, x_val = x_train[:split_idx], x_train[split_idx:] y_train_part, y_val = y_train[:split_idx], y_train[split_idx:] # 3. 构建模型 def build_lenet5(): model = models.Sequential([ layers.Conv2D(6, kernel_size=(5, 5), activation='relu', input_shape=(28, 28, 1)), layers.MaxPooling2D(pool_size=(2, 2), strides=2), layers.Conv2D(16, kernel_size=(5, 5), activation='relu'), layers.MaxPooling2D(pool_size=(2, 2), strides=2), layers.Flatten(), layers.Dense(120, activation='relu'), layers.Dropout(0.5), layers.Dense(84, activation='relu'), layers.Dense(10, activation='softmax') ]) return model model = build_lenet5() # 4. 编译模型 model.compile( optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'] ) # 5. 启动训练 history = model.fit( x_train, y_train_part, batch_size=128, epochs=15, validation_data=(x_val, y_val), verbose=1 ) # 6. 在测试集上评估最终效果 test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0) print(f'Test accuracy: {test_acc:.4f}')

训练过程中你会看到类似下表的输出（每行对应一个epoch）。如果你第一次跑，建议仔细看这个日志，它会告诉你好多信息：

从日志中能清楚地看到几个典型规律：第一个epoch训练准确率就已经冲到90%，说明MNIST确实是一个非常好学的任务；验证集loss在前期持续下降，到了第12个epoch左右开始波动，训练loss还在降但验证loss不怎么动了，这就是过拟合的前兆。好在有Dropout的抑制，最终的验证准确率维持在98.9%左右，和测试集上的结果非常接近。

4.2 训练过程的可视化：曲线比数据更直观

训练结束后，history对象里保存了每一个epoch的loss和accuracy，画出来能直观看到训练动态。这是我建议每个入门者都要做的步骤，因为“看曲线”比“看数字”更容易发现问题。

import matplotlib.pyplot as plt def plot_training_history(history): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # 损失曲线 ax1.plot(history.history['loss'], label='train_loss') ax1.plot(history.history['val_loss'], label='val_loss') ax1.set_title('Loss Curves') ax1.set_xlabel('Epoch') ax1.set_ylabel('Loss') ax1.legend() # 准确率曲线 ax2.plot(history.history['accuracy'], label='train_acc') ax2.plot(history.history['val_accuracy'], label='val_acc') ax2.set_title('Accuracy Curves') ax2.set_xlabel('Epoch') ax2.set_ylabel('Accuracy') ax2.legend() plt.tight_layout() plt.show() plot_training_history(history)

读这两条曲线的方法很简单：如果训练loss不断下降但验证loss开始上升，说明过拟合，需要加强正则化（增加Dropout比例、加L2惩罚、用数据增强）；如果两条loss都在高位不下降，说明模型没有在学习，可能是学习率设置不合理、数据预处理有问题、或者网络结构本身有缺陷。我在训练一个自定义数据集时，曾经见过验证准确率在三个epoch内纹丝不动，后来查了半天发现是数据没有shuffle，每个batch里全是同一个类别，模型根本学不到东西。这类“看起来模型坏了、实际是数据预处理的问题”的坑，新手最容易碰上。

4.3 评估与预测：从准确率到具体错误

model.evaluate()给出的是整体指标，但它掩盖了一个细节：模型错误地识别了哪些数字？它们长什么样子？可视化错误样本是一个很实用的排查手段。

import numpy as np predictions = model.predict(x_test) pred_labels = np.argmax(predictions, axis=1) true_labels = np.argmax(y_test, axis=1) misclassified = np.where(pred_labels != true_labels)[0] print(f'Total misclassified: {len(misclassified)} out of {len(x_test)}') print(f'Accuracy: {1 - len(misclassified) / len(x_test):.4f}') # 展示前10个错误样本 import matplotlib.pyplot as plt plt.figure(figsize=(12, 6)) for i, idx in enumerate(misclassified[:10]): plt.subplot(2, 5, i + 1) plt.imshow(x_test[idx].reshape(28, 28), cmap='gray') plt.title(f'True: {true_labels[idx]}, Pred: {pred_labels[idx]}') plt.axis('off') plt.tight_layout() plt.show()

我每次跑这个可视化，都能发现一个规律：大多数错误样本集中在这种情形——手写的“4”和“9”在形态上确实非常接近，如果笔画连笔或者比例稍微奇怪一点，模型就会分不清。还有“3”和“8”，“5”和“6”，这些也是经典的混淆对。这个观察很重要，因为它说明模型的错误分布是符合人类直觉的，模型的判断逻辑并没有出现奇怪的失常行为。如果有一天你发现模型把“1”误认成“8”，那才值得怀疑哪里出了问题。

4.4 卷积核与特征图的可视化

训练结束后的卷积核，理解起来比读任何教科书都直观。第一个卷积层只有6个5x5的卷积核，可以把它们原样打印出来看看学了什么：

filters = model.layers[0].get_weights()[0] print(filters.shape) # (5, 5, 1, 6) fig, axes = plt.subplots(2, 3, figsize=(8, 5)) for i, ax in enumerate(axes.flat): ax.imshow(filters[:, :, 0, i], cmap='viridis') ax.set_title(f'Filter {i+1}') ax.axis('off') plt.tight_layout() plt.show()

你会看到有些核呈现出明显的方向性纹理：有的敏感于横向边缘，有的敏感于纵向边缘，有的能响应斜向纹路。这就是“卷积核自动学到特征检测器”的直接证据。再往深一层走，可以取一张输入图片，看看经过第一层卷积后输出的6张特征图长什么样。你会发现每张特征图像是从不同角度“画出”了输入图片的轮廓，有的强调横线、有的强调竖线，非常有意思。

# 取出第一个卷积层的输出作为中间模型 layer_output = model.layers[0].output activation_model = tf.keras.models.Model(inputs=model.input, outputs=layer_output) sample = x_test[0].reshape(1, 28, 28, 1) activations = activation_model.predict(sample) fig, axes = plt.subplots(2, 3, figsize=(8, 5)) for i in range(6): ax = axes[i // 3][i % 3] ax.imshow(activations[0, :, :, i], cmap='gray') ax.set_title(f'Feature Map {i+1}') ax.axis('off') plt.tight_layout() plt.show()

这个可视化就是卷积神经网络“层层提取特征”最直观的展示，建议每个人动手跑一下。我到现在都会在给学生讲卷积原理的时候现场跑这段代码——一个静态的公式比不上一张活生生的特征图带来的冲击力。

5. 常见问题与排查技巧实录

5.1 Loss不降反升：从优化器参数开始排查

这是我被问得最多的一个问题。训练了十几个epoch，loss从一开始的0.3不降反升到0.8，或者剧烈波动根本下不去，怎么办？

排错顺序应该是：先看数据预处理是否正确，再看学习率是否太大，最后怀疑模型结构甚至梯度计算。

数据预处理是最容易忽视的一环。如果你忘了归一化、直接把原始像素值丢进网络，或者标签没有正确对应，模型看着一堆五花八门的大数值，很容易在训练初期根本不收敛。先检查x_train的数值范围是否为0到1，y_train的shape是否正确，这些基础问题排除了再谈别的。

学习率过大是loss震荡最常见的原因。优化器沿着梯度方向更新参数，如果步子迈得太大，就会在极小值附近来回跳跃甚至直接跳出最优区域。把learning_rate从0.001改成0.0001再试一次，如果loss曲线从剧烈震荡变成平缓下降，那就证实了这个判断。直观的类比是：你要走下山坡，每一步都迈三米，最后可能直接越过山脚跑到了对面山坡上；步长调到0.3米才能稳稳走到谷底。

梯度消失或梯度爆炸在LeNet这种浅层网络上不太容易出现，但如果你自己调深了网络结构、把激活函数换成sigmoid再加深层数，就要警惕这个问题。在MNIST这种简单数据集上，一个合理的排查手段是打印每一层的梯度范数，看数值是否在合理范围内（不趋于0也不爆炸到天文数字）。

如果以上都排除了，还有一个“玄学”层面的可能性：随机种子没有固定，某次训练运气不好。深度学习中确实存在“同样的代码跑两次，结果差异明显”的情况——参数初始化是随机的、数据打乱的顺序是随机的、Dropout丢哪些神经元也是随机的。把全局随机种子固定能让实验可复现，这是做实验的基本素养。

import random import numpy as np random.seed(42) np.random.seed(42) tf.random.set_seed(42)

5.2 全连接层输出全一：激活函数与权重初始化的坑

有一个非常经典的翻车现场：训练后拿模型做预测，发现输出向量里softmax之后某一类的概率永远是1.0，其他全是0。这种“模型完全瘫痪”的现象，本质上是某些神经元的输出饱和了。

最常见的触发原因是权重初始化不当。如果初始化权重过大，加权求和后的值进入了ReLU的饱和区或softmax的陡峭区，梯度不足以让参数退出那个状态，网络就“卡死”了。解决办法是使用合适的初始化器——Keras默认的glorot_uniform在大多数情况下足够好，但如果你手动用随机正态分布初始化且标准差设得过大，就会踩坑。

另一个原因是学习率太大导致参数更新一步跨进了“死亡区域”。ReLU在输入为负时输出恒为0，如果某些神经元的所有输入加权和都为负，那它的梯度也恒为0，这个神经元就永远无法恢复，这种情况叫“神经元死亡”。Dropout比例设太高、加上学习率偏大，也会加重这个问题。我实测过：Dropout=0.9配上learning_rate=0.01，训练几轮后模型输出就开始退化了，精度掉到和随机猜差不多。

排查方法很直接。把测试集的一批样本喂给模型，对model.layers[i].output做一次中间层输出统计，看看那些神经元输出的平均值是不是一大片0。如果真是这样，把学习率调低、Dropout调回0.5，从头再训一般就能解决。

5.3 用Minist数据集时的过拟合控制

LeNet的参数量是6万，MNIST训练集有6万张图片——比例接近1:1。这个数量关系决定了模型有足够的能力去“背”训练集的模式，过拟合几乎是必然会出现的。我在第一个版本里没有加Dropout，训练到第20个epoch时训练准确率升到了99.7%，验证准确率停在98.5%左右，两者之间的差距就是过拟合的直接证据。

控制过拟合的手段有很多，但入门阶段优先级最高的是这三条：Dropout、早停和简化模型。Dropout是最省事的，加一个层、一个参数就完事了。早停需要在训练时监控验证loss，一旦开始连续上升就提前终止训练，Keras里可以用EarlyStopping回调函数。

from tensorflow.keras.callbacks import EarlyStopping early_stop = EarlyStopping( monitor='val_loss', patience=3, restore_best_weights=True )

patience=3的意思是如果连续3个epoch验证loss都没下降，就停止训练，并自动回滚到验证loss最低的那个epoch的权重。这个机制能有效防止最后一两个过拟合的epoch影响最终模型质量。简化模型则更基础——如果你的任务只有10分类，输出层之前放两个全连接层就够了，堆太多层只会加剧过拟合，不会带来任何收益。

5.4 CPU训练速度：优化那些低效操作

很多新手的第一个拦路虎是“用CPU跑神经网络会不会很慢”。我的实测经验是：MNIST + LeNet + CPU，一个epoch大约耗时5到10秒，15个epoch全部跑完也就两分多钟。完全不需要GPU。真正拖慢速度的往往不是网络本身，反而是一些低效操作的叠加。

最容易犯的低效错误是在Python循环里逐张处理图片——把x_train拆成60000次单独的前向传播，一次一张。TensorFlow本身的向量化能力被彻底废掉，速度慢十几倍。要避免频繁在NumPy数组和Tensor之间切换，整体操作尽量改成TensorFlow的批量接口，让数据保持一个大矩阵从头走到尾。

数据加载本身的瓶颈也值得重视。TensorFlow 2.x里提供一个tf.data.Dataset的官方推荐数据管线，其中batch()、shuffle()、cache()这些操作能显著减少数据读取对训练的阻塞。MNIST数据量小，cache()直接把数据缓存进内存后还能省一次重复的磁盘读取。不过作为入门项目，直接使用NumPy数组作为输入配合model.fit()就够了——等你期望训练流程更进一步优化的时候，再考虑切换到Dataset API也不迟。

5.5 测试集准确率比验证集低：分布差异有多微妙

有时候你会发现一件怪事：验证集准确率98.9%，测试集却只有97.8%。这通常不是因为模型坏了，而是因为两个分布之间存在细微差异。MNIST官方划分的训练集和测试集来自不同的书写者样本，书写风格本身有系统性差异；另外我们做验证集划分时随机抽取，而官方测试集的数字分布可能会有细微差别。这类差异在简单模型上表现得比较明显，用复杂模型或更充分的数据增强往往能拉平。

不过入门阶段完全没必要过度纠结测试集准确率和验证集差的那一个百分点。看整体趋势即可——如果你的测试集准确率稳定在98%以上，说明这个模型和流程是健康的。接下来想从头复现更高分（比如99%以上），可以把精力放在：调优超参数（batch size、学习率、dropout比例）、尝试其它优化器（SGD带动量、AdamW）以及训练更多个epoch。我在几个不同设置下的实测记录里，最终测试准确率基本在98.7%到99.0%之间浮动，这个成绩对LeNet这个体量的模型来说已经非常不错了。

6. 优化思路与扩展方向

6.1 替换优化器与学习率策略

Adam是当代深度学习默认的优化器，但它不是最优解。在某些任务上，带动量的SGD（momentum=0.9）配合合适的学习率调度策略，最终收敛精度反而比Adam更好。Adam的优势是自适应学习率、调参难度低，适合快速得到一个不错的结果；SGD的优势是收敛到的极小值往往更平缓、泛化能力更好，但对学习率的设定更敏感。

入门阶段我建议先老老实实用Adam跑通流程，之后再尝试一个进阶实验：把优化器换成SGD、初始学习率0.01、每训练5个epoch把学习率衰减为原来的0.1倍。你会发现loss下降曲线完全不同——SGD前期下降慢一些，但后期验证准确率有可能比Adam高出0.1到0.2个百分点。这种“亲自感受到优化器之间的差异”的经验，比读十篇优化器对比的文章都更有价值。

6.2 调整网络宽度与深度的影响

LeNet的原始宽度（卷积通道数6和16）是为1998年的计算资源设计的。今天你可以做一组对照实验：把第一个卷积层的filter数量从6改成32，第二个从16改成64，其他不变。你会看到参数量从6万暴涨到几十万，训练时间变长，但测试准确率可能只会提升0.1个百分点——这就是“增加模型容量不等于提升效果”的经典教学案例。

反向实验也很有趣：把通道数改成4和8，模型参数少了一半，准确率大概也会掉0.5到1个百分点。通过这几组对照，你就能建立起对“模型容量与任务复杂度”匹配关系的直觉：MNIST的复杂度根本不需要大模型，小模型足够胜任，大模型只会浪费算力并增加过拟合风险。

6.3 把LeNet迁移到另一个数据集

理解LeNet最好的方式，是把它用到一个MNIST之外的场景。我建议把模型修改后迁移到CIFAR-10数据集：32x32的32张彩色图片、10个类别。这是一个难度突然跳升的任务——从灰度到彩色、从简单笔画到复杂自然图像、从清晰到模糊带背景。直接把LeNet的结构搬到CIFAR-10上，准确率大概会掉到60%到70%左右，因为模型容量确实不够。这时你可以复刻经典的VGG思路：把网络加深，增加更多的卷积层，把通道数扩展到64以上，准确率就能逐步拉回85%左右。

这个过程会逼你去思考很多MNIST上不需要考虑的问题：数据增广怎么做才能有效缓解过拟合、Batch Normalization加在哪里能把收敛速度提上去、输入图像的均值和标准差要如何在数据集中统计出来。如果你能把这个扩展实验完整走一遍，你对深度学习建模的理解会比看二十篇教程更深入得多。

6.4 半精度训练与量化部署

LeNet只有6万参数，但出了MNIST之后如果想要部署到移动端，把它做小做快就是真需求了。TensorFlow有现成的工具链可以对训练好的模型做后训练量化（Post-Training Quantization），把权重从32位浮点压缩到8位整数。这里有个直观的对比：原始模型大小约250KB，量化后能压到80KB以内，推理速度提升的同时准确率几乎不受影响。

如果你对这部分感兴趣，推荐试一试tf.lite.TFLiteConverter的量化转换流程，顺带了解一下TensorFlow Lite的模型部署流程。做一次“从训练到部署”的完整闭环，比单纯在Jupyter里跑通一个模型，能学到的东西要多一个维度。

7. 结尾：一点个人经验

这个项目我带着不同阶段的同学反复跑过很多遍，每次都能看到一些相似的学习曲线。LeNet本身不难，难的是第一次建立起“我确实理解一个神经网络是怎么工作的”这种感觉。所以最后想说几点自己的体会。

第一遍跑代码时，不要追求一次到位。建议先把原版结构不加Dropout跑一遍，观察过拟合是怎么来的；然后加上Dropout，感受它带来的变化；再把学习率调大调小各试一次，看看训练曲线怎么变。有了这些经验，你对深度学习训练的理解会实现质的跨越。再把卷积核和特征图可视化做出来，你一定会有强烈的新奇感——这些“数字模式”不是任何人手工设计的，而是模型自己从数据里学出来的。深度学习的核心魅力，就藏在这个细节里。

这个项目后续还有很多可以继续玩的方向，试着自己改结构、换数据集、加各种正则手段，你会发现每一次小改动都会带来新的体验。训练模型这件事永远是从实践中来。祝你跑通第一个模型，享受这个过程。