CV - 目标检测

物体检测

目标检测和图片分类的区别：

图像分类（Image Classification）

目的 ：图像分类的目的是识别出图像中主要物体的类别。它试图回答"图像是什么？"的问题。
输出 ：通常输出是一个标签或一组概率值，表示图像属于各个预定义类别的可能性。例如，对于一张包含猫的图片，分类器可能会输出"猫"这个标签。
应用场景：适用于只需要了解图像整体内容的场景，如识别照片中的动物种类、区分不同的风景类型等。

目标检测（Object Detection）

目的 ：目标检测不仅需要识别图像中所有感兴趣物体的类别，还需要确定每个物体在图像中的具体位置。它试图回答"图像中有什么？它们在哪里？"的问题。
输出 ：除了给出物体的类别外，还会输出物体所在的边界框（bounding box），即用矩形框标记出每个物体的位置。例如，在自动驾驶场景下，系统不仅要能识别出行人、车辆等物体，还要精确地定位它们的位置以便做出安全决策。
应用场景：适合于需要知道图像内特定对象位置的情况，比如视频监控、自动驾驶汽车、医学影像分析等领域。

边缘框

• 一个边缘框可以通过 4 个数字定义
  • (左上 x，左上 y，右下 x，右下 y)
  • (左上 x，左上 y，宽，高)
    

目标检测数据集

• 每行表示一个物体
  • 图片文件名，物体类别，边缘框
• COCO (cocodataset.org)
  • 80 物体，330K 图片，1.5M 物体

总结

• 物体检测识别图片里的多个物体的类别和位置
• 位置通常用边缘框表示。

边缘框实现

%matplotlib inline
import torch
from d2l import torch as d2l

d2l.set_figsize()
img = d2l.plt.imread('../img/catdog.jpg')
d2l.plt.imshow(img);

定义在这两种表示法之间进行转换的函数

#@save
def box_corner_to_center(boxes):
    """从（左上，右下）转换到（中间，宽度，高度）"""
    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    cx = (x1 + x2) / 2
    cy = (y1 + y2) / 2
    w = x2 - x1
    h = y2 - y1
    boxes = torch.stack((cx, cy, w, h), axis=-1)
    return boxes

#@save
def box_center_to_corner(boxes):
    """从（中间，宽度，高度）转换到（左上，右下）"""
    cx, cy, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    x1 = cx - 0.5 * w
    y1 = cy - 0.5 * h
    x2 = cx + 0.5 * w
    y2 = cy + 0.5 * h
    boxes = torch.stack((x1, y1, x2, y2), axis=-1)
    return boxes

定义图像中狗和猫的边界框

# bbox是边界框的英文缩写
dog_bbox, cat_bbox = [60.0, 45.0, 378.0, 516.0], [400.0, 112.0, 655.0, 493.0]

boxes = torch.tensor((dog_bbox, cat_bbox))
box_center_to_corner(box_corner_to_center(boxes)) == boxes

将边界框在图中画出

#@save
def bbox_to_rect(bbox, color):
    # 将边界框(左上x,左上y,右下x,右下y)格式转换成matplotlib格式：
    # ((左上x,左上y),宽,高)
    return d2l.plt.Rectangle(
        xy=(bbox[0], bbox[1]), width=bbox[2]-bbox[0], height=bbox[3]-bbox[1],
        fill=False, edgecolor=color, linewidth=2)

fig = d2l.plt.imshow(img)
fig.axes.add_patch(bbox_to_rect(dog_bbox, 'blue'))
fig.axes.add_patch(bbox_to_rect(cat_bbox, 'red'));

数据集

李沐老师收集并标记了一个小型数据集，下面首先是下载该数据集：

%matplotlib inline
import os
import pandas as pd
import torch
import torchvision
from d2l import torch as d2l

#@save
d2l.DATA_HUB['banana-detection'] = (
    d2l.DATA_URL + 'banana-detection.zip',
    '5de26c8fce5ccdea9f91267273464dc968d20d72')

