基于YOLO+LPRNet的中文车牌识别：从数据到部署全流程解析-育师

简介：基于深度学习的高性能中文车牌识别毕设/课设项目包，面向计算机类毕业生与课程设计学生，提供一套从模型训练到系统部署的完整参考实现。项目综合运用Python、C++，覆盖图像预处理、CNN特征提取、字符识别、后处理等关键环节，并涉及OCR、CTC损失函数与NMS优化，适合动手实践深度学习落地流程。资源共179个文件，以py、cpp、h源码为主，包含MNN模型文件、Android工程、Gradle构建脚本、演示图片等，压缩包整体约32.91MB。目前已有123人学习浏览。包内提供可直接安装的APK、SDK核心源码（如hyper_lpr_sdk.cc、inference_helper_mnn.cpp）以及识别引擎、检测架构实现，同时包含数据集、训练/评估脚本和Dockerfile辅助环境配置，目录结构清晰，便于按模块阅读与二次开发，可作为毕业设计选题论证、系统设计及功能实现的直接参考。

1. 中文车牌识别：毕设 zip 里最不该省的那几步

如果你是在做毕设或课程作业，拿到一份“基于深度学习高性能中文车牌识别”的项目压缩包，第一反应多半是赶紧把训练脚本跑起来看损失曲线。但我见过太多人卡在这儿：环境配好、训练跑完、测试准确率也有 95%，一放到门口的实拍照片上就翻车。问题不在深度学习模型本身，而在数据分布、字符解码和前后处理这几件看起来不起眼的事。这篇笔记就围绕中文车牌识别整条落地链路展开，从模型选型、环境搭建、训练调参到推理部署，讲清楚每一步怎么做、参数怎么设、坑在哪，适合正拿这个方向做毕设或课程设计的同学直接照着复现。

2. 原理先行：汉字、绿牌和模糊帧，为什么中文车牌更容易翻车

2.1 车牌结构与识别难点：不止是 7 个字符

中国普通蓝牌是单行 7 个字符：第 1 位是省份汉字，第 2 位是发牌机关字母，后 5 位是大写字母和数字混合。新能源绿牌则是 8 位，第 2 位直接跟 D 或 F（D 代表纯电、F 代表混动），长度和蓝牌差一位。如果代码硬按“1 汉字 + 1 字母 + 5 位数字”解码，绿牌几乎全错。除此之外还有黄底黑字的大型车车牌、白底黑字的警车车牌，检测模型在训练时如果没见过这些颜色，推理时也会漏检。

字符集的复杂性是中文车牌区别于国外车牌的核心。省份汉字有三十多个，而且字形相近的组合特别多，比如“湘”和“鄂”、“渝”和“沪”、“赣”和“豫”，在低分辨率和强反光下，人眼都容易看错。字母侧也有坑，官方车牌字符集刻意剔除了 I 和 O，但不少公开数据集里还残留着这两个字符，模型会把数字 1 误判成 I、把 0 误判成 O。数据分布偏差则是另一道坎：公开数据集 CCPD 全部来自安徽合肥同一批摄像头，样本基本都是“皖 A”开头，拿它训练出的模型去识别外地车牌，省份汉字这一项会出现明显下滑。所以真正的高性能方案必须在数据层补足省份和车牌类型的多样性。

早期传统方案依赖边缘检测定位车牌、按固定宽度做字符分割、再用模板库匹配。这套方法在停车场出入口那种正视角、均匀光照的场景下还能用，一旦遇到模糊、倾斜或夜间反光，分割位置偏一点，后面全盘皆错。深度学习方案不需要显式分割字符，直接学习“从图像到字符串”的映射，鲁棒性高出一个量级，这也是这个方向在毕设和课程作业里经久不衰的原因。

2.2 检测 + 识别两级架构，为什么是主流

基于深度学习的车牌识别，行业落地的主流是“检测 + 识别”两级架构。第一步用目标检测模型（YOLO、SSD 这类）在整张图中框出车牌位置；第二步把裁剪出来的车牌区域缩放到固定宽高，用序列识别模型输出车牌字符串。两个模型各管一件事，检测模型只回答“车牌框在哪”，识别模型只回答“框里的字是什么”。

两级架构最大的好处是解耦。两者可以分别准备训练数据、单独调参，推理时还能在中间插入预处理步骤：用透视变换把倾斜车牌转正，再送入识别模型。这一步对识别准确率的影响，经常比换更大的模型还明显。检索车牌识别方向论文时能看到不少端到端方案，输入整张图直接输出车牌字符串，公开数据集上指标很好看，但复现成本高，且对检测框质量极度敏感——一旦车辆密集或被遮挡，整串输出就崩。毕设算力和时间都有限，我更推荐两级架构，每一步都能单独写进报告、单独画流程图，答辩时也好讲。

