计算机视觉常用数据集

本文记录计算机视觉中常用的数据集，包括它们的官网、下载链接、目录结构、文件大小、加载方式等等。其中「本地目录结构」为我个人组织数据的方式，仅供参考。

AFHQ

官网 | Paper with Code | Dropbox

简要介绍：Animal FacesHQ (AFHQ) 是一个高质量动物面部图像的数据集，包含猫、狗和野生动物三个域。所有图像都已经过水平和垂直对齐，以确保将眼睛置于图像中心。低质量图像已由人工剔除。

基本信息：

  • 数量：15,803
  • 划分（train / test）：
    • Total：14,336 / 1,467
    • Cat：5,065 / 493
    • Dog：4,678 / 491
    • Wild：4,593 / 483
  • 分辨率：512×512

注意：上述信息对应第二个版本（AFHQv2），其在 v1 版本上更换了更好的重采样方式（Nearest neighbor => Lanczos）、删除了大约 2% 的图片、以及改用 png 格式保存。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
data
└── AFHQ
    ├── afhq_v2.zip    (7.0 GB)
    ├── train          (extracted from afhq_v2.zip)
    │   ├── cat        (contains 5065 images)
    │   ├── dog        (contains 4678 images)
    │   └── wild       (contains 4593 images)
    └── test           (extracted from afhq_v2.zip)
        ├── cat        (contains 493 images)
        ├── dog        (contains 491 images)
        └── wild       (contains 483 images)

需要自定义 Dataset 加载数据集。


CelebA

官网 | Papers with Code | Google drive | Baidu drive (password: rp0s)

简要介绍：CelebFaces Attribute (CelebA) 数据集包含来自 10,177 位名人的 202,599 张面部图像，每张图像的尺寸为 178×218 像素，并且用 40 个二进制标签进行注释，这些标签指示了面部属性，如头发颜色、性别和年龄。

基本信息：

  • 数量：202,599
  • 划分：162,770 / 19,867 / 19,962 (train / valid / test)
  • 分辨率：
    • align 处理后：178×218
    • 原始图片：不一致，200+ 到 2000+ 都有
  • 标注：每张图像有
    • 40 个 binary labels，指示发色、性别、年龄等信息
    • 人脸 bounding box
    • 5 个位置的 landmark（左眼、右眼、鼻尖、左嘴角、右嘴角）
    • identity（名人身份 id，共 10,177 人）

官方目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
.
├── Anno
│   ├── identity_CelebA.txt
│   ├── list_attr_celeba.txt
│   ├── list_bbox_celeba.txt
│   ├── list_landmarks_align_celeba.txt
│   └── list_landmarks_celeba.txt
├── Eval
│   └── list_eval_partition.txt
├── Img
│   ├── img_align_celeba_png.7z
│   ├── img_celeba.7z
│   └── img_align_celeba.zip
└── README.txt

注：三个图片压缩包中，一般用 img_align_celeba.zip 即可.

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
data
└── CelebA
    └── celeba
        ├── identity_CelebA.txt
        ├── img_align_celeba.zip       (1.44 GB)
        ├── img_celeba.7z              (10.19 GB)
        ├── img_align_celeba           (extracted from img_align_celeba.zip)
        │   ├── 000001.jpg
        │   ├── ...
        │   └── 202599.jpg
        ├── img_celeba                 (extracted from img_celeba.7z)
        │   ├── 000001.jpg
        │   ├── ...
        │   └── 202599.jpg
        ├── list_attr_celeba.txt
        ├── list_bbox_celeba.txt
        ├── list_eval_partition.txt
        ├── list_landmarks_align_celeba.txt
        ├── list_landmarks_celeba.txt
        └── README.txt

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> import torchvision.datasets as dset
>>> celeba = dset.CelebA(root='/data/CelebA', split='train')
>>> len(celeba)
162770
>>> celeba = dset.CelebA(root='/data/CelebA', split='valid')
>>> len(celeba)
19867
>>> celeba = dset.CelebA(root='/data/CelebA', split='test')
>>> len(celeba)
19962
>>> celeba = dset.CelebA(root='/data/CelebA', split='all')
>>> len(celeba)
202599


CelebA-HQ

官网 | Papers with Code

简要介绍：CelebA-HQ 数据集是 CelebA 数据集的高质量版本，由 30,000 张 1024×1024 分辨率的图像组成。

基本信息：

  • 数量：30,000，是 CelebA 的子集
  • 遵从 CelebA 原始划分：24,183 / 2,993 / 2,824 (train / valid / test)
  • 分辨率：1024×1024

官方生成方式：下载 img_celeba.7z 和 delta 文件，使用 dataset_tool.py 生成高清图片。

其他生成方式：用网上其他人魔改的 h5tool.py 生成高清图片。问题：生成的图片可能有噪点或质量不高。

推荐方式：下载 CelebAMask-HQ 数据集（见下文），然后根据 CelebA-HQ-to-CelebA-mapping.txt 把文件名映射回原 id，例如，以下是一个简单的映射脚本 map_index.py：

1
2
3
4
5
6
7
8
9
10
11
12
import os
import pandas as pd


mapping = pd.read_table('CelebA-HQ-to-CelebA-mapping.txt', sep='\s+', index_col=0)
mapping_dict = dict()
for i in range(30000):
	mapping_dict.update({f'{i}.jpg': mapping.iloc[i]['orig_file']})

for key, value in mapping_dict.items():
	assert os.path.isfile(os.path.join('CelebA-HQ-img', key))
	os.rename(os.path.join('CelebA-HQ-img', key), os.path.join('CelebA-HQ-img', value))

本地目录结构：

1
2
3
4
5
6
7
8
9
data
└── CelebA-HQ
    ├── CelebA-HQ-img.zip     (2.74 GB)
    ├── CelebA-HQ-img         (extracted from CelebA-HQ-img.zip)
    │   ├── 000004.jpg
    │   ├── ...
    │   └── 202591.jpg
    ├── CelebA-HQ-to-CelebA-mapping.txt
    └── map_index.py

需要自定义 Dataset 加载数据集，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import os
from PIL import Image
from torch.utils.data import Dataset


