# 基于YOLOv8+LPRNet的中文车牌检测识别系统：python源码+onnx推理+车牌颜色判断（附CCPD数据处理脚本）

【算法介绍】

车牌识别（LPR，License Plate Recognition）是计算机视觉里落地最早的方向之一，停车场道闸、高速收费、小区门禁、车险投保、事故查勘都离不开它。这个任务通常拆成两段：

1. **车牌检测**：在整张图里找到车牌的位置，这里用 YOLOv8n，目标单一、特征明显，轻量模型就够用；
2. **车牌字符识别**：把裁出来的车牌小图转成字符串，这里用经典的 LPRNet，不需要字符分割，端到端用 CTC 训练，模型只有几百 KB，CPU 上也很快。

再加一个简单的后处理：格式校验、去掉噪声字符，再用 HSV 颜色统计粗判一下车牌颜色（蓝/黄/绿/白/黑）。

整套方案全部基于公开模型和公开数据集，适合作为入门练手项目，也适合课程设计、毕业设计参考。

写这篇的起因是：之前在车险录单项目里用的是蓝兴AI的车牌号识别接口，效果一直不错，就想自己动手实现一遍，弄清楚背后的原理。

【效果展示】

![effect.png](https://developer.qcloudimg.com/http-save/yehe-12867055/b202b0dc5a0815042f92f90fb7a1b7c0.png)

上图是检测→裁剪→识别的示意：检测模型给出车牌外接框，裁剪后缩放到 LPRNet 的输入尺寸，再解码出车牌号。

自己训练的模型在 CCPD 测试集上效果不错，但换成手机随手拍的照片就差很多。我把一批"难图"（夜间、逆光、斜拍、翻拍屏幕）拿去和蓝兴AI车牌号识别的结果做了对比，它官网有网页在线体验，每天可以免费识别 10 张，支持图片和 PDF，正好用来当一个参照。对比下来，自建模型在停车场正面图上差距不大，但在翻拍屏幕、PDF 截图和双层黄牌上差距明显。

【测试环境】

Windows10 / Ubuntu 22.04，python3.10，torch==2.1.0，ultralytics==8.2.x，onnxruntime==1.17.0，opencv-python==4.9.0

【模型可以识别的字符】

检测类别（1 类）：plate

识别字符集（省份 31 个 + 数字 10 个 + 字母 24 个 + 特殊字符若干 + CTC 空白符）：

```
京沪津渝冀晋蒙辽吉黑苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云藏陕甘青宁新
0123456789
ABCDEFGHJKLMNPQRSTUVWXYZ
学警港澳挂使领
```

注意字母表里没有 `I` 和 `O`，这是国标车牌的编码规则，`0/O`、`1/I` 的混淆在字符集层面就排除掉了。

【整体流程】

![pipeline.png](https://developer.qcloudimg.com/http-save/yehe-12867055/3ad1e081247189e1bb54d8a07d9f49ce.png)

【训练数据集介绍】

开源的 **CCPD2019（蓝牌）** 和 **CCPD2020（绿牌）** 是最常用的车牌数据集，图片总量几十万张。它的标注直接写在文件名里，例如：

```
025-95_113-154&383_386&473-386&473_177&454_154&383_363&402-0_0_22_27_27_33_16-37-15.jpg
```

用 `-` 分隔后，第 3 段是外接框左上和右下坐标，第 5 段是车牌字符的编码。转换成 YOLO 检测格式：

```python
import os
import cv2

def ccpd_to_yolo(img_dir, label_dir):
    """CCPD 文件名 -> YOLO txt：cls cx cy w h（归一化）"""
    os.makedirs(label_dir, exist_ok=True)
    for name in os.listdir(img_dir):
        if not name.endswith(".jpg"):
            continue
        box = name.split("-")[2]
        (x1, y1), (x2, y2) = [map(int, p.split("&")) for p in box.split("_")]
        img = cv2.imread(os.path.join(img_dir, name))
        if img is None:
            continue
        h, w = img.shape[:2]
        cx, cy = (x1 + x2) / 2 / w, (y1 + y2) / 2 / h
        bw, bh = (x2 - x1) / w, (y2 - y1) / h
        with open(os.path.join(label_dir, name[:-4] + ".txt"), "w") as f:
            f.write(f"0 {cx:.6f} {cy:.6f} {bw:.6f} {bh:.6f}\n")
```

再解析出车牌号，用来训练识别模型：

```python
PROVINCES = ["皖", "沪", "津", "渝", "冀", "晋", "蒙", "辽", "吉", "黑", "苏", "浙", "京", "闽", "赣", "鲁",
             "豫", "鄂", "湘", "粤", "桂", "琼", "川", "贵", "云", "藏", "陕", "甘", "青", "宁", "新"]
ALPHABETS = list("ABCDEFGHJKLMNPQRSTUVWXYZ")
ADS = list("ABCDEFGHJKLMNPQRSTUVWXYZ0123456789")

def ccpd_plate_text(name):
    idx = list(map(int, name.split("-")[4].split("_")))
    return PROVINCES[idx[0]] + ALPHABETS[idx[1]] + "".join(ADS[i] for i in idx[2:])
```

**数据上的两个坑**：

- CCPD 里省份**绝大多数是"皖"**，直接训出来的识别模型对其他省份很弱，需要自己补充其他省份的数据，或者用字体渲染合成一部分车牌做增强；
- 场景单一，基本是停车场正面拍摄，没有黄牌双层、白牌、港澳牌，也没有翻拍、扫描件这类图片。

【检测模型训练】

数据配置 `plate.yaml`：

```yaml
path: datasets/plate
train: images/train
val: images/val
names:
  0: plate
```

训练与导出：

```bash
pip install ultralytics onnxruntime opencv-python
yolo detect train data=plate.yaml model=yolov8n.pt epochs=100 imgsz=640 batch=32
yolo export model=runs/detect/train/weights/best.pt format=onnx imgsz=640
```

训练完在 `runs/detect/train/` 下能看到 `results.png`、`PR_curve.png`、混淆矩阵等评估曲线。车牌检测在 CCPD 上 mAP50 很容易到 0.99，但这个数字参考意义有限，一定要准备一份自己场景的测试集。

【识别模型训练】

LPRNet 的论文和 PyTorch 实现都是公开的，网上有很多现成仓库可以直接训练。核心点就三个：

1. 输入是固定尺寸的车牌小图（常见实现为 94×24）；
2. 网络输出一个长度为 T 的序列，每个位置是对所有字符（含空白符）的打分；
3. 用 `nn.CTCLoss` 训练，推理时做贪心解码："去掉空白、合并相邻重复"。

```python
def ctc_greedy_decode(indices, charset, blank):
    out, prev = [], blank
    for i in indices:
        if i != blank and i != prev:
            out.append(charset[i])
        prev = i
    return "".join(out)
```

训练时的增强建议：随机亮度对比度、高斯模糊、轻微旋转和透视、随机裁剪边缘。这些对提升真实场景的鲁棒性比加深网络有效得多。

【onnx推理完整代码】

下面是只依赖 onnxruntime 和 opencv 的推理脚本。检测部分是 YOLOv8 导出的标准 onnx（输出 `[1, 5, 8400]`，需要自己做 NMS），识别部分以常见的 LPRNet 实现为例，字符集和预处理请和你自己训练时保持一致：

```python
import cv2
import numpy as np
import onnxruntime as ort

CHARS = list("京沪津渝冀晋蒙辽吉黑苏浙皖闽赣鲁豫鄂湘粤桂琼川贵云藏陕甘青宁新"
             "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ学警港澳挂使领") + ["-"]  # 最后一个为空白符
BLANK = len(CHARS) - 1


class SimpleLPR:
    def __init__(self, det_path, rec_path, conf=0.4, iou=0.5):
        self.det = ort.InferenceSession(det_path, providers=["CPUExecutionProvider"])
        self.rec = ort.InferenceSession(rec_path, providers=["CPUExecutionProvider"])
        self.conf, self.iou = conf, iou

    def detect(self, img, size=640):
        h, w = img.shape[:2]
        r = min(size / h, size / w)
        nh, nw = int(h * r), int(w * r)
        canvas = np.full((size, size, 3), 114, np.uint8)
        canvas[:nh, :nw] = cv2.resize(img, (nw, nh))
        x = cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB).transpose(2, 0, 1)[None].astype(np.float32) / 255
        pred = self.det.run(None, {self.det.get_inputs()[0].name: x})[0][0].T  # [8400, 5]
        pred = pred[pred[:, 4] > self.conf]
        if len(pred) == 0:
            return []
        boxes = np.stack([pred[:, 0] - pred[:, 2] / 2, pred[:, 1] - pred[:, 3] / 2,
                          pred[:, 2], pred[:, 3]], 1) / r
        keep = cv2.dnn.NMSBoxes(boxes.tolist(), pred[:, 4].tolist(), self.conf, self.iou)
        res = []
        for i in np.array(keep).flatten():
            x0, y0, bw, bh = boxes[i]
            res.append((max(int(x0), 0), max(int(y0), 0), int(x0 + bw), int(y0 + bh), float(pred[i, 4])))
        return res

    def recognize(self, crop):
        x = cv2.resize(crop, (94, 24)).astype(np.float32)
        x = ((x - 127.5) * 0.0078125).transpose(2, 0, 1)[None]
        logits = self.rec.run(None, {self.rec.get_inputs()[0].name: x})[0][0]  # [num_chars, T]
        idx = logits.argmax(0)
        text, prev = "", BLANK
        for i in idx:
            if i != BLANK and i != prev:
                text += CHARS[i]
            prev = i
        return text

    @staticmethod
    def guess_color(crop):
        """HSV 粗判车牌底色，够用就行"""
        hsv = cv2.cvtColor(crop, cv2.COLOR_BGR2HSV)
        h, s, v = [c.mean() for c in cv2.split(hsv)]
        if v < 60:
            return "black"
        if s < 50:
            return "white"
        if 100 <= h <= 130:
            return "blue"
        if 15 <= h <= 35:
            return "yellow"
        if 35 < h < 100:
            return "green"
        return "unknown"

    def __call__(self, img):
        out = []
        for x1, y1, x2, y2, score in self.detect(img):
            crop = img[y1:y2, x1:x2]
            if crop.size == 0:
                continue
            out.append({"plateNumber": self.recognize(crop),
                        "plateColor": self.guess_color(crop),
                        "box": [x1, y1, x2, y2], "detScore": round(score, 3)})
        return out


if __name__ == "__main__":
    lpr = SimpleLPR("models/plate_det_yolov8n.onnx", "models/lprnet.onnx")
    image = cv2.imdecode(np.fromfile("test.jpg", dtype=np.uint8), cv2.IMREAD_COLOR)  # 兼容中文路径
    for r in lpr(image):
        print(r)
```

输出示例：

```
{'plateNumber': '皖AD12345', 'plateColor': 'green', 'box': [154, 383, 386, 473], 'detScore': 0.93}
```

返回字段按 `plateNumber / plateColor` 命名，和常见车牌识别云接口的字段风格保持一致，以后业务上想在"自建模型"和"调用云接口"之间切换，只需要换一下调用层。

【常用评估指标介绍】

检测部分（ultralytics 训练日志里的几列）：

1. **P（Precision）**：预测为车牌的框中，真正是车牌的比例；
2. **R（Recall）**：所有真实车牌中被检出的比例，车牌场景里漏检比误检更麻烦，要重点看；
3. **mAP50**：IoU 阈值 0.5 下的平均精度；
4. **mAP50-95**：IoU 从 0.5 到 0.95 的平均，反映框的精细程度，框不准会直接影响后面的识别。

识别部分：

1. **整牌准确率**：整串号码完全一致才算对；
2. **字符准确率**：按字符统计，能看出是省份字、字母还是数字错得多；
3. 建议**按省份、按车牌颜色分组统计**，CCPD 这种分布不均衡的数据，总准确率会掩盖长尾类别的问题。

【常见问题】

| 现象 | 可能原因 | 建议 |
| --- | --- | --- |
| 其他省份的简称经常识别错 | 训练数据几乎全是"皖" | 补充其他省份数据或合成数据 |
| 斜拍车牌识别丢字 | 外接框裁剪带入背景、字符变形 | 加旋转/透视增强，适当外扩裁剪框 |
| 双层黄牌识别乱码 | LPRNet 默认按单行设计 | 需要单独处理双层牌，或单独训练 |
| 夜间、反光图片漏检 | 数据里缺少此类场景 | 补充数据，加亮度、模糊增强 |
| 颜色判断不准 | HSV 阈值受光照影响大 | 改用小型分类网络判断颜色 |

【使用步骤】

1. 安装环境：`pip install onnxruntime opencv-python numpy`；
2. 按上文训练并导出两个 onnx，放到 `models/` 目录，修改图片路径后运行 `python infer_onnx.py`。

如果你只是业务上需要用车牌识别，不打算自己收集数据、训练和部署，也可以直接用现成服务。比如蓝兴AI的车牌号识别88apis.com，支持蓝、绿、黄、白和港澳黑牌，能识别图片和 PDF，有按次计费的 API，也支持私有化部署，可以先拿几张自己场景的图片试试，再决定是自己训练还是直接接入。

【写在最后】

YOLOv8 + LPRNet 是车牌识别最经典的入门组合，跑通一遍能把检测、CTC 识别、onnx 部署这一整条链路都串起来。不过从"CCPD 上 99%"到"真实业务能用"还有不小距离，主要差在数据覆盖和各种边角场景的处理上，这也是蓝兴AI这类成熟服务真正花功夫的地方。有问题欢迎在评论区交流。


车牌识别（LPR，License Plate Recognition）是计算机视觉里落地最早的方向之一，停车场道闸、高速收费、小区门禁、车险投保、事故查勘都离不开它。这个任务通常拆成两段：

基于YOLOv8+LPRNet的中文车牌检测识别系统：python源码+onnx推理+车牌颜色判断（附CCPD数据处理脚本）

基于 YOLOv8 + LPRNet 实现中文车牌检测与识别：用 CCPD 数据集训练检测模型，LPRNet 结合 CTC 端到端识别车牌字符，HSV 粗判车牌颜色，附 CCPD 标注转换脚本和只依赖 onnxruntime 的完整推理代码，并总结了从数据集到真实场景常见的问题与解决思路。

人工智能

基于YOLOv8n与LPRNet构建的车牌识别系统，覆盖检测、字符识别与颜色判断，支持ONNX部署，训练基于CCPD公开数据集，适配停车场等场景，提供完整训练及推理流程，适合入门与课程设计参考。

计算机视觉

车牌识别

数据处理

代码解释

Python

Ubuntu

YOLO

文字识别限时特惠，新用户0.7折起


让每一个 Agent，都跑在云上

imagerecognition

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

基于YOLOv8+LPRNet的中文车牌检测识别系统：python源码+onnx推理+车牌颜色判断（附CCPD数据处理脚本）-腾讯云开发者社区-腾讯云

基于YOLOv8+LPRNet的中文车牌检测识别系统：python源码+onnx推理+车牌颜色判断（附CCPD数据处理脚本）

基于YOLOv8+LPRNet的中文车牌检测识别系统：python源码+onnx推理+车牌颜色判断（附CCPD数据处理脚本）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