也有人会问，为什么不直接拿通用 OCR 来识别车牌？通用 OCR 对印刷体效果好，但车牌是特殊字体加反光材质加小尺寸，直接上 PaddleOCR 这类通用模型，准确率通常到不了 90%。车牌识别必须定制字符字典和图像预处理，专用模型才是正解。另一个常踩的误区是想自创网络结构来当“创新点”。车牌识别方向已经非常成熟，自己设计的轻量网络几乎打不过 LPRNet 这类经过大量数据验证的结构。我一般建议把创新点放在数据增强策略、后处理纠错或部署优化上，网络结构保持经典，交付更快，答辩也不容易被问倒。

2.3 高性能的瓶颈：速度与精度从哪抠

“高性能”在这类项目里通常拆成两个指标：识别准确率和推理耗时，两者经常需要权衡。准确率侧，字符识别的主流做法是 LPRNet 类轻量 CNN 加 CTC 损失。LPRNet 不依赖字符预分割，用卷积把图像特征映射成序列概率，CTCLoss 负责对齐不定长的字符序列，对模糊、倾斜、带噪声的车牌鲁棒性比“先切割再逐个分类”好得多。

速度侧，真正的瓶颈往往不在模型计算量，而在数据通道和前后处理。检测模型输入分辨率从 640 降到 320，计算量直接降到原来的约四分之一；视频流里每 2 到 3 帧只做一次检测、中间帧复用上一帧的框，整条链路立刻接近实时。把模型导出成 TensorRT FP16 或 OpenVINO 又能再省一截时间。这些优化不影响原代码逻辑，又是答辩时能讲清楚的高性能交付点，我通常建议先做这三件事，再去折腾模型结构。

3. 把 zip 变成能跑的识别系统：环境、数据与最小命令

3.1 环境配置：先让深度学习框架跑通

这个方向的代码绝大多数是 Python 写的，依赖集中在 PyTorch 和 ultralytics（YOLO 的训练库）。配置顺序建议是先确认 NVIDIA 驱动，再创建虚拟环境，最后用 pip 装依赖。不要直接装在系统 Python 里，否则后面换版本非常痛苦。conda 创建环境时 Python 版本选 3.10 最稳，3.11 上有些老项目依赖没有预编译 wheel，会临时编译浪费半小时。

# 创建虚拟环境，Python 3.10 兼容性最好 conda create -n plate python=3.10 -y conda activate plate # 安装 PyTorch，cu118 对应 CUDA 11.8，cu121 对应 CUDA 12.1 # 先去 NVIDIA 官网确认驱动支持哪个 CUDA，再选对应版本 pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118 --trusted-host download.pytorch.org # 安装 YOLO 训练库和图像处理依赖 pip install ultralytics opencv-python numpy pandas tqdm

装完立刻验证 CUDA 是否可用，命令是python -c "import torch; print(torch.cuda.is_available())"。如果输出 False，说明驱动、CUDA 版本和 PyTorch 编译版本不匹配，而不是代码有问题。我遇到过最浪费时间的情况是一个人调了两天模型效果，最后发现 torch 装成了 CPU 版。nvidia-smi能显示驱动版本，python -c "import torch;print(torch.__version__)"能看 torch 编译的 CUDA 版本，两个一对比就知道问题出在哪。

3.2 数据准备：公开数据集怎么组织成 YOLO 格式

毕设里最常用的公开数据集是 CCPD，包含约 25 万张自然场景车牌图，标注信息直接写在文件名里，解析起来比读 json 还方便。但 CCPD 有个明显缺陷：全部拍摄于安徽合肥，车牌以“皖 A”为主、场景单一，全是停车场出入口。如果项目要求识别全国车牌或应对复杂街道场景，就要额外补充自采数据或合成数据。

数据集目录建议按下面这样组织，训练脚本、验证脚本、配置都基于这个结构。

plate_data/ ├── images/ │ ├── train/ │ └── val/ ├── labels/ │ ├── train/ │ └── val/ └── plate.yaml

YOLO 训练要求图片和标签文件名相同、后缀不同。把 CCPD 文件名里的坐标解析成 YOLO 格式 txt 的脚本如下：

