简介：这份程序包面向模式识别与机器学习初学者及课程实践者，围绕手写数字识别这一经典任务，提供KNN近邻、K-means聚类与BP神经网络三种方法的完整实现，可用于ATM、智能手机等场景的入门理解与结课作业参考。压缩包共12个文件、约60.11MB，包含3个Python脚本分别对应自写算法、调库K-means和sklearn直接识别，另有idx3-ubyte与idx1-ubyte格式的MNIST二进制数据、docx作业参考、txt说明及配套数据集压缩包，覆盖从数据读取到模型对比的全流程。目前已有1230人学习下载。读者可借此动手搭建识别系统，对比三种算法在特征度量、无监督聚类与反向传播调参上的差异，并借助readme与作业格式参考快速理清实验组织方式，适合作为模式识别课程的实操起点。

1. 模式识别入门绕不开的那道坎：手写数字识别到底在识别什么

很多人第一次接触模式识别，都是从手写数字识别开始的。一张 28×28 的灰度图，像素值 0 到 255，要判断它到底是 0 到 9 里的哪一个。听起来简单，但真正动手跑一遍就会发现，同一个数字 7，有人写得带钩，有人写得像 1，有人写得歪到几乎认不出来。模式识别要做的，就是从这些千变万化的像素分布里，找到能把不同类别分开的边界。

这个方向之所以经典，是因为它把模式识别的完整流程压缩到了一个极小的规模里：数据获取、预处理、特征提取、分类器设计、性能评估，一个环节都不少，但每一步的计算量又小到可以在普通笔记本上跑完。MNIST 数据集提供了 60000 张训练图和 10000 张测试图，每张都是标准化过的黑底白字，省去了大量清洗工作。对于想入门模式识别的人来说，这是一个能让你把注意力放在方法本身而不是数据整理上的起点。

三种方法进行手写数字识别，通常指的是模板匹配、基于特征工程的分类器（比如 KNN 或 SVM）、以及神经网络。这三种方法代表了模式识别发展的三个阶段，也对应着不同的思维方式和适用场景。模板匹配最直观，KNN 最容易理解，神经网络效果最好但需要调参。把这三种方法都跑一遍，你对模式识别的理解会比只看书深得多。

2. 三种方法怎么选：从模板匹配到神经网络的落地逻辑

2.1 模板匹配：最笨但最能帮你理解“相似度”的方法

模板匹配的思路非常直接：为每个数字类别准备一个标准模板，然后把待识别的图片和每个模板逐一比对，看它和哪个模板最像。这里的“最像”通常用像素级的距离来度量，比如欧氏距离或者余弦相似度。

具体做法是，先把训练集中每个类别的所有图片取平均，得到一个“平均模板”。比如数字 0 的平均模板，就是把所有标注为 0 的训练图逐像素求平均后得到的那张图。然后对于一张测试图，计算它和 10 个平均模板的距离，距离最小的那个类别就是预测结果。

这个方法的好处是几乎不需要训练，计算逻辑透明，你能清楚地看到模型在做什么。但它的局限也很明显：手写数字的类内差异太大，平均模板会模糊掉很多细节，导致对书写风格差异大的样本识别率很低。实际跑下来，模板匹配在 MNIST 上的准确率通常只有 70% 到 82% 左右，具体取决于预处理方式。

如果你决定从模板匹配入手，我建议把重点放在预处理上。二值化、去噪、居中、尺寸归一化，这些步骤对模板匹配的影响远大于对神经网络的影响。因为模板匹配直接依赖像素对齐，图片稍微偏移几个像素，距离就会急剧变大。

