目标检测数据集

:label:sec_object-detection-dataset

目标检测领域没有像MNIST和Fashion-MNIST那样的小数据集。 为了快速测试目标检测模型，[我们收集并标记了一个小型数据集]。 首先，我们拍摄了一组香蕉的照片，并生成了1000张不同角度和大小的香蕉图像。 然后，我们在一些背景图片的随机位置上放一张香蕉的图像。 最后，我们在图片上为这些香蕉标记了边界框。

[下载数据集]

包含所有图像和CSV标签文件的香蕉检测数据集可以直接从互联网下载。

```{.python .input} %matplotlib inline from d2l import mxnet as d2l from mxnet import gluon, image, np, npx import os import pandas as pd

npx.set_np()

  2. ```{.python .input}
  3. #@tab pytorch
  4. %matplotlib inline
  5. from d2l import torch as d2l
  6. import torch
  7. import torchvision
  8. import os
  9. import pandas as pd

```{.python .input}

@tab all

@save

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

  2. ## 读取数据集
  4. 通过`read_data_bananas`函数，我们[**读取香蕉检测数据集**]。
  5. 该数据集包括一个的CSV文件，内含目标类别标签和位于左上角和右下角的真实边界框坐标。
  7. ```{.python .input}
  8. #@save
  9. def read_data_bananas(is_train=True):
  10.     """读取香蕉检测数据集中的图像和标签"""
  11.     data_dir = d2l.download_extract('banana-detection')
  12.     csv_fname = os.path.join(data_dir, 'bananas_train' if is_train
  13.                              else 'bananas_val', 'label.csv')
  14.     csv_data = pd.read_csv(csv_fname)
  15.     csv_data = csv_data.set_index('img_name')
  16.     images, targets = [], []
  17.     for img_name, target in csv_data.iterrows():
  18.         images.append(image.imread(
  19.             os.path.join(data_dir, 'bananas_train' if is_train else
  20.                          'bananas_val', 'images', f'{img_name}')))
  21.         # 这里的target包含（类别，左上角x，左上角y，右下角x，右下角y），
  22.         # 其中所有图像都具有相同的香蕉类（索引为0）
  23.         targets.append(list(target))
  24.     return images, np.expand_dims(np.array(targets), 1) / 256

```{.python .input}

@tab pytorch

@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}’)))

  1.     # 这里的target包含（类别，左上角x，左上角y，右下角x，右下角y），
  2.     # 其中所有图像都具有相同的香蕉类（索引为0）
  3.     targets.append(list(target))
  4. return images, torch.tensor(targets).unsqueeze(1) / 256
  2. 通过使用`read_data_bananas`函数读取图像和标签，以下`BananasDataset`类别将允许我们[**创建一个自定义`Dataset`实例**]来加载香蕉检测数据集。
  4. ```{.python .input}
  5. #@save
  6. class BananasDataset(gluon.data.Dataset):
  7.     """一个用于加载香蕉检测数据集的自定义数据集"""
  8.     def __init__(self, is_train):
  9.         self.features, self.labels = read_data_bananas(is_train)
  10.         print('read ' + str(len(self.features)) + (f' training examples' if
  11.               is_train else f' validation examples'))
  13.     def __getitem__(self, idx):
  14.         return (self.features[idx].astype('float32').transpose(2, 0, 1),
  15.                 self.labels[idx])
  17.     def __len__(self):
  18.         return len(self.features)

```{.python .input}

@tab pytorch

@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’))

  1. def __getitem__(self, idx):
  2.     return (self.features[idx].float(), self.labels[idx])
  4. def __len__(self):
  5.     return len(self.features)
  2. 最后，我们定义`load_data_bananas`函数，来[**为训练集和测试集返回两个数据加载器实例**]。对于测试集，无须按随机顺序读取它。
  4. ```{.python .input}
  5. #@save
  6. def load_data_bananas(batch_size):
  7.     """加载香蕉检测数据集"""
  8.     train_iter = gluon.data.DataLoader(BananasDataset(is_train=True),
  9.                                        batch_size, shuffle=True)
  10.     val_iter = gluon.data.DataLoader(BananasDataset(is_train=False),
  11.                                      batch_size)
  12.     return train_iter, val_iter

```{.python .input}

@tab pytorch

@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

  2. 让我们[**读取一个小批量，并打印其中的图像和标签的形状**]。
  3. 图像的小批量的形状为（批量大小、通道数、高度、宽度），看起来很眼熟：它与我们之前图像分类任务中的相同。
  4. 标签的小批量的形状为（批量大小，$m$，5），其中$m$是数据集的任何图像中边界框可能出现的最大数量。
  6. 小批量计算虽然高效，但它要求每张图像含有相同数量的边界框，以便放在同一个批量中。
  7. 通常来说，图像可能拥有不同数量个边界框；因此，在达到$m$之前，边界框少于$m$的图像将被非法边界框填充。
  8. 这样，每个边界框的标签将被长度为5的数组表示。
  9. 数组中的第一个元素是边界框中对象的类别，其中-1表示用于填充的非法边界框。
  10. 数组的其余四个元素是边界框左上角和右下角的（$x$，$y$）坐标值（值域在0到1之间）。
  11. 对于香蕉数据集而言，由于每张图像上只有一个边界框，因此$m=1$。
  13. ```{.python .input}
  14. #@tab all
  15. batch_size, edge_size = 32, 256
  16. train_iter, _ = load_data_bananas(batch_size)
  17. batch = next(iter(train_iter))
  18. batch[0].shape, batch[1].shape

[演示]

让我们展示10幅带有真实边界框的图像。 我们可以看到在所有这些图像中香蕉的旋转角度、大小和位置都有所不同。 当然，这只是一个简单的人工数据集，实践中真实世界的数据集通常要复杂得多。

```{.python .input} imgs = (batch[0][0:10].transpose(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’])

  2. ```{.python .input}
  3. #@tab pytorch
  4. imgs = (batch[0][0:10].permute(0, 2, 3, 1)) / 255
  5. axes = d2l.show_images(imgs, 2, 5, scale=2)
  6. for ax, label in zip(axes, batch[1][0:10]):
  7.     d2l.show_bboxes(ax, [label[0][1:5] * edge_size], colors=['w'])

小结

  • 我们收集的香蕉检测数据集可用于演示目标检测模型。
  • 用于目标检测的数据加载与图像分类的数据加载类似。但是，在目标检测中，标签还包含真实边界框的信息，它不出现在图像分类中。

练习

  1. 在香蕉检测数据集中演示其他带有真实边界框的图像。它们在边界框和目标方面有什么不同？
  2. 假设我们想要将数据增强（例如随机裁剪）应用于目标检测。它与图像分类中的有什么不同？提示：如果裁剪的图像只包含物体的一小部分会怎样？

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab: