基于Spark中文手写数字识别：HOG特征与逻辑回归完整实践

简介：一套面向计算机专业毕业设计、课程设计及大数据实训场景的中文手写数字实时识别系统，基于Hadoop与Spark框架构建，完整覆盖数据预处理、特征提取、模型训练与实时识别流程，适合在校学生、高校老师及程序员参考学习或二次开发。压缩包共18个文件，包含12个Python脚本、2个PDF实验方案报告、2个MP4演示视频和2个TXT说明文档，整体大小25.79MB，目录结构清晰，便于按模块查阅。源码提供RDD与DataFrame两种Spark实现，并给出基于Sklearn的对比模型，同时配套特征工程与可视化分析脚本；实验方案PDF详述系统设计，演示视频直观呈现识别效果，说明文档还特别提示项目路径不能含中文等易错点，能帮助用户快速跑通并理解项目。目前已有146人学习下载，难度适中，是完成课设、毕设或日常练手的可靠参考。

1. 一个必须跑在 Hadoop 上的手写数字识别，到底在解决什么

单机跑 MNIST 用 sklearn 几十行就能拿到 97% 准确率，大数据课程设计如果只是换成本地 Python 脚本，根本体现不出 Hadoop 和 Spark 的价值。这套资源把中文手写数字识别硬是塞进了分布式环境：图片批量上传到 HDFS，Spark 并行读取并提取 HOG 特征，再用逻辑回归训练多分类模型，从存储、特征工程到模型评估，整条链路都跑在 Hadoop 生态里。对于正在做大数据毕业设计、数据科学与大数据技术专业课设的人，它比单纯调库多出两个关键点：一是真正执行了 spark-submit 到 YARN 的完整提交流程；二是同一份数据分别用 RDD 手写梯度下降和 MLlib 的 DataFrame API 训练，能直观看出两种写法的性能差异。源码解压后按实验报告跑一遍，基本能把分布式的入门套路摸透。

2. HDFS 上的图像数据怎么变成分布式特征：HOG 与 RDD/DataFrame 选型

2.1 数据集组织与标签映射

中文手写数字识别通常指识别“零、一、二、三、四、五、六、七、八、九”这十个汉字，而不是阿拉伯数字。汉字的笔画结构比 MNIST 更复杂，直接用原始像素做逻辑回归很容易欠拟合，所以要先手工抽特征。数据集在 HDFS 上按类别建目录，每个目录下放同类别的图像，目录名建议用0到9而不是中文，避免 Spark 读取时遇到编码问题。

路径设计上把标签放在倒数第二级，这样在 Spark 里解析路径时直接取path.split("/")[-2]就能得到 label。实验报告里会建议你先把本地准备好的图像用hdfs dfs -put传到这个目录，然后再写特征提取脚本。注意项目根目录和解压后的路径都不要出现中文，这套资源在 Windows 上解压后尤其容易踩这个坑。

2.2 HOG 特征为什么适合中文手写数字

HOG（Histogram of Oriented Gradients）统计图像局部区域的梯度方向直方图，对笔画边缘的方向分布非常敏感，中文数字笔画相对规整，HOG 能抓住轮廓和结构信息，而且对光照、粗细变化不敏感。常见参数组合是：图像 resize 到 64x64，orientations=9，pixels_per_cell=(8,8)，cells_per_block=(2,2)。

这样算下来：64x64 图像被分成 8x8 个 cell，每个 block 包含 2x2 个 cell，横向纵向滑动后产生 7x7 个 block，每个 block 的特征维度是 4 cells × 9 bins = 36 维，最终特征向量为 49 × 36 = 1764 维。这个维度对逻辑回归来说不算高，又不至于丢失结构信息。

2.3 feature_hog.py：在 Spark 里并行提取 HOG 特征

资源里的feature_hog.py本质上是一个 Spark 作业。先用sc.textFile读入一个包含所有图片路径的文件，再通过map把每张图片的 HOG 特征提取任务分发到 executor 上。代码如下：