class CelebA_HQ(Dataset):
    """
    The downloaded 30,000 images should be stored under `root/CelebA-HQ-img/`.

    The file names should be the same as their counterparts in the original CelebA dataset.

    The train/valid/test sets are split according to the original CelebA dataset,
    resulting in 24,183 training images, 2,993 validation images, and 2,824 test images.

    """
    def __init__(self, root, split='train', transform=None):
        image_root = os.path.join(os.path.expanduser(root), 'CelebA-HQ-img')
        assert os.path.isdir(image_root), f'{image_root} is not a valid directory'
        assert split in ['train', 'valid', 'test', 'all']

        self.transform = transform

        img_ext = ['.png', '.jpg', '.jpeg']
        self.img_paths = []
        for curdir, subdirs, files in os.walk(image_root):
            for file in files:
                if os.path.splitext(file)[1].lower() in img_ext:
                    self.img_paths.append(os.path.join(curdir, file))
        self.img_paths = sorted(self.img_paths)

        celeba_splits = [1, 162771, 182638, 202600]

        def filter_func(p):
            if split == 'all':
                return True
            k = 0 if split == 'train' else (1 if split == 'valid' else 2)
            return celeba_splits[k] <= int(os.path.splitext(os.path.basename(p))[0]) < celeba_splits[k+1]

        self.img_paths = list(filter(filter_func, self.img_paths))

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

    def __getitem__(self, item):
        X = Image.open(self.img_paths[item])
        if self.transform is not None:
            X = self.transform(X)
        return X


if __name__ == '__main__':
    dataset = CelebA_HQ(root='/data/CelebA-HQ/', split='train')
    print(len(dataset))
    dataset = CelebA_HQ(root='/data/CelebA-HQ/', split='valid')
    print(len(dataset))
    dataset = CelebA_HQ(root='/data/CelebA-HQ/', split='test')
    print(len(dataset))
    dataset = CelebA_HQ(root='/data/CelebA-HQ/', split='all')
    print(len(dataset))


CelebAMask-HQ

官网 | Google drive | Baidu drive

简要介绍：在 CelebA-HQ 数据集的基础上增加了对应 CelebA 面部属性的 segmentation mask.

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
data
├── CelebAMask-HQ.zip       (3.15 GB)
└── CelebAMask-HQ           (extracted from CelebAMask-HQ.zip)
    ├── CelebA-HQ-img
    │   ├── 0.jpg
    │   ├── ...
    │   └── 29999.jpg
    ├── CelebA-HQ-to-CelebA-mapping.txt
    ├── CelebAMask-HQ-attribute-anno.txt
    ├── CelebAMask-HQ-mask-anno
    │   ├── 0
    │   │   ├── 00000_hair.png
    │   │   └── ...
    │   └── ...
    ├── CelebAMask-HQ-pose-anno.txt
    └── README.txt

需要自定义 Dataset 加载数据集。


CIFAR-10

官网 | Papers with Code

简要介绍：CIFAR-10 数据集是 Tiny Images 数据集的子集，包括 60,000 张 32×32 像素的彩色图像。这些图像被标记为10个相互独立的类别：飞机、汽车（但不包括卡车或皮卡车）、鸟、猫、鹿、狗、青蛙、马、船和卡车（但不包括皮卡车）。每个类别有 6,000 张图像，每个类别包含 5,000 张训练图像和 1,000 张测试图像。

基本信息：

  • 数量：60,000
  • 划分：50,000 / 10,000 (train / test)
  • 分辨率：32×32
  • 标注：10 类

存储为 png：原文件并非图片格式，如果有 png 格式的需求，可用以下脚本转换 makepng.py：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import os
from tqdm import tqdm
import torchvision.datasets as dsets


for i in range(10):
	os.makedirs(f'./png/train/{i}/', exist_ok=True)
	os.makedirs(f'./png/test/{i}/', exist_ok=True)

ids = {k: 0 for k in range(10)}
cifar10 = dsets.CIFAR10(root='.', train=True)
for X, y in tqdm(cifar10):
	X.save(f'./png/train/{y}/{ids[y]}.png')
	ids[y] += 1

ids = {k: 0 for k in range(10)}
cifar10 = dsets.CIFAR10(root='.', train=False)
for X, y in tqdm(cifar10):
	X.save(f'./png/test/{y}/{ids[y]}.png')
	ids[y] += 1

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
data
└── CIFAR-10
    ├── cifar-10-python.tar.gz   (170.5 MB)
    └── cifar-10-batches-py      (extracted from cifar-10-python.tar.gz)
        ├── batches.meta
        ├── data_batch_1
        ├── data_batch_2
        ├── data_batch_3
        ├── data_batch_4
        ├── data_batch_5
        ├── readme.html
        └── test_batch

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> cifar10 = dset.CIFAR10(root='/data/CIFAR-10', train=True)
>>> len(cifar10)
50000
>>> cifar10 = dset.CIFAR10(root='/data/CIFAR-10', train=False)
>>> len(cifar10)
10000


CIFAR-100

官网 | Papers with Code

简要介绍：CIFAR-100 数据集是 Tiny Images 数据集的子集，包括 60,000 张 32×32 像素的彩色图像。CIFAR-100 的 100 个类别被分成 20 个超类别。每个图像都带有一个“细”标签（它所属的类别）和一个“粗”标签（它所属的超类别）。每个类别有 600 张图像——500 张训练图像和 100 张测试图像。

基本信息：

  • 数量：60,000
  • 划分：50,000 / 10,000 (train / test)
  • 分辨率：32×32
  • 标注：100 类，分组为 20 个 superclass

存储为 png：原文件并非图片格式，如果有 png 格式的需求，可用以下脚本转换 makepng.py：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import os
from tqdm import tqdm
import torchvision.datasets as dsets


for i in range(100):
	os.makedirs(f'./png/train/{i}/', exist_ok=True)
	os.makedirs(f'./png/test/{i}/', exist_ok=True)

ids = {k: 0 for k in range(100)}
cifar100 = dsets.CIFAR100(root='.', train=True)
for X, y in tqdm(cifar100):
	X.save(f'./png/train/{y}/{ids[y]}.png')
	ids[y] += 1

ids = {k: 0 for k in range(100)}
cifar100 = dsets.CIFAR100(root='.', train=False)
for X, y in tqdm(cifar100):
	X.save(f'./png/test/{y}/{ids[y]}.png')
	ids[y] += 1

本地目录结构：

1
2
3
4
5
6
7
data
├── cifar-100-python.tar.gz   (169 MB)
└── cifar-100-python          (extracted from cifar-100-python.tar.gz)
    ├── file.txt~
    ├── meta
    ├── test
    └── train

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> cifar100 = dset.CIFAR100(root='/data/CIFAR-100', train=True)
>>> len(cifar100)
50000
>>> cifar100 = dset.CIFAR100(root='/data/CIFAR-100', train=False)
>>> len(cifar100)
10000


Fashion-MNIST

官网 | Papers with Code

