从零构建手写数字识别系统：基于PyTorch的CNN实战指南

1. 项目概述：从零构建一个手写数字识别系统

手写数字识别，这个听起来有点“古典”的课题，几乎是每个机器学习入门者的必经之路。它就像编程里的“Hello World”，但内涵要丰富得多。我当年第一次接触这个项目时，觉得不就是把图片里的数字认出来嘛，用点规则判断一下不就行了？结果被现实狠狠教育了一番——手写的“7”和“1”有时候连人眼都分不清，更别说让机器去“看”了。这个项目的核心价值，不在于实现一个多高精度的识别器，而在于它能让你完整地走一遍一个机器学习项目的标准流程：从数据理解、预处理、模型选择与训练，到最后的评估与部署。它麻雀虽小，五脏俱全，涵盖了监督学习、图像处理、模型调优等多个核心概念。

对于学生党来说，这是一个绝佳的大作业选题；对于刚转行的朋友，这是建立信心的基石；对于有经验的从业者，重温MNIST数据集，用现代的工具链（比如PyTorch Lightning或TensorFlow 2.x的高级API）重新实现一遍，也能带来新的感悟。我们这次要做的，不是一个调包就能完事的玩具，而是一个你可以清晰解释每一步“为什么”的系统。我们会从最经典的MNIST数据集开始，但不止步于此，我会带你思考如何处理更“脏”、更真实的手写数据，比如你自己在纸上写的数字。整个系统将围绕数据流水线、模型架构、训练策略和结果可视化这几个核心模块展开，目标是让你不仅能跑通代码，更能理解背后的逻辑，下次遇到图像分类问题，能举一反三。

2. 核心思路与技术选型：为什么是卷积神经网络？

当我们拿到“手写数字识别”这个任务，第一个要回答的问题是：用什么模型？历史上，人们试过很多方法，比如K近邻（K-NN）、支持向量机（SVM），甚至简单的全连接神经网络（MLP）。在MNIST这个28x28像素、相对简单的数据集上，这些方法都能达到90%以上的准确率。但为什么今天我们几乎无一例外地选择卷积神经网络（CNN）？这背后是对于问题本质的深刻理解。

手写数字图像，本质上是具有强烈空间局部相关性的二维数据。一个数字“8”，它是由上下两个圆圈在特定位置组合而成的。全连接网络把图像拉平成一个784维的向量，完全破坏了像素之间的空间结构关系。它需要从零开始学习“像素A和像素B相邻”这个先验知识，这极其低效。而CNN天生就为处理这类数据而生。它的卷积核在图像上滑动，自动提取局部特征（如边缘、角点），池化层则对这些特征进行降维和抽象，保留最显著的信息。这种“局部感知”和“参数共享”的特性，使得CNN在图像任务上具有压倒性的效率和性能优势。

注意：虽然对于MNIST，一个3-4层的简单CNN就足以达到99%+的准确率，但我们在设计时，不能只满足于在MNIST上刷高分。我们的架构应该具备一定的通用性和可扩展性，以便未来可以迁移到更复杂的数据（如Fashion-MNIST甚至CIFAR-10）上。

基于以上考量，我们的技术栈选型如下：

• 深度学习框架：PyTorch。相比TensorFlow，PyTorch的动态计算图和更Pythonic的API设计，对于学习和调试更加友好。它的torchvision库提供了便捷的数据集加载和预处理工具。
• 模型架构：一个中等深度的CNN。我们将设计一个包含多个卷积-池化块，最后接全连接层的网络。具体层数会在后续详细展开。
• 开发环境：推荐使用Anaconda创建独立的Python环境，避免包冲突。IDE可以选择VS Code（配合Python和Pytorch插件）或Jupyter Notebook（用于快速实验和可视化）。
• 辅助工具：Matplotlib用于可视化，TensorBoard或Weights & Biases用于跟踪训练过程。

这个选型平衡了易用性、学习价值和实用性，是完成这个项目并深入理解CNN的黄金组合。

2.1 数据：项目的基石与挑战

任何机器学习项目，数据都是重中之重。MNIST数据集包含了60000张训练图像和10000张测试图像，每张都是28x28的灰度图，像素值在0-255之间，标签是0-9的数字。它干净、规整，是理想的学习起点。但我们必须清醒地认识到，MNIST是一个高度标准化的数据集，与现实世界中杂乱的手写数字相去甚远。

