手写拼音识别实战：基于CRNN+CTC的Python完整方案

简介：作为面向Python学习者与课程设计场景的手写拼音识别项目资源，核心基于KNN最近邻分类算法，实现对手写拼音字符的自动分类识别。资源内含设计报告Word文档、完整源码与配套数据，适合机器学习入门、模式识别课程实验、毕业设计或课程答辩前的快速准备。包体共2589个文件，其中txt特征文本1649个、jpg手写样本图片924个、Python脚本4个，另有xml、png及docx等辅助文件，整体压缩包约1.79MB；数据集与代码组织清晰，txt多用于存储特征向量，jpg为标注样本，py实现距离计算与邻居投票流程，docx为设计报告正文，整体数据规模适中，便于对照阅读和完整跑通流程。目前已有170人下载学习，通过源码和报告可系统理解KNN分类原理、特征处理与结果评估的完整链路，也能借完整数据快速复现实验，配合设计报告中的实验分析与结论，是课程设计与算法入门的高性价比实践型资料。

1. 手写拼音识别：Python 生态里最难抄的“小项目”

手写拼音识别这个名字听起来像是个“把字母认出来”的分类任务，真正用 Python 动手做一次才发现，难点根本不在模型，而在数据和序列对齐上。手写拼音不是印刷体，p 写得像 q、n 写得像 h，整个拼音串的字母之间又是连在一起的，先切字母再分类的第一刀就会翻车。基于 Python 的常规落地路线是 CRNN 加 CTC：不切分字符，直接从整行手写图像里读出“zhong”“xie”这类拼音文本。这个方向能解决拼音学习 App、智能写字板原型里的输入问题，也是课程设计和毕业设计里性价比很高的一道题。先给个反直觉的结论：网络结构照抄就能用，真正决定项目能不能跑通的是数据生成和标签编码。

2. 数据先行：用脚本把手写拼音样本“造”出来再对齐标签

手写拼音识别和汉字识别最大的差别在于，拼音是由 26 个拉丁字母组成的短序列，单独拆开每个字母没有语义，标注时也拿不到可靠的字符框。公开 OCR 数据集里大多是印刷体英文，或者 EMNIST 这种单字母手写集，和“整词手写拼音”的任务分布差得很远。常见做法是绕开公开数据集，先用 Python 脚本合成一批高度仿真手写的拼音图像，跑通训练流程后，再用手写样本微调。这一步决定模型上限，值得多花时间。

2.1 为什么不能用现成 OCR 数据集，要先建拼音字符集

拼音的词表是可以枚举的：由声母韵母组合而成，常用合法拼音大概在 400 个左右，远小于汉字集，也小于英文单词集。基于 Python 生成数据时，最自然的方式是用 pypinyin 库从常用汉字反推拼音，既能保证标签是合法拼音，又能模拟真实使用频率。合成数据的好处是标签天然准确，不用人工标注，可以按需生成任意规模，出问题时还能定向补充难例。

对比一下直接用现成数据集的代价：找英文手写单词集，字母分布和拼音不一致，比如拼音里大量出现 zh、ch、sh 这种双字母声母，英文里没有；找中文手写汉字集，标签是汉字而不是拼音，还得再转一层。合成数据冷启动之后，再拿真手写样本微调，这是当前最容易复制落地的手写拼音数据方案。

先建好字符集，后续所有训练和推理都围绕这套字符集展开：

2.2 用 Python 生成第一批手写拼音训练图

下面这段脚本是合成数据的核心：从常用汉字反推拼音列表，再用 PIL 渲染成灰度高对比度图像。先不要加太多随机扰动，第一版数据干净一点，方便排查问题。

import random from PIL import Image, ImageDraw, ImageFont from pypinyin import lazy_pinyin # 常用汉字表，这里只截取片段，实际可以读入常用字库 common_chars = "的一是不了在人有和这中大为上个国我以要他时来用们生到作地于出就分对成会可主发年动同工也能下过子说产种面而方后多定行学法所民得经十三之进着等部度家电力里如水化高自二理起小物现实加量都两体制机当使点从业本去把性好应开它合还因由其些然前外天政四日那社义事平形相全表间样与关各重新线内数正心反你明看原又么利比或但质气第向道命此变条只没结解问意建月公无系军很情者最立代想已通并提直题党程展五果料象员革位入常文总次品式活设及管特件长求老头基资边流路级少图山统接知较将组见计别她手角期根论运农指几九区强放决西被干做必战先回则任取据手觉际白何" pinyin_set = sorted(set(lazy_pinyin(common_chars))) def synth_one(font_path, out_size=(160, 64)): text = random.choice(pinyin_set) # 灰度图，白底黑字，单通道节省显存 img = Image.new("L", out_size, 255) draw = ImageDraw.Draw(img) # 字号随机，模拟手写大小不稳定 font = ImageFont.truetype(font_path, size=random.randint(36, 52)) # 随机落笔位置，让模型不依赖绝对坐标 x = random.randint(-10, 20) y = random.randint(0, 12) draw.text((x, y), text, font=font, fill=0) return img, text