简要介绍：Fashion-MNIST 是一个由 10 个类别、每个类别 7,000 张 28×28 像素的灰度图像组成数据集，总计70,000 张时尚产品图像。训练集包含 60,000 张图像，测试集包含 10,000 张图像。Fashion-MNIST 与原始的 MNIST 数据集具有相同的图像大小、数据格式以及训练和测试集的划分结构。

基本信息：

  • 数量：70,000
  • 划分：60,000 / 10,000 (train / test)
  • 分辨率：28×28
  • 标注：10 类

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
data
└── Fashion-MNIST
    └── FashionMNIST
        └── raw
            ├── t10k-images-idx3-ubyte
            ├── t10k-images-idx3-ubyte.gz
            ├── t10k-labels-idx1-ubyte
            ├── t10k-labels-idx1-ubyte.gz
            ├── train-images-idx3-ubyte
            ├── train-images-idx3-ubyte.gz
            ├── train-labels-idx1-ubyte
            └── train-labels-idx1-ubyte.gz

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> fashion = dset.FashionMNIST(root='/data/Fashion-MNIST', train=True)
>>> len(fashion)
60000
>>> fashion = dset.FashionMNIST(root='/data/Fashion-MNIST', train=False)
>>> len(fashion)
10000


FFHQ

官网 | Papers with Code | Google drive

简要介绍：Flickr-Faces-HQ (FFHQ) 由 70,000 张高质量 PNG 图像组成，分辨率为 1024×1024，具有年龄、种族和图像背景等方面的相当大的变化。它还涵盖了各种饰品，如眼镜、太阳镜、帽子等。这些图像是从 Flickr 爬取的，因此继承了该网站的所有偏见，并使用 dlib 自动对齐和裁剪。只收集了许可证宽松的图像。使用各种自动过滤器对数据集进行了修剪，最后使用 Amazon Mechanical Turk 删除了偶尔出现的雕像、绘画或照片等。

基本信息：

  • 数量：70,000
  • 划分：60,000 / 10,000 (train / valid)
  • 分辨率：1024×1024

官方目录结构：

1
2
3
4
5
6
7
8
9
.
├── LICENSE.txt
├── README.txt
├── ffhq-dataset-v2.json
├── images1024x1024         (89.1 GB)
├── in-the-wild-images      (955 GB)
├── tfrecords               (273 GB)
├── thumbnails128x128       (1.95 GB)
└── zips                    (1.28 TB)

注：一般而言，我们只需要用 images1024x1024 图片。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
data
└── FFHQ
    ├── LICENSE.txt
    ├── README.txt
    ├── ffhq-dataset-v2.json
    ├── images1024x1024.zip      (95.73 GB)
    └── images1024x1024          (extracted from images1024x1024.zip)
        ├── LICENSE.txt
        ├── 00000
        │   ├── 00000.png
        │   ├── ...
        │   └── 00999.png
        ├── ...
        └── 69000
            ├── 69000.png
            ├── ...
            └── 69999.png

需要自定义 Dataset 加载数据集，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
import os
from PIL import Image
from torch.utils.data import Dataset


class FFHQ(Dataset):
    """
    The downloaded 70,000 images should be organized in the following structure:

    - root/
        - image1024x1024/
            - 00000/
                - 00000.png
                - 00001.png
                - ...
                - 00999.png
            - ...
            - 69000/
                - 69000.png
                - 69001.png
                - ...
                - 69999.png

    If `official_split` is True, the first 60,000 images will be the training set and the remaining 10,000 images will be the test set.
    Otherwise, the 10,000 images in the test set are further divided into a 5,000-image validation set and a 5,000-image test set.

    """
    def __init__(self, root, split='train', original_size=1024, transform=None, official_split=True):
        image_root = os.path.join(os.path.expanduser(root), f'images{original_size}x{original_size}')
        assert os.path.isdir(image_root), f'{image_root} is not a valid directory'
        assert split in ['train', 'valid', 'test', 'all']

        self.transform = transform

        img_ext = ['.png', '.jpg', '.jpeg']
        self.img_paths = []
        for curdir, subdirs, files in os.walk(image_root):
            for file in files:
                if os.path.splitext(file)[1].lower() in img_ext:
                    self.img_paths.append(os.path.join(curdir, file))
        self.img_paths = sorted(self.img_paths)

        if official_split:
            if split == 'train':
                self.img_paths = list(filter(lambda p: '00000' <= (os.path.dirname(p)).split('/')[-1] < '60000', self.img_paths))
            elif split == 'test':
                self.img_paths = list(filter(lambda p: '60000' <= (os.path.dirname(p)).split('/')[-1] < '70000', self.img_paths))
            elif split == 'valid':
                raise ValueError(f'FFHQ official split does not have a validation set.')
        else:
            if split == 'train':
                self.img_paths = list(filter(lambda p: '00000' <= (os.path.dirname(p)).split('/')[-1] < '60000', self.img_paths))
            elif split == 'valid':
                self.img_paths = list(filter(lambda p: '60000' <= (os.path.dirname(p)).split('/')[-1] < '65000', self.img_paths))
            elif split == 'test':
                self.img_paths = list(filter(lambda p: '65000' <= (os.path.dirname(p)).split('/')[-1] < '70000', self.img_paths))

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

    def __getitem__(self, item):
        X = Image.open(self.img_paths[item])
        if self.transform is not None:
            X = self.transform(X)
        return X


if __name__ == '__main__':
    dataset = FFHQ(root='/data/FFHQ/', split='train', official_split=False)
    print(len(dataset))
    dataset = FFHQ(root='/data/FFHQ/', split='valid', official_split=False)
    print(len(dataset))
    dataset = FFHQ(root='/data/FFHQ/', split='test', official_split=False)
    print(len(dataset))
    dataset = FFHQ(root='/data/FFHQ/', split='all', official_split=False)
    print(len(dataset))
    print()
    dataset = FFHQ(root='/data/FFHQ/', split='train', official_split=True)
    print(len(dataset))
    dataset = FFHQ(root='/data/FFHQ/', split='test', official_split=True)
    print(len(dataset))
    dataset = FFHQ(root='/data/FFHQ/', split='all', official_split=True)
    print(len(dataset))


Flare7K

官网 | Papers with Code

简要介绍：Flare7K 是第一个夜间光晕去除数据集，它是基于真实世界夜间镜头光晕的观察和统计生成的。该数据集包括 5,000 张散射光晕图像和 2,000 张反射光晕图像，涵盖了 25 种散射光晕类型和 10 种反射光晕类型。这 7,000 个光晕图案可以随机添加到无光晕的图像中，形成光晕污染和无光晕的图像对。

