0701-數據處理

• 2021 年 4 月 27 日
• 筆記
• torch_long

0701-數據處理

pytorch完整教程目錄：//www.cnblogs.com/nickchen121/p/14662511.html

一、概述

在機器學習中，尤其是在深度學習中，需要耗費大量的精力去處理數據，並且數據的處理對訓練神經網路來說也是很重要的，良好的數據不僅會加速模型的訓練，也可以提高模型的效率。

為此，torch 提供了幾個高效便捷的工具，以便使用者更方便的對數據做處理，同時也可以並行化加速數據載入。

二、載入自定義數據集

在 torch 中，可以載入自定義數據集，在這個過程中，需要自定義數據集對象，數據集對象將被抽象為 Dataset 類，也就是說實現自定義的數據集需要繼承 Dataset，同時也需要實現兩個 Python 魔法方法：

• __getiter__：返回一條數據或一個樣本。obj[index] 等價於 obj.__getitem__(index)
• __len__：返回樣本的數量。len(obj) 等價於 obj.__len__()

在這裡我們以 Kaggle 經典挑戰賽「Dogs vs. Cat」的數據為例，詳細講解如何處理數據。其中該數據是一個分類問題的數據，判斷一張圖片是狗還是貓，它的所有圖片都放在一個文件夾下，並可以根據文件名的前綴是狗還是貓。需要圖片數據的可以加我微信：chenyoudea

import os

imgs = os.listdir('./img/dogcat')  # 獲取./img/dogcat下的所有圖片文件
for img in imgs:
    print(img)

dog.12497.jpg
cat.12484.jpg
cat.12485.jpg
dog.12496.jpg
cat.12487.jpg
cat.12486.jpg
dog.12498.jpg
dog.12499.jpg

import os
import torch as t
import numpy as np
from PIL import Image
from torch.utils import data


class DogCat(data.Dataset):
    def __init__(self, root):
        imgs = os.listdir(root)
        # 所有圖片的絕對路徑
        # 這裡不實際載入圖片，只是指定路徑
        # 當調用__getitem__時才會真正讀圖片
        self.imgs = [os.path.join(root, img) for img in imgs]

    def __getitem__(self, index):
        img_path = self.imgs[index]
        # dog->1, cat->0
        label = 1 if 'dog' in img_path.split(
            '/')[-1] else 0  # 通過對圖片文件名前綴的判斷給圖片增加標籤
        pil_img = Image.open(img_path)  # 打開圖片
        array = np.asarray(pil_img)  # 把圖片轉為 ndarray 數據
        data = t.from_numpy(array)  # 把圖片轉為 Tensor 數據
        return data, label


dataset = DogCat('./img/dogcat/')
# img, label = dataset[0]  # 相當於調用 dataset.__getitem__(0)
for img, label in dataset:
    print(img.size(), img.float().mean(), label)

torch.Size([375, 499, 3]) tensor(150.5080) 1
torch.Size([500, 497, 3]) tensor(106.4915) 0
torch.Size([499, 379, 3]) tensor(171.8085) 0
torch.Size([375, 499, 3]) tensor(116.8139) 1
torch.Size([374, 499, 3]) tensor(115.5177) 0
torch.Size([236, 289, 3]) tensor(130.3004) 0
torch.Size([377, 499, 3]) tensor(151.7174) 1
torch.Size([400, 300, 3]) tensor(128.1550) 1


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:23: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at  ../torch/csrc/utils/tensor_numpy.cpp:143.)

上述所示的 /Applications/anaconda3/lib…… 的錯誤，是因為圖片是 git 上拿下來的，沒有修改許可權，我懶得修改了，自己有空把它修改下，反正沒啥影響。

對於我們自定義的數據集，我們已經學會了如何通過程式碼定義這樣的數據集，但是這樣的數據並不適合使用，因為它們有兩個這樣的問題：

1. 每張圖片的大小不一樣，這對於需要取 batch 訓練的神經網路來說並不友好
2. 返回樣本的數值較大，沒有歸一化到 [-1,1]