import numpy as np from tensorflow.keras.datasets import mnist # 加载 MNIST 数据集 (x_train, y_train), (x_test, y_test) = mnist.load_data() # 归一化到 0-1 之间 x_train = x_train.astype('float32') / 255.0 x_test = x_test.astype('float32') / 255.0 # 为每个类别计算平均模板 templates = np.zeros((10, 28, 28), dtype='float32') for digit in range(10): # 取出所有该数字的训练样本，逐像素求平均 templates[digit] = x_train[y_train == digit].mean(axis=0) # 用欧氏距离做预测 def predict_template(image): distances = [] for digit in range(10): # 计算测试图与每个模板的欧氏距离 dist = np.sqrt(np.sum((image - templates[digit]) ** 2)) distances.append(dist) return np.argmin(distances) # 在测试集上评估 correct = 0 for i in range(len(x_test)): if predict_template(x_test[i]) == y_test[i]: correct += 1 print(f"模板匹配准确率: {correct / len(x_test) * 100:.2f}%")

这段代码的核心逻辑是：先对训练集按类别分组求平均，得到 10 个模板；然后对每张测试图计算它与 10 个模板的欧氏距离，取最小距离对应的类别作为预测。参数方面，归一化到 0-1 是为了避免像素值范围过大导致距离计算不稳定。如果你想让模板匹配效果稍微好一点，可以在求平均之前先对每张图做居中处理，减少位置偏移带来的干扰。

2.2 KNN 与 SVM：特征工程时代的两种典型打法

模板匹配之后，自然过渡到基于特征的方法。KNN 和 SVM 是两种最常用的分类器，它们对输入特征的依赖远大于对模型结构的依赖。

KNN 的思路是：对于一张测试图，在训练集中找到离它最近的 K 张图，看这 K 张图里哪个类别最多，就预测为那个类别。KNN 不需要显式训练，但预测时需要遍历整个训练集，计算量随训练集增大而线性增长。在 MNIST 上，如果直接用原始像素做特征，KNN 的准确率大约在 94% 到 96% 之间，K 取 3 到 5 比较合适。

SVM 则是找一个超平面，把不同类别的样本尽可能分开。对于多分类问题，通常采用一对多或者一对一策略。SVM 对特征尺度敏感，所以归一化是必须的。在 MNIST 上，用线性核的 SVM 大概能到 92% 到 94%，用 RBF 核可以到 96% 到 98%。但 RBF 核的训练时间会明显增加，尤其是参数调优阶段。

这两种方法的关键都在特征。原始像素作为特征，维度是 784，其中很多维度是冗余的。常见的改进方向包括：提取 HOG 特征、投影到低维空间（比如 PCA）、或者用一些简单的形状描述子。我一般会先跑一遍原始像素的基线，然后逐步加入特征工程，观察准确率的变化。

from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from sklearn.decomposition import PCA from sklearn.metrics import accuracy_score import numpy as np from tensorflow.keras.datasets import mnist # 加载数据 (x_train, y_train), (x_test, y_test) = mnist.load_data() # 展平为 784 维向量并归一化 x_train_flat = x_train.reshape(-1, 784).astype('float32') / 255.0 x_test_flat = x_test.reshape(-1, 784).astype('float32') / 255.0 # 用 PCA 降到 50 维，减少计算量并去冗余 pca = PCA(n_components=50) x_train_pca = pca.fit_transform(x_train_flat) x_test_pca = pca.transform(x_test_flat) # KNN 分类器 knn = KNeighborsClassifier(n_neighbors=3, metric='euclidean') knn.fit(x_train_pca, y_train) knn_pred = knn.predict(x_test_pca) print(f"KNN 准确率: {accuracy_score(y_test, knn_pred) * 100:.2f}%") # SVM 分类器，使用 RBF 核 svm = SVC(kernel='rbf', C=10.0, gamma='scale') svm.fit(x_train_pca, y_train) svm_pred = svm.predict(x_test_pca) print(f"SVM 准确率: {accuracy_score(y_test, svm_pred) * 100:.2f}%")

