深入解析CARPK数据集：技术原理与实战应用指南

1次阅读

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

高空俯视角度下的车辆检测是计算机视觉中的一个重要应用场景，但同时也面临诸多技术挑战：

小目标密集 ：车辆在高空视角下呈现为小目标，像素占比小，特征提取困难
严重遮挡 ：停车场等场景中车辆排列紧密，相互遮挡严重
视角畸变 ：俯视角度导致的几何形变影响检测精度
光照变化 ：不同时段、天气条件下的光照差异显著

CARPK 数据集正是为解决这些问题而设计，它包含：

1,500 张高空俯视图像
89,777 个精细标注的车辆边界框
涵盖不同时段、天气和场景复杂度

数据集	图像数量	标注数量	分辨率	标注格式	场景特点
CARPK	1,500	89,777	1280×720	XML	高空俯视，密集停车
UA-DETRAC	140,000	1,210,000	960×540	XML	交通监控，多视角
COCO	328,000	2,500,000	多种	JSON	通用物体，复杂场景

CARPK 的 XML 标注结构示例：

<annotation>
  <filename>IMG_0001.jpg</filename>
  <size>
    <width>1280</width>
    <height>720</height>
    <depth>3</depth>
  </size>
  <object>
    <name>car</name>
    <bndbox>
      <xmin>542</xmin>
      <ymin>321</ymin>
      <xmax>582</xmax>
      <ymax>361</ymax>
    </bndbox>
  </object>
  <!-- 更多 object 标签 -->
</annotation>

from lxml import etree
from typing import List, Dict, Tuple
import cv2
import numpy as np

class CARPKAnnotationParser:
    """解析 CARPK XML 标注文件的工具类"""

    def __init__(self, xml_path: str):
        self.xml_path = xml_path

    def parse(self) -> Dict:
        """解析 XML 文件，返回标注字典"""
        tree = etree.parse(self.xml_path)
        root = tree.getroot()

        result = {'filename': root.find('filename').text,
            'size': {'width': int(root.find('size/width').text),
                'height': int(root.find('size/height').text),
                'depth': int(root.find('size/depth').text)
            },
            'objects': []}

        for obj in root.iter('object'):
            bbox = obj.find('bndbox')
            result['objects'].append({'name': obj.find('name').text,
                'bbox': [int(bbox.find('xmin').text),
                    int(bbox.find('ymin').text),
                    int(bbox.find('xmax').text),
                    int(bbox.find('ymax').text)
                ]
            })

        return result

class MosaicAugmentation:
    """针对小目标的 Mosaic 数据增强"""

    def __init__(self, size=640, p=0.5):
        self.size = size
        self.p = p

    def __call__(self, images: List[np.ndarray], targets: List[Dict]) -> Tuple[np.ndarray, Dict]:
        if random.random() > self.p:
            return images[0], targets[0]

        # 创建 Mosaic 画布
        output_image = np.zeros((self.size, self.size, 3), dtype=np.uint8)
        output_targets = {'bboxes': [], 'labels': []}

        # 随机选择拼接位置
        cx, cy = random.randint(self.size//4, 3*self.size//4), random.randint(self.size//4, 3*self.size//4)
        positions = [(0, 0), (cx, 0), (0, cy), (cx, cy)]

        for i, (img, target) in enumerate(zip(images, targets)):
            # 随机缩放图像
            scale = random.uniform(0.5, 1.5)
            img = cv2.resize(img, (0,0), fx=scale, fy=scale)

            # 计算粘贴位置
            x1, y1 = positions[i]
            x2, y2 = min(x1+img.shape[1], self.size), min(y1+img.shape[0], self.size)

            # 粘贴图像
            output_image[y1:y2, x1:x2] = img[:y2-y1, :x2-x1]

            # 调整 bbox 坐标
            for bbox in target['bboxes']:
                xmin, ymin, xmax, ymax = bbox
                new_bbox = [
                    x1 + xmin * scale,
                    y1 + ymin * scale,
                    x1 + xmax * scale,
                    y1 + ymax * scale
                ]
                output_targets['bboxes'].append(new_bbox)
                output_targets['labels'].append(target['labels'])

        return output_image, output_targets

标注偏移问题
现象：模型预测的 bbox 与实际位置有系统性偏移
原因：未考虑镜头畸变导致的几何变形
解决：在数据加载时应用畸变校正，或使用可学习的位置偏移参数
空标注文件处理
现象：遇到空标注文件时程序崩溃
原因：未检查标注文件有效性

解决：在数据加载器中添加空文件检查逻辑：

if len(annotation['objects']) == 0:
    return None  # 跳过空标注样本

内存泄漏
现象：训练过程中内存占用持续增长
原因：未正确释放 XML 解析资源

解决：使用 with 语句管理文件资源：

with open(xml_path, 'rb') as f:
    tree = etree.parse(f)

Batch Size 选择
单 GPU 建议 batch_size=8

使用梯度累积模拟更大 batch：

optimizer.zero_grad()
for i, (images, targets) in enumerate(dataloader):
    outputs = model(images)
    loss = criterion(outputs, targets)
    loss.backward()

    if (i+1) % 4 == 0:  # 每 4 个 batch 更新一次
        optimizer.step()
        optimizer.zero_grad()

混合精度训练

from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

with autocast():
    outputs = model(inputs)
    loss = criterion(outputs, targets)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()