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