# 解析 CCPD 文件名中的标注，生成 YOLO 格式标签 import os def ccpd_filename_to_label(filename): # 示例: 2016-03-30-11-24-48.jpg?ccpd_bb=268,194,317,232&... parts = filename.split('&') bbox_str = parts[0].replace('ccpd_bb=', '') x1, y1, x2, y2 = map(int, bbox_str.split(',')) img_w, img_h = 720, 1160 # CCPD 统一尺寸 x_center = ((x1 + x2) / 2) / img_w y_center = ((y1 + y2) / 2) / img_h w = (x2 - x1) / img_w h = (y2 - y1) / img_h return f"0 {x_center:.6f} {y_center:.6f} {w:.6f} {h:.6f}\n" # 按目录批量生成 labels for img in os.listdir('ccpd/images'): if img.endswith('.jpg'): label = ccpd_filename_to_label(img) with open(f'ccpd/labels/{img.replace(".jpg", ".txt")}', 'w') as f: f.write(label)

脚本逻辑是先提取文件名里ccpd_bb后的坐标，再做归一化。CCPD 图片尺寸固定 720×1160，所以可以直接写死，换成其他数据集时必须用cv2.imread读实际宽高。YOLO 格式要求坐标是相对值，所以每一项都除了宽高。类别 id 默认是0表示单类车牌；如果要把蓝牌和绿牌当两个类别，这里要分别写0和1，训练配置里的类别数也要同步改。

划分训练集和验证集时有个典型错误：随机打乱。同一辆车在 CCPD 连续多帧出现，随机划分会让相同车辆同时出现在训练集和验证集，评估结果虚高。应该按文件名排序后取前 80% 做训练、后 20% 做验证，模拟真实泛化场景。

3.3 训练检测模型：最小命令与三个关键参数

检测模型不需要从零预训练，直接用 YOLOv8s 的公开权重做迁移学习，参数量小、训练快，适合毕设的算力环境。先写一个数据配置：

# plate.yaml：定义训练集、验证集路径和类别 train: ./plate_data/images/train val: ./plate_data/images/val nc: 1 names: ['license_plate']

训练命令一行就能跑起来：

yolo detect train data=plate.yaml model=yolov8s.pt epochs=100 imgsz=640 batch=16 patience=10 workers=8

这里面三个必调的参数是imgsz、batch和patience。imgsz是输入分辨率，640 精度好，显存紧张或追求速度就降到 320；batch受显卡显存限制，8G 显存建议 16 以内；patience是早停轮数，10 表示连续 10 个 epoch 验证集没提升就自动停。workers=8是为了让 CPU 多线程做数据加载，避免 GPU 空等。

训练过程中关注两个信号：验证集 mAP50 是否还在上升，训练 loss 和验证 loss 的差距是否过大。验证集 mAP50 到 95% 以上就够用了，再往上对最终字符识别准确率帮助不大，因为识别阶段有自己的纠错能力。ultralytics 默认开启 Mosaic 数据增强，在 CCPD 这种背景高度一致的数据集上，Mosaic 容易让模型学到背景套路，建议在超参配置里把mosaic调低或关掉。

3.4 识别模型训练：LPRNet 的输入和字典

检测模型负责找“车牌在哪”，识别模型负责把“车牌区域”变成字符串。LPRNet 是中文车牌识别里的经典轻量结构，输入是一张固定高度的宽幅图（如 96×24），输出是序列概率分布。训练前先定义字符字典：

# 字符字典：省份汉字 + 大写字字母 + 数字 provinces = "京津冀晋蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼渝川贵云陕甘青宁新" letters = "ABCDEFGHJKLMNPQRSTUVWXYZ" digits = "0123456789" # 注意车牌字母里没有 I 和 O，避免和数字 1、0 混淆 charset = provinces + letters + digits char_to_index = {c: i for i, c in enumerate(charset)}

字典是识别模型的“黑匣子”入口，决定了模型能输出哪些字符。很多人训练时发现模型永远不输出某个省份的字，十有八九是字典漏了这个字。字母表剔除了 I 和 O，这是车牌规则决定的，不是笔误。训练识别模型的损失函数用 CTCLoss，PyTorch 里直接调用：

import torch.nn as nn criterion = nn.CTCLoss(blank=len(char_to_index), zero_infinity=True) # log_probs: (T, N, C)，T 是序列长度，N 是 batch，C 是字符类别数 # target_lengths: 每个样本真实字符数，蓝牌 7，绿牌 8 loss = criterion(log_probs, targets, input_lengths, target_lengths)

