目標檢測的常用資料處理方法

到這裡，我們的訓練資料就準備好了，接下來開始一步步構建訓練所需的dataloader吧！

2. 構建dataloader

在這裡，我們假設你對Pytorch的 Dataset 和 DataLoader 兩個概念有最基本的了解。下面開始介紹構建dataloader的相關程式碼:

首先了解一下訓練的時候在哪裡定義了dataloader以及是如何定義的。以下是train.py中的部分程式碼段：

 #train_dataset和train_loader的實例化
  train_dataset = PascalVOCDataset(data_folder,
                                   split='train',
                                   keep_difficult=keep_difficult)
  train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True,collate_fn=train_dataset.collate_fn, num_workers=workers,pin_memory=True) 
  # note that we're passing the collate function here

可以看到，首先需要實例化PascalVOCDataset類得到train_dataset，然後將train_dataset傳入torch.utils.data.DataLoader，進而得到train_loader。

pin_memory就是鎖頁記憶體,創建DataLoader時，設置pin_memory=True，則意味著生成的Tensor資料最開始是屬於記憶體中的鎖頁記憶體，這樣將記憶體的Tensor轉義到GPU的視訊記憶體就會更快一些。顯示卡不好就不要開了。

collate_fn是如何將(C,H,W)組合成(N,C,H,W)的方式。

接下來看一下PascalVOCDataset是如何定義的。

程式碼位於 datasets.py 腳本中，可以看到，PascalVOCDataset繼承了torch.utils.data.Dataset，然後重寫了__init__ , getitem, len 和 collate_fn 四個方法，這也是我們在構建自己的dataset的時候需要經常做的工作，配合下面註釋理解程式碼：

"""python
    PascalVOCDataset具體實現過程
"""
import torch
from torch.utils.data import Dataset
import json
import os
from PIL import Image
from utils import transform


class PascalVOCDataset(Dataset):
    """
    A PyTorch Dataset class to be used in a PyTorch DataLoader to create batches.
    """

    #初始化相關變數
    #讀取images和objects標註資訊
    def __init__(self, data_folder, split, keep_difficult=False):
        """
        :param data_folder: folder where data files are stored
        :param split: split, one of 'TRAIN' or 'TEST'
        :param keep_difficult: keep or discard objects that are considered difficult to detect?
        """
        self.split = split.upper()    #保證輸入為純大寫字母，便於匹配{'TRAIN', 'TEST'}

        assert self.split in {'TRAIN', 'TEST'}

        self.data_folder = data_folder
        self.keep_difficult = keep_difficult

        # Read data files
        with open(os.path.join(data_folder, self.split + '_images.json'), 'r') as j:
            self.images = json.load(j)
        with open(os.path.join(data_folder, self.split + '_objects.json'), 'r') as j:
            self.objects = json.load(j)

        assert len(self.images) == len(self.objects)

    #循環讀取image及對應objects
    #對讀取的image及objects進行tranform操作（資料增廣）
    #返回PIL格式圖像，標註框，標註框對應的類別索引，對應的difficult標誌(True or False)
    def __getitem__(self, i):
        # Read image
        #*需要注意，在pytorch中，圖像的讀取要使用Image.open()讀取成PIL格式，不能使用opencv
        #*由於Image.open()讀取的圖片是四通道的(RGBA)，因此需要.convert('RGB')轉換為RGB通道
        image = Image.open(self.images[i], mode='r')
        image = image.convert('RGB')

        # Read objects in this image (bounding boxes, labels, difficulties)
        objects = self.objects[i]
        boxes = torch.FloatTensor(objects['boxes'])  # (n_objects, 4)
        labels = torch.LongTensor(objects['labels'])  # (n_objects)
        difficulties = torch.ByteTensor(objects['difficulties'])  # (n_objects)

        # Discard difficult objects, if desired
        #如果self.keep_difficult為False,即不保留difficult標誌為True的目標
        #那麼這裡將對應的目標刪去
        if not self.keep_difficult:
            boxes = boxes[(1 - difficulties).bool()]  #uint8可以作為索引,但是轉成bool去索引更好
            labels = labels[(1 - difficulties).bool()]
            difficulties = difficulties[(1 - difficulties).bool()]

        # Apply transformations
        #對讀取的圖片應用transform
        image, boxes, labels, difficulties = transform(image, boxes, labels, difficulties, split=self.split)

        return image, boxes, labels, difficulties

    #獲取圖片的總數，用於計算batch數
    def __len__(self):
        return len(self.images)

    #我們知道，我們輸入到網路中訓練的資料通常是一個batch一起輸入，而通過__getitem__我們只讀取了一張圖片及其objects資訊
    #如何將讀取的一張張圖片及其object資訊整合成batch的形式呢？
    #collate_fn就是做這個事情，
    #對於一個batch的images，collate_fn通過torch.stack()將其整合成4維tensor，對應的objects資訊分別用一個list儲存
    def collate_fn(self, batch):
        """
        Since each image may have a different number of objects, we need a collate function (to be passed to the DataLoader).
        This describes how to combine these tensors of different sizes. We use lists.
        Note: this need not be defined in this Class, can be standalone.
        :param batch: an iterable of N sets from __getitem__()
        :return: a tensor of images, lists of varying-size tensors of bounding boxes, labels, and difficulties
        """

        images = list()
        boxes = list()
        labels = list()
        difficulties = list()

        for b in batch:
            images.append(b[0])
            boxes.append(b[1])
            labels.append(b[2])
            difficulties.append(b[3])

        #(3,224,224) -> (N,3,224,224)
        images = torch.stack(images, dim=0)

        return images, boxes, labels, difficulties  # tensor (N, 3, 224, 224), 3 lists of N tensors each