这段代码先做了 PCA 降维，把 784 维降到 50 维。这样做有两个好处：一是减少 KNN 和 SVM 的计算量，二是去掉像素间的冗余信息，有时反而能提升泛化能力。KNN 的 n_neighbors 设为 3 是一个经验值，太小容易受噪声影响，太大则模糊类别边界。SVM 的 C 参数控制惩罚力度，C 越大对误分类的容忍度越低，gamma 控制 RBF 核的影响范围。这两个参数通常需要用网格搜索来调，但在 MNIST 上，C=10、gamma='scale' 已经能给出不错的结果。

2.3 神经网络：从全连接到卷积的演进路径

神经网络方法在 MNIST 上的表现明显优于前两种。最简单的全连接网络，两三个隐藏层，就能轻松达到 97% 以上的准确率。而卷积神经网络（CNN）可以做到 99% 以上。

全连接网络的做法是把 28×28 的图片展平成 784 维向量，然后经过若干全连接层，最后接一个 10 类的 softmax 输出。隐藏层通常用 ReLU 激活函数，输出层用 softmax。训练时用交叉熵损失，优化器选 Adam 或 SGD。全连接网络的结构简单，训练速度快，适合快速验证想法。

CNN 则利用了图像的局部相关性。卷积层通过滑动窗口提取局部特征，池化层降低空间维度，最后接全连接层做分类。在 MNIST 上，一个典型的 CNN 结构是：卷积层（32 个 3×3 卷积核）→ 池化层 → 卷积层（64 个 3×3 卷积核）→ 池化层 → 全连接层（128 个神经元）→ 输出层。这个结构参数量不大，训练几分钟就能收敛。

import tensorflow as tf from tensorflow.keras import layers, models from tensorflow.keras.datasets import mnist # 加载数据并归一化 (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 # 为 CNN 增加通道维度 x_train_cnn = x_train.reshape(-1, 28, 28, 1) x_test_cnn = x_test.reshape(-1, 28, 28, 1) # 构建 CNN 模型 model = models.Sequential([ layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Flatten(), layers.Dense(128, activation='relu'), layers.Dropout(0.5), # 防止过拟合 layers.Dense(10, activation='softmax') ]) # 编译模型 model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) # 训练 history = model.fit(x_train_cnn, y_train, epochs=5, batch_size=64, validation_split=0.1) # 评估 test_loss, test_acc = model.evaluate(x_test_cnn, y_test) print(f"CNN 测试准确率: {test_acc * 100:.2f}%")

这段代码构建了一个两层卷积加两层池化的 CNN。Conv2D 的 32 和 64 是卷积核数量，也就是输出通道数。MaxPooling2D 用 2×2 窗口把特征图尺寸减半。Dropout 层在训练时随机丢弃 50% 的神经元，这是防止过拟合的常用手段。优化器用 Adam，学习率默认 0.001，在 MNIST 上通常不需要改。batch_size 设为 64 是一个平衡训练速度和梯度稳定性的选择。epochs 设为 5 是因为 MNIST 很简单，5 轮足够收敛，再多容易过拟合。

三种方法跑下来，你会发现一个清晰的梯度：模板匹配 70% 到 82%，KNN 和 SVM 94% 到 98%，CNN 99% 以上。但准确率不是唯一指标。模板匹配和 KNN 几乎不需要训练时间，SVM 训练几分钟，CNN 训练几分钟到十几分钟。选择哪种方法，取决于你对准确率、可解释性和计算资源的要求。

3. 把 MNIST 跑通：数据加载、预处理与训练环境的最小闭环

3.1 数据加载的三种方式和各自适用场景

MNIST 数据集的加载方式主要有三种：通过 Keras 内置接口、通过 sklearn 的 fetch_openml、以及直接读取原始 IDX 文件。Keras 的 mnist.load_data() 最方便，它会自动下载并缓存数据，返回四个 numpy 数组。sklearn 的方式适合已经在用 sklearn 做特征工程的场景，但下载速度有时不稳定。直接读 IDX 文件适合需要完全控制数据加载流程的情况，比如你要做自定义的数据增强。

