简介：基于YOLOv8与LPRNet的车牌识别系统，是一套面向计算机相关专业毕业设计、课程实践和小型智能监控项目的完整工程。项目采用YOLOv8定位车牌区域，LPRNet识别车牌字符，并整合Flask后端与Vue前端，实现了从图像/视频输入到结果可视化展示的完整流程，适合作为算法学习、系统集成练习或初期项目演示的起点。资源包共60个文件，压缩后约36.15MB。核心代码为13个Python脚本，覆盖模型训练、数据集生成、批量图像预处理、标注创建等环节；同时包含YOLOv8权重文件（pt）与LPRNet模型参数文件（pth），以及一批用于验证的jpg图片和Vue前端工程（含vue、js、css、json等）。整体目录按功能模块划分，便于按需查阅。目前已有1146人浏览学习，代码经测试可正常运行，既能支持毕业设计中的实验复现，也可作为二次开发的基础框架。
1. 拿到「基于 YOLOv8 和 LPRNet 的车牌识别系统 python源码+模型.zip」之后，先别急着跑
这标题背后是一个典型的两段式车牌识别落地方案：YOLOv8 负责在画面里把车牌区域框出来，LPRNet 负责把这块小图直接翻译成“京A·12345”这样的车牌字符串。很多读者拿到这类压缩包第一反应是赶紧装环境跑推理，实际真正决定项目能不能用的，是数据集分布、字符解码逻辑和部署转换这几层，不是网络结构本身。本篇按从推理反推训练的顺序拆解：先讲选型边界，再给训练与推理的完整脚本，最后把高频踩坑点一次说透。适合正在做课设、工程预研或准备把识别能力集成到现有业务系统的开发者。
2. 技术选型：为什么是 YOLOv8 + LPRNet，而不是一个端到端模型
2.1 两段式架构的主流程与数据流
整个识别系统的调用关系很直接：摄像头视频帧或单张图片进入 YOLOv8 检测器，输出若干个车牌候选框及其置信度；程序按坐标从原图裁出车牌小图，做一次固定尺寸缩放后送给 LPRNet；LPRNet 输出一个字符序列概率分布，经解码变成最终车牌字符串。
这个流程里最重要的一点是“裁剪”这个动作。检测框的坐标精度直接影响识别输入质量，检测框稍微偏一点，LPRNet 见到的就是残缺字符。因此实际工程里不会直接按检测框硬裁，而是在四个方向各向外扩 5～10 个像素，把车牌边框和铆钉一起包进来，让识别网络的输入更接近训练数据分布。
两段式架构另一个隐性好处是替换成本低。如果需要识别新能源绿牌、挂车黄牌或警车白牌，只需要重新准备对应数据并微调 LPRNet；如果摄像头距离远导致检测框小，只需要单独换更大的 YOLOv8 模型。端到端方案虽然看起来简洁，但在这个场景下数据采集成本高、问题定位难，落地时并不划算。
2.2 YOLOv8 做车牌定位：生态与部署便利性
车牌在画面里属于典型的小目标，尤其停车场出入口抓拍时，车牌可能只占整帧画面的百分之一。YOLOv8 的 anchor-free 设计对小目标的回归更直接，而且模型家族从 n/s/m/l/x 到不同分辨率都有现成权重，做工程原型很快。
环境配置层面，常见做法是pip install ultralytics，然后命令行yolo就能直接跑起来。PyTorch 版本建议 2.0 以上，Python 3.8～3.10 之间是比较稳的区间；opencv-python 必须单独确认装上了，因为后面所有图像预处理都依赖它。我踩过的坑是 conda 里 torch 装的是 CPU 版，检测速度掉到一秒一帧，所以配置完环境后一定要先跑一次 GPU 推理确认设备可用。
YOLOv8 在这里只做一件事：输出(x1, y1, x2, y2, class_id, confidence)。车牌通常作为唯一类别训练，但实际监控场景里也可以顺便把车脸、车尾标成同一类，提升召回率后由识别网络去过滤非车牌区域。这种“检测放宽、识别收紧”的策略在复杂场景下很实用。
2.3 LPRNet 的定位：不切字符，直接输出序列
LPRNet 的核心价值是省掉字符切分这一步。传统方案要先把车牌图按字符宽度切开再逐个分类，一旦字符粘连、模糊或倾斜，切分就崩了。LPRNet 把整张车牌图送进 CNN 提取特征，输出一个时序特征序列，再用 CTC 损失对齐到最终字符序列，字符个数由模型自己决定。
具体实现上，LPRNet 的输入通常是(batch, 3, 24, 94)，即高 24、宽 94 的横向车牌图。backbone 用几层卷积把空间维度压缩，保留宽度方向上的序列信息，再接一层 RNN/LSTM 增强时序建模，最后每个时间步输出一个字符类别概率分布。
字符表一般包含 31 个省份汉字缩写、24 个字母（排除 I 和 O，避免与数字 1、0 混淆）、10 个数字，外加一个 CTC blank，合计 66 类。训练时数据标签是变长字符串，比如“京A12345”拆成字符序列后与各时间步做对齐；推理时常用的解码策略是贪心解码——每个时间步取概率最大的类别，去掉连续重复和 blank。如果要求更高，也可以用 beam search，但车牌字符集小，贪心解码通常已经够用。
3. 训练自己的数据集：从标注到两个模型的权重
3.1 YOLOv8 训练：标注格式、数据划分与关键参数
车牌检测模型的训练数据组织方式跟通用目标检测没有区别。先用 LabelImg 按矩形框标注车牌位置，导出为 YOLO TXT 格式：每行class_id cx cy w h，坐标全部归一化到 0～1。目录结构如下：
plate_dataset/ ├── images/ │ ├── train/ │ └── val/ └── labels/ ├── train/ └── val/数据划分建议训练集与验证集按 8:2 或 9:1 分配，验证集最好来自与训练集不同的摄像头点位，避免场景重叠导致评估虚高。对应的数据集配置文件plate.yaml这样写：
path: ./plate_dataset train: images/train val: images/val names: 0: license_plate启动训练用一行命令即可：
yolo detect train data=plate.yaml model=yolov8n.pt epochs=100 imgsz=640 batch=16 device=0imgsz的选择需要权衡。640 是通用默认值，训练和推理速度都快；如果摄像头画面里车牌较小，建议提到 960 或 1280，小目标召回率会明显上升。model=yolov8n.pt是最小的 nano 版本，适合快速验证流程；正式训练我一般换yolov8s.pt或yolov8m.pt，精度更高，部署到 RK3588 之类的板子前再蒸馏或量化回轻量版本。
训练日志里重点看val/box_loss和metrics/mAP50-95。前几个 epoch 的 mAP 可能很低，但 50 轮之后如果还在缓慢上升，说明模型没吃饱，可以适当加大epochs或引入更多数据增强。
3.2 LPRNet 训练数据：合成数据的生成思路
车牌识别网络最缺的往往不是背景多样性，而是汉字字符样本。真实场景里“京、沪、粤、苏”出现频率远高于“藏、青、宁”，直接训练汉字识别率会明显偏向高频字符。常见的做法是用合成数据打底：选几种常见的商用字体，渲染白字蓝底或黑字黄底的车牌图，再叠加透视变换、模糊、噪声和亮度扰动。
合成车牌时字符间距和排列要按真实规范来，蓝牌 7 位、绿牌 8 位，第一位必须是汉字。生成脚本框架如下：
import random import cv2 import numpy as np from PIL import Image, ImageDraw, ImageFont char_set = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领" plate_template = "京A12345" # 也可随机组合 # 在 240x60 画布上绘制字符 img = Image.new("RGB", (240, 60), (0, 0, 200)) # 蓝底 draw = ImageDraw.Draw(img) font = ImageFont.truetype("./simhei.ttf", 40) draw.text((10, 5), plate_template, font=font, fill=(255, 255, 255)) # 转为 OpenCV 格式，加透视和噪声 frame = cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR) frame = cv2.resize(frame, (94, 24))合成数据的关键是让 LPRNet 看到足够的字符排列组合，而不是只换背景。字体至少要准备三种，否则模型会对特定字体的笔画纹理过拟合，真实照片上识别率掉得厉害。
3.3 LPRNet 训练脚本的结构与超参数
LPRNet 网络本身不大，单卡训练几十个 epoch 就能收敛。核心网络结构可以按下面的方式定义：
import torch import torch.nn as nn class SmallBasicBlock(nn.Module): def __init__(self, ch_in, ch_out): super().__init__() self.conv1 = nn.Conv2d(ch_in, ch_out, kernel_size=1) self.bn1 = nn.BatchNorm2d(ch_out) self.conv2 = nn.Conv2d(ch_out, ch_out, kernel_size=3, padding=1, groups=ch_out) self.bn2 = nn.BatchNorm2d(ch_out) self.conv3 = nn.Conv2d(ch_out, ch_out, kernel_size=1) self.bn3 = nn.BatchNorm2d(ch_out) self.relu = nn.ReLU(inplace=True) def forward(self, x): out = self.relu(self.bn1(self.conv1(x))) out = self.relu(self.bn2(self.conv2(out))) return self.relu(self.bn3(self.conv3(out))) class LPRNet(nn.Module): def __init__(self, class_num, dropout=0.5): super().__init__() self.backbone = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(64, 128, kernel_size=3, padding=1), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), nn.Conv2d(128, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.MaxPool2d(2, 2), SmallBasicBlock(256, 256), nn.Conv2d(256, 512, kernel_size=3, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True), ) self.rnn = nn.LSTM(512, 256, num_layers=2, batch_first=True, bidirectional=True) self.fc = nn.Linear(512, class_num) def forward(self, x): x = self.backbone(x) # (B, 512, 4, W) B, C, H, W = x.size() x = x.view(B, C * H, W) # 把高度方向压缩成通道 x = x.permute(0, 2, 1) # (B, W, C*H) x, _ = self.rnn(x) # 双向 LSTM x = self.fc(x) # (B, W, class_num) return x网络输入是(batch, 3, 24, 94)，经过三次 MaxPool 和一次卷积 stride 后，宽度方向的时间步长会根据下采样倍数动态变化，forward里用W变量承接，不需要硬编码。训练时损失函数直接调 PyTorch 内置的 CTC loss：
criterion = nn.CTCLoss(blank=len(char_set) - 1, zero_infinity=True) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)注意 CTC loss 的输入格式是(time_steps, batch, num_classes)，而模型输出是(batch, time_steps, num_classes)，喂给 loss 之前要做一次log_softmax再transpose(0, 1)。标签则用字符在 char_set 里的索引序列表示，长度可以不等，这就是 CTC 能够处理变长车牌（蓝牌 7 位、绿牌 8 位）的原因。
训练过程中每几个 epoch 保存一次权重，同时打印验证集整牌识别率。我习惯在组织训练数据时，把字符个数放在标签张量的第一个维度，并用torch.nn.utils.rnn处理批次内的变长标签；如果嫌麻烦，也可以按固定长度 8 补齐并忽略 padding 位置，效果差别不大。
4. 推理流水线的 Python 实现：从一帧画面到车牌字符串
4.1 检测环节：解析 YOLOv8 的输出
推理侧我先写一个独立的检测函数，返回所有满足置信度阈值的车牌框：
import cv2 import numpy as np from ultralytics import YOLO detector = YOLO("./weights/yolov8_plate.pt") def detect_plates(frame, conf_threshold=0.25, iou_threshold=0.45): results = detector.predict(frame, conf=conf_threshold, iou=iou_threshold, verbose=False)[0] boxes = results.boxes.xyxy.cpu().numpy() # (N, 4)，像素坐标 scores = results.boxes.conf.cpu().numpy() # (N,) return boxes, scoresconf_threshold是置信度阈值，调太低会把车身反光、路面文字等误检为车牌；调太高又会漏检远处小目标。监控场景我一般先用 0.25 跑一遍，看误检率再决定是否提高到 0.4。iou_threshold控制 NMS 的抑制力度，车牌与车牌之间不会重叠，0.45 基本不需要动。
4.2 识别环节：裁剪、预处理与 CTC 解码
拿到检测框后，先按比例外扩，再缩放成 LPRNet 期望的尺寸。这里的关键是尽量保持车牌宽高比，不要原图是 200x60 就直接拉成 94x24 导致字符、变形。实际代码里先按检测框宽高比裁剪，再 resize。
from lprnet_model import LPRNet recognizer = LPRNet(num_classes=66) recognizer.load_state_dict(torch.load("./weights/lprnet.pt", map_location="cpu")) recognizer.eval() CHARS = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领ABCDEFGHJKLMNPQRSTUVWXYZ0123456789" def preprocess_crop(crop_bgr): crop = cv2.resize(crop_bgr, (94, 24)) crop = crop.astype(np.float32) / 255.0 crop = (crop - 0.588) / 0.193 crop = crop.transpose(2, 0, 1)[None, ...] return torch.from_numpy(crop) def decode_ctc(pred): pred = pred.softmax(dim=-1).argmax(dim=-1) # (1, T) pred = pred.squeeze(0).cpu().numpy() result = [] prev = None for idx in pred: if idx != len(CHARS) and idx != prev: result.append(CHARS[idx]) prev = idx return "".join(result)归一化的均值和方差 0.588、0.193 是很多开源 LPRNet 复现里沿用的统计值，如果自己重新训练，建议从训练集重新统计。decode_ctc里的逻辑是贪心解码：每帧取最大概率字符，空格重复的相邻字符只保留一个，遇到 blank 直接跳过。这套逻辑简单直接，适合车牌这种字符表小、序列短的任务。
值得提醒的是，许多工程实现会在解码后做一次车牌格式校验，比如判断第一位是否为省份汉字、第七位是否为数字或字母，不满足则标记为低置信度结果。这个校验能挡掉不少误识别，别省。
4.3 主流程：检测与识别串起来并绘制结果
下面把检测、外扩、识别、画框合成一个可直接跑的主流程：
cap = cv2.VideoCapture("./test_video.mp4") while True: ret, frame = cap.read() if not ret: break boxes, scores = detect_plates(frame) for (x1, y1, x2, y2), score in zip(boxes, scores): # 外扩 8 像素，避免裁掉车牌边缘字符 x1 = max(0, int(x1) - 8) y1 = max(0, int(y1) - 8) x2 = min(frame.shape[1], int(x2) + 8) y2 = min(frame.shape[0], int(y2) + 8) crop = frame[y1:y2, x1:x2] if crop.size == 0: continue input_tensor = preprocess_crop(crop) with torch.no_grad(): pred = recognizer(input_tensor) plate_text = decode_ctc(pred) cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) cv2.putText(frame, plate_text, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2) cv2.imshow("plate_recognition", frame) if cv2.waitKey(1) & 0xFF == ord("q"): break cap.release() cv2.destroyAllWindows()外扩 8 像素是一个经验值。检测框通常紧贴车牌字符，直接裁剪会把第一个汉字或最后一个数字压掉；但外扩太多又可能带入车身纹理干扰识别。边框、铆钉这些是噪声，但也能为 LPRNet 提供位置上下文，所以适度外扩反而提升精度。
视频流场景要注意检测器的执行频率。如果摄像头是 25 帧每秒，GPU 足够强可以每帧检测；边缘设备上则每 2～3 帧做一次检测，中间帧沿用上一帧的检测框，识别网络保持每帧运行。这样可以显著降低功耗和延迟。
5. 避坑指南：训练和部署中最常遇到的五个翻车现场
5.1 模型加载成功，但识别结果是一串乱码字符
现象：检测框位置正常，但输出的字符串完全不是车牌格式，例如“A1京B2C3D”这种顺序混乱的内容。
原因：最常见的是裁剪后的图像被直接拉伸到 94x24，破坏了车牌宽高比；或者是识别网络输入通道与训练时不一致，训练用的灰度图、推理时喂了 BGR 三通道，特征分布全乱了。
解决：严格复用训练时的预处理流程，包括通道顺序、归一化均值和方差、缩放尺寸。换用不同来源的 LPRNet 权重时，先确认它期望的输入尺寸和字符表顺序。字符表顺序不一致是隐蔽坑，同一个LPRNet.pt文件在不同项目里字符表排序可能完全不同，但没人会肉眼去对。
5.2 汉字总是识别错，“京”变成“示”或“就”
现象：数字和字母识别率很高，唯独省份汉字频繁出错。
原因：汉字类别在字符表里只占 31 类，真实数据中严重不均衡——粤、京、沪、苏出现率高，藏、青、宁样本极少。模型学到的是高频汉字特征，遇到低频汉字只会瞎猜。
解决：训练时对低频汉字做加权采样，或者通过合成数据把每个汉字类别的样本数拉平。推理时利用格式先验：车牌第一位必然是省份汉字，所以解码时把这一步的候选类别限制为 31 个汉字，再取最大概率。很多项目加了这一条规则后，整牌识别率直接提升两个点。
5.3 新能源绿牌整牌识别率明显低于蓝牌
现象：蓝牌识别 99%，绿牌却经常把第 8 位字符漏掉或把“D”读成“0”。
原因：绿牌是 8 位字符，LPRNet 训练时蓝牌样本占多数，模型隐含地倾向输出 7 位序列；另外绿牌字符是黑字配渐变绿底，对比度低于蓝牌白字，预处理阶段归一化后字符信号更弱。
解决：训练数据里绿牌比例至少占到 20%～30%，并且不要限制标签固定为 7 位。输入尺寸如果从 94x24 改成 110x24，能容纳更多字符间距，但需要同比例调整网络的时间步长并重新训练。推理时对绿色像素占比高的检测框，可以走一套单独的预处理参数。
5.4 部署到 RK3588 或端侧 NPU 后精度整体下降
现象：同一个权重在 PC 上跑得很好，转 RKNN 或 TensorRT 后整牌识别率掉了 5% 以上。
原因：端侧量化把权重压缩到 INT8，对 LPRNet 这种小模型影响尤其明显；YOLOv8 导出 ONNX 时若未固定输入尺寸，NPU 上动态分辨率会触发多余的 resize 操作，特征图发生偏移。
解决：部署前先用统一输入尺寸导出 ONNX，在 PC 上用 ONNX Runtime 验证输出与 PyTorch 原版一致后再转 RKNN。量化时准备 200～300 张真实车牌图作为校准集，不要用合成图。如果量化后检测框坐标明显偏移，优先在导出配置里关闭某些算子的量化，比较常见的耗时大户Sigmoid和Gather算子可以保留为 FP16。
5.5 训练 loss 正常下降，但验证集整牌识别率几乎为零
现象：CTC loss 从几十降到 3 左右，但解码输出和真实车牌完全对不上。
原因：标签字符顺序错了。CTC 训练要求标签与输入序列保持从左到右的对应关系，如果数据管道里把车牌字符串反转了或者按字符表索引映射时少了一个偏移量，loss 照样能降，但解码永远错位。
解决：在训练脚本里加一个可视化 debug 开关，随机抽 10 个 batch，把标签索引还原成字符串打印出来，人工确认与图像内容一致。这个检查只要做一次，能省出后面一整周的排查时间。
6. 从能跑到能用：批量验证、多帧投票与部署前的检查清单
6.1 批量验证脚本：用整牌正确率和字符正确率说话
单张图片能识别成功不代表系统可用。我建议准备一个 200～500 张真实图片的验证集，跑一个批量统计脚本：
def evaluate(predictor, dataset): total_plate = 0 correct_plate = 0 total_char = 0 correct_char = 0 for img_path, gt_text in dataset: plate_text = predictor(img_path) total_plate += 1 if plate_text == gt_text: correct_plate += 1 total_char += len(gt_text) correct_char += sum(a == b for a, b in zip(plate_text, gt_text)) print(f"整牌正确率: {correct_plate / total_plate:.2%}") print(f"字符正确率: {correct_char / total_char:.2%}")整牌正确率是你的业务指标，字符正确率是排查指标。如果整牌率低但字符率高，说明解码层问题，比如格式校验规则太严；如果两者都低，回头看检测或预处理。只要跑一次这个脚本，模型到底是检测的问题还是识别的问题，基本一目了然。
6.2 多帧投票：稳定输出比单帧识别更重要
监控视频里同一辆车会连续出现多帧，单帧识别偶尔闪错一个字符，就会导致整个后续业务流程判断失败。常见做法是维护一个车牌结果队列，对同一检测框 ID 在连续 5～10 帧内的识别结果做逐字符投票，最终输出出现频率最高的组合。
这个逻辑实现起来不复杂，但效果非常明显。字符投票能把偶发的1误识成I这类噪声消掉，同时还可以统计每个字符的可信频次，低于 60% 的判定为低置信度结果。真实停车场场景下，单帧精度做到 95% 已经不错，多帧投票后可以稳定推到 99% 以上。
6.3 部署前检查清单与个人习惯
把模型从 PyTorch 移到端侧前，建议对照下面的清单过一遍：输入尺寸是否固定、颜色通道顺序是 BGR 还是 RGB、归一化均值方差是否与训练一致、检测框坐标从模型输出映射回原图时是否处理了 letterbox、CTC 解码是否保留在端侧而不是交给服务端、LPRNet 导出的时间步长是否与训练时一致。
我现在的习惯是先把模型在验证集上跑出基线指标，再动手做任何部署优化。如果 RK3588 上转换后指标掉点，先用 ONNX Runtime 逐层对比特征，看是第一个卷积层输入就不一致，还是某个算子在 NPU 上行为不同。这个排查虽然费时间，但比反复调量化参数更接近根因。车牌识别这种场景，真正决定系统寿命的从来不是模型有多新，而是数据、解码和部署这三层有没有被认真对待，希望帮到你。
本文还有配套的精品资源，点击获取