3. 關於資料增強

到這裡為止，我們的dataset就算是構建好了，已經可以傳給torch.utils.data.DataLoader來獲得用於輸入網路訓練的資料了。但是不急，構建dataset中有個很重要的一步我們上面只是提及了一下，那就是transform操作(資料增強)，也就是這一行程式碼

image, boxes, labels, difficulties = transform(image, boxes, labels, difficulties, split=self.split)

這部分比較重要，但是涉及程式碼稍多，對於基礎較薄弱的夥伴可以作為選學內容，後面再認真讀程式碼。你只需知道，同分類網路一樣，訓練目標檢測網路同樣需要進行資料增強，這對提升網路精度和泛化能力很有幫助。

需要注意的是，涉及位置變化的資料增強方法，同樣需要對目標框進行一致的處理，因此目標檢測框架的資料處理這部分的程式碼量通常都不小，且比較容易出bug。這裡為了降低程式碼的難度，我們只是使用了幾種比較簡單的資料增強。

transform 函數的具體程式碼實現位於 utils.py 中，下面簡單進行講解：

"""python
    transform操作是訓練模型中一項非常重要的工作，其中不僅包含資料增強以提升模型性能的相關操作，也包含如資料類型轉換(PIL to Tensor)、歸一化(Normalize)這些必要操作。
"""
import json
import os
import torch
import random
import xml.etree.ElementTree as ET
import torchvision.transforms.functional as FT

"""
可以看到，transform分為TRAIN和TEST兩種模式，以本實驗為例：

在TRAIN時進行的transform有：
1.以隨機順序改變圖片亮度，對比度，飽和度和色相，每種都有50％的概率被執行。photometric_distort
2.擴大目標，expand
3.隨機裁剪圖片，random_crop
4.0.5的概率進行圖片翻轉，flip
*注意：a. 第一種transform屬於像素級別的圖像增強，目標相對於圖片的位置沒有改變，因此bbox座標不需要變化。
         但是2，3，4，5都屬於圖片的幾何變化，目標相對於圖片的位置被改變，因此bbox座標要進行相應變化。

在TRAIN和TEST時都要進行的transform有：
1.統一圖像大小到(224,224)，resize
2.PIL to Tensor
3.歸一化，FT.normalize()

注1: resize也是一種幾何變化，要知道應用資料增強策略時，哪些屬於幾何變化，哪些屬於像素變化
注2: PIL to Tensor操作，normalize操作必須執行
"""