读取香蕉检测数据集

#@save
def read_data_bananas(is_train=True):
    """读取香蕉检测数据集中的图像和标签"""
    data_dir = d2l.download_extract('banana-detection')
    csv_fname = os.path.join(data_dir, 'bananas_train' if is_train
                             else 'bananas_val', 'label.csv')
    csv_data = pd.read_csv(csv_fname)
    csv_data = csv_data.set_index('img_name')
    images, targets = [], []
    for img_name, target in csv_data.iterrows():
        images.append(torchvision.io.read_image(
            os.path.join(data_dir, 'bananas_train' if is_train else
                         'bananas_val', 'images', f'{img_name}')))
        # 这里的target包含（类别，左上角x，左上角y，右下角x，右下角y），
        # 其中所有图像都具有相同的香蕉类（索引为0）
        targets.append(list(target))
    return images, torch.tensor(targets).unsqueeze(1) / 256

创建一个自定义 Dataseet 实例：

#@save
class BananasDataset(torch.utils.data.Dataset):
    """一个用于加载香蕉检测数据集的自定义数据集"""
    def __init__(self, is_train):
        self.features, self.labels = read_data_bananas(is_train)
        print('read ' + str(len(self.features)) + (f' training examples' if
              is_train else f' validation examples'))

    def __getitem__(self, idx):
        return (self.features[idx].float(), self.labels[idx])

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

为训练集和测试集返回两个数据加载器实例

#@save
def load_data_bananas(batch_size):
    """加载香蕉检测数据集"""
    train_iter = torch.utils.data.DataLoader(BananasDataset(is_train=True),
                                             batch_size, shuffle=True)
    val_iter = torch.utils.data.DataLoader(BananasDataset(is_train=False),
                                           batch_size)
    return train_iter, val_iter

读取一个小批量，并打印其中的图像和标签的形状

batch_size, edge_size = 32, 256
train_iter, _ = load_data_bananas(batch_size)
batch = next(iter(train_iter))
batch[0].shape, batch[1].shape

演示：

imgs = (batch[0][0:10].permute(0, 2, 3, 1)) / 255
axes = d2l.show_images(imgs, 2, 5, scale=2)
for ax, label in zip(axes, batch[1][0:10]):
    d2l.show_bboxes(ax, [label[0][1:5] * edge_size], colors=['w'])

QA 思考

Q1：如果在工业检测中数据集非常小(近百张)，除了进行数据增强外，还有什么更好的方法吗？

A1：迁移学习：找一个非常好的，在一个比较大的目标检测数据集上训练的比较好的模型，然后拿过来进行微调。近百张其实也不算小的了，只是说模型训练出来不是很好。数据增强的话，对图像进行处理，对应的框也必须要相应的变化一下，这是比较麻烦的点。

后记

自己实现了一遍，然后也是使用的李沐老师在课件中提供的狗猫图片：

import torch
from matplotlib import pyplot as plt
from PIL import Image

def set_image_display_size():
    plt.figure(figsize=(8, 6))

def load_image(img_path):
    return Image.open(img_path)

def show_single_image(img):
    plt.imshow(img)
    plt.axis('on')  # 显示坐标轴
    plt.show()

def box_corner_to_center(boxes):
    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    cx = (x1 + x2) / 2
    cy = (y1 + y2) / 2
    w = x2 - x1
    h = y2 - y1
    boxes = torch.stack((cx, cy, w, h), axis=-1)
    return boxes

def box_center_to_corner(boxes):
    # 这里向左和向上都是减小的
    cx, cy, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
    x1 = cx - 0.5 * w
    y1 = cy - 0.5 * h
    x2 = cx + 0.5 * w
    y2 = cy + 0.5 * h
    boxes = torch.stack((x1, y1, x2, y2), axis=-1)
    return boxes