# feature_hog.py import numpy as np from pyspark import SparkContext, SparkConf from skimage.io import imread from skimage.color import rgb2gray from skimage.transform import resize from skimage.feature import hog def extract_hog_from_file(path): # 每张图在 executor 节点上单独读取 img = imread(path) if img.ndim == 3: img = rgb2gray(img) img = resize(img, (64, 64), anti_aliasing=True, mode='reflect') feat = hog(img, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), block_norm='L2-Hys') return feat def parse_label(path): # HDFS 路径形如 /user/hadoop/recog_data/3/xxx.jpg return int(path.split("/")[-2]) def to_libsvm(label_feat): label, feat = label_feat # 转成 libsvm 稀疏格式：label idx:value idx:value ... items = " ".join(f"{i}:{v:.6f}" for i, v in enumerate(feat)) return f"{label} {items}" conf = SparkConf().setAppName("feature_hog") sc = SparkContext(conf=conf) img_paths = sc.textFile("hdfs:///user/hadoop/img_paths.txt") samples = img_paths.map(lambda p: (parse_label(p), extract_hog_from_file(p))) samples.map(to_libsvm).saveAsTextFile("hdfs:///user/hadoop/hog_features/libsvm.txt")

逻辑说明：extract_hog_from_file把图片统一转灰度并 resize 到 64x64，然后调用skimage.feature.hog返回一维特征向量；parse_label从路径倒数第二层目录提取标签；to_libsvm把特征向量序列化成 libsvm 文本格式，这是后续 Spark 读取训练数据的标准输入。

参数说明：orientations=9表示梯度方向分成 9 个 bin；pixels_per_cell=(8,8)决定 cell 的大小；cells_per_block=(2,2)决定 block 归一化的范围；block_norm='L2-Hys'是局部直方图归一化方式，能降低光照影响。如果你图像质量比较差，可以调大orientations到 12 或 18，但特征维度会相应增加，训练耗时也会上升。

3. 逻辑回归从手写梯度下降到 MLlib：rdd_logistic.py 与 df_logistic.py

3.1 逻辑回归的目标函数与分布式迭代

逻辑回归本身是一个凸优化问题，给定样本 ( (x_i, y_i) )，多分类场景下通常是 softmax 回归，目标函数是交叉熵加上正则项。分布式训练的思路很简单：每一轮迭代把当前权重广播到所有 executor，各节点计算本地梯度，然后聚合到 driver 端更新权重。这就是 RDD 版本的核心逻辑，也是理解 Spark 通信开销很好的例子。

3.2 用 RDD 手写梯度下降

rdd_logistic.py不依赖 MLlib 分类器，而是手动实现梯度下降。这样做的目的是看清楚分布式计算的 map 和 reduce 过程。关键代码片段如下：

# rdd_logistic.py import numpy as np from pyspark import SparkContext num_features = 1764 num_classes = 10 iterations = 50 alpha = 0.1 def parse_vector(line): parts = line.split() label = float(parts[0]) feat = np.zeros(num_features) for item in parts[1:]: idx, val = item.split(":") feat[int(idx)] = float(val) return label, feat def softmax(z): # 减去最大值避免指数溢出 e = np.exp(z - np.max(z)) return e / np.sum(e) def compute_grad(label_feat, w): label, feat = label_feat score = w @ feat p = softmax(score) y_vec = np.zeros(num_classes) y_vec[int(label)] = 1.0 return np.outer(p - y_vec, feat) sc = SparkContext() data = sc.textFile("hdfs:///user/hadoop/hog_features/libsvm.txt") \ .map(parse_vector).repartition(4) w = np.zeros((num_classes, num_features)) for it in range(iterations): bc_w = sc.broadcast(w) grads = data.map(lambda lf: compute_grad(lf, bc_w.value)) \ .reduce(lambda a, b: a + b) w -= alpha * grads bc_w.destroy()