下载：官方 github 页面包含了以下三个下载链接：

内容 文件名 说明 大小
Flares Flare7k.zip 5,000 张散射光晕和 2,000 张反射光晕图像 3.01 GB
Background Images Flickr24K.zip 23,949 张背景图像 1.12 GB
Flare-corrupted images flare_corrupted_test_imgs.zip 额外 645 张无 ground-truth 的有光晕图像 212.4 MB

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
data
└── Flare7K
    ├── flare_corrupted_test_imgs.zip     (222.7 MB)
    ├── Flare7k.zip                       (3.24 GB)
    ├── Flickr24K.zip                     (1.2 GB)
    ├── flare_corrupted_test_imgs         (extracted from flare_corrupted_test_imgs.zip)
    │   ├── test_00000.png
    │   ├── ...
    │   └── test_00644.png
    ├── Flare7k                           (extracted Flare7k.zip)
    │   ├── Reflective_Flare              (contains 2000 png images)
    │   │   ├── reflective_img_000000.png
    │   │   ├── ...
    │   │   └── reflective_img_001999.png
    │   ├── Scattering_Flare
    │   │   ├── Compound_Flare            (contains 5000 png images)
    │   │   ├── Glare_with_shimmer        (contains 5000 png images)
    │   │   ├── Light_Source              (contains 5000 png images)
    │   │   └── Streak                    (contains 5000 png images)
    │   └── test_data
    │       ├── real
    │       │   ├── gt                    (contains 100 png images)
    │       │   └── input                 (contains 100 png images)
    │       └── synthetic
    │           ├── gt                    (contains 100 png images)
    │           └── input                 (contains 100 png images)
    └── Flickr24K                         (extracted from Flickr24K.zip, contains 23949 jpg images)
        ├── 2.jpg
        ├── ...
        └── r (13746).jpg


ImageNet-21K (ImageNet-22K)

官网 | Papers with Code

简要介绍：完整的 ImageNet 数据集包含 14,197,122 张按 WordNet 层次结构注释的图像，共有 21,841 类，因此也被称作 ImageNet-21K 或 ImageNet-22K. 自 2010 年以来，该数据集被用于 ImageNet 大规模视觉识别挑战赛（ILSVRC），成为了图像分类和目标检测的基准。其中，ILSVRC2012 比赛所采用的子集成为了研究者最常用的版本，详见下文 ImageNet-1K.

基本信息：

  • 数量：14,197,122
  • 标注：21,814 类

下载：用教育邮箱登录官网，选择下载页面，可以在 Winter 2021 release 处看到链接，有若干版本：

  • 原始全部数据
  • 可以只下载某一类
  • 使用论文 "ImageNet-21K pretraining for the masses" 的脚本处理后的版本
  • ImageNet10K from ECCV2010

WIP：尚未下载和使用过完整的 ImageNet-21K，因此无法给出更多的细节。


ImageNet-1K (ILSVRC2012)

官网

简要介绍：ILSVRC2012 是最常用的 ImageNet 子集，包含 1000 类物体，因此也被称作 ImageNet-1K.

基本信息：

  • 数量：1,431,167
  • 划分：1,281,167 / 50,000 / 100,000 (train / valid / test)
  • 分辨率：各图片不一致，据说平均 469×387
  • 标注：1000 类。此链接有标签到类别名称的映射。

下载：用教育邮箱登录官网，选择 ILSVRC2012 下载页面可看到链接，包含：

内容 文件名 大小
Development Kit Development Kit (Task 1 & 2) ILSVRC2012_devkit_t12.tar.gz 2.5MB
Development Kit (Task 3) ILSVRC2012_devkit_t3.tar.gz 22MB
Images Training images (Task 1 & 2) ILSVRC2012_img_train.tar 138GB
Training images (Task 3) ILSVRC2012_img_train_t3.tar 728MB
Validation images (all tasks) ILSVRC2012_img_val.tar 6.3GB
Test images (all tasks) ILSVRC2012_img_test_v10102019.tar 13GB
Bounding Boxes Training bounding box annotations (Task 1 & 2 only) ILSVRC2012_bbox_train_v2.tar.gz 20MB
Training bounding box annotations (Task 3 only) ILSVRC2012_bbox_train_dogs.tar.gz 1MB
Validation bounding box annotations (all tasks) ILSVRC2012_bbox_val_v3.tgz 2.2MB
Test bounding box annotations (Task 3 only) ILSVRC2012_bbox_test_dogs.zip 33MB

其中 Task 1 是粗粒度分类任务、Task 2 是分类并定位任务、Task 3 是细粒度分类任务。

注：一般使用的（以及「基本信息」里面描述的）是 Task 1 & 2 任务的训练数据。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
data
└── ImageNet
    ├── ILSVRC2012_bbox_train_v2.tar.gz         (20.9 MB)
    ├── ILSVRC2012_bbox_train_dogs.tar.gz       (726 KB)
    ├── ILSVRC2012_bbox_val_v3.tgz              (2.2 MB)
    ├── ILSVRC2012_bbox_test_dogs.zip           (34.6 MB)
    ├── ILSVRC2012_devkit_t12.tar.gz            (2.6 MB)
    ├── ILSVRC2012_devkit_t3.tar.gz             (22.4 MB)
    ├── ILSVRC2012_img_train.tar                (147.9 GB)
    ├── ILSVRC2012_img_train_t3.tar             (762.5 MB)
    ├── ILSVRC2012_img_val.tar                  (6.74 GB)
    ├── ILSVRC2012_img_test_v10102019.tar       (13.69 GB)
    ├── meta.bin                                (created by torchvision)
    ├── train                                   (extracted and organized by torchvision)
    │   ├── n01440764
    │   ├── ...
    │   └── n15075141
    ├── val                                     (extracted and organized by torchvision)
    │   ├── n01440764
    │   ├── ...
    │   └── n15075141
    └── test                                    (extracted from ILSVRC2012_img_test_v10102019.tar)
        ├── ILSVRC2012_test_00000001.JPEG
        ├── ...
        └── ILSVRC2012_test_00100000.JPEG

注：第一次使用 torchvision 加载 ImageNet 数据集时，它会自动帮你解压并组织文件，最终得到上述目录结构，这个过程耗时较长。这个目录结构与直接解压不同，例如 ILSVRC2012_img_val.tar 中其实是直接包含了所有图片，但 torchvision 将它组织成和训练集一致的结构便于加载。