def transform(image, boxes, labels, difficulties, split):
    """
    Apply the transformations above.
    :param image: image, a PIL Image
    :param boxes: bounding boxes in boundary coordinates, a tensor of dimensions (n_objects, 4)
    :param labels: labels of objects, a tensor of dimensions (n_objects)
    :param difficulties: difficulties of detection of these objects, a tensor of dimensions (n_objects)
    :param split: one of 'TRAIN' or 'TEST', since different sets of transformations are applied
    :return: transformed image, transformed bounding box coordinates, transformed labels, transformed difficulties
    """

    #在訓練和測試時使用的transform策略往往不完全相同，所以需要split變數指明是TRAIN還是TEST時的transform方法
    assert split in {'TRAIN', 'TEST'}

    # Mean and standard deviation of ImageNet data that our base VGG from torchvision was trained on
    # see: https://pytorch.org/docs/stable/torchvision/models.html
    #為了防止由於圖片之間像素差異過大而導致的訓練不穩定問題，圖片在送入網路訓練之間需要進行歸一化
    #對所有圖片各通道求mean和std來獲得
    mean = [0.485, 0.456, 0.406]
    std = [0.229, 0.224, 0.225]

    new_image = image
    new_boxes = boxes
    new_labels = labels
    new_difficulties = difficulties

    # Skip the following operations for evaluation/testing
    if split == 'TRAIN':
        # A series of photometric distortions in random order, each with 50% chance of occurrence, as in Caffe repo
        new_image = photometric_distort(new_image)

        # Convert PIL image to Torch tensor
        new_image = FT.to_tensor(new_image)

        # Expand image (zoom out) with a 50% chance - helpful for training detection of small objects
        # Fill surrounding space with the mean of ImageNet data that our base VGG was trained on
        if random.random() < 0.5:
            new_image, new_boxes = expand(new_image, boxes, filler=mean)

        # Randomly crop image (zoom in)
        new_image, new_boxes, new_labels, new_difficulties = random_crop(new_image, new_boxes, new_labels,new_difficulties)

        # Convert Torch tensor to PIL image
        new_image = FT.to_pil_image(new_image)

        # Flip image with a 50% chance
        if random.random() < 0.5:
            new_image, new_boxes = flip(new_image, new_boxes)

    # Resize image to (224, 224) - this also converts absolute boundary coordinates to their fractional form
    new_image, new_boxes = resize(new_image, new_boxes, dims=(224, 224))

    # Convert PIL image to Torch tensor
    new_image = FT.to_tensor(new_image)

    # Normalize by mean and standard deviation of ImageNet data that our base VGG was trained on
    new_image = FT.normalize(new_image, mean=mean, std=std)

    return new_image, new_boxes, new_labels, new_difficulties

TRAIN transform的步驟：

• 顏色變化、to_tensor(變形(CHW),歸一化，pil變tensor)

• 創建一個背景並把圖放上去(等效縮小圖片)

• 隨機裁剪圖片(丟失了部分框)

• 轉為pil、隨機左右翻轉、resize(這裡面對boxes做了歸一化處理)

• 再變tensor、標準化處理

4. 構建DataLoader

至此，我們已經將VOC資料轉換成了dataset，接下來可以用來創建dataloader，這部分pytorch已經幫我們實現好了，我們只需將創建好的dataset送入即可，注意理解相關參數。

"""python
    DataLoader
"""
#參數說明：
#在train時一般設置shufle=True打亂資料順序，增強模型的魯棒性
#num_worker表示讀取資料時的執行緒數，一般根據自己設備配置確定（如果是windows系統，建議設預設值0，防止出錯）
#pin_memory，在計算機記憶體充足的時候設置為True可以加快記憶體中的tensor轉換到GPU的速度，具體原因可以百度哈~
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True,collate_fn=train_dataset.collate_fn, num_workers=workers, pin_memory=True)  # note that we're passing the collate function here

小結

本文介紹了經典VOC資料集並對其進行了資料讀取和預處理工作。現在，大家可以拿著這些已經處理好的資料，丟進模型裡，盡情煉丹了。

參考連接：https://github.com/datawhalechina/dive-into-cv-pytorch