ADE20K数据集详解

一、ADE20K实验

ADE20K是一个用于分割场景的数据集，其提供了大量的真实场景图像以及相应的每个像素的标注。ADE20K主要用于场景分割的训练和评估，因为它具有大规模和多样性的特点，正逐渐成为计算机视觉领域中最重要的数据集之一。本实验使用ADE20K数据集训练及评估模型，以实现场景的分割。

# 安装依赖
!pip install torch torchvision matplotlib opencv-python pillow tqdm

# 下载ADE20K数据集
!wget -c http://sceneparsing.csail.mit.edu/data/ADEChallengeData2016.zip

二、ADE20K颜色编码

ADE20K的标签信息保存在图片中的rgb空间中，因此需要进行rgb颜色解码，将图片标注转换为类id，这是使用ADE20K数据集时必不可少的步骤。

# ADE20K颜色编码详细实现，请参考以下代码

def parse_color_map_viz():
    lines = open('color150_viz.txt').readlines()
    lines = [l.rstrip() for l in lines]
    lines = [l.split('\t') for l in lines]
    lines = [[int(l[0]), l[1], l[2]] for l in lines]
    lines = sorted(lines, key=lambda x: x[0])
    lines = [[l[1], l[2]] for l in lines]
    return lines

三、ADE20K数据集

ADE20K共提供22210张图片，同时提供了两种形式的数据集：标准ADE20K和ADE20K-HR，标准ADE20K是1007个类别的语义分割数据集，包括涵盖了各种物体、天空、树木、地面、建筑物、人物以及室内外等环境，总的类别数超过了十万个。ADE20K-HR是一个高分辨率版本的ADE20K数据集，它采用了与标准ADE20K相同的格式。两个数据集均提供了兼容PyTorch的格式，包括图像和语义分割标注，同样也提供了对应的颜色编码器。

# 下载ADE20K-HR数据集数据集
!wget -c http://data.csail.mit.edu/places/ADEchallenge/ADEChallengeData2016.zip

# 解压并进入目录
!unzip -q ADEChallengeData2016.zip
!rm -rf ADEChallengeData2016.zip
!mv ADEChallengeData2016/* .

# 将类别说明存放于classes文件中
!mv ../cls_names.txt classes/ADE20K_classes.txt

四、ADE20K文档权限密码

在使用ADE20K时，需要先获得ADE的许可，在官网上通过验证后即可获取下载文件的地址及密码。

# 官方文档权限密码
Doc Password: scene-parse-challenge-2016 
Link: https://docs.google.com/forms/d/e/1FAIpQLScJyTltwLxBb6B8f8oDNoC6LEMZG5Pji-bsc8ahA7ktV7Ky_A/viewform

五、ADE20K trick

ADE20K mask和label的区别，mask是对类别所涉及的像素进行了标记，而label是为所有的像素进行了标记。在训练时，对于一个类别的标记，例如人类的id为12，要么全都标记，要么就都不标记，这种方法在多数情况下有利于提高训练效果

# ADE20K trick 实现，其他模块请参考以下代码

def convert_label_to_mask(label_tensor):
    label_tensor = label_tensor.cpu().numpy()
    unique_labels = np.unique(label_tensor)
    h, w = label_tensor.shape[1:]
    num_classes = len(unique_labels)
    mask = np.zeros((num_classes, h, w), np.uint8)
    for i in range(num_classes):
        mask[i] = (label_tensor == unique_labels[i]).astype(np.uint8)
    return mask

六、ADE20K语义分割实验模块

本实验使用U-Net网络进行图像分割，该网络模型是由Encoder和Decoder两个分别负责提取特征和恢复分辨率的部分，中间连接着一系列的特征图，其中每一层的特征图都是上一层的3倍大，由于这个结构，可以将分辨率和语义信息同时保留，并使得网络不需要大量的跳跃连接。

import torch.nn as nn
import torch.nn.functional as F
 
class DoubleConv(nn.Module):
    def __init__(self, in_channels, out_channels, mid_channels=None):
        super().__init__()
        if not mid_channels:
            mid_channels = out_channels
        self.double_conv = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(mid_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True)
        )
 
    def forward(self, x):
        return self.double_conv(x)
 
class UNet(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=1, init_features=32
    ):
        super(UNet, self).__init__()
        features = init_features
        self.encoder1 = DoubleConv(in_channels, features)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.encoder2 = DoubleConv(features, features * 2)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.encoder3 = DoubleConv(features * 2, features * 4)
        self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.encoder4 = DoubleConv(features * 4, features * 8)
        self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2)
 
        self.bottleneck = DoubleConv(features * 8, features * 16)
 
        self.up1 = nn.ConvTranspose2d(
            features * 16, features * 8, kernel_size=2, stride=2
        )
        self.decoder1 = DoubleConv(features * 16, features * 8)
        self.up2 = nn.ConvTranspose2d(
            features * 8, features * 4, kernel_size=2, stride=2
        )
        self.decoder2 = DoubleConv(features * 8, features * 4)
        self.up3 = nn.ConvTranspose2d(
            features * 4, features * 2, kernel_size=2, stride=2
        )
        self.decoder3 = DoubleConv(features * 4, features * 2)
        self.up4 = nn.ConvTranspose2d(
            features * 2, features, kernel_size=2, stride=2
        )
        self.decoder4 = DoubleConv(features * 2, features)
 
        self.out = nn.Conv2d(
            features, out_channels, kernel_size=1
        )
 
    def forward(self, x):
        # Encoder
        x1 = self.encoder1(x)
        x2 = self.encoder2(self.pool1(x1))
        x3 = self.encoder3(self.pool2(x2))
        x4 = self.encoder4(self.pool3(x3))
 
        # Bottleneck
        xb = self.bottleneck(self.pool4(x4))
 
        # Decoder
        xd = self.up1(xb)
        xd = self.decoder1(torch.cat([x4, xd], 1))
 
        xd = self.up2(xd)
        xd = self.decoder2(torch.cat([x3, xd], 1))
 
        xd = self.up3(xd)
        xd = self.decoder3(torch.cat([x2, xd], 1))
 
        xd = self.up4(xd)
        xd = self.decoder4(torch.cat([x1, xd], 1))
 
        # Output
        xd = self.out(xd)
        return xd

七、ADE20K_classes.pdf

ADE20K_classes.pdf文件描述了该数据集中所有支持的物体类别以及类别id，其根据提供的标注对像素进行了分类。本文档想通过此pdf文件为您提供更多关于ADE20K数据集中类别的详细信息。

# ADE20K_classes.pdf 的类别列表示例

[cls]:wall
[id]:1
[inst]:41462
[category]:10

[cls]:person
[id]:2
[inst]:5129
[category]:4

[cls]:door
[id]:3
[inst]:12067
[category]:1

[cls]:window
[id]:4
[inst]:501
[category]:1

[cls]:sky
[id]:5
[inst]:11779
[category]:2