CTCLoss 的blank参数必须等于字符类别数，表示空白符，不能指向任何真实字符。zero_infinity=True防止训练初期 log 值为 0 导致 loss 变成无穷大。训练时固定输入高度（比如 24），宽度可以变，LPRNet 的卷积对宽度不敏感，batch 内按最宽图 padding 即可。

真实摄像头里车牌往往是斜的，直接把倾斜的裁剪图扔给识别模型，即使 LPRNet 能容忍一定倾斜，效果也会打折。送入识别模型前用 OpenCV 透视变换矫正，是最划算的预处理：

# 矫正：把斜车牌转正 import cv2 import numpy as np def rectify_plate(plate_crop, corners): # corners 是检测到的车牌四个角点，顺序为左上、右上、左下、右下 # 输出尺寸：宽 96，高 24 dst = np.array([[0, 0], [96, 0], [0, 24], [96, 24]], dtype=np.float32) src = np.array(corners, dtype=np.float32) M = cv2.getPerspectiveTransform(src, dst) warped = cv2.warpPerspective(plate_crop, M, (96, 24)) return warped

如果检测模型只输出正矩形框，可以先对框内区域做轮廓分析，找出车牌的四个角点再做矫正。这一步在很多开源方案里是效果优化的关键动刀点。

3.5 推理链路：检测框到车牌号的一行输出

训练完成后，把检测和识别串起来。流程是：读图 → 检测出车牌框 → 裁剪 → 透视矫正 → 送入 LPRNet → CTC 解码 → 后处理纠错。

# inference.py：完整识别流程 import cv2 import torch from ultralytics import YOLO detect_model = YOLO('best_detect.pt') recog_model = torch.jit.load('lprnet_jit.pt') # 用 TorchScript 加速推理 def decode_ctc(output, charset): # output shape: (T, C)，每个时间步取最大概率类别 pred_ids = output.argmax(dim=1).tolist() result = [] prev = None for i, idx in enumerate(pred_ids): if idx == prev: continue # 相邻重复字符合并 prev = idx if idx < len(charset): result.append(charset[idx]) return ''.join(result) def recognize(img_path): img = cv2.imread(img_path) results = detect_model(img)[0] for box in results.boxes.xyxy: x1, y1, x2, y2 = map(int, box.tolist()) plate_crop = img[y1:y2, x1:x2] warped = rectify_plate(plate_crop, get_corners(plate_crop)) warped = cv2.resize(warped, (96, 24)) warp_t = torch.from_numpy(warped / 255.0).permute(2, 0, 1).unsqueeze(0).float() with torch.no_grad(): output = recog_model(warp_t) return decode_ctc(output, charset)

注意几个细节：送入识别模型的图要先归一化到 0 到 1，维度转成 C×H×W。检测结果results.boxes.conf是置信度，车牌检测一般把阈值设在 0.5 左右，太低会混入噪声框，太高会漏掉模糊车牌。NMS 的 IoU 阈值通常设 0.45。torch.jit.load是加载 script 化模型的方式，比直接调 eval 模式快，但要求模型结构不带动态分支。

4. 避坑与常见问题：五条能救回一整周的血泪经验

4.1 现象：训练集 99%，测试集 60%，过拟合的典型表现

现象：训练集准确率接近 100%，放到实拍图中立刻打回原形。
原因：检测模型把背景里某种固定模式当成了特征，或者识别模型只记住了特定字体、特定光照下的字形。CCPD 图片全部来自同一批监控摄像头，背景和角度高度一致，模型很容易学会“背景套路”而不是“车牌特征”。
解决：第一，增强数据，对车牌图做随机亮度、对比度、透视变换。我常用的参数是亮度 ±20%、对比度 ±10%、透视 ±5°、旋转 ±10°，这组范围不会破坏字符结构；第二，按拍摄场景切分训练集和验证集，而不是随机切分；第三，识别模型只喂“裁剪后的车牌图”，别把背景图直接送进去，减少背景干扰。训练时同时盯训练 loss 和验证 loss，两者差距持续拉大就是过拟合信号。

4.2 现象：绿牌识别率低得离谱，字符数变了但模型不知道

现象：蓝牌识别率正常，绿牌基本全错，或者多一位少一位。
原因：绿牌是 8 位字符，很多训练代码把输出序列长度固定成 7。更隐蔽的是绿牌第 2 位是 D/F 新能源标识，不是传统发牌机关字母，字符字典里要是没有 D 和 F，解码必然错位。
解决：训练 CTC 时target_lengths按真实字符数传，蓝牌 7、绿牌 8；字典必须补上 D 和 F。推理时 CTC 解码本身支持变长输出，不需要改网络结构。如果代码里用了全连接层把输出维度硬顶成 7，那就要把结构改成序列输出。另外，绿牌数据在标注阶段如果全按蓝牌 7 位标，加再多样本也没用，要先统一标注规则。