因此，我们的数据处理流程需要包含两个层面：

1. 对标准MNIST的预处理：这主要是为模型训练做准备。包括将像素值归一化到[0, 1]区间（加速模型收敛），以及可能的数据增强（如随机旋转、平移、缩放），以提升模型的鲁棒性，防止过拟合。
2. 对真实手写图像的预处理：这才是项目的升华点。想象一下，你用手机拍下自己写在白纸上的数字。这张图会是彩色的、可能有阴影、数字可能不在中心、大小不一、背景杂乱。处理这样的图像，需要一个额外的预处理流水线：
   • 灰度化：将彩色图转为灰度图。
   • 二值化：通过阈值处理，将图像转为黑白，分离前景（数字）和背景。这里选择合适的阈值（如大津法）是关键。
   • 降噪：使用形态学操作（如开运算、闭运算）去除小的噪点。
   • 数字定位与分割：如果一张图有多个数字，需要找到每个数字的边界框并裁剪出来。
   • 尺寸归一化：将裁剪出的数字图像缩放或填充到28x28像素，并做反色处理（MNIST是黑底白字，而我们拍的照片通常是白底黑字）。

这个自定义的预处理流水线，是将你的模型从“实验室”推向“现实”的关键一步，也是大作业的加分亮点。

2.2 模型架构设计详解

我们的CNN模型不会追求极致的深度（如ResNet），而是采用一个经典且有效的结构，确保在MNIST上高效收敛，同时结构清晰易懂。下面是一个推荐的设计：

import torch import torch.nn as nn import torch.nn.functional as F class DigitRecognizerCNN(nn.Module): def __init__(self): super(DigitRecognizerCNN, self).__init__() # 特征提取部分 self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, padding=1) # 输出: 28x28x32 self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) # 输出: 28x28x64 self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2) # 输出: 14x14x64 self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1) # 输出: 14x14x128 self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1) # 输出: 14x14x128 self.pool2 = nn.MaxPool2d(2, 2) # 输出: 7x7x128 # 分类部分 self.flatten = nn.Flatten() # 将7x7x128 = 6272维向量拉平 self.fc1 = nn.Linear(6272, 512) self.dropout = nn.Dropout(p=0.5) # 丢弃层，防止过拟合 self.fc2 = nn.Linear(512, 10) # 输出10个类别的分数 def forward(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = self.pool1(x) x = F.relu(self.conv3(x)) x = F.relu(self.conv4(x)) x = self.pool2(x) x = self.flatten(x) x = F.relu(self.fc1(x)) x = self.dropout(x) x = self.fc2(x) # 这里不接Softmax，因为损失函数CrossEntropyLoss自带 return x

设计逻辑解析：

• 卷积层：我们使用小尺寸卷积核（3x3），这是VGG网络推广的经典设计，在减少参数量的同时能保持足够的感受野。padding=1是为了保持特征图空间尺寸不变（output_size = (input_size - kernel_size + 2*padding)/stride + 1），便于计算和设计。
• 通道数增长：通道数从1（灰度）->32->64->128，逐步增加。浅层卷积捕捉简单特征（边缘），需要较少的滤波器；深层卷积组合简单特征形成复杂模式（如圆圈、交叉），需要更多滤波器来表达。
• 池化层：在两组卷积后使用2x2最大池化，将特征图尺寸减半。这实现了空间层次的下采样，在扩大后续卷积感受野的同时，显著减少了参数和计算量，并提供了某种程度的平移不变性。
• 全连接层与Dropout：将最后的特征图拉平后送入全连接层。在第一个全连接层后加入了Dropout，在训练时随机“关闭”一部分神经元（这里设为50%），这是一种非常有效的正则化技术，强迫网络不依赖于任何单个神经元，从而减轻过拟合。
• 激活函数：使用ReLU，因为它能有效缓解梯度消失问题，计算速度快。
• 输出层：输出10个值，对应0-9的得分。注意，我们没有在模型最后使用Softmax，因为PyTorch的nn.CrossEntropyLoss损失函数内部已经包含了Softmax计算，这样在数值计算上更稳定。