三、利用 torchvision 工具處理數據集

為了解決上一節的遺留的問題，torch 提供了 torchvision，它是一個視覺工具包，提供了很多視覺影像處理的工具，其中 transform 模組提供了對 PIL Image 對象和 Tensor 對象的常用操作。如果想更詳細的了解這個工具，可以去去查看官方文檔：//github.com/pytorch/vision/

對 PIL Image 的常見操作如下：

• Resize：調整圖片尺寸
• CenterCrop、RandomCrop、RandomSizedCrop：裁剪圖片
• Pad：填充
• ToTensor：把 PIL Image 對象轉成 Tensor，會自動將 [0,255] 歸一化為 [0,1]

對 Tensor 的常見操作如下：

• Normalize：標準化，即減均值，除以標準差
• ToPILImage：將 Tensor 轉為 PIL Image 對象

如果需要對圖片進行多個操作，可以通過 Compose 把這些操作拼接起來，類似於 nn.Sequential。需要注意的是，這些操作定義後是以對象的形式存在，真正使用時需要調用它的 __call__ 方法，類似於 nn.Module。

例如，如果要把圖片調整為 224*224，首先構建操作 trans = Scale((224,224))，然後調用 trans(img)。接下來我們就用 transform 的這些操作來優化上面實現的 dataset。

import os
from PIL import Image
import numpy as np
from torchvision import transforms as T

transform = T.Compose([
    T.Resize(224),  # 縮放圖片，保持長寬比不變，最短邊為 224 像素
    T.CenterCrop(224),  # 從圖片中間切出 224*224 的圖片
    T.ToTensor(),  # 把圖片轉成 Tensor，歸一化至 [0,1]
    T.Normalize(mean=[.5, .5, .5], std=[.5, .5, .5])  # 標準化至 [-1,1]
])


class DogCat(data.Dataset):
    def __init__(self, root, transforms=None):
        imgs = os.listdir(root)
        self.imgs = [os.path.join(root, img) for img in imgs]  # 拼接圖片路徑
        self.transforms = transforms  # 作為圖片是否進行處理的標誌

    def __getitem__(self, index):
        img_path = self.imgs[index]
        label = 0 if 'dog' in img_path.split('/')[-1] else 1
        data = Image.open(img_path)
        if self.transforms:  # 判斷圖片是否需要進行處理
            data = self.transforms(data)
        return data, label

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


dataset = DogCat('./img/dogcat/', transforms=transform)
img, label = dataset[0]
for img, label in dataset:
    print(img.size(), label)

torch.Size([3, 224, 224]) 0
torch.Size([3, 224, 224]) 1
torch.Size([3, 224, 224]) 1
torch.Size([3, 224, 224]) 0
torch.Size([3, 224, 224]) 1
torch.Size([3, 224, 224]) 1
torch.Size([3, 224, 224]) 0
torch.Size([3, 224, 224]) 0

從上述程式碼可以看到 transforms 的強大，除了這些，transforms 還可以通過 Lambda 封裝自定義的轉換策略。

例如，如果相對 PIL Image 進行隨機旋轉，則可以寫成 trans = T.Lambda(lambda img: img.rotate(random()*360))

上面我們說到了如何載入自定義的數據集，對於很多研究者來說，只是想試驗自己的演算法有沒有問題，如果自己去獲取數據，再加上深度學習對數據量的要求，那是非常困難的。

為此 torchvision 預先實現了常用的 Dataset，包括 CIFAR-10、ImageNet、COCO、MNIST、LSUN 等數據集，可以通過調用 torchvision.datasets 下相應的對象來調用相關的數據集，具體的使用方法可以查看官方文檔：//pytorch.org/vision/stable/datasets.html

四、ImageFolder 的使用——處理數據集

本節介紹一個我們經常會用到的一個 Dataset——ImageFolder，它的實現和上述 DogCat類 的功能類似，主要是對圖片進行處理。