我一般先用 Keras 接口快速跑通，确认环境和模型结构没问题，再根据需求切换到其他加载方式。如果你在离线环境或者网络受限的机器上跑，可以提前把 mnist.npz 文件下载好，放到 ~/.keras/datasets/ 目录下，Keras 会自动识别。

# 方式一：Keras 内置接口 from tensorflow.keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() # 方式二：sklearn 接口 from sklearn.datasets import fetch_openml mnist_sk = fetch_openml('mnist_784', version=1, as_frame=False) X, y = mnist_sk.data, mnist_sk.target.astype(int) # 方式三：直接读取 IDX 文件（需要提前下载好四个文件） import struct import numpy as np def read_idx_images(filename): with open(filename, 'rb') as f: magic, num, rows, cols = struct.unpack('>IIII', f.read(16)) images = np.frombuffer(f.read(), dtype=np.uint8).reshape(num, rows, cols) return images def read_idx_labels(filename): with open(filename, 'rb') as f: magic, num = struct.unpack('>II', f.read(8)) labels = np.frombuffer(f.read(), dtype=np.uint8) return labels

Keras 接口返回的 x_train 形状是 (60000, 28, 28)，y_train 是 (60000,)，取值 0 到 9。sklearn 接口返回的 X 是 (70000, 784)，y 是字符串类型的标签，需要转成整数。IDX 文件读取需要自己解析二进制头，适合对数据加载有完全控制需求的场景。

3.2 预处理里最容易被忽略的三个参数

预处理对最终准确率的影响，在模板匹配和 KNN 上尤其明显。有三个参数经常被忽略：归一化方式、是否居中、以及是否做数据增强。

归一化方式有两种常见选择：除以 255 缩放到 0-1，或者用 (x - mean) / std 做标准化。对于神经网络，0-1 归一化通常就够了。对于 SVM 和 KNN，标准化有时能带来一点提升，但差别不大。关键是保持一致：训练集和测试集必须用同样的归一化参数。

居中处理是指把数字的质心移到图片中心。MNIST 原始数据已经做过一定程度的居中，但并不是完全精确。如果你用模板匹配，建议手动做一次质心居中，能明显减少位置偏移带来的误判。做法是计算图片中所有非零像素的质心坐标，然后平移图片使质心落在 (14, 14) 附近。

数据增强在 MNIST 上不是必须的，但如果你想进一步提升 CNN 的泛化能力，可以加入小幅度的旋转、平移和缩放。注意增强幅度不能太大，否则会把 6 和 9 转混。我一般用 ±10 度的旋转和 ±2 像素的平移。

import numpy as np from scipy.ndimage import shift, rotate def center_image(img): """将图片质心平移到中心""" total = img.sum() if total == 0: return img rows, cols = img.shape r_center = np.sum(img * np.arange(rows).reshape(-1, 1)) / total c_center = np.sum(img * np.arange(cols).reshape(1, -1)) / total shift_r = rows / 2 - r_center shift_c = cols / 2 - c_center return shift(img, [shift_r, shift_c], cval=0) def augment_image(img): """随机旋转和平移""" angle = np.random.uniform(-10, 10) rotated = rotate(img, angle, reshape=False, cval=0) shifted = shift(rotated, [np.random.uniform(-2, 2), np.random.uniform(-2, 2)], cval=0) return shifted

center_image 函数计算非零像素的质心，然后平移使质心落在图片中心。augment_image 先随机旋转 ±10 度，再随机平移 ±2 像素。这两个函数可以组合使用：先居中，再增强。注意增强只在训练时做，测试集不能增强。

3.3 训练环境的最小依赖和版本兼容性

跑通这三种方法，需要的核心依赖是 numpy、tensorflow（或 pytorch）、scikit-learn、scipy。如果你只用 KNN 和 SVM，可以只装 numpy 和 scikit-learn。模板匹配只需要 numpy。CNN 需要 tensorflow 或 pytorch。

