CCPD数据集实战指南：从数据预处理到模型训练的全流程解析

1次阅读

共计 4869 个字符，预计需要花费 13 分钟才能阅读完成。

CCPD（Chinese City Parking Dataset）是一个包含大量中国车牌图片的数据集，广泛应用于车牌识别任务。对于新手来说，使用 CCPD 数据集时常常会遇到以下几个问题：

数据格式不统一，包含多种分辨率和大小的图片
标注信息复杂，需要特殊解析方法
数据量大，处理起来比较耗时

首先需要从官方网站下载 CCPD 数据集。数据集通常分为几个子集，如 CCPD-Base、CCPD-DB 等，每个子集针对不同的车牌识别场景。

下载完成后，解压数据集，你会看到类似如下的目录结构：

CCPD2019/
    ├── ccpd_base/
    ├── ccpd_blur/
    ├── ccpd_db/
    └── ccpd_fn/

每个子目录中包含大量.jpg 图片文件，文件名包含了丰富的标注信息，这是 CCPD 数据集的一大特点。例如：

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

这个文件名包含了车牌区域、车牌号码、亮度、模糊度等多种信息，需要通过特定方法解析。

下面是一个 Python 代码示例，展示如何解析 CCPD 数据集的标注信息：

import os
import cv2
import re

def parse_ccpd_filename(filename):
    """解析 CCPD 文件名中的标注信息"""
    basename = os.path.basename(filename).split('.')[0]
    parts = basename.split('-')

    # 解析车牌区域坐标
    coords = parts[2].split('_')
    points = []
    for coord in coords:
        x, y = map(int, coord.split('&'))
        points.append((x, y))

    # 解析车牌号码
    plate_number = parts[4].split('_')[-1]

    return {
        'points': points,  # 车牌区域四个角的坐标
        'plate_number': plate_number  # 车牌号码
    }

# 使用示例
filename = "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"
annotations = parse_ccpd_filename(filename)
print(annotations)

车牌识别任务中，常用的数据增强方法包括：

随机旋转（小角度）：

import random
import numpy as np

def random_rotate(image, angle_range=(-10, 10)):
    angle = random.uniform(*angle_range)
    h, w = image.shape[:2]
    center = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(center, angle, 1.0)
    rotated = cv2.warpAffine(image, M, (w, h))
    return rotated

颜色抖动：

def color_jitter(image, brightness=0.2, contrast=0.2, saturation=0.2):
    # 随机调整亮度、对比度和饱和度
    alpha = 1 + random.uniform(-contrast, contrast)
    beta = random.uniform(-brightness, brightness)
    image = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)

    # 转换到 HSV 空间调整饱和度
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    hsv[..., 1] = hsv[..., 1] * (1 + random.uniform(-saturation, saturation))
    image = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
    return image

随机裁剪和缩放：

def random_crop_and_scale(image, annotations, scale_range=(0.8, 1.2)):
    h, w = image.shape[:2]
    scale = random.uniform(*scale_range)
    new_h, new_w = int(h * scale), int(w * scale)

    # 先缩放
    resized = cv2.resize(image, (new_w, new_h))

    # 再随机裁剪回原尺寸
    if new_h > h:
        y = random.randint(0, new_h - h)
        resized = resized[y:y+h, :]
    else:
        pad = h - new_h
        top = random.randint(0, pad)
        bottom = pad - top
        resized = cv2.copyMakeBorder(resized, top, bottom, 0, 0, cv2.BORDER_REPLICATE)

    # 调整标注点坐标
    if new_w > w:
        x = random.randint(0, new_w - w)
        resized = resized[:, x:x+w]
        for i in range(len(annotations['points'])):
            annotations['points'][i] = (annotations['points'][i][0] - x, annotations['points'][i][1])
    else:
        pad = w - new_w
        left = random.randint(0, pad)
        right = pad - left
        resized = cv2.copyMakeBorder(resized, 0, 0, left, right, cv2.BORDER_REPLICATE)
        for i in range(len(annotations['points'])):
            annotations['points'][i] = (annotations['points'][i][0] + left, annotations['points'][i][1])

    return resized, annotations

下面是一个基于 PyTorch 的简单车牌识别模型训练示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 自定义数据集类
class CCPDDataset(Dataset):
    def __init__(self, image_paths, transform=None):
        self.image_paths = image_paths
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        image_path = self.image_paths[idx]
        image = cv2.imread(image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # 解析标注
        annotations = parse_ccpd_filename(image_path)
        plate_number = annotations['plate_number']

        # 这里简化处理，实际需要将车牌号码转换为张量
        # 例如可以转换为字符索引序列

        if self.transform:
            image = self.transform(image)

        return image, plate_number

# 简单 CNN 模型
class PlateRecognitionModel(nn.Module):
    def __init__(self, num_chars=68):  # 假设有 68 个可能的字符
        super().__init__()
        self.features = nn.Sequential(nn.Conv2d(3, 32, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(64, 128, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )

        self.classifier = nn.Sequential(nn.Linear(128 * 16 * 16, 512),
            nn.ReLU(),
            nn.Linear(512, num_chars)
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

# 训练循环
def train_model(model, dataloader, criterion, optimizer, num_epochs=10):
    model.train()

    for epoch in range(num_epochs):
        running_loss = 0.0

        for images, labels in dataloader:
            # 这里简化了，实际需要处理标签转换
            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()

        print(f'Epoch {epoch+1}, Loss: {running_loss/len(dataloader)}')

# 使用示例
if __name__ == '__main__':
    # 假设已经获取了所有图片路径
    image_paths = [...]  # 替换为实际的图片路径列表

    dataset = CCPDDataset(image_paths)
    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

    model = PlateRecognitionModel()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    train_model(model, dataloader, criterion, optimizer, num_epochs=10)