这段代码里有两个参数直接影响识别效果：字号随机范围 36-52，对应不同粗细笔迹；落笔偏移 x 范围 -10 到 20，是为了让字母不总在正中间。字符集里的第 0 位必须是 blank，这个位置索引和第 3 章的 CTCLoss 参数直接绑定，后面不会再改。

生成完之后，把每一张图片按train/images/0001.png命名，并在train/labels.txt里写一行“图片路径\t拼音”，用 tab 分隔。合成脚本和数据目录结构保持简单，后面 DataLoader 直接读这个文件。

2.3 数据增强三件套：仿射、噪声和笔画重构

合成字体再怎么选，还是比真实手写干净，直接拿去训练会出现“训练集 99%，真实手写 50%”的典型落差。下面三个增强必须加，缺一个后面都得补课。

import numpy as np from PIL import Image, ImageOps def augment(img: Image.Image) -> Image.Image: angle = np.random.uniform(-25, 25) img = img.rotate(angle, resample=Image.BICUBIC, fillcolor=255) arr = np.array(img).astype(np.float32) # 高斯噪声，模拟纸面颗粒和扫描纹理 arr += np.random.normal(0, 10, arr.shape) # 轻微模糊，削弱合成字体的锐利边缘 arr = np.clip(arr, 0, 255) img = Image.fromarray(arr.astype(np.uint8)) return img

旋转角度 ±25 度比常规 OCR 任务大，因为真实手写倾斜幅度很夸张；高斯噪声标准差 10 是经验值，太小没效果，太大会让合成图失真。模糊可以直接用ImageFilter.GaussianBlur(0.5)，或者依靠噪声叠加来实现。第三个增强是笔画粗细仿真，可以用 Pillow 的ImageOps.expand配合形态学操作，但最简单的替代方案是混用不同字体：圆珠笔手写体和钢笔手写体本身粗细就差很多，字体混合比像素级膨胀腐蚀更省事、更自然。

训练顺序也有讲究：先不加增强训到 loss 降下来，再加增强拉一轮，最后混入真实手写图微调。一套跑下来，模型的泛化能力和出问题时的可排查性都比一次性全上要强。

3. 模型选型：CRNN + CTC 是手写拼音识别的最短路径

数据准备好之后，模型结构其实没有太多悬念。手写拼音是一个典型的“图像到序列”任务，模型输出的是不定长字母串。真正要在训练和部署之间权衡的，是选 CRNN、纯 CNN 分类还是 Transformer。

3.1 拼音识别到底该用 CNN、Transformer 还是 CRNN

三种方案的取舍非常清晰：

纯 CNN 分类的思路是把整张图直接分成“zhou / xie / xue”这种类别，看似简单，但手写连笔让同一个拼音在不同样本里形态差异很大，而且遇到训练集里没有的词表组合就彻底失效。Transformer 方案在长文本识别上确实强，但对 2-6 个字母的短序列来说属于杀鸡用牛刀，小数据集上容易过拟合，部署时的序列解码也比 CTC 复杂。

CRNN 加 CTC 的组合最贴合这个任务：CRNN 负责从图像里提取序列特征，CTC 负责把不定长的特征序列对齐到拼音标签，整个模型不需要任何字符级切分，训练和推理都干净。

3.2 用 PyTorch 实现 CRNN：卷积层、双向 LSTM 与 CTC 头

下面是一个可以直接跑通的 CRNN 最小实现。输入固定为灰度图(B, 1, 64, 160)，输出是(B, 40, 27)，其中 40 是图像宽度方向压缩出来的时间步，27 是 26 个字母加 1 个 blank。