版本兼容性方面，tensorflow 2.x 和 numpy 的版本对应关系需要注意。tensorflow 2.10 之前对 numpy 1.x 支持较好，2.10 之后开始支持 numpy 2.x。如果你遇到 "numpy.ndarray size changed" 之类的报错，通常是版本不匹配导致的。最稳妥的做法是用虚拟环境，先装 tensorflow，再让它自动拉取兼容的 numpy 版本。

# 创建虚拟环境 python -m venv mnist_env source mnist_env/bin/activate # Linux/Mac # mnist_env\Scripts\activate # Windows # 安装核心依赖 pip install tensorflow scikit-learn scipy matplotlib # 验证安装 python -c "import tensorflow as tf; print(tf.__version__)" python -c "import sklearn; print(sklearn.__version__)"

虚拟环境能避免不同项目之间的依赖冲突。tensorflow 会自动安装兼容的 numpy 版本，不需要手动指定。scipy 用于图像平移和旋转，matplotlib 用于可视化中间结果。如果你用 GPU 训练，还需要装 CUDA 和 cuDNN，但 MNIST 的规模用 CPU 就够了，GPU 不是必须的。

4. 避坑与排查：跑 MNIST 时最容易翻车的五个地方

4.1 准确率卡在 10% 不动

现象：训练时 loss 不下降，准确率始终在 10% 左右，相当于随机猜测。

原因：最常见的是标签和图片没有对齐。比如你用了 sklearn 的 fetch_openml，返回的 X 是 (70000, 784)，y 是字符串标签，如果你没有把 y 转成整数，或者没有把 X reshape 成 (70000, 28, 28)，后续的模型输入就会错位。另一个可能是归一化时用了错误的轴，比如对每张图做了全局归一化而不是逐像素归一化。

解决：先打印 x_train[0] 的形状和 y_train[0] 的值，确认数据格式正确。然后检查归一化后的像素值范围是否在 0-1 之间。如果用的是 sklearn 接口，记得 y = y.astype(int)，X = X.reshape(-1, 28, 28)。

4.2 CNN 训练时 loss 变成 NaN

现象：训练几个 batch 后，loss 突然变成 NaN，准确率崩掉。

原因：学习率太大是最常见的原因。Adam 默认学习率 0.001 在 MNIST 上通常没问题，但如果你手动改大了，或者用了 SGD 没调学习率，就容易出现梯度爆炸。另一个可能是输入数据没有归一化，像素值 0-255 直接输入，导致梯度太大。

解决：先把输入归一化到 0-1。如果已经归一化了，把学习率降到 0.0001 试试。还可以加梯度裁剪，在 compile 时设置 clipnorm=1.0。如果用的是自定义训练循环，检查 loss 计算是否有除零操作。

4.3 模板匹配准确率远低于预期

现象：模板匹配跑出来只有 60% 多，比理论值低很多。

原因：模板匹配对位置极其敏感。如果训练图和测试图的数字位置不一致，像素级距离会非常大。MNIST 原始数据虽然做过居中，但不同书写风格的数字质心位置仍有差异。另一个可能是你没有做二值化，灰度图的背景噪声干扰了距离计算。

解决：在计算模板之前，先对每张图做质心居中。然后对图片做二值化，把大于某个阈值的像素设为 1，其余设为 0。阈值可以取 0.5 或者用 Otsu 方法自动确定。居中加二值化之后，模板匹配的准确率通常能回到 75% 以上。

4.4 KNN 预测速度慢到无法接受

现象：KNN 在测试集上跑一次要十几分钟甚至更久。

原因：KNN 预测时需要计算测试样本与所有训练样本的距离。60000 个训练样本，每个 784 维，10000 个测试样本，计算量是 60000 × 10000 × 784，非常大。如果你没有做降维，计算量会直接拖垮预测速度。