逻辑说明：每一轮迭代都先broadcast当前权重，让所有 executor 持有一份权重副本；然后map阶段每个分区内的样本独立计算梯度矩阵，reduce阶段把所有分区的梯度逐元素相加，得到全局梯度；最后在 driver 端用梯度下降公式更新权重。bc_w.destroy()是主动释放广播变量，避免每次迭代都累积无用的广播数据。

参数说明：alpha=0.1是学习率，太大会导致损失震荡，太小收敛过慢；iterations=50是轮数，实际跑的时候建议同时输出 loss，观察是否收敛。这个原生实现没有加正则项，如果训练集比较小，很容易过拟合，可以在梯度里加上reg * w作为 L2 惩罚。

3.3 用 DataFrame + MLlib 一行训练

df_logistic.py走的是 Spark MLlib 的标准流程。先用spark.read.format("libsvm")读入文本，再交给LogisticRegression去训练。代码简洁很多：

# df_logistic.py from pyspark.sql import SparkSession from pyspark.ml.classification import LogisticRegression from pyspark.ml.evaluation import MulticlassClassificationEvaluator spark = SparkSession.builder.appName("df_logistic").getOrCreate() train = spark.read.format("libsvm").load("hdfs:///user/hadoop/hog_features/train.libsvm") test = spark.read.format("libsvm").load("hdfs:///user/hadoop/hog_features/test.libsvm") lr = LogisticRegression(maxIter=50, regParam=0.1, family="multinomial", elasticNetParam=0.0) model = lr.fit(train) pred = model.transform(test) evaluator = MulticlassClassificationEvaluator( labelCol="label", predictionCol="prediction", metricName="accuracy") acc = evaluator.evaluate(pred) print("test accuracy:", acc)

逻辑说明：read.format("libsvm")会自动解析前面生成的label idx:value文本，不需要手动写解析函数；fit内部完成了特征标准化、权重初始化和迭代优化；transform输出预测结果列，MulticlassClassificationEvaluator计算准确率。

参数说明：maxIter=50是最大迭代次数；regParam=0.1是正则化系数，值越大模型越简单；elasticNetParam=0.0表示纯 L2 正则，如果设为 1.0 则是 L1；family="multinomial"指定使用多分类 softmax 模型。实际使用中，RDD 版本和 DataFrame 版本最终准确率基本一致，但 DataFrame 版本代码少了三分之一，执行效率也更高。

4. 提交到 YARN 运行：spark-submit 参数、运行模式与常见坑

4.1 spark-submit 命令模板

不管跑feature_hog.py还是df_logistic.py，最终都要通过spark-submit提交到集群。最常见的模式是--master yarn --deploy-mode client，这样 driver 跑在客户端，日志直接打在终端，方便调试。完整命令如下：

spark-submit \ --master yarn \ --deploy-mode client \ --name handwrite-recog \ --num-executors 4 \ --executor-cores 2 \ --executor-memory 4g \ --driver-memory 2g \ --conf spark.yarn.executor.memoryOverhead=512m \ --conf spark.sql.shuffle.partitions=200 \ df_logistic.py

逻辑说明：--num-executors指定申请多少个 executor 容器；--executor-cores是每个 executor 上的 CPU 核数；--executor-memory是每个 executor 的堆内内存；--conf spark.yarn.executor.memoryOverhead是给堆外内存预留的空间，跑图像特征提取时尤其要留足。后面的.py文件是实际运行的入口。

如果你在 Hadoop 伪分布式环境下测试，只需要保留一个 executor 和较小的内存，重点是确认任务能跑通HDFS -> RDD -> 训练的完整流程。如果是 spark on yarn 提交，只要客户端安装了 Spark，并且能连上 YARN 的 ResourceManager，就不需要每台节点单独装 Spark。

4.2 资源参数与并行度对照