ImageFoder 假設所有的文件按文件夾保存，每個文件夾下存儲同一個類別的圖片，文件夾名為類名，它的構造函數如下所示：ImageFolder(root, transform=None, target_transform=None, loader=default_loader)

它主要有以下四個參數：

• root：在 root 指定的路徑下尋找圖片
• transform：對 PIL Image進行轉換操作，transform 的輸入是使用 loader 讀取圖片的返回對象
• target_transform：對 label 的轉換
• loader：指定載入圖片的函數，默認操作是讀取為 PIL Image 對象

label 是按照文件夾名字順序排序後存成字典的，即 {類名：類序號（從 0 開始）}，一般來說最好直接將文件命名為從 0 開始的數字，這樣回合 ImageFolder 實際的 label 一致。

from torchvision.datasets import ImageFolder

dataset = ImageFolder('./img/dogcat_2')

# cat 文件夾的圖片對應 label 0，dog 對應 1
dataset.class_to_idx

{'cat': 0, 'dog': 1}

# 所有圖片的路徑和對應的 label
dataset.imgs

[('./img/dogcat_2/cat/cat.12484.jpg', 0),
 ('./img/dogcat_2/cat/cat.12485.jpg', 0),
 ('./img/dogcat_2/cat/cat.12486.jpg', 0),
 ('./img/dogcat_2/cat/cat.12487.jpg', 0),
 ('./img/dogcat_2/dog/dog.12496.jpg', 1),
 ('./img/dogcat_2/dog/dog.12497.jpg', 1),
 ('./img/dogcat_2/dog/dog.12498.jpg', 1),
 ('./img/dogcat_2/dog/dog.12499.jpg', 1)]

dataset[0][1]  # 第一維是第幾張圖，第二維為 1 返回 label

0

# 沒有任何的 transform，多以返回的還是 PIL Image 對象
dataset[0][0]  # 為 0 返回圖片數據，返回的 Image 對象如下圖所示

# 加上 transform
normalize = T.Normalize(mean=[0.4, 0.4, 0.4], std=[0.2, 0.2, 0.2])
transform = T.Compose([
    T.RandomResizedCrop(224),
    T.RandomHorizontalFlip(),
    T.ToTensor(),
    normalize,
])
dataset = ImageFolder('img/dogcat_2', transform=transform)
dataset[0][0].size()  # 深度學習圖片數據一般保存成 C*H*W，即 通道數*圖片高*圖片寬

torch.Size([3, 224, 224])

to_img = T.ToPILImage()
# 0.2 和 0.4 是標準差和均值的近似
to_img(dataset[0][0]*0.2+0.4) # 程式輸出如下圖所示

五、DataLoader 的使用——批載入數據

Dataset 只負責抽象數據，並且一次調用 __getitem__ 只返回一個樣本。

在訓練神經網路的時候，是對一個 batch 的數據進行操作，同時還需要對數據進行 shuffle 和並行加速等，為此，torch 提供了 DataLoader 去實現這些功能。

DataLoader 的函數定義如下：

DataLoader(dataset,
           batch_size=1,
           shuffle=False,
           sampler=None,
           num_workers=0,
           collate_fn=default_collate,
           pin_memory=False,
           drop_last=False)

• dataset：載入的數據集（Dataset 對象）
• batch_size：batch size（批大小）
• shuffle：是否把數據打亂
• sampler：樣本抽樣，後面會詳細解釋
• num_workers：使用多進程載入的進程數，0 表示不使用多進程
• collate_fn：如何把多個數據拼接成一個 batch，一般使用默認的方式就可以了
• pin_memory：是否將數據保存在 pin memory 區，pin memory 中的數據轉到 GPU 中速度會快一些
• drop_last：dataset 中的數據個數可能不是 batch_size 的整數倍，drop_last 為 True，會把多出來不足一個 Batch 的數據丟棄

from torch.utils.data import DataLoader