解决：用 PCA 降到 50 维左右，计算量能减少 90% 以上。还可以用 KDTree 或 BallTree 加速最近邻搜索，sklearn 的 KNeighborsClassifier 支持 algorithm='kd_tree' 参数。如果还是慢，可以考虑对训练集做抽样，比如只用 10000 个训练样本，准确率下降不多但速度提升明显。

4.5 测试集准确率远低于训练集

现象：训练集准确率 99%，测试集只有 95% 甚至更低。

原因：过拟合。MNIST 虽然简单，但如果模型参数量太大或者训练轮数太多，仍然会过拟合。另一个可能是数据泄露：你在预处理时用了全部数据计算均值和方差，然后才划分训练集和测试集。正确的做法是先划分，再分别计算预处理参数。

解决：加 Dropout 层，或者用早停（EarlyStopping）在验证集 loss 不再下降时停止训练。数据增强也能缓解过拟合。如果是预处理导致的数据泄露，确保归一化参数只从训练集计算，然后应用到测试集。

5. 从跑通到跑好：三种方法的对比验证与一个实用技巧

三种方法都跑通之后，你需要一个统一的验证框架来对比它们。我一般会固定一个测试集划分，然后记录每个方法的准确率、训练时间、预测时间和模型大小。准确率不是唯一指标，训练时间在快速迭代时很重要，预测时间在部署时很重要，模型大小在嵌入式场景下很重要。

这个表格里的数字是大致范围，具体取决于预处理和参数调优。模板匹配的模型大小就是 10 个 28×28 的模板，非常小，但准确率也最低。KNN 需要保存整个训练集，模型大小等于训练集大小，预测时要遍历所有样本。SVM 只保存支持向量，模型大小介于 KNN 和神经网络之间。神经网络模型大小取决于参数量，全连接网络大概几 MB，CNN 也差不多。

一个实用技巧是：用 CNN 的中间层特征来提升 KNN 和 SVM 的表现。具体做法是，先训练一个 CNN，然后取倒数第二层（全连接层之前的那层）的输出作为特征，再用这些特征训练 KNN 或 SVM。这样做的原因是，CNN 学到的特征比原始像素更有判别力，而 KNN 和 SVM 在小样本或者需要快速更新的场景下比 CNN 更灵活。

# 假设已经训练好了一个 CNN 模型 model # 取倒数第二层的输出作为特征 feature_extractor = models.Model( inputs=model.input, outputs=model.layers[-3].output # 倒数第三层通常是全连接层 ) # 提取训练集和测试集的特征 train_features = feature_extractor.predict(x_train_cnn) test_features = feature_extractor.predict(x_test_cnn) # 用 CNN 特征训练 SVM svm_on_cnn = SVC(kernel='rbf', C=10.0, gamma='scale') svm_on_cnn.fit(train_features, y_train) svm_pred = svm_on_cnn.predict(test_features) print(f"SVM on CNN features 准确率: {accuracy_score(y_test, svm_pred) * 100:.2f}%")

这个技巧的关键是选对层。倒数第二层通常是全连接层，维度是 128 或 256，比原始 784 维更紧凑，同时保留了 CNN 学到的判别信息。用这些特征训练 SVM，准确率通常能接近甚至超过直接用 CNN 分类，而且 SVM 的训练和更新比重新训练 CNN 快得多。如果你需要在生产环境中快速迭代模型，这个组合很实用。

我自己跑 MNIST 最大的教训是：不要一上来就追求 99% 的准确率。先把模板匹配跑通，理解相似度度量的含义；再跑 KNN 和 SVM，理解特征和分类器的关系；最后跑 CNN，理解端到端学习的优势。每一步都手动改几个参数，观察准确率的变化。这样走一遍，比直接复制一个 99% 的 CNN 代码收获大得多。希望帮到你。

本文还有配套的精品资源，点击获取