def bbox_to_rect(bbox, color):
    # 将边界框(左上x, 左上y, 右下x, 右下y)格式转换成matplotlib格式：
    # ((左上x, 左上y), 宽, 高)
    return plt.Rectangle(
        xy=(bbox[0], bbox[1]), width=bbox[2] - bbox[0], height=bbox[3] - bbox[1],
        fill=False, edgecolor=color, linewidth=2)

if __name__ == "__main__":
    # 设置图像显示大小
    set_image_display_size()

    # 加载图像
    img_path = '../image/catdog.jpg'  # 确保路径正确
    img = load_image(img_path)
    show_single_image(img)

    # dog, cat 边界框
    dog_bbox, cat_bbox = [60.0, 45.0, 378.0, 516.0], [400.0, 112.0, 655.0, 493.0]

    # 转换为张量并测试转换函数是否正确
    boxes = torch.tensor((dog_bbox, cat_bbox))
    converted_boxes = box_center_to_corner(box_corner_to_center(boxes))
    # torch.allclose，判断两个张量是否在一定容差范围内相等。
    print("转换是否一致:", torch.allclose(converted_boxes, boxes))

    # 显示图像并绘制边界框,imshow 将 img 显示在画布上
    fig = plt.imshow(img)
    # add_patch 是 matplotlib 中用于在坐标轴上添加图形元素（如矩形、圆形等）的函数
    fig.axes.add_patch(bbox_to_rect(dog_bbox, 'blue'))  # 狗的边界框
    fig.axes.add_patch(bbox_to_rect(cat_bbox, 'red'))  # 猫的边界框
    plt.show()

我在colab上跑了一下下面的代码，发现可以，下载不了的可能需要一点 "魔法"

import hashlib
import os
import tarfile
import zipfile
import pandas as pd
import requests
import torch
import torchvision

from matplotlib import pyplot as plt

"""
    这段代码本身并没有包含训练过程。它只是加载了已经标注好的香蕉检测数据集，并可视化了图像及其对应的边界框。
    这些边界框信息是预先标注好的（存储在 CSV 文件中），而不是通过模型训练得到的。
    
    read_data_bananas 函数读取数据集中的图像和标签：
        图像存储在文件夹中（如 bananas_train/images/）。
        标签存储在 CSV 文件中（如 bananas_train/label.csv）。
        每个标签包括图像名称、目标类别（香蕉类别的索引为 0）、以及边界框坐标。
        
    zip 结构类似如下：
            banana-detection/
        ├── bananas_train/
        │   ├── images/
        │   │   ├── image1.jpg
        │   │   ├── image2.jpg
        │   │   └── ...
        │   └── label.csv  # 包含每张图像的标注信息（即边界框和类别）
        └── bananas_val/
            ├── images/
            │   ├── image1.jpg
            │   ├── image2.jpg
            │   └── ...
            └── label.csv
"""
DATA_HUB = dict()
DATA_URL = 'http://d2l-data.s3-accelerate.amazonaws.com/'

DATA_HUB['banana-detection'] = (
    DATA_URL + 'banana-detection.zip',
    '5de26c8fce5ccdea9f91267273464dc968d20d72')