这个架构在MNIST上通常经过5-10个epoch就能达到98.5%以上的测试准确率，是一个强力的基线模型。

3. 项目实现：构建端到端的训练与评估流水线

有了清晰的架构设计，接下来就是将其转化为可运行的代码。一个健壮的项目不应该把所有代码堆在一个文件里。合理的模块化能让开发、调试和分享都变得更容易。我建议的项目结构如下：

handwritten_digit_recognizer/ ├── data/ │ ├── __init__.py │ ├── dataset.py # 自定义数据集加载与预处理 │ └── transforms.py # 自定义数据增强 ├── models/ │ ├── __init__.py │ └── cnn.py # CNN模型定义 ├── engine/ │ ├── __init__.py │ ├── trainer.py # 训练循环封装 │ └── evaluator.py # 评估函数封装 ├── utils/ │ ├── __init__.py │ └── visualization.py # 可视化工具函数 ├── config.yaml # 超参数配置文件 ├── train.py # 主训练脚本 ├── predict.py # 预测脚本（用于单张图片） └── requirements.txt # 项目依赖

3.1 数据加载与预处理模块实现

在data/dataset.py中，我们不仅要加载标准的MNIST，还要为自定义图像预留接口。

# data/dataset.py import torch from torch.utils.data import Dataset, DataLoader from torchvision import datasets, transforms import cv2 import numpy as np import os class MNISTDataset: """封装标准的MNIST数据集加载""" def __init__(self, data_dir='./data', batch_size=64): self.data_dir = data_dir self.batch_size = batch_size # 定义标准变换：转为Tensor，并归一化到[0,1] transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) # MNIST的均值和标准差 ]) # 加载训练集和测试集 self.train_dataset = datasets.MNIST(root=data_dir, train=True, download=True, transform=transform) self.test_dataset = datasets.MNIST(root=data_dir, train=False, download=True, transform=transform) # 创建DataLoader self.train_loader = DataLoader(self.train_dataset, batch_size=batch_size, shuffle=True, num_workers=2) self.test_loader = DataLoader(self.test_dataset, batch_size=batch_size, shuffle=False, num_workers=2) class CustomDigitDataset(Dataset): """用于加载自定义手写图片的数据集类""" def __init__(self, image_dir, transform=None): self.image_dir = image_dir self.transform = transform self.image_paths = [os.path.join(image_dir, f) for f in os.listdir(image_dir) if f.endswith(('.png', '.jpg', '.jpeg'))] # 假设文件名包含标签，例如 '5_sample1.jpg' self.labels = [int(os.path.basename(p).split('_')[0]) for p in self.image_paths] def __len__(self): return len(self.image_paths) def __getitem__(self, idx): img_path = self.image_paths[idx] label = self.labels[idx] # 使用OpenCV读取，并应用自定义预处理流水线 image = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE) # 1. 灰度化 _, image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU) # 2. 二值化+反色 image = cv2.resize(image, (28, 28)) # 3. 尺寸归一化 image = image.astype(np.float32) / 255.0 # 4. 归一化到[0,1] image = np.expand_dims(image, axis=0) # 增加通道维度 (1, 28, 28) if self.transform: image = self.transform(torch.from_numpy(image)) return image, label

在data/transforms.py中，我们可以定义一些数据增强策略，用于提升模型泛化能力。

# data/transforms.py from torchvision import transforms def get_train_transforms(): """训练集的数据增强变换""" return transforms.Compose([ transforms.RandomRotation(degrees=10), # 随机旋转±10度 transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)), # 随机平移10% transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) def get_test_transforms(): """测试集的变换，通常只包含归一化""" return transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])

3.2 训练引擎的封装

将训练循环封装起来，可以使主程序非常简洁，也便于复用。engine/trainer.py是关键。