使用 torchvision 加载数据集（不支持测试集，因为测试集没有 ground-truth 标签）：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> imagenet = dset.ImageNet(root='/data/ImageNet', split='train')
>>> len(imagenet)
1281167
>>> imagenet = dset.ImageNet(root='/data/ImageNet', split='val')
>>> len(imagenet)
50000

对于不需要标签的任务，可以自定义 Dataset 加载测试集。


ImageNet-Downsampled

官网 | 官方博客

简要介绍：论文 “A Downsampled Variant of ImageNet as an Alternative to the CIFAR datasets” 提出的 ImageNet-1K 数据集的下采样版本，包括 8x8, 16x16, 32x32 和 64x64 四种分辨率版本。

基本信息：

  • 划分：1,281,167 / 50,000 (train / valid)
  • 标注：1000 类

下载：用教育邮箱登录官网，选择下载页面，可以在 Download downsampled image data (32x32, 64x64) 处看到链接。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
data
└── ImageNet64
    ├── Imagenet64_train_part1.zip  (6.9 GB)
    ├── Imagenet64_train_part2.zip  (6.9 GB)
    ├── Imagenet64_val.zip          (534 MB)
    ├── train_data_batch_1          (extracted from Imagenet64_train_part1.zip)
    ├── train_data_batch_2          (extracted from Imagenet64_train_part1.zip)
    ├── train_data_batch_3          (extracted from Imagenet64_train_part1.zip)
    ├── train_data_batch_4          (extracted from Imagenet64_train_part1.zip)
    ├── train_data_batch_5          (extracted from Imagenet64_train_part1.zip)
    ├── train_data_batch_6          (extracted from Imagenet64_train_part2.zip)
    ├── train_data_batch_7          (extracted from Imagenet64_train_part2.zip)
    ├── train_data_batch_8          (extracted from Imagenet64_train_part2.zip)
    ├── train_data_batch_9          (extracted from Imagenet64_train_part2.zip)
    ├── train_data_batch_10         (extracted from Imagenet64_train_part2.zip)
    └── val_data                    (extracted from Imagenet64_val.zip)

自定义 Dataset 加载数据集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import os
import pickle
import numpy as np
from PIL import Image

from torch.utils.data import Dataset
import torchvision.transforms as T


class ImageNet64(Dataset):
    def __init__(self, root, split='train', transform=None):
        assert split in ['train', 'valid']
        assert os.path.isdir(root), f'{root} is not an existing directory'

        self.transform = transform

        if split == 'train':
            self.data, self.labels = [], []
            for idx in range(1, 11):
                filepath = os.path.join(root, f'train_data_batch_{idx}')
                with open(filepath, 'rb') as f:
                    d = pickle.load(f)
                self.data.append(d['data'])
                self.labels.extend(d['labels'])
            self.data = np.concatenate(self.data, axis=0)
            self.labels = [i-1 for i in self.labels]
        else:
            with open(os.path.join(root, f'val_data'), 'rb') as f:
                d = pickle.load(f)
            self.data = d['data']
            self.labels = [i-1 for i in d['labels']]
        self.data = np.dstack((self.data[:, :64*64], self.data[:, 64*64:2*64*64], self.data[:, 2*64*64:]))
        self.data = self.data.reshape((self.data.shape[0], 64, 64, 3))  # HWC

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

    def __getitem__(self, item):
        img, label = self.data[item], self.labels[item]
        img = Image.fromarray(img)
        if self.transform is not None:
            img = self.transform(img)
        return img, label


if __name__ == '__main__':
    dataset = ImageNet64(root='/data/ImageNet64/', split='train')
    print(len(dataset))
    dataset = ImageNet64(root='/data/ImageNet64/', split='valid')
    print(len(dataset))

ISTD

官网 | Papers with Code

简要介绍：Image Shadow Triplets Dataset (ISTD) 是一个用于阴影理解（检测/去除）的数据集，包含 1,870 个图像三元组，每个三元组由阴影图像、阴影掩膜和无阴影图像构成。

基本信息：

  • 数量：1,870
  • 划分：1,330 / 540 (train / test)
  • 分辨率：640×480
  • 标注：三元组（A：阴影图像；B：阴影掩膜；C：无阴影图像）

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
data
└── ISTD
    ├── ISTD_Dataset.rar       (2.14 GB)
    ├── train                  (extracted from ISTD_Dataset.rar)
    │   ├── train_A            (contains 1330 images)
    │   ├── train_B            (contains 1330 images)
    │   └── train_C            (contains 1330 images)
    └── test                   (extracted from ISTD_Dataset.rar)
        ├── test_A             (contains 540 images)
        ├── test_B             (contains 540 images)
        └── test_C             (contains 540 images)

需要自定义 Dataset 加载数据集。


官网 | OneDrive

简要介绍：LOGO 是一个用于水印去除的数据集。背景图像选自 MSCOCO 数据集的 VAL2014 子集；水印收集自互联网上 1000 多个不同的著名标志。将水印（标志）在不同位置、半透明度和大小随机放置在自然图像上来生成水印样本。每个训练/测试样本都包含合成的水印图像、原始背景、水印以及水印掩膜以进行监督。所有水印和背景图像在训练和验证分区中都没有重叠。按照水印的不同透明度和大小，整个数据集分为四种设置：LOGO-L、LOGO-H、LOGO-Gray、LOGO30K.

基本信息：

LOGO-L LOGO-H LOGO-Gray LOGO30K
transparency 35% - 60% 60% - 85% 35% - 85% 35% - 85%
Percentage of the watermarks size 35% - 60% 60% - 85% 35% - 85% 35% - 85%
Numbers of samples (train : val) 12k : 2k 12k : 2k 12k : 2k 28k : 4k
Colorful watermark? yes yes no yes
  • 数量：
    • LOGO-L、LOGO-H、LOGO-Gray：14,176
    • LOGO30K：32,403
  • 划分（train / valid）：
    • LOGO-L、LOGO-H、LOGO-Gray：12,151 / 2,025
    • LOGO30K：28,352 / 4,051
  • 分辨率：对应 COCO 数据集的原始图片大小，另提供 resize 到 256×256 的验证集。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
