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

1次阅读

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

BTAD（BTech Anomaly Detection Dataset）是工业缺陷检测领域的重要基准数据集，由韩国浦项科技大学发布，专门针对工业产品表面缺陷检测任务设计。该数据集包含三种不同工业产品的图像数据：PCB 板、织物和药片，每种产品类别下又包含正常样本和多种缺陷类型的样本。数据集总量约 1500 张高分辨率图像（1400×1400 像素），采用 PNG 格式存储，标注文件为 COCO 格式的 JSON 文件。

BTAD 数据集的主要特点包括：

真实工业场景采集，包含光照变化、复杂背景等实际干扰因素
缺陷类型多样，涵盖划痕、污渍、缺失等多种典型工业缺陷
标注精细，每个缺陷区域都有精确的边界框和多边形标注

在实际使用 BTAD 数据集时，开发者常遇到以下技术挑战：

数据不平衡问题：正常样本远多于缺陷样本，某些罕见缺陷类别样本极少
高分辨率处理：原始图像尺寸大（1400×1400），直接输入模型会导致显存不足
标注格式转换：COCO 格式需要转换为模型特定的输入格式
小目标检测：部分缺陷区域面积很小，容易被常规检测方法忽略
跨产品泛化：不同产品类别的特征差异大，单一模型难以通用

以下是完整的 BTAD 数据预处理代码示例，包含数据加载、增强和格式转换等关键步骤：

import json
import cv2
import albumentations as A
from albumentations.pytorch import ToTensorV2

# 1. 数据加载与解析
class BTADDataset:
    def __init__(self, root_path, annotation_file, transform=None):
        self.root = root_path
        self.transform = transform
        with open(annotation_file) as f:
            self.coco_data = json.load(f)

        # 建立图像 ID 到文件名的映射
        self.image_info = {img['id']: img for img in self.coco_data['images']}

        # 建立图像 ID 到标注的映射
        self.annotations = {}
        for ann in self.coco_data['annotations']:
            img_id = ann['image_id']
            if img_id not in self.annotations:
                self.annotations[img_id] = []
            self.annotations[img_id].append(ann)

    def __getitem__(self, idx):
        img_info = self.image_info[idx]
        img_path = f"{self.root}/{img_info['file_name']}"
        image = cv2.imread(img_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # 获取当前图像的所有标注
        annotations = self.annotations.get(idx, [])
        boxes = []
        labels = []
        for ann in annotations:
            # COCO 格式的 bbox 是 [x,y,width,height]
            x, y, w, h = ann['bbox']
            boxes.append([x, y, x+w, y+h])  # 转换为 [x_min,y_min,x_max,y_max]
            labels.append(ann['category_id'])

        # 应用数据增强
        if self.transform:
            transformed = self.transform(
                image=image,
                bboxes=boxes,
                class_labels=labels
            )
            image = transformed['image']
            boxes = transformed['bboxes']
            labels = transformed['class_labels']

        target = {'boxes': torch.tensor(boxes, dtype=torch.float32),
            'labels': torch.tensor(labels, dtype=torch.int64)
        }

        return image, target

# 2. 定义数据增强流程
train_transform = A.Compose([A.Resize(512, 512),  # 降低分辨率以节省显存
    A.HorizontalFlip(p=0.5),
    A.VerticalFlip(p=0.5),
    A.RandomBrightnessContrast(p=0.2),
    A.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ToTensorV2()], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['class_labels']))

针对 BTAD 数据集的特点，推荐使用 Faster R-CNN 或 YOLOv5 等目标检测框架。以下是基于 PyTorch 的 Faster R-CNN 训练示例：

import torch
import torchvision
from torch.utils.data import DataLoader

# 1. 准备数据集
dataset = BTADDataset(
    root_path='BTAD/train',
    annotation_file='BTAD/annotations/train.json',
    transform=train_transform
)
dataloader = DataLoader(dataset, batch_size=4, shuffle=True, collate_fn=lambda x: tuple(zip(*x)))

# 2. 加载预训练模型
model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
num_classes = 3  # 正常 + 两类缺陷
in_features = model.roi_heads.box_predictor.cls_score.in_features
model.roi_heads.box_predictor = torchvision.models.detection.faster_rcnn.FastRCNNPredictor(in_features, num_classes)

# 3. 训练配置
device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)

# 4. 训练循环
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    for images, targets in dataloader:
        images = list(image.to(device) for image in images)
        targets = [{k: v.to(device) for k, v in t.items()} for t in targets]

        loss_dict = model(images, targets)
        losses = sum(loss for loss in loss_dict.values())

        optimizer.zero_grad()
        losses.backward()
        optimizer.step()

    lr_scheduler.step()
    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {losses.item()}")