# engine/trainer.py import torch from tqdm import tqdm import torch.nn as nn import torch.optim as optim from torch.utils.tensorboard import SummaryWriter class Trainer: def __init__(self, model, train_loader, test_loader, device, config): self.model = model.to(device) self.train_loader = train_loader self.test_loader = test_loader self.device = device self.config = config # 损失函数与优化器 self.criterion = nn.CrossEntropyLoss() self.optimizer = optim.Adam(model.parameters(), lr=config['lr'], weight_decay=config['weight_decay']) self.scheduler = optim.lr_scheduler.StepLR(self.optimizer, step_size=config['step_size'], gamma=config['gamma']) # 日志记录 self.writer = SummaryWriter(log_dir=config['log_dir']) def train_one_epoch(self, epoch): self.model.train() running_loss = 0.0 correct = 0 total = 0 pbar = tqdm(self.train_loader, desc=f'Epoch {epoch}') for batch_idx, (data, target) in enumerate(pbar): data, target = data.to(self.device), target.to(self.device) self.optimizer.zero_grad() output = self.model(data) loss = self.criterion(output, target) loss.backward() self.optimizer.step() running_loss += loss.item() _, predicted = output.max(1) total += target.size(0) correct += predicted.eq(target).sum().item() # 更新进度条描述 pbar.set_postfix({'Loss': loss.item(), 'Acc': 100.*correct/total}) avg_loss = running_loss / len(self.train_loader) train_acc = 100. * correct / total # 记录到TensorBoard self.writer.add_scalar('Loss/train', avg_loss, epoch) self.writer.add_scalar('Accuracy/train', train_acc, epoch) return avg_loss, train_acc def evaluate(self, epoch): self.model.eval() test_loss = 0 correct = 0 total = 0 with torch.no_grad(): for data, target in self.test_loader: data, target = data.to(self.device), target.to(self.device) output = self.model(data) test_loss += self.criterion(output, target).item() _, predicted = output.max(1) total += target.size(0) correct += predicted.eq(target).sum().item() avg_test_loss = test_loss / len(self.test_loader) test_acc = 100. * correct / total self.writer.add_scalar('Loss/test', avg_test_loss, epoch) self.writer.add_scalar('Accuracy/test', test_acc, epoch) print(f'\nTest set: Average loss: {avg_test_loss:.4f}, Accuracy: {correct}/{total} ({test_acc:.2f}%)') return avg_test_loss, test_acc def fit(self, epochs): best_acc = 0.0 for epoch in range(1, epochs + 1): print(f'\nEpoch {epoch}/{epochs}') train_loss, train_acc = self.train_one_epoch(epoch) test_loss, test_acc = self.evaluate(epoch) self.scheduler.step() # 保存最佳模型 if test_acc > best_acc: best_acc = test_acc torch.save({ 'epoch': epoch, 'model_state_dict': self.model.state_dict(), 'optimizer_state_dict': self.optimizer.state_dict(), 'test_acc': test_acc, }, self.config['model_save_path']) print(f'Model saved with accuracy: {test_acc:.2f}%') self.writer.close()

3.3 主训练脚本与配置

最后，train.py作为入口点，将各个模块串联起来。

# train.py import yaml import torch from data.dataset import MNISTDataset from models.cnn import DigitRecognizerCNN from engine.trainer import Trainer def main(): # 加载配置 with open('config.yaml', 'r') as f: config = yaml.safe_load(f) # 设置设备 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Using device: {device}') # 准备数据 print('Loading data...') data_module = MNISTDataset(data_dir=config['data_dir'], batch_size=config['batch_size']) # 初始化模型 print('Initializing model...') model = DigitRecognizerCNN() print(model) # 初始化训练器并开始训练 trainer = Trainer( model=model, train_loader=data_module.train_loader, test_loader=data_module.test_loader, device=device, config=config ) print('Starting training...') trainer.fit(epochs=config['epochs']) if __name__ == '__main__': main()

对应的config.yaml文件：

# config.yaml data_dir: './data' batch_size: 64 epochs: 15 lr: 0.001 weight_decay: 1e-5 step_size: 5 gamma: 0.5 log_dir: './runs/exp1' model_save_path: './best_model.pth'

运行python train.py，一个完整的、模块化的、可配置的手写数字识别模型训练流程就启动了。你可以通过TensorBoard实时监控损失和准确率曲线。

4. 模型优化、调试与结果分析

模型跑起来只是第一步，如何让它跑得更好、更稳，并理解其行为，才是体现功力的地方。这部分我们深入训练过程，看看如何调优和诊断。

4.1 超参数调优实战

超参数是训练开始前就设定好的参数，它们对模型性能有巨大影响。对于我们的CNN，关键的超参数包括：

