整理一下看到的自定義數據讀取的方法，較好的有一下三篇文章， 其實自定義的方法就是把現有數據集的train和test分別用 含有圖像路徑與label的list返回就好了，所以需要根據數據集隨機應變。
所有圖片都在一個文件夾1
之前剛開始用的時候，寫Dataloader遇到不少坑。網上有一些教程 分為all images in one folder 和 each class one folder。后面的那種寫的人比較多，我寫一下前面的這種，程式化的東西，每次不同的任務改幾個參數就好。
等訓練的時候寫一篇文章把2333
一.已有的東西
舉例子：用kaggle上的一個dog breed的數據集為例。數據文件夾里面有三個子目錄
test: 幾千張圖片，沒有標簽，測試集
train: 10222張狗的圖片，全是jpg，大小不一，有長有寬，基本都在400×300以上
labels.csv ： excel表格, 圖片名稱+品種名稱
我喜歡先用pandas把表格信息讀出來看一看
import pandas as pd
import numpy as np
df = pd.read_csv('./dog_breed/labels.csv')
print(df.info())
print(df.head())
看到，一共有10222個數據，id對應的是圖片的名字，但是沒有后綴 .jpg。 breed對應的是犬種。
二.預處理
我們要做的事情是：
1)得到一個長 list1 : 里面是每張圖片的路徑
2)另外一個長list2: 里面是每張圖片對應的標簽（整數），順序要和list1對應。
3)把這兩個list切分出來一部分作為驗證集
1）看看一共多少個breed,把每種breed名稱和一個數字編號對應起來：
from pandas import Series,DataFrame
breed = df['breed']
breed_np = Series.as_matrix(breed)
print(type(breed_np) )
print(breed_np.shape) #(10222,)
看一下一共多少不同種類
breed_set = set(breed_np)
print(len(breed_set)) #120
構建一個編號與名稱對應的字典，以后輸出的數字要變成名字的時候用：
breed_120_list = list(breed_set)
dic = {}
for i in range(120):
dic[ breed_120_list[i] ] = i
2）處理id那一列，分割成兩段：
file = Series.as_matrix(df["id"])
print(file.shape)
import os
file = [i+".jpg" for i in file]
file = [os.path.join("./dog_breed/train",i) for i in file ]
file_train = file[:8000]
file_test = file[8000:]
print(file_train)
np.save( "file_train.npy" ,file_train )
np.save( "file_test.npy" ,file_test )
里面就是圖片的路徑了
3）處理breed那一列，分成兩段：
breed = Series.as_matrix(df["breed"])
print(breed.shape)
number = []
for i in range(10222):
number.append( dic[ breed[i] ] )
number = np.array(number)
number_train = number[:8000]
number_test = number[8000:]
np.save( "number_train.npy" ,number_train )
np.save( "number_test.npy" ,number_test )
三.Dataloader
我們已經有了圖片路徑的list,target編號的list。填到Dataset類里面就行了。
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
preprocess = transforms.Compose([
#transforms.Scale(256),
#transforms.CenterCrop(224),
transforms.ToTensor(),
normalize
])
def default_loader(path):
img_pil = Image.open(path)
img_pil = img_pil.resize((224,224))
img_tensor = preprocess(img_pil)
return img_tensor
當然出來的時候已經全都變成了tensor
class trainset(Dataset):
def init(self, loader=default_loader):
#定義好 image 的路徑
self.images = file_train
self.target = number_train
self.loader = loader
def __getitem__(self, index):
fn = self.images[index]
img = self.loader(fn)
target = self.target[index]
return img,target
def __len__(self):
return len(self.images)
我們看一下代碼，自定義Dataset只需要最下面一個class,繼承自Dataset類。有三個私有函數
def init(self, loader=default_loader):
這個里面一般要初始化一個loader(代碼見上面),一個images_path的列表，一個target的列表
def getitem(self, index)：
這里嗎就是在給你一個index的時候，你返回一個圖片的tensor和target的tensor,使用了loader方法，經過 歸一化，剪裁，類型轉化，從圖像變成tensor
def len(self):
return你所有數據的個數
這三個綜合起來看呢，其實就是你告訴它你所有數據的長度，它每次給你返回一個shuffle過的index,以這個方式遍歷數據集，通過 getitem(self, index)返回一組你要的（input,target）
四.使用
實例化一個dataset,然后用Dataloader 包起來
train_data = trainset()
trainloader = DataLoader(train_data, batch_size=4,shuffle=True)
所有圖片都在一個文件夾2
在上一篇博客PyTorch學習之路（level1）——訓練一個圖像分類模型中介紹了如何用PyTorch訓練一個圖像分類模型，建議先看懂那篇博客后再看這篇博客。在那份代碼中，采用torchvision.datasets.ImageFolder這個接口來讀取圖像數據，該接口默認你的訓練數據是按照一個類別存放在一個文件夾下。但是有些情況下你的圖像數據不是這樣維護的，比如一個文件夾下面各個類別的圖像數據都有，同時用一個對應的標簽文件，比如txt文件來維護圖像和標簽的對應關系，在這種情況下就不能用torchvision.datasets.ImageFolder來讀取數據了，需要自定義一個數據讀取接口。另外這篇博客最后還順帶介紹如何保存模型和多GPU訓練。
怎么做呢？
先來看看torchvision.datasets.ImageFolder這個類是怎么寫的，主要代碼如下，想詳細了解的可以看：官方github代碼。
看起來很復雜，其實非常簡單。繼承的類是torch.utils.data.Dataset，主要包含三個方法：初始化__init__，獲取圖像__getitem__，數據集數量 __len__。__init__方法中先通過find_classes函數得到分類的類別名（classes）和類別名與數字類別的映射關系字典（class_to_idx）。然后通過make_dataset函數得到imags，這個imags是一個列表，其中每個值是一個tuple，每個tuple包含兩個元素：圖像路徑和標簽。剩下的就是一些賦值操作了。在__getitem__方法中最重要的就是 img = self.loader(path)這行，表示數據讀取，可以從__init__方法中看出self.loader采用的是default_loader，這個default_loader的核心就是用python的PIL庫的Image模塊來讀取圖像數據。
class ImageFolder(data.Dataset):
"""A generic data loader where the images are arranged in this way: :: root/dog/xxx.png root/dog/xxy.png root/dog/xxz.png root/cat/123.png root/cat/nsdf3.png root/cat/asd932_.png Args: root (string): Root directory path. transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed version. E.g, ``transforms.RandomCrop`` target_transform (callable, optional): A function/transform that takes in the target and transforms it. loader (callable, optional): A function to load an image given its path. Attributes: classes (list): List of the class names. class_to_idx (dict): Dict with items (class_name, class_index). imgs (list): List of (image path, class_index) tuples """
def __init__(self, root, transform=None, target_transform=None, loader=default_loader):
classes, class_to_idx = find_classes(root)
imgs = make_dataset(root, class_to_idx)
if len(imgs) == 0:
raise(RuntimeError("Found 0 images in subfolders of: " + root + "\n"
"Supported image extensions are: " + ",".join(IMG_EXTENSIONS)))
self.root = root
self.imgs = imgs
self.classes = classes
self.class_to_idx = class_to_idx
self.transform = transform
self.target_transform = target_transform
self.loader = loader
def __getitem__(self, index):
""" Args: index (int): Index Returns: tuple: (image, target) where target is class_index of the target class. """
path, target = self.imgs[index]
img = self.loader(path)
if self.transform is not None:
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
return img, target
def __len__(self):
return len(self.imgs)稍微看下default_loader函數，該函數主要分兩種情況調用兩個函數，一般采用pil_loader函數。
def pil_loader(path):
with open(path, 'rb') as f:
with Image.open(f) as img:
return img.convert('RGB')
def accimage_loader(path):
import accimage
try:
return accimage.Image(path)
except IOError:
# Potentially a decoding problem, fall back to PIL.Image
return pil_loader(path)
def default_loader(path):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path)看懂了ImageFolder這個類，就可以自定義一個你自己的數據讀取接口了。
首先在PyTorch中和數據讀取相關的類基本都要繼承一個基類：torch.utils.data.Dataset。然后再改寫其中的__init__、__len__、__getitem__等方法即可。
下面假設img_path是你的圖像文件夾，該文件夾下面放了所有圖像數據（包括訓練和測試），然后txt_path下面放了train.txt和val.txt兩個文件，txt文件中每行都是圖像路徑，tab鍵，標簽。所以下面代碼的__init__方法中self.img_name和self.img_label的讀取方式就跟你數據的存放方式有關，你可以根據你實際數據的維護方式做調整。__getitem__方法沒有做太大改動，依然采用default_loader方法來讀取圖像。最后在Transform中將每張圖像都封裝成Tensor。
class customData(Dataset):
def __init__(self, img_path, txt_path, dataset = '', data_transforms=None, loader = default_loader):
with open(txt_path) as input_file:
lines = input_file.readlines()
self.img_name = [os.path.join(img_path, line.strip().split('\t')[0]) for line in lines]
self.img_label = [int(line.strip().split('\t')[-1]) for line in lines]
self.data_transforms = data_transforms
self.dataset = dataset
self.loader = loader
def __len__(self):
return len(self.img_name)
def __getitem__(self, item):
img_name = self.img_name[item]
label = self.img_label[item]
img = self.loader(img_name)
if self.data_transforms is not None:
try:
img = self.data_transforms[self.dataset](img)
except:
print("Cannot transform image: {}".format(img_name))
return img, label定義好了數據讀取接口后，怎么用呢？
在代碼中可以這樣調用。
image_datasets = {x: customData(img_path='/ImagePath',
txt_path=('/TxtFile/' + x + '.txt'),
data_transforms=data_transforms,
dataset=x) for x in ['train', 'val']}這樣返回的image_datasets就和用torchvision.datasets.ImageFolder類返回的數據類型一樣，有點狸貓換太子的感覺，這就是在第一篇博客中說的寫代碼類似搭積木的感覺。
有了image_datasets，然后依然用torch.utils.data.DataLoader類來做進一步封裝，將這個batch的圖像數據和標簽都分別封裝成Tensor。
dataloders = {x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=batch_size,
shuffle=True) for x in ['train', 'val']}另外，每次迭代生成的模型要怎么保存呢？非常簡單，那就是用torch.save。輸入就是你的模型和要保存的路徑及模型名稱，如果這個output文件夾沒有，可以手動新建一個或者在代碼里面新建。
torch.save(model, 'output/resnet_epoch{}.pkl'.format(epoch))最后，關於多GPU的使用，PyTorch支持多GPU訓練模型，假設你的網絡是model，那么只需要下面一行代碼（調用 torch.nn.DataParallel接口）就可以讓后續的模型訓練在0和1兩塊GPU上訓練，加快訓練速度。
model = torch.nn.DataParallel(model, device_ids=[0,1])完整代碼請移步：Github
每個類的圖片放在一個文件夾
這是一個適合PyTorch入門者看的博客。PyTorch的文檔質量比較高，入門較為容易，這篇博客選取官方鏈接里面的例子，介紹如何用PyTorch訓練一個ResNet模型用於圖像分類，代碼邏輯非常清晰，基本上和許多深度學習框架的代碼思路類似，非常適合初學者想上手PyTorch訓練模型（不必每次都跑mnist的demo了）。接下來從個人使用角度加以解釋。解釋的思路是從數據導入開始到模型訓練結束，基本上就是搭積木的方式來寫代碼。
首先是數據導入部分，這里采用官方寫好的torchvision.datasets.ImageFolder接口實現數據導入。這個接口需要你提供圖像所在的文件夾，就是下面的data_dir=‘/data’這句，然后對於一個分類問題，這里data_dir目錄下一般包括兩個文件夾：train和val，每個文件件下面包含N個子文件夾，N是你的分類類別數，且每個子文件夾里存放的就是這個類別的圖像。這樣torchvision.datasets.ImageFolder就會返回一個列表（比如下面代碼中的image_datasets[‘train’]或者image_datasets[‘val]），列表中的每個值都是一個tuple，每個tuple包含圖像和標簽信息。
data_dir = '/data'
image_datasets = {x: datasets.ImageFolder(
os.path.join(data_dir, x),
data_transforms[x])，
for x in ['train', 'val']}另外這里的data_transforms是一個字典，如下。主要是進行一些圖像預處理，比如resize、crop等。實現的時候采用的是torchvision.transforms模塊，比如torchvision.transforms.Compose是用來管理所有transforms操作的，torchvision.transforms.RandomSizedCrop是做crop的。需要注意的是對於torchvision.transforms.RandomSizedCrop和transforms.RandomHorizontalFlip()等，輸入對象都是PIL Image，也就是用python的PIL庫讀進來的圖像內容，而transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])的作用對象需要是一個Tensor，因此在transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])之前有一個 transforms.ToTensor()就是用來生成Tensor的。另外transforms.Scale(256)其實就是resize操作，目前已經被transforms.Resize類取代了。
data_transforms = {
'train': transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val': transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}前面torchvision.datasets.ImageFolder只是返回list，list是不能作為模型輸入的，因此在PyTorch中需要用另一個類來封裝list，那就是：torch.utils.data.DataLoader。torch.utils.data.DataLoader類可以將list類型的輸入數據封裝成Tensor數據格式，以備模型使用。注意，這里是對圖像和標簽分別封裝成一個Tensor。這里要提到另一個很重要的類：torch.utils.data.Dataset，這是一個抽象類，在pytorch中所有和數據相關的類都要繼承這個類來實現。比如前面說的torchvision.datasets.ImageFolder類是這樣的，以及這里的torch.util.data.DataLoader類也是這樣的。所以當你的數據不是按照一個類別一個文件夾這種方式存儲時，你就要自定義一個類來讀取數據，自定義的這個類必須繼承自torch.utils.data.Dataset這個基類，最后同樣用torch.utils.data.DataLoader封裝成Tensor。
dataloders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4, shuffle=True, num_workers=4)
for x in ['train', 'val']}生成dataloaders后再有一步就可以作為模型的輸入了，那就是將Tensor數據類型封裝成Variable數據類型，來看下面這段代碼。dataloaders是一個字典，dataloders[‘train’]存的就是訓練的數據，這個for循環就是從dataloders[‘train’]中讀取batch_size個數據，batch_size在前面生成dataloaders的時候就設置了。因此這個data里面包含圖像數據（inputs）這個Tensor和標簽（labels）這個Tensor。然后用torch.autograd.Variable將Tensor封裝成模型真正可以用的Variable數據類型。
為什么要封裝成Variable呢？在pytorch中，torch.tensor和torch.autograd.Variable是兩種比較重要的數據結構，Variable可以看成是tensor的一種包裝，其不僅包含了tensor的內容，還包含了梯度等信息，因此在神經網絡中常常用Variable數據結構。那么怎么從一個Variable類型中取出tensor呢？也很簡單，比如下面封裝后的inputs是一個Variable，那么inputs.data就是對應的tensor。
for data in dataloders['train']:
inputs, labels = data
if use_gpu:
inputs = Variable(inputs.cuda())
labels = Variable(labels.cuda())
else:
inputs, labels = Variable(inputs), Variable(labels)封裝好了數據后，就可以作為模型的輸入了。所以要先導入你的模型。在PyTorch中已經默認為大家准備了一些常用的網絡結構，比如分類中的VGG，ResNet，DenseNet等等，可以用torchvision.models模塊來導入。比如用torchvision.models.resnet18(pretrained=True)來導入ResNet18網絡，同時指明導入的是已經預訓練過的網絡。因為預訓練網絡一般是在1000類的ImageNet數據集上進行的，所以要遷移到你自己數據集的2分類，需要替換最后的全連接層為你所需要的輸出。因此下面這三行代碼進行的就是用models模塊導入resnet18網絡，然后獲取全連接層的輸入channel個數，用這個channel個數和你要做的分類類別數（這里是2）替換原來模型中的全連接層。這樣網絡結果也准備好。
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)但是只有網絡結構和數據還不足以讓代碼運行起來，還需要定義損失函數。在PyTorch中采用torch.nn模塊來定義網絡的所有層，比如卷積、降采樣、損失層等等，這里采用交叉熵函數，因此可以這樣定義：
criterion = nn.CrossEntropyLoss()然后你還需要定義優化函數，比如最常見的隨機梯度下降，在PyTorch中是通過torch.optim模塊來實現的。另外這里雖然寫的是SGD，但是因為有momentum，所以是Adam的優化方式。這個類的輸入包括需要優化的參數：model.parameters()，學習率，還有Adam相關的momentum參數。現在很多優化方式的默認定義形式就是這樣的。
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)然后一般還會定義學習率的變化策略，這里采用的是torch.optim.lr_scheduler模塊的StepLR類，表示每隔step_size個epoch就將學習率降為原來的gamma倍。
scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)准備工作終於做完了，要開始訓練了。
首先訓練開始的時候需要先更新下學習率，這是因為我們前面制定了學習率的變化策略，所以在每個epoch開始時都要更新下：
scheduler.step()然后設置模型狀態為訓練狀態：
model.train(True)然后先將網絡中的所有梯度置0：
optimizer.zero_grad()然后就是網絡的前向傳播了：
outputs = model(inputs)然后將輸出的outputs和原來導入的labels作為loss函數的輸入就可以得到損失了：
loss = criterion(outputs, labels)輸出的outputs也是torch.autograd.Variable格式，得到輸出后（網絡的全連接層的輸出）還希望能到到模型預測該樣本屬於哪個類別的信息，這里采用torch.max。torch.max()的第一個輸入是tensor格式，所以用outputs.data而不是outputs作為輸入；第二個參數1是代表dim的意思，也就是取每一行的最大值，其實就是我們常見的取概率最大的那個index；第三個參數loss也是torch.autograd.Variable格式。
_, preds = torch.max(outputs.data, 1)計算得到loss后就要回傳損失。要注意的是這是在訓練的時候才會有的操作，測試時候只有forward過程。
loss.backward()回傳損失過程中會計算梯度，然后需要根據這些梯度更新參數，optimizer.step()就是用來更新參數的。optimizer.step()后，你就可以從optimizer.param_groups[0][‘params’]里面看到各個層的梯度和權值信息。
optimizer.step()這樣一個batch數據的訓練就結束了！當你不斷重復這樣的訓練過程，最終就可以達到你想要的結果了。
另外如果你有gpu可用，那么包括你的數據和模型都可以在gpu上操作，這在PyTorch中也非常簡單。判斷你是否有gpu可以用可以通過下面這行代碼，如果有，則use_gpu是true。
use_gpu = torch.cuda.is_available()完整代碼請移步：Github