4.3 现象：GPU 利用率上不去，训练慢是因为数据加载拖后腿

现象：用 GPU 训练，但nvidia-smi里利用率只有 20%。
原因：读图、缩放、归一化都在 CPU 上做，成了瓶颈。CCPD 图片是 720×1160 的 JPEG，解压很慢，GPU 在空等数据。
解决：先把 DataLoader 的num_workers调到 CPU 核心数减 1，并开启pin_memory=True。ultralytics 训练命令里加workers=8和cache=True能明显缓解。如果显存占满但利用率还是低，说明单张图计算量太小而拷贝频繁，调大 batch 就能解决。还有一个土办法：把 JPEG 全部预转成 PNG 或内存映射格式，磁盘占用高一些，但训练速度立竿见影。

4.4 现象：识别结果多字漏字，CTC 解码顺序反了

现象：车牌“皖A12345”被识别成“皖A123345”或“皖A1235”。
原因：CTC 解码时先做了相邻去重再取最大概率，导致本应相邻的重复字符被错误合并；或者blank索引设置到了字典内某个真实字符上，解码结果混入空白符。
解决：顺序必须是先argmax拿到每个时间步的类别序列，再合并相邻重复符号，最后去掉空白符号。正确逻辑如下：

def decode_ctc(preds, charset): preds = preds.argmax(dim=-1).tolist() # 先取每个时间步的类别 out = [] for i, idx in enumerate(preds): if i > 0 and idx == preds[i - 1]: continue # 合并相邻重复 if idx >= len(charset): continue # 跳过空白符号 out.append(charset[idx]) return ''.join(out)

注意idx == preds[i - 1]只在相邻位置才跳过，非相邻的重复字符（比如“皖A·55555”里的连续 5）会完整保留。这个细节是我见过最频繁的翻车点。

4.5 现象：推理速度比预期慢很多，图片尺寸和 batch 是元凶

现象：单张图要 200ms，离实时差一大截。
原因：检测输入设成 640 没有降；识别模型单独跑，模型加载和预处理重复耗时；没有用批处理或加速引擎。
解决：检测输入降到 416 或 320，识别模型固定输入宽度；用torch.cuda.synchronize()加time.time()分段计时，看耗时到底是检测还是识别占掉。视频流场景每 2 到 3 帧跑一次检测，中间帧复用上一帧检测结果，车牌在视频里不会瞬移，这个 trick 在监控场景里很常用。再进一步就是导出 TensorRT FP16 或 OpenVINO，具体做法见第 5 章。

5. 进阶玩法：从能跑到好用，只差这三步

5.1 用 TensorRT 把推理速度再压一半

这是“高性能”最容易立竿见影的一步。PyTorch 模型先导出成 ONNX，再用 TensorRT 转成 FP16 engine，命令如下：

# 导出 ONNX，opset 版本建议 12 以上 yolo export model=best_detect.pt format=onnx opset=12 dynamic=True # 用 trtexec 生成 FP16 engine trtexec --onnx=best_detect.onnx --saveEngine=best_detect_fp16.engine --fp16

dynamic=True会生成动态 batch 的 ONNX，TensorRT 转换时可以指定最大 batch。FP16 精度损失在车牌识别任务上几乎看不出来，但速度能提 40% 到 60%。如果项目明确要求 CPU 部署，就不要碰 TensorRT，改用 OpenVINO，流程一样。

5.2 自动化评估：用一张表格说服答辩老师

毕设最怕“演示成功、答辩被问死”。我一般会先跑一个批量评估脚本，算三个指标：字符级准确率、车牌级准确率、平均推理耗时。遍历测试集调用前面的recognize函数，比对结果后统计：

correct_plate = sum(1 for pred, gt in results if pred == gt) total = len(results) char_total = sum(len(gt) for _, gt in results) char_correct = sum( sum(1 for p, g in zip(pred, gt) if p == g) for pred, gt in results if len(pred) == len(gt) ) print(f"车牌级准确率: {correct_plate / total:.2%}") print(f"字符级准确率: {char_correct / char_total:.2%}")

这个脚本不花多少时间，但能帮你定位模型到底在哪个省份、哪种光照下表现差，答辩时也能拿出数字支撑，而不是只说“效果还不错”。