import torch import torch.nn as nn class CRNN(nn.Module): def __init__(self, n_classes=27): super().__init__() self.cnn = nn.Sequential( nn.Conv2d(1, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), # 高度 64 -> 32，宽度 160 -> 80 nn.Conv2d(64, 128, 3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), # 高度 32 -> 16，宽度 80 -> 40 nn.Conv2d(128, 256, 3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.MaxPool2d((2, 1), (2, 1)), # 只在高度上池化，宽度保持 40 ) # 经过 CNN 后特征图是 (B, 256, 8, 40)，每个时间步展平成 256*8=2048 维 self.lstm = nn.LSTM(2048, 256, num_layers=2, bidirectional=True, batch_first=True) # 双向 LSTM 输出维度是 256*2=512 self.fc = nn.Linear(512, n_classes) def forward(self, x): # x: (B, 1, 64, 160) x = self.cnn(x) # (B, 256, 8, 40) b, c, h, w = x.shape x = x.permute(0, 3, 1, 2).reshape(b, w, c * h) # (B, 40, 2048) x, _ = self.lstm(x) # (B, 40, 512) return self.fc(x) # (B, 40, 27)

CNN 部分最后那个MaxPool2d((2, 1))是关键：它只在高度方向压缩、保留宽度方向的序列长度。如果把宽度也池化到 20 或者更小，2-4 个字母的拼音可能只剩 20 帧，CTC 对齐空间不足，识别会变差。LSTM 输入维度 2048 来自256*8，如果改了 CNN 结构，这里必须同步调整。双向 LSTM 的 hidden size 256，双向后输出 512，再映射到 27 个类别。

batch_first=True让 LSTM 接受(B, T, C)输入，省去在 forward 里来回 permute。最后fc输出的第 0 类就是 blank。

3.3 训练参数：blank、batch、学习率和 epoch 怎么定

CTC Loss 对输入格式非常敏感，90% 的训练问题出在这一步。PyTorch 的nn.CTCLoss要求 log_probs 的维度是(T, B, C)，而且 target 是一个不定长的 list，不是补齐后的二维矩阵。

import torch.nn.functional as F criterion = torch.nn.CTCLoss(blank=0) # model(images) 输出 (B, T, C)，转成 (T, B, C) log_probs = F.log_softmax(model(images).permute(1, 0, 2), dim=2) loss = criterion( log_probs, targets, # list of LongTensor，每个长度不等 torch.full((batch_size,), 40, dtype=torch.long), # 固定输入宽度，T 恒为 40 target_lengths, # 每个样本的拼音字母长度 )

训练参数建议直接照抄下面这张表，跑通后再调：

排查训练问题时，第一个动作是打印targets的 min 和 max，确认没有越界索引；第二个动作是打印model(images).shape，确认 T 确实是 40。PyTorch 的 CTC 不会因为你传错维度就报错，它只会默默算出一个错误结果，这地方只能靠人工检查。

4. 训练与部署：把 PyTorch 模型导出成可用的推理服务

训练脚本能跑出 loss 只是第一步，真正能交出去的是一段可以脱离训练环境运行的推理代码。这一章从标签编码讲到 TorchScript 导出，全部围绕“一个模型文件 + 一个推理类”来落。

4.1 标签编码和 DataLoader：处理好不定长序列

拼音标签是长度不等的字符串，CTC 要求 target 是一个 list，里面每个元素是对应样本的 LongTensor，不能 padding 成矩阵。DataLoader 里注意不要写复杂的 collate_fn，保持 targets 是 list 原样传出就行。

import torch from torch.utils.data import Dataset class PinyinDataset(Dataset): def __init__(self, img_paths, labels): self.img_paths = img_paths self.labels = labels self.chars = "_abcdefghijklmnopqrstuvwxyz" self.char2idx = {ch: i for i, ch in enumerate(self.chars)} def __len__(self): return len(self.img_paths) def encode(self, label): # 拼音字母都是小写，直接查表 return [self.char2idx[ch] for ch in label] def __getitem__(self, idx): img = load_image(self.img_paths[idx]) # 返回 (1, 64, 160) 的 tensor target = torch.tensor(self.encode(self.labels[idx]), dtype=torch.long) return img, target, self.labels[idx]

这里字符集和 2.2 节保持一致，第 0 位是_也就是 blank。如果字符集改了顺序，模型的输出维度和解码逻辑全都要跟着改，所以一开始就要定死。先把 label 的原始字符串也返回出来，是为了训练过程中打印样本对比预测结果。数据读取部分要特别注意图像预处理和训练时完全一致：灰度、resize 到(64, 160)、像素值除以 255。

这个阶段如果发现跑不起来，先检查 Python 解释器有没有切对。很多人图省事直接在全局环境里 pip install torch，最后 import 都走错环境，这种问题最难查也最不该浪费时间去查。

4.2 导出 TorchScript：固定宽度才能 trace

模型训练完成后，用torch.jit.trace导出。CRNN 结构本身适合 trace，但前提是模型 forward 里没有pack_padded_sequence，也没有依赖数据的 if 分支。

model.load_state_dict(torch.load("best.pth", map_location="cpu")) model.eval() example_input = torch.randn(1, 1, 64, 160) scripted = torch.jit.trace(model, example_input) scripted.save("pinyin.pt")

导出前先eval()是血泪教训：不切 eval，BatchNorm 的 running_mean 还在更新，导出的模型在推理时行为会漂移。example_input 必须是(1, 1, 64, 160)，和训练时完全一致的尺寸；输入宽度一旦不同，time step T 就不同，LSTM 能跑但输出长度对不上。有些项目训练时用可变宽度，到导出时才固定，结果 trace 出来的模型效果和训练时不一致，原因就是训练推理尺寸不一致。

如果想要更短的推理耗时，可以在 trace 后打开scripted.eval()，再用torch.no_grad()包一层测试。常见优化是把 LSTM 换成torch.jit.optimize_for_inference，但先别急着优化，等精度确认没问题再做。

4.3 推理封装：预处理、模型和解码拼成一个类

导出后的模型本身只是“特征到字符概率”的计算器，还要配上预处理和 CTC 解码才能用。下面这个类可以直接拿去做接口层。

import numpy as np import torch from PIL import Image class PinyinRecognizer: def __init__(self, pt_path): self.model = torch.jit.load(pt_path, map_location="cpu") self.model.eval() self.chars = "_abcdefghijklmnopqrstuvwxyz" def preprocess(self, img: Image.Image) -> torch.Tensor: img = img.convert("L").resize((160, 64)) arr = np.array(img, dtype=np.float32) / 255.0 return torch.from_numpy(arr).unsqueeze(0).unsqueeze(0) def decode(self, log_probs: torch.Tensor) -> str: # log_probs: (B, T, C)，取每帧最大概率的类别 pred = log_probs.argmax(dim=1).squeeze(0).tolist() result = [] prev = -1 for idx in pred: if idx != 0 and idx != prev: # 0 是 blank，跳过 result.append(self.chars[idx]) prev = idx return "".join(result) def predict(self, img: Image.Image) -> str: x = self.preprocess(img) with torch.no_grad(): log_probs = self.model(x) return self.decode(log_probs)

decode 函数里的逻辑是 CTC 贪心解码的标准写法：连续相同字母只保留一个，blank 是分隔符。举个容易出错的反例，拼音“xue”，如果模型预测出x, x, blank, u, e，贪心解码会得到xue；但如果连续帧输出x, x, u, e而中间没有 blank，解码结果是xue还是xu e取决于模型输出结构。所以 blank 的位置和概率分布直接影响结果，训练时 blank 的初始权重不能设为零。

推理时不要在预处理里做二值化。灰度信息对笔画深浅变化很关键，二值化会把弱笔画直接抹掉。归一化保持除以 255 就好，不需要减均值除方差，因为训练时就是这么处理的。

部署文件建议按这个结构存放，方便接口层直接引用：

5. 手写拼音识别避坑手册：5 个最常见的翻车点

这一章写的是我按经验反复踩过的坑，每条都按现象、原因、解决来写。你要是训练中遇到类似问题，直接按这个顺序排查。

5.1 现象一：loss 一直是 nan，模型根本没在学

现象：训练刚开始第一个 step 就报 loss 为 nan，打印 logits 全是 nan。

原因：最常见的不是网络结构问题，而是 target 里有 -1 或者说越界的索引。比如有人习惯把空白字符编成 -1 留到后面处理，CTC 不认；还有 input_lengths 传成了原图宽度而不是模型输出时间步 T，导致 CTC 内部索引越界。第二种被忽略的原因是灰度图被当三通道处理，有些预训练模型要求三通道输入，转成 3 通道后网络统计量全错。

解决：训练循环里加断言，检查target.min() >= 0且target.max() < n_classes；打印model(x).shape和input_lengths是否一致；顺手开一下torch.set_anomaly_enabled(True)，PyTorch 会定位具体是哪个算子出现 inf。

5.2 现象二：训练集准确率 99%，手写输入一测全错

现象：合成数据测试集上几乎不犯错，但换一支笔、换一个角度写出来就完全认不出。

原因：过拟合了合成字体的纹理。合成图像边缘干净、粗细均匀，模型记住的是“这一套字体的锐利边缘”，而不是“字母的抽象形状”。这是合成数据最经典的翻车，和网络结构无关，换成 Transformer 一样会翻。

解决：增强里必须加弹性形变或随机透视，单纯旋转不够；训练时混合 3 种以上手写字体。有条件就找几块数位板或触屏设备，录 100-200 张真实手写图，放进训练集里做最后几轮的微调。这个动作带来的准确率提升比换任何网络结构都明显。

5.3 现象三：合成数据跑得好，真实手写样本崩盘

现象：合成测试集准确率 90% 以上，真实手写样本只有 50% 左右，而且错误集中在字写歪、笔画断开的样本上。

原因：真实手写和合成数据的差异不只是字体，还包括笔画不连续、写字倾斜超过 30 度、位置忽上忽下。合成增强里的旋转范围如果只开到 ±15 度，模型根本没有见过大角度的字。

解决：把旋转范围提到 ±30 度，再叠加随机透视变换。另一个关键点：真实手写样本不要在预处理阶段做二值化，灰度图对笔锋轻重的鲁棒性强得多。如果真实样本量太少，可以先把同一张图做 5-10 次随机增强，把分布撑开，再参与微调。

5.4 现象四：torch.jit.trace 报错，导出失败

现象：模型在 PyTorch 里 forward 完全正常，但一torch.jit.trace就报 “Does not support” 或者导出的模型输出形状对不上。

原因：模型里用了pack_padded_sequence。这东西在训练时可以提升 LSTM 速度，但 trace 时不支持动态序列长度；还有人的 forward 里有依赖数据的 if 分支，trace 只会记录一次走到的路径，导出后其他分支就丢了。

解决：训练阶段就别用 pack_padded_sequence，手写拼音序列长度差异不大，省下的时间有限。forward 里把 if 分支全部去掉，固定输入尺寸，CRNN 就完全可 trace。导出前再检查一遍有没有在 forward 里调用 numpy 操作，那是 PyTorch 和 TorchScript 之间最容易踩的雷。

5.5 现象五：decode 出来的拼音乱加字母，多出重复字符

现象：正确标签是 “xue”，解码结果是 “xxue” 或 “xuee”，多出来的重复字母刚好是模型输出概率最高的那一帧。

原因：CTC 贪心解码只做相邻帧合并，对连续帧里出现的瞬时高概率错误毫无抵抗力。手写拼音里 i/l/t、n/h 这类形状相近的字母，很容易在 2-3 帧里轮流出现高概率，贪心解码就被带偏了。

解决：把贪心解码换成 beam search，保留下 top3 候选路径。拿到候选后，再用合法拼音表过滤一遍，输出里必须是合法声韵母组合才显示。这一步是纯解码优化，不碰网络权重，就能把整体准确率提升几个点，属于性价比最高的后处理。

6. 验证与进阶：用混淆矩阵压准确率，再谈落地的边界

6.1 混淆矩阵和错误样本回看

测试阶段不要只盯着整体准确率。把测试集里每个字母级别的预测结果收集起来，画一张混淆矩阵，你会立刻看到问题集中在哪几个字母对上。

from sklearn.metrics import confusion_matrix import numpy as np y_true = [] # 每个字母的真实标签 y_pred = [] # 每个字母的预测标签 for image, target, text in test_dataset: pred = recognizer.predict(image) for a, b in zip(text, pred): y_true.append(a) y_pred.append(b) labels = list("abcdefghijklmnopqrstuvwxyz") cm = confusion_matrix(y_true, y_pred, labels=labels)

重点看对角线之外的密集格。手写拼音的典型难点是 i/l/t 三个字母互相打架、n/h 混淆、u/v 在连笔场景下分不清。这些位置如果密集，就回去补对应字母的合成数据和真实样本，而不是改网络。拿错误样本直接回看，比任何指标都有说服力。

6.2 拼音到词语的后处理：让模型输出更“像话”

识别出拼音串之后，很多上游应用还要把拼音转成汉字词语。常见做法是用 pypinyin 反查表，把 beam search 的 topk 候选和词表匹配。比如模型输出 “xue”，即使置信度不高，只要 top3 里有 “xue”，结合词表筛出“学、雪、血”三个候选，用户就能二次选择。这个后处理不改网络结构，完全是一层装饰器，对产品体验提升很明显。

最后说一个我的习惯：测模型时永远留一份“完全没见过”的真实手写样本，而且这份样本要一直留在 Docker 外面，不进训练集。每次模型改完，跑一遍回归测试，看看有没有把之前能认的样本弄坏。我做这个项目最大的教训是不要先调模型，先调数据和解码策略。合成数据只是起点，真实手写样本哪怕只有一两百张，混进去微调带来的提升比换任何网络结构都大。希望帮到你。

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