dataloader = DataLoader(dataset,
                        batch_size=3,
                        shuffle=True,
                        num_workers=0,
                        drop_last=False)

dataiter = iter(dataloader)  # dataloader是一個可迭代對象，通過 iter 把 dataloader 變成一個迭代器
imgs, labels = next(dataiter)
imgs.size()  # batch_size,channel,height,weight

torch.Size([3, 3, 224, 224])

dataloader 是一個可迭代的對象，因此可以像使用迭代器一樣使用它。迭代器如果你忘記了是啥，可以看這篇文章：迭代器

# 迭代器的兩種使用方法
# 第一種直接獲取所有數據，數據量大不建議使用
for batch_datas, batch_labels in dataloader:
    train()

# 第二種只生成一個迭代器，用一個取一個數據
dataiter = iter(dataloader)
imgs, labels = next(dataiter)

六、處理損壞圖片

class NewDogCat(DogCat):
    def __getitem__(self, index):
        try:
            # 調用父類的獲取函數，相當於 DogCat.__getitem__(self,index)
            return super(NewDogCat, self).__getitem__(index)
        except:
            return None, None  # 獲取異常的對象返回 None


from torch.utils.data.dataloader import default_collate  # 導入默認的拼接方式


def my_collate_fn(batch):
    """
    batch 中每個元素形如（data，label）
    """
    batch = list(filter(lambda x: x[0] is not None, batch))  # 過濾為 None 的數據
    return default_collate(batch)  # 用默認方式拼接過濾後的 batch 數據


dataset = NewDogCat('img/dogcat_wrong/', transforms=transform)
dataset[6]

(None, None)

dataloader = DataLoader(dataset, 2, collate_fn=my_collate_fn, num_workers=0)
for batch_datas, batch_labels in dataloader:
    print(batch_datas.size(), batch_labels.size())

torch.Size([2, 3, 224, 224]) torch.Size([2])
torch.Size([2, 3, 224, 224]) torch.Size([2])
torch.Size([2, 3, 224, 224]) torch.Size([2])
torch.Size([1, 3, 224, 224]) torch.Size([1])
torch.Size([1, 3, 224, 224]) torch.Size([1])

通過查看上面的列印結果，可以看到第 4 個 batch_size 為 1，這是因為其中有一張圖片損壞，而最後一個 batch_size 也是 1，是因為總共有 9 張圖片，無法整除 2，因此最後一個 batch 的數據會少於 batch_size，可以通過指定 drop_last=True 丟棄最後一個樣本數目不足 batch_size 的 batch。

除了上述所說的方法，對於損壞或數據集載入異常等情況，還可以通過其他方法解決，例如遇到異常圖片，就可以隨機選擇另外一張圖片代替，則 batch_size 就不會小於規定的 batch_size。

class NewDogCat(DogCat):
    def __getitem__(self, index):
        try:
            return super(NewDogCat, self).__getitem__(index)
        except:
            new_index = random.randint(0, len(self) - 1)
            return self[new_index]

上述所說的方法看起來很好，但是如果我們換個角度去想，我為什麼要讓文件夾裡面有一張異常的圖片呢？因此為了防止圖片異常，更應該對數據進行徹底清洗。

DataLoader 為了實現多進程加速，它封裝了 Python 的標準庫 multiprocessing，因此在 Dataset 和 DataLoader 使用時有以下兩個建議：

1. 高負載的操作放在 __getitem__中，如載入圖片等
2. dataset 中應該盡量只包含只讀對象，避免修改任何可變對象

第一點是因為多進程會並行地調用 __getitem__ 函數，把負載高的放在 __getitem__ 函數中能夠實現並行加速。

第二點是因為 dataloader 使用多進程載入，如果在 Dataset 中使用了可變對象，可能會有意想不到的衝突。在多執行緒/多進程中，修改一個可變對象需要加鎖，但是 dataloader 的設計讓它很難加鎖，因此最好避免在 dataset 中修改可變對象。