data
└── LOGO
    ├── 10kgray.zip               (14.99 GB)
    ├── 10khigh.zip               (15.18 GB)
    ├── 10kmid.zip                (15 GB)
    ├── 27kpng.zip                (24.11 GB)
    ├── 10kgray                   (extracted from 27kpng.zip)
    │   ├── train_images.txt
    │   ├── train_wm.txt
    │   ├── val_images.txt
    │   ├── val_wm.txt
    │   ├── natural               (contains 40504 jpg images selected from COCO_val2014)
    │   ├── train_images
    │   │   ├── image             (contains 12151 png images)
    │   │   ├── mask              (contains 12151 png images)
    │   │   └── wm                (contains 12151 png images)
    │   ├── val_images
    │   │   ├── image             (contains 2025 png images)
    │   │   ├── mask              (contains 2025 png images)
    │   │   └── wm                (contains 2025 png images)
    │   ├── val_input_256         (contains 2025 png images, resized to 256x256)
    │   └── val_target_256        (contains 2025 png images, resized to 256x256)
    ├── 10khigh                   (extracted from 10khigh.zip)
    │   └── same as 10kgray
    ├── 10kmid                    (extracted from 10kmid.zip)
    │   └── same as 10kgray
    └── 27kpng                    (extracted from 27kpng.zip)
        ├── natural               (contains 32403 jpg images selected from COCO_val2014)
        ├── train_images
        │   ├── image             (contains 28352 png images)
        │   ├── mask              (contains 28352 png images)
        │   └── wm                (contains 28352 png images)
        ├── val_images
        │   ├── image             (contains 4055 png images)
        │   ├── mask              (contains 4051 png images)
        │   └── wm                (contains 4051 png images)
        └── val_target_256        (contains 4051 png images, cropped to 256x256)

需要自定义 Dataset 加载数据集。


MNIST

官网

简要介绍：MNIST 手写数字数据集包含 60,000 个训练样本和 10,000 个测试样本。数字的大小已标准化且放置在图像中心。

基本信息：

  • 数量：70,000
  • 划分：60,000 / 10,000 (train / test)
  • 分辨率：28×28
  • 标注：10 类

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
data
└── MNIST
    └── MNIST
        └── raw
            ├── t10k-images-idx3-ubyte
            ├── t10k-images-idx3-ubyte.gz
            ├── t10k-labels-idx1-ubyte
            ├── t10k-labels-idx1-ubyte.gz
            ├── train-images-idx3-ubyte
            ├── train-images-idx3-ubyte.gz
            ├── train-labels-idx1-ubyte
            └── train-labels-idx1-ubyte.gz

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> mnist = dset.MNIST(root='/data/MNIST', train=True)
>>> len(mnist)
60000
>>> mnist = dset.MNIST(root='/data/MNIST', train=False)
>>> len(mnist)
10000


NVIDIA Irregular Mask Dataset

官网 | Dropbox (irregular_mask.zip) | Dropbox (test_mask.zip)

简要介绍：随机掩码来源于估计视频中两个相邻帧之间遮挡/非遮挡掩码。数据集提出者采用这种方式生成了 55,116 个用于训练的掩码，训练时首先从 55,116 个掩码中随机采样一个掩码，然后进行随机膨胀、旋转和裁剪来增强掩码数据集。用同样的方式生成了 24,866 个测试掩码，经过随机增强后按照面积比例划分为 6 组：(0.01, 0.1], (0.1, 0.2], (0.2, 0.3], (0.3, 0.4], (0.4, 0.5], (0.5, 0.6]，每组 2,000 个掩码，其中 1,000 个没有靠近边缘的缺失像素，另外 1,000 个有靠近边缘的缺失像素，最终形成大小为 12,000 的测试集。

基本信息：

  • 划分（官方）：55,116 / 12,000 (train / test)
  • 划分（个人用法，见「使用说明」）：76,800 / 19,200 (train / test)
  • 分辨率：
    • 训练集（增强前）：960×640
    • 测试集：512×512

使用说明（重要！）：从「简要介绍」可以看到，NVIDIA 官方提供的训练集并不是最终的训练数据，需要在训练时做增强操作。但考虑到数据增强的耗时，很多研究只采用官方测试集中的图片训练和测试，因此需要重新制作和划分训练、测试集。我这里采用类似于 EdgeConnect 的做法重新划分训练、测试集，具体方法为：每张官方测试集中的掩码图片在翻转和旋转后可以生成 8 张图片，因此原来的测试集大小被扩张到 96,000，再随机按 4:1 划分新的训练/测试集（详见 knazeri/edge-connect#28 (comment)）。划分脚本如下 _make_irregular_dataset.py：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import os
import numpy as np
from PIL import Image
from tqdm import tqdm

import torch
import torchvision.transforms as T


if __name__ == '__main__':
    irregular_mask = '/data/NVIDIAIrregularMaskDataset/downloaded_test/'
    save_path_train = '/data/NVIDIAIrregularMaskDataset/train/'
    save_path_test = '/data/NVIDIAIrregularMaskDataset/test/'

    masks = os.listdir(irregular_mask)
    for k in range(6):
        if not os.path.exists(os.path.join(save_path_train, str(k))):
            os.mkdir(os.path.join(save_path_train, str(k)))
        if not os.path.exists(os.path.join(save_path_test, str(k))):
            os.mkdir(os.path.join(save_path_test, str(k)))

        tests = np.random.choice(np.arange(2000), size=400, replace=False)
        for idx, fileid in enumerate(tqdm(range(k * 2000, (k + 1) * 2000))):
            mask = Image.open(os.path.join(irregular_mask, str(fileid).zfill(5)+'.png'))
            mask = T.ToTensor()(mask)
            # binarization
            mask = torch.where(mask < 0.5, 0., 1.)
            # rotation & flipping
            for i in range(4):
                for j in range(2):
                    tmp = T.RandomRotation((i * 90, i * 90))(mask)
                    tmp = T.RandomHorizontalFlip(p=j)(tmp)
                    tmp = T.ToPILImage()(tmp)

                    if idx in tests:
                        tmp.save(os.path.join(save_path_test, str(k), str(fileid).zfill(5)+f'_{i*2+j}.png'))
                    else:
                        tmp.save(os.path.join(save_path_train, str(k), str(fileid).zfill(5)+f'_{i*2+j}.png'))

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
data
└── NVIDIAIrregularMaskDataset
    ├── _make_irregular_dataset.py
    ├── downloaded_train.zip          (1.33 GB, renamed)
    ├── downloaded_test.zip           (44.9 MB, renamed)
    ├── downloaded_train              (extracted from downloaded_train.zip, renamed)
    │   ├── 00001.png
    │   ├── ...
    │   └── 55116.png
    ├── downloaded_test               (extracted from downloaded_test.zip, renamed)
    │   ├── 00000.png
    │   ├── ...
    │   └── 11999.png
    ├── train.zip                     (285 MB)
    ├── test.zip                      (71.3 MB)
    ├── train                         (created by _make_irregular_dataset.py)
    └── test                          (created by _make_irregular_dataset.py)

需要自定义 Dataset 加载数据集。