def download(name, cache_dir=os.path.join('..', 'data')):
    """下载一个DATA_HUB中的文件，返回本地文件名"""
    # assert 条件, 错误信息
    assert name in DATA_HUB, f"{name} 不存在于 {DATA_HUB}"
    """
        url：文件的下载地址。 http://d2l-data.s3-accelerate.amazonaws.com/banana-detection.zip
        sha1_hash：文件内容的 SHA-1 校验值，用于验证文件完整性。5de26c8fce5ccdea9f91267273464dc968d20d72
    """
    url, sha1_hash = DATA_HUB[name]
    """
        递归创建目录：包括所有必要的父目录。
        避免重复创建导致的错误：如果目录已经存在，不会抛出异常。
    """
    os.makedirs(cache_dir, exist_ok=True)
    """
        url.split('/')[-1]：提取 URL 路径的最后一部分（通常是文件名）。
        os.path.join(cache_dir, ...)：将缓存目录和文件名组合成完整的本地文件路径。
    """
    fname = os.path.join(cache_dir, url.split('/')[-1])  # fname = ../data/banana-detection.zip
    if os.path.exists(fname):  # 文件存在，进入校验流程
        # 创建一个 SHA-1 哈希对象，用于计算文件的哈希值。
        sha1 = hashlib.sha1()
        # 以二进制模式读取文件
        with open(fname, 'rb') as f:
            while True:
                # 每次读取 1MB 数据（1048576 字节），更新哈希对象。
                data = f.read(1048576)
                # 为空，退出循环
                if not data:
                    break
                # 将读取的数据块逐步添加到哈希计算中
                sha1.update(data)
        """
            计算哈希值：
                调用 sha1.hexdigest() 获取最终的 SHA-1 哈希值（40 个字符的十六进制字符串）。
            校验哈希值：
                将计算得到的哈希值与预期的哈希值 sha1_hash 进行比较。
                如果两者相等，说明文件完整且未被篡改，直接返回文件路径（命中缓存）。
                否则，继续执行下载逻辑。
        """
        if sha1.hexdigest() == sha1_hash:
            return fname  # 命中缓存
    print(f'正在从{url}下载{fname}...')
    """
        使用 requests.get 方法发送 HTTP 请求，从远程服务器下载文件。
        参数说明：
            stream=True：以流式方式下载文件，避免一次性加载整个文件到内存中。
            verify=True：启用 SSL 证书验证，确保安全连接。
    """
    r = requests.get(url, stream=True, verify=True)
    """
        打开本地文件 fname，以二进制写入模式（'wb'）创建或覆盖文件。
            将下载的内容 r.content 写入文件。
            下载完成后，关闭文件。
    """
    with open(fname, 'wb') as f:
        f.write(r.content)
    return fname


def download_extract(name, folder=None):
    """下载并解压zip/tar文件"""
    fname = download(name)  # 下载文件的完整路径
    """
        os.path.dirname(fname)：提取文件所在的目录路径（即父目录）。
            例如，如果 fname 是 '../data/example.zip'，则 base_dir 是 '../data'。
        os.path.splitext(fname)：将文件路径拆分为文件名和扩展名。
            例如，如果 fname 是 '../data/example.zip'，则 data_dir 是 '../data/example'，ext 是 '.zip'。
    """
    base_dir = os.path.dirname(fname)
    data_dir, ext = os.path.splitext(fname)
    if ext == '.zip':
        fp = zipfile.ZipFile(fname, 'r')
    elif ext in ('.tar', '.gz'):
        fp = tarfile.open(fname, 'r')
    else:
        assert False, '只有zip/tar/gz 文件可以被解压缩'
    # 解压文件到指定的目录 base_dir
    fp.extractall(base_dir)
    """
        如果 folder 参数存在：
            返回 os.path.join(base_dir, folder)，即解压后目录下的指定子目录。
        如果 folder 参数不存在：
            返回 data_dir，即解压后的默认目录。
    """
    return os.path.join(base_dir, folder) if folder else data_dir


def read_data_bananas(is_train=True):
    """读取香蕉检测数据集中的图像和标签"""
    data_dir = download_extract('banana-detection')
    """
        根据 is_train 参数，确定加载训练集还是验证集的标注文件：
            如果 is_train=True，加载 'bananas_train/label.csv'。
            如果 is_train=False，加载 'bananas_val/label.csv'。
        使用 pandas 库的 read_csv 方法读取 CSV 文件内容。
        将 img_name 列设置为索引列（方便后续按图像名称访问数据）。
    """
    csv_fname = os.path.join(data_dir, 'bananas_train' if is_train
    else 'bananas_val', 'label.csv')  # for example: ../data/banana-detection/banana_train/label.csv
    csv_data = pd.read_csv(csv_fname)  # 读取 csv 文件
    # 将 img_name 列设置为索引列
    csv_data = csv_data.set_index('img_name')
    """
        images：用于存储读取的图像数据。
        targets：用于存储每张图像对应的标注信息。
    """
    images, targets = [], []
    """
        img_name：当前行的索引值（即图像名称）。
        target：当前行的数据（即标注信息）。
    """
    for img_name, target in csv_data.iterrows():
        images.append(torchvision.io.read_image(
            os.path.join(data_dir, 'bananas_train' if is_train else
            'bananas_val', 'images', f'{img_name}')))
        # 这里的target包含（类别，左上角x，左上角y，右下角x，右下角y），
        # 其中所有图像都具有相同的香蕉类（索引为0）
        targets.append(list(target))
    """
        images：图像数据列表。
        torch.tensor(targets).unsqueeze(1) / 256：
        将 targets 转换为 PyTorch 张量。
        使用 unsqueeze(1) 在维度 1 上增加一个维度，使其形状变为 (N, 1, 5)，其中 N 是样本数量，5 是每个标注信息的长度。
        所有边界框坐标除以 256，进行归一化处理（假设图像大小为 256x256）。
    """
    return images, torch.tensor(targets).unsqueeze(1) / 256


class BananasDataset(torch.utils.data.Dataset):
    """一个用于加载香蕉检测数据集的自定义数据集"""

    def __init__(self, is_train):
        self.features, self.labels = read_data_bananas(is_train)
        print('read ' + str(len(self.features)) + (f' training examples' if
                                                   is_train else f' validation examples'))
        # such as : read 1000 training examples

    def __getitem__(self, idx):
        return self.features[idx].float(), self.labels[idx]

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


def load_data_bananas(batch_size):
    """加载香蕉检测数据集"""
    train_iter = torch.utils.data.DataLoader(BananasDataset(is_train=True),
                                             batch_size, shuffle=True)
    val_iter = torch.utils.data.DataLoader(BananasDataset(is_train=False),
                                           batch_size)
    return train_iter, val_iter


def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    figsize = (num_cols * scale, num_rows * scale)
    """
        _：表示整个图形对象（这里用下划线忽略）
        axes：表示所有子图的数组
    """
    _, axes = plt.subplots(num_rows, num_cols, figsize=figsize)
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes


def bbox_to_rect(bbox, color):
    """将边界框(左上x,左上y,右下x,右下y)格式转换成matplotlib格式：
    ((左上x,左上y),宽,高)"""
    return plt.Rectangle(
        xy=(bbox[0], bbox[1]), width=bbox[2] - bbox[0], height=bbox[3] - bbox[1],
        fill=False, edgecolor=color, linewidth=2)


# 定义一个名为 numpy 的函数，它能够将 PyTorch 张量转换为 NumPy 数组，并且自动处理张量的梯度信息
numpy = lambda x, *args, **kwargs: x.detach().numpy(*args, **kwargs)