• 学习率（lr）：这是最重要的超参数。太大可能导致震荡不收敛，太小则收敛缓慢。通常从0.001（Adam优化器的常用初始值）开始尝试。可以使用学习率预热（Warmup）或余弦退火等策略动态调整。
• 批大小（batch_size）：影响训练速度和模型泛化能力。较小的批次（如32、64）通常有更好的泛化性能，但训练更慢；较大的批次（如256、512）训练更快，但可能收敛到尖锐的极小点。对于MNIST，64或128是一个不错的起点。
• 优化器权重衰减（weight_decay）：即L2正则化系数，用于惩罚大的权重，防止过拟合。值通常在1e-5到1e-3之间。
• Dropout率（p）：在全连接层随机丢弃神经元的比例。0.5是一个常用值，对于较小的网络，可以尝试0.3-0.5；对于较大的网络或过拟合严重时，可以尝试0.5-0.7。

调优策略：不要盲目网格搜索，那太耗时。建议采用随机搜索，在合理的范围内随机采样超参数组合。更高效的方法是使用贝叶斯优化工具（如optuna），它能根据历史试验结果智能地建议下一个可能更优的参数组合。

实操心得：对于这类“入门级”项目，我个人的经验是，先把模型结构和数据处理好，学习率是第一个需要精细调整的参数。你可以先固定其他参数，用几个不同的学习率（如0.1, 0.01, 0.001, 0.0001）各跑2-3个epoch，观察初始几批数据的损失下降情况。选择那个损失平稳、快速下降的学习率。这比盲目跑完所有epoch再调要高效得多。

4.2 训练过程监控与可视化

训练不是黑盒。我们必须监控关键指标，以判断模型是否在正常学习。除了上面代码中已经集成到TensorBoard的损失和准确率，还有几个重要的可视化工具：

1. 权重与梯度分布：使用TensorBoard的add_histogram可以记录每一层权重和梯度的分布。理想情况下，权重分布应该保持在一个合理的范围内（不会过大或过小），梯度不应该消失（全为0）或爆炸（出现极大值）。
2. 混淆矩阵（Confusion Matrix）：这是分析分类错误不可或缺的工具。它能清晰显示模型最容易混淆哪些类别（比如，把“9”预测成“7”，把“4”预测成“9”）。这能指导我们进行有针对性的改进，例如为易混淆的类别收集更多数据，或设计针对性的数据增强。

# utils/visualization.py 片段：绘制混淆矩阵 from sklearn.metrics import confusion_matrix import seaborn as sns import matplotlib.pyplot as plt def plot_confusion_matrix(model, data_loader, device, class_names): model.eval() all_preds = [] all_labels = [] with torch.no_grad(): for data, target in data_loader: data, target = data.to(device), target.to(device) output = model(data) _, preds = torch.max(output, 1) all_preds.extend(preds.cpu().numpy()) all_labels.extend(target.cpu().numpy()) cm = confusion_matrix(all_labels, all_preds) plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names, yticklabels=class_names) plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.title('Confusion Matrix') plt.tight_layout() plt.savefig('confusion_matrix.png') plt.show()

3. 激活可视化：对于CNN，我们可以可视化卷积层的输出（即激活图），看看网络在图像的哪些部分被激活。这有助于理解网络到底“看”到了什么。例如，第一层卷积核可能学习到识别各种方向的边缘。

4.3 模型评估与错误分析

在测试集上达到99%的准确率固然可喜，但更重要的是分析那1%的错误。这些错误样本是改进模型的宝贵资源。

错误分析步骤：

1. 收集错例：在评估后，将预测错误的样本（图像、真实标签、预测标签、模型预测的置信度）保存下来。
2. 人工检查：仔细观察这些错例。它们有什么共同特征？
   • 书写风格极端：数字写得过于潦草、倾斜、断笔？
   • 数字本身模糊：图像质量差？
   • 类别间固有歧义：“7”和“1”（如果横杠短）、“9”和“4”（如果圆圈不闭合）？