Oxford 102 Flower

官网 | Papers with Code

简要介绍：Oxford 102 Flower 是一个包含 102 个花卉类别的图像分类数据集。所选花卉是英国常见的花卉。每个类别包含 40 至 258 张图像。这些图像在大小、姿态和光照上都有很大的变化。此外，有些类别内部变化很大，还有一些类别非常相似。

基本信息：

  • 数量：8,189
  • 划分：1,020 / 1,020 / 6,149 (train / valid / test)
  • 分辨率：不一致，但最小边长均为 500
  • 标注：102 类

下载：官网提供了 6 个下载链接，分别是：

内容 文件名 大小
Dataset images 102flowers.tgz 344.9 MB
Image segmentations 102segmentations.tgz 203.6 MB
&Chi2 distances distancematrices102.mat 1.98 GB
The image labels imagelabels.mat 502 B
The data splits setid.mat 15 KB
README README.txt /

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
data
└── Oxford-102-Flower
    └── flowers-102
        ├── README.txt
        ├── imagelabels.mat
        ├── setid.mat
        ├── distancematrices102.mat
        ├── 102flowers.tgz            (344.9 MB)
        ├── 102segmentations.tgz      (203.6 MB)
        ├── jpg                       (extracted from 102flowers.tgz)
        │   ├── image_00001.jpg
        │   ├── ...
        │   └── image_08189.jpg
        └── segmim                    (extracted from 102segmentations.tgz)
            ├── segmim_00001.jpg
            ├── ...
            └── segmim_08189.jpg

使用 torchvision 加载数据集。


Paris StreetView

官网与下载：需要联系作者，见 https://github.com/pathak22/context-encoder/issues/24

基本信息：

  • 数量：15,000
  • 划分：14,900 / 100 (train / test)
  • 分辨率：
    • 训练集：936×537
    • 测试集：227×227

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
data
└── ParisStreetView
    ├── paris_eval_75876.zip                  (16.2 MB)
    ├── paris_train_original.zip              (1.22 GB)
    ├── paris_eval_gt                         (extracted from paris_eval_75876.zip)
    │   ├── 001_im.png
    │   ├── ...
    │   └── 100_im.png
    ├── paris_eval_corrupted                  (extracted from paris_eval_75876.zip)
    │   ├── 001_im.png
    │   ├── ...
    │   └── 100_im.png
    └── paris_train_original                  (extracted from paris_train_original.zip)
        ├── 48.842502_2.344968_90_-004.JPG
        ├── ...
        └── 48.867048_2.348918_270_-004.JPG

需要自定义 Dataset 加载数据集，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import os
from PIL import Image
from torch.utils.data import Dataset


class ParisStreetView(Dataset):
    """
    The downloaded data should be organized in the following structure:

    - root/
        - paris_train_original/ (14,900 images extracted from paris_train_original.zip)
            - 48.842502_2.344968_90_-004.JPG
            - ...
        - paris_eval_gt/ (100 images extracted from paris_eval_75876.zip)
            - 001_im.png
            - ...

    """
    def __init__(self, root, split='train', transform=None):
        assert split in ['train', 'test', 'all']
        train_root = os.path.join(root, 'paris_train_original')
        eval_root = os.path.join(root, 'paris_eval_gt')
        assert os.path.isdir(root) and os.path.isdir(train_root) and os.path.isdir(eval_root)

        self.transform = transform

        img_ext = ['.png', '.jpg', '.jpeg']
        self.img_paths = []
        if split in ['train', 'all']:
            for curdir, subdirs, files in os.walk(train_root):
                for file in files:
                    if os.path.splitext(file)[1].lower() in img_ext:
                        self.img_paths.append(os.path.join(curdir, file))
        if split in ['test', 'all']:
            for curdir, subdirs, files in os.walk(eval_root):
                for file in files:
                    if os.path.splitext(file)[1].lower() in img_ext:
                        self.img_paths.append(os.path.join(curdir, file))
        self.img_paths = sorted(self.img_paths)

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

    def __getitem__(self, item):
        X = Image.open(self.img_paths[item])
        if self.transform is not None:
            X = self.transform(X)
        return X


if __name__ == '__main__':
    dataset = ParisStreetView(root='/data/ParisStreetView', split='train')
    print(len(dataset))
    dataset = ParisStreetView(root='/data/ParisStreetView', split='test')
    print(len(dataset))
    dataset = ParisStreetView(root='/data/ParisStreetView', split='all')
    print(len(dataset))


PASCAL-VOC

官网 | Papers with Code

详细统计数据：http://host.robots.ox.ac.uk/pascal/VOC/voc2007/dbstats.html

说明：最常用的两个版本是 2007 和 2012，检测和分割可用的数据量也有所不同

  • 数量及划分：

    • 2007 Detection

      9,963 images，24,640 objects

      2,501 / 2,510 / 4,952 (train / valid / test)

    • 2007 Segmentation

      632 images

      209 / 213 / 210 (train / valid / test)

    • 2012 Detection

      11,540 images，27,450 objects

      5,717 / 5,823 (train / valid)

    • 2012 Segmentation

      2,913 images

      1,464 / 1,449 (train / valid)

  • 分辨率：各图片不一致，大多 500×375 左右

  • 标注：Bounding boxes、语义/实例分割 mask

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
data
└── PASCAL-VOC
    ├── VOCtrainval_06-Nov-2007.tar      (460 MB)
    ├── VOCtest_06-Nov-2007.tar          (451 MB)
    ├── VOCtrainval_11-May-2012.tar      (2 GB)
    └── VOCdevkit                        (extracted from *.tar)
        ├── VOC2007
        │   ├── Annotations
        │   │   ├── 000001.xml
        │   │   ├── ...
        │   │   └── 009963.xml
        │   ├── ImageSets
        │   │   ├── Layout
        │   │   │   ├── test.txt
        │   │   │   ├── train.txt
        │   │   │   ├── trainval.txt
        │   │   │   └── val.txt
        │   │   ├── Main
        │   │   │   ├── aeroplane_test.txt
        │   │   │   ├── ...
        │   │   │   └── val.txt
        │   │   └── Segmentation
        │   │       ├── test.txt
        │   │       ├── train.txt
        │   │       ├── trainval.txt
        │   │       └── val.txt
        │   ├── JPEGImages
        │   │   ├── 000001.jpg
        │   │   ├── ...
        │   │   └── 009963.jpg
        │   ├── SegmentationClass
        │   │   ├── 000032.jpg
        │   │   ├── ...
        │   │   └── 009950.jpg
        │   └── SegmentationObject
        │       ├── 000032.jpg
        │       ├── ...
        │       └── 009950.jpg
        └── VOC2012                      (same as VOC2007)