下面就是一個不好的例子，在多進程中處理的 self.num 可能和預期不符，這種問題不會報錯，所以很難發現。如果真的一定要修改可變對象，可以使用 Python 標準庫 Queue 中的相關數據結構。

class BadDataset(data.Dataset):
    def __init__(self):
        self.datas = range(10)
        self.num = 0  # 取數據的次數

    def __getitem__(self, index):
        self.num += 1
        return self.datas[index]

使用 Python 的 multiprocessing 庫的另一個問題就是，在使用多進程時，如果主程式異常終止，相應的數據載入進程可能無法正常退出。這個時候你可能會發現程式已經退出了，但是 GPU 顯示記憶體和記憶體仍然被佔用著，這個時候就需要手動強行終止進程。

七、數據取樣

torch 中還單獨提供了一個 sampler 模組，用來進行數據取樣。常用的有隨機取樣器 RandomSampler，當 dataloader 的 shuffle 參數為 True 時，系統就會自動調用這個取樣器，進而打亂數據。

默認的取樣器是 SequentialSampler，它會按順序一個一個進行取樣。

在這裡介紹另外一個很有用的取樣方法 WeightedRandomSampler，它會根據每個樣本的權重選取數據，在樣本比例不均衡的問題中，可以用它進行重取樣。

構建 WeightedRandomSampler 時需要提供3個參數：

• 每個樣本的權重weights
• 共選取的樣本總數 num_samples
• 可選參數 replacement，指定是否可以重複選取一個樣本，默認為 True，也就是說允許一個 epoch 中重複取樣一個數據。如果設置為 False，則當某一類樣本被全部選取結束後，它的樣本還沒有達到 num_samples 時，sampler 將不會再從該類中選擇數據，此時可能會導致 weights 參數失效

註：權重越大的樣本被選中的概率越大，待選取的樣本數目一般小於全部的樣本數目。

dataset = DogCat('./img/dogcat/', transforms=transform)
# 狗的圖片被取出的概率是貓的概率的兩倍
# 兩類圖片被取出的概率和 weights 的絕對大小無關，只和比值有關，例如這裡的比值為 2：1
weights = [2 if label == 1 else 1 for data, label in dataset]
weights

[1, 2, 2, 1, 2, 2, 1, 1]

from torch.utils.data.sampler import WeightedRandomSampler

sampler = WeightedRandomSampler(weights, num_samples=9, replacement=True)
dataloader = DataLoader(dataset, batch_size=3, sampler=sampler)

for datas, labels in dataloader:
    print(labels.tolist())

[1, 1, 1]
[1, 0, 0]
[1, 0, 1]

從上面可以看到貓狗樣本的比例約為 1：2，另外一共只有 8 個樣本，卻返回了 9 個，說明有樣本被重複返回，這就是 replacement 參數的左右，下面我們把 replacement 設為 False。

# 如果 weights 設定為 100：1，則 貓 的被選中的概率幾乎為 0
weights = [100 if label == 1 else 1 for data, label in dataset]

sampler = WeightedRandomSampler(weights, num_samples=9, replacement=True)
dataloader = DataLoader(dataset, batch_size=3, sampler=sampler)

for datas, labels in dataloader:
    print(labels.tolist())

[1, 1, 1]
[1, 1, 1]
[1, 1, 1]

sampler = WeightedRandomSampler(weights, 8, replacement=False)
dataloader = DataLoader(dataset, batch_size=4, sampler=sampler)
for datas, labels in dataloader:
    print(labels.tolist())

[1, 1, 1, 1]
[0, 0, 0, 0]

從上面的程式碼可以看到，num_samples 等於 dataset 的樣本總數，為了不重複選取，sampler 會把每個樣本都返回，這樣就失去了 weight 參數的意義。

從上面的例子可以看出 sampler 在樣本取樣中的作用：如果指定了 sampler，shuffle 將不會再生效，並且 sampler.num_samples 會覆蓋 dataset 的實際大小，也就是一個 epoch 返回的圖片總數取決於 sampler.num_samples。