3. 制定改进策略：
   • 数据层面：如果错误集中在某几种书写风格，可以尝试收集或合成更多类似风格的数据，加入训练集。
   • 数据增强：如果数字倾斜导致错误，可以增加随机旋转的角度范围。
   • 模型层面：如果模型对某些易混淆类别的区分能力弱，可以考虑使用标签平滑（Label Smoothing）或Focal Loss来让模型不那么“自信”地拟合噪声标签，或者调整网络最后全连接层的维度。
   • 后处理：在某些应用场景下，可以结合上下文信息（如连续数字的概率）进行后处理纠错。

通过这样系统的错误分析，你对模型的理解就不再是一个冰冷的准确率数字，而是知道它的强项和弱点在哪里，从而能进行精准的改进。

5. 系统部署与扩展思考

训练出一个高精度的模型只是完成了工作的一半。如何让这个模型“用起来”，以及如何让这个项目变得更有深度，是区分普通作业和优秀作业的关键。

5.1 构建一个简单的预测服务

我们可以创建一个简单的脚本predict.py，加载训练好的模型，并对单张自定义手写图片进行预测。这模拟了模型部署后的推理过程。

# predict.py import torch import cv2 import numpy as np from models.cnn import DigitRecognizerCNN from data.dataset import preprocess_custom_image # 假设我们抽象出了一个预处理函数 def load_model(model_path, device): model = DigitRecognizerCNN() checkpoint = torch.load(model_path, map_location=device) model.load_state_dict(checkpoint['model_state_dict']) model.to(device) model.eval() # 切换到评估模式 return model def predict_single_image(image_path, model, device): # 1. 预处理图像 processed_tensor = preprocess_custom_image(image_path) # 返回形状为(1, 1, 28, 28)的tensor processed_tensor = processed_tensor.to(device) # 2. 预测 with torch.no_grad(): outputs = model(processed_tensor) _, predicted = torch.max(outputs, 1) probabilities = torch.nn.functional.softmax(outputs, dim=1) # 3. 返回结果 return predicted.item(), probabilities.squeeze().cpu().numpy() if __name__ == '__main__': device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = load_model('best_model.pth', device) image_path = 'my_digit.jpg' # 替换成你的图片路径 digit, probs = predict_single_image(image_path, model, device) print(f'Predicted Digit: {digit}') print('Probabilities for each class (0-9):') for i, prob in enumerate(probs): print(f' {i}: {prob:.4f}')

更进一步，你可以使用Flask或FastAPI框架，将模型封装成一个REST API服务，这样就能通过网络请求来调用识别功能，为开发一个真正的Web或移动应用打下基础。

5.2 项目扩展方向与深度思考

如果你想让这个大作业脱颖而出，可以考虑以下扩展方向：

1. 模型轻量化与加速：我们的CNN模型虽然小，但在资源受限的设备（如手机、嵌入式设备）上仍有优化空间。可以探索：
   • 知识蒸馏：用一个更大的“教师模型”来指导训练一个更小的“学生模型”。
   • 模型剪枝：移除网络中不重要的权重或神经元。
   • 量化：将模型参数从32位浮点数转换为8位整数，大幅减少模型体积和推理时间。
2. 集成学习：训练多个不同的模型（如不同初始化的CNN、CNN+MLP等），让它们“投票”决定最终结果。这通常能提升1-2个百分点的准确率，是竞赛中的常用技巧。
3. 探索更先进的架构：虽然简单CNN够用，但你可以尝试引入更现代的组件，如残差连接（ResNet）、注意力机制或胶囊网络，并对比它们在MNIST上的性能和训练动态。这能极大加深你对前沿模型的理解。
4. 跨域泛化测试：这是最能体现研究思维的扩展。将在MNIST上训练的模型，直接在另一个手写数字数据集（如USPS、SVHN（街景门牌号数字））上测试，观察性能下降多少。然后尝试使用领域自适应技术，让模型能更好地适应新数据分布。

完成这个手写数字识别项目，你收获的不仅仅是一个能识别数字的程序。你完整实践了机器学习项目的生命周期，理解了数据、模型、训练、评估、调优和部署的每一个环节。更重要的是，你学会了如何像一名工程师一样思考：定义问题、设计方案、实现、调试、优化。这个思维模式，是应对未来任何更复杂AI挑战的基石。当你下次看到“猫狗分类”、“自动驾驶感知”这些项目时，你会发现，它们的内核与你刚刚完成的这个“Hello World”项目，惊人地相似。