使用 torchvision 加载数据集：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
>>> import torchvision.datasets as dset
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2007', image_set='train')
>>> len(voc)
2501
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2007', image_set='val')
>>> len(voc)
2510
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2007', image_set='trainval')
>>> len(voc)
5011
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2007', image_set='test')
>>> len(voc)
4952

>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2007', image_set='train')
>>> len(voc)
209
>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2007', image_set='val')
>>> len(voc)
213
>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2007', image_set='trainval')
>>> len(voc)
422
>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2007', image_set='test')
>>> len(voc)
210

>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2012', image_set='train')
>>> len(voc)
5717
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2012', image_set='val')
>>> len(voc)
5823
>>> voc = dset.VOCDetection(root='/data/PASCAL-VOC', year='2012', image_set='trainval')
>>> len(voc)
11540

>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2012', image_set='train')
>>> len(voc)
1464
>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2012', image_set='val')
>>> len(voc)
1449
>>> voc = dset.VOCSegmentation(root='/data/PASCAL-VOC', year='2012', image_set='trainval')
>>> len(voc)
2913


Places365

官网 | Papers with Code | 下载链接

简要介绍：Places365 数据集是一个场景识别数据集，由 1000 万张图像组成，包括 434 个场景类别。数据集有两个版本：Places365-Standard 包括 180 万个训练图像和 36000 个验证图像，涵盖了 365 个场景类别；Places365-Challenge-2016 在训练集中增加了 620 万张额外的图像，包括了 69 个新的场景类别（总共涵盖了 434 个场景类别），达到了 800 万张的训练图像。

基本信息：

  • Places365-Standard
    • 数量：2,168,460
    • 划分：1,803,460 / 36,500 / 328,500 (train / valid / test)
    • 分辨率：
      • High-resolution：按照短边 512、保留长宽比缩放，若原图小于 512 则不变
      • Small：直接缩放至 256×256，不管原始长宽比
    • 标注：365 类场景
  • Places365-Challenge-2016
    • 数量：训练集在 Standard 的基础上额外添加了 6.2 million；验证集和测试集不变
    • 划分：8,026,628 / 36,500 / 328,500 (train / valid / test)
    • 标注：365 类场景
  • Places-Extra69
    • 划分：98,721 / 6,600 (train / test)
    • 标注：额外 69 类场景

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
data
└── Places365
    ├── categories_places365.txt
    ├── places365_train_standard.txt
    ├── places365_train_challenge.txt
    ├── places365_val.txt
    ├── places365_test.txt
    ├── train_256_places365standard.tar    (26.1 GB, MD5: 53ca1c756c3d1e7809517cc47c5561c5)
    ├── train_large_places365standard.tar  (112.6 GB, MD5: 67e186b496a84c929568076ed01a8aa1)
    ├── train_256_places365challenge.tar   (108 GB, MD5: 741915038a5e3471ec7332404dfb64ef)
    ├── train_large_places365challenge.tar (477 GB, MD5: 605f18e68e510c82b958664ea134545f)
    ├── val_256.tar                        (525.2 MB, MD5: e27b17d8d44f4af9a78502beb927f808)
    ├── val_large.tar                      (2.27 GB, MD5: 9b71c4993ad89d2d8bcbdc4aef38042f)
    ├── test_256.tar                       (4.74 GB, MD5: f532f6ad7b582262a2ec8009075e186b)
    ├── test_large.tar                     (20.48 GB, MD5: 41a4b6b724b1d2cd862fb3871ed59913)
    ├── data_256_standard                  (extracted from train_256_places365standard.tar)
    │   ├── a
    │   ├── ...
    │   └── z
    ├── data_large_standard                (extracted from train_large_places365standard.tar)
    │   ├── a
    │   ├── ...
    │   └── z
    ├── val_256                            (extracted from val_256.tar)
    │   ├── Places365_val_00000001.jpg
    │   ├── ...
    │   └── Places365_val_00036500.jpg
    ├── val_large                          (extracted from val_large.tar)
    │   ├── Places365_val_00000001.jpg
    │   ├── ...
    │   └── Places365_val_00036500.jpg
    ├── test_256                           (extracted from test_256.tar)
    │   ├── Places365_test_00000001.jpg
    │   ├── ...
    │   └── Places365_test_00328500.jpg
    └── test_large                         (extracted from test_large.tar)
        ├── Places365_test_00000001.jpg
        ├── ...
        └── Places365_test_00328500.jpg

注：我目前只下载了 Places365-Standard.

使用 torchvision 加载数据集（不支持测试集）：

1
2
3
4
5
6
7
>>> import torchvision.datasets as dset
>>> places = dset.Places365(root='/data/Places365', split='train-standard', small=True)
>>> len(places)
1803460
>>> places = dset.Places365(root='/data/Places365', split='val', small=True)
>>> len(places)
36500

可以自定义 Dataset 加载测试集。


Raindrop

官网 | Papers with Code | Google Drive

简要介绍：Raindrop 是一个真实拍摄（而非合成）的用于去雨滴任务的数据集，由若干图像对构成。每对图像包含完全相同的背景，但其中一个图像有雨滴，而另一个图像则没有。为此，使用两片完全相同的玻璃——一片喷有水、另一片保持干净——附在相机镜头上拍摄。拍摄设备为 Sony A6000 和 Canon EOS 60.

基本信息：

  • 数量：1,110
  • 划分：861 / 249 (train / test_b)；另外，取 test_b 中对齐比较好的 58 对图片构成 test_a.
  • 分辨率：多数 720×480，有少量例外，但也很接近。

本地目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
data
└── Raindrop
    ├── train.zip               (1.07 GB)
    ├── test_a.zip              (63.7 MB)
    ├── test_b.zip              (154.4 MB)
    ├── train                   (extracted from train.zip)
    │   ├── data                (contains 861 png images)
    │   ├── gt                  (contains 861 png images)
    │   └── preview.html
    ├── test_a                  (extracted from test_a.zip)
    │   ├── data                (contains 58 png images)
    │   └── gt                  (contains 58 png images)
    └── test_b                  (extracted from test_b.zip)
        ├── data                (contains 249 jpg images)
        └── gt                  (contains 249 jpg images)

需要自定义 Dataset 加载数据集。


计算机视觉
#computer vision
计算机视觉常用数据集
https://xyfjason.github.io/blog-main/2022/09/14/计算机视觉常用数据集/
作者
xyfJASON
发布于
2022年9月14日
许可协议