def show_bboxes(axes, bboxes, labels=None, colors=None):
    """显示所有边界框"""
    """
        功能：将输入对象转换为列表形式。
        如果 obj 是 None，返回默认值 default_values。
        如果 obj 不是列表或元组，则将其包装成单元素列表。
        否则，直接返回 obj。
        作用：确保 labels 和 colors 参数始终是列表形式，以便后续迭代操作。
    """

    def _make_list(obj, default_values=None):
        if obj is None:
            obj = default_values
        elif not isinstance(obj, (list, tuple)):
            obj = [obj]
        return obj

    """
        将 labels 转换为列表形式。如果未提供标签，则返回空列表。
        将 colors 转换为列表形式。如果未提供颜色，则使用默认颜色列表 ['b', 'g', 'r', 'm', 'c']（蓝色、绿色、红色、洋红色、青色）。
    """
    labels = _make_list(labels)
    colors = _make_list(colors, ['b', 'g', 'r', 'm', 'c'])
    """
        遍历 bboxes 列表中的每个边界框 bbox。
        根据索引 i，从 colors 列表中循环选择颜色（防止颜色不足时重复使用）。
        调用 bbox_to_rect 函数，将边界框坐标转换为 Matplotlib 的矩形对象。
        假设 bbox_to_rect 是一个已定义的函数，用于将边界框坐标转换为 matplotlib.patches.Rectangle 对象。
        numpy(bbox)：将边界框数据转换为 NumPy 数组（假设 bbox 是 PyTorch 张量）。
        使用 axes.add_patch(rect) 将矩形添加到绘图区域中。
    """
    for i, bbox in enumerate(bboxes):
        color = colors[i % len(colors)]
        rect = bbox_to_rect(numpy(bbox), color)
        axes.add_patch(rect)
        """
            检查是否提供了标签，并且当前索引 i 在标签范围内。
            根据边界框颜色选择标签文字的颜色：
            如果边界框颜色为白色（'w'），标签文字颜色为黑色（'k'）。
            否则，标签文字颜色为白色（'w'）。
            使用 axes.text 方法，在边界框的左上角位置添加标签文本。
            rect.xy[0] 和 rect.xy[1]：矩形左上角的 x 和 y 坐标。
            va='center' 和 ha='center'：设置文本垂直和水平居中对齐。
            fontsize=9：设置字体大小为 9。
            color=text_color：设置文本颜色。
            bbox=dict(facecolor=color, lw=0)：为文本添加背景框，背景颜色与边界框一致，边框宽度为 0。
        """
        if labels and len(labels) > i:
            text_color = 'k' if color == 'w' else 'w'
            axes.text(rect.xy[0], rect.xy[1], labels[i],
                      va='center', ha='center', fontsize=9, color=text_color,
                      bbox=dict(facecolor=color, lw=0))


if __name__ == "__main__":
    batch_size, edge_size = 32, 256
    train_iter, _ = load_data_bananas(batch_size)
    """
        使用 iter(train_iter) 创建一个迭代器对象。
        调用 next() 获取迭代器的第一个批次的数据。
    """
    batch = next(iter(train_iter))
    """
        torch.Size([32, 3, 256, 256])：表示 32 张 RGB 图像，每张图像大小为 256x256。
        torch.Size([32, num_boxes, 5])：表示每张图像有 num_boxes 个边界框，每个边界框包含 5 个值（类别 + 坐标）。    
    """
    print(batch[0].shape, batch[1].shape)
    """
    功能：
        batch[0][0:10]：从 batch[0] 中提取前 10 张图像。
        .permute(0, 2, 3, 1)：调整张量的维度顺序，将 (N, C, H, W) 转换为 (N, H, W, C)，即从 PyTorch 的默认格式转换为适合显示的格式。
        / 255：将像素值归一化到 [0, 1] 范围（假设原始像素值范围是 [0, 255]）。
    结果：
        imgs 是一个形状为 (10, 256, 256, 3) 的张量，表示 10 张归一化的 RGB 图像。
    """
    imgs = (batch[0][0:10].permute(0, 2, 3, 1)) / 255
    axes = show_images(imgs, 2, 5, scale=2)
    for ax, label in zip(axes, batch[1][0:10]):
        """
            label[0][1:5]：提取第一个边界框的坐标信息（[x_min, y_min, x_max, y_max]）。
            * edge_size：将归一化的坐标值还原为原始像素坐标。
            show_bboxes(ax, ...)：在子图 ax 上绘制边界框，颜色为白色 ('w')。
        """
        show_bboxes(ax, [label[0][1:5] * edge_size], colors=['w'])
    plt.show()
"""
归一化是为了模型训练：确保输入数据在合理的范围内，加速收敛并提高稳定性。
还原是为了可视化：将数据转换回原始范围，以便人类可以直观地理解图像和标注信息。
"""