参数说明：feature_hog.py阶段是 CPU 密集和网络 IO 密集，需要多核；df_logistic.py阶段有大量 shuffle，spark.sql.shuffle.partitions可以根据数据量调大，否则 reducer 端内存压力会很大。实验报告里给出的对照是：4 个 executor、每个 2 核、每核内存 2g 时，10000 张图特征提取约 10 分钟，训练约 1 分钟。

4.3 四个最容易遇到的坑

提示：项目路径一定不要出现中文。Windows 下解压后默认文件夹名是中文时，先重命名为纯英文，再打开实验报告里的命令。

第一个坑是skimage在 executor 上找不到。spark-submit提交的 Python 环境默认只有当前提交机器上的依赖会被分发，如果你的环境不是 Spark 自带 Python，需要加--py-files打包依赖，或者直接在每台节点上pip install scikit-image numpy。

第二个坑是 HDFS 路径的权限。saveAsTextFile到/user/hadoop/hog_features时，当前用户没有写权限会直接抛异常。最简单的办法是先hdfs dfs -mkdir -p并hdfs dfs -chmod 777该目录，或者用当前用户自己的家目录。

第三个坑是 libsvm 格式的 label 必须从 0 开始。如果你的类别编号是 1-10，而 MLlib 期望 0-9，训练会报下标越界错误。检查to_libsvm输出的第一列是不是从 0 开始的整数。

第四个坑是内存不足。compute_grad中每个样本都会产生一个(10, 1764)的梯度矩阵，如果一次 map 处理太多样本，executor 内存直接顶不住。解决方法是先repartition提高分区数，或者每个分区内部先做局部聚合再上报，相当于 mapPartitions 版本的梯度聚合。

5. 用 t-SNE 验证特征质量，再把离线模型变成实时识别

5.1 运行 tsne_plot.py 看特征分布

训练之前先确认 HOG 特征是否真的把十个类别分开了。tsne_plot.py从特征文件里随机抽 500 个样本，降维到二维后绘制散点图。代码片段如下：

import numpy as np from sklearn.manifold import TSNE import matplotlib.pyplot as plt data = np.loadtxt("features.csv", delimiter=",") X, y = data[:, 1:], data[:, 0] sample_idx = np.random.RandomState(0).choice(len(y), 500, replace=False) tsne = TSNE(n_components=2, perplexity=30, n_iter=1000, random_state=42) X_2d = tsne.fit_transform(X[sample_idx]) plt.figure(figsize=(8, 6)) plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y[sample_idx], cmap="tab10", s=10) plt.savefig("tsne.png", dpi=150)

如果图上十个颜色各自成团，说明 HOG 特征线性可分性不错，逻辑回归能学到有效边界。如果同一颜色分散成多块，就要回头调 HOG 参数或重新检查图像预处理。

5.2 从离线模型到实时识别管线的三个关键改动

资源里的演示视频展示的是“实时识别”，但代码本身是离线训练。想复现这种效果，常见做法是加一层 Spark Streaming 或 Structured Streaming。改动点有三个：

第一，模型保存与加载。训练完成后调用model.save("hdfs:///user/hadoop/model")，预测时用LogisticRegressionModel.load读进来，避免每次对新图片都重新训练。

第二，用spark.readStream监听一个目录。可以把摄像头或应用上传的图片写入 HDFS 指定目录，Streaming 作业监控新文件并自动提取 HOG 特征后预测。示例是readStream.format("text").load("hdfs:///user/hadoop/realtime_imgs").writeStream.foreachBatch(recognize).start()，每个批次处理一批新图片路径。

第三，对预测结果加去重逻辑。Streaming 作业重复触发时，同一个文件可能被处理两次。我会在图片路径上做md5去重，把已处理路径写入 Redis 或 HDFS，避免重复输出识别结果。这个细节在实际项目里比模型准确率更容易被忽略，但也最能提升体验。

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