本篇是利用 Python 和 PyTorch 處理面向對象的數據集系列博客的第 3 篇。

第 3 部分：repetita iuvant(*)：貓和狗

(*) 是一個拉丁語詞組，意為“水滴石穿，功到自成”

在本篇博文中，我們將在“貓和狗”數據庫上重復先前第 2 部分中已完成的過程，并且我們將添加一些其它內容。

通常，簡單的數據集都是按文件夾來組織的。例如，貓、狗以及每個類別的“訓練”、“驗證”和“測試”文件夾。

通過將數據集組織為單一對象，即可避免文件夾樹的復雜性。在此應用中，所有圖片都保存到同一個文件夾內。

我們只需 1 個標簽文件來標明哪個是狗，哪個是貓即可。

以下包含了用于自動創建標簽文件的代碼。即使每張圖片名稱本身就包含了標簽，我們也特意創建 1 個專用 label.txt 文件：其中每行都包含文件名和標簽：貓 (cat) = 0 狗 (dog) = 1。

在此示例最后，我們將回顧使用 PyTorch 拆分數據集的 2 種方法，并訓練 1 個非常簡單的模型。

輸入 [ ]：

data_path = './raw_data/dogs_cats/all'

import os

files = [f for f in os.listdir(data_path) ]

#for f in files:

# print(f)

with open(data_path + '/'+ "labels.txt", "a") as myfile:

for f in files:

if f.split('.')[0]=='cat':

label = 0

elif f.split('.')[0]=='dog':

label = 1

else:

print("ERROR in recognizing file " + f + "label")

myfile.write(f + ' ' + str(label) + '\n')

輸入 [106]：

raw_data_path = './raw_data/dogs_cats/all'

im_example_cat = Image.open(raw_data_path + '/' + 'cat.1070.jpg')

im_example_dog = Image.open(raw_data_path + '/' + 'dog.1070.jpg')

fig, axs = plt.subplots(1, 2, figsize=(10, 3))

axs[0].set_title('should be a cat')

axs[0].imshow(im_example_cat)

axs[1].set_title('should be a dog')

axs[1].imshow(im_example_dog)

plt.show()

請務必刷新樣本列表：

輸入 [ ]：

del sample_list

@functools.lru_cache(1)

def getSampleInfoList(raw_data_path):

sample_list = []

with open(str(raw_data_path) + '/labels.txt', mode = 'r') as f:

reader = csv.reader(f, delimiter = ' ')

for i, row in enumerate(reader):

imgname = row[0]

label = int(row[1])

sample_list.append(DataInfoTuple(imgname, label))

sample_list.sort(reverse=False, key=myFunc)

# print("DataInfoTouple: samples list length = {}".format(len(sample_list)))

return sample_list

數據集對象創建非常簡單，只需 1 行代碼即可：

輸入 [114]：

mydataset = MyDataset(isValSet_bool = None, raw_data_path = raw_data_path, norm = False, resize = True, newsize = (64, 64))

如需進行歸一化，則應計算平均值和標準差，并重新生成歸一化后的數據集。

代碼如下，以確保代碼完整性。

輸入 [ ]：

imgs = torch.stack([img_t for img_t, _ in mydataset], dim = 3)

im_mean = imgs.view(3, -1).mean(dim=1).tolist()

im_std = imgs.view(3, -1).std(dim=1).tolist()

del imgs

normalize = transforms.Normalize(mean=im_mean, std=im_std)

mydataset = MyDataset(isValSet_bool = None, raw_data_path = raw_data_path, norm = True, resize = True, newsize = (64, 64))

將數據庫拆分為訓練集、驗證集和測試集。

下一步是訓練階段所必需的。通常，整個樣本數據集已重新打亂次序，隨后拆分為三個集：訓練集、驗證集和測試集。

如果您已將數據集組織為數據張量和標簽張量，那么您可使用 2 次“sklearn.model_selection.train_test_split”。

首先，將其拆分為“訓練”和“測試”，然后再將“訓練”拆分為“驗證”和“訓練”。

結果如下所示：

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1) X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=1)

但我們想把數據集保留為對象，而 PyTorch 則可幫助我們簡化這一操作。

例如，我們僅創建“訓練和驗證”集。

方法 1：

此處，我們對索引進行打亂次序，然后創建數據集

輸入 [ ]：

n_samples = len(mydataset)

# 驗證集中將包含多少樣本

n_val = int(0.2 * n_samples)

# 重要！對數據集進行打亂次序。首先對索引進行打亂次序。

shuffled_indices = torch.randperm(n_samples)

# 第一步是拆分索引

train_indices = shuffled_indices[:-n_val]

val_indices = shuffled_indices[-n_val:]

train_indices, val_indices

輸入 [ ]：

from torch.utils.data.sampler import SubsetRandomSampler

batch_size = 64

train_sampler = SubsetRandomSampler(train_indices)

valid_sampler = SubsetRandomSampler(val_indices)

train_loader = torch.utils.data.DataLoader(mydataset, batch_size=batch_size, sampler=train_sampler)

validation_loader = torch.utils.data.DataLoader(mydataset, batch_size=batch_size, sampler=valid_sampler)

方法 2

以下是直接對數據庫進行打亂次序的示例。代碼風格更抽象：

輸入 [116]：

train_size = int(0.9 * len(mydataset))

valid_size = int(0.1 * len(mydataset))

train_dataset, valid_dataset = torch.utils.data.random_split(mydataset, [train_size, valid_size])

# 如需“測試”數據集，則請取消注釋

#test_size = valid_size

#train_size = train_size - test_size

#train_dataset, test_dataset = torch.utils.data.random_split(train_dataset, [train_size, test_size])

len(mydataset), len(train_dataset), len(valid_dataset)

輸出 [116]：

(25000, 22500, 2500)

模型定義

輸入 [41]：

import torch.nn as nn

import torch.nn.functional as F

n_out = 2

輸入 [ ]：

# NN 極小

# 期望的精確度為 0.66

class Net(nn.Module):

def __init__(self):

super(Net, self).__init__()

self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding = 1)

self.conv2 = nn.Conv2d(16, 8, kernel_size=3, padding = 1)

self.fc1 = nn.Linear(8*16*16, 32)

self.fc2 = nn.Linear(32, 2)

def forward(self, x):

out = F.max_pool2d(torch.tanh(self.conv1(x)), 2)

out = F.max_pool2d(torch.tanh(self.conv2(out)), 2)

#print(out.shape)

out = out.view(-1,8*16*16)

out = torch.tanh(self.fc1(out))

out = self.fc2(out)

return out

輸入 [131]：

# 模型更深 - 但訓練時間在我的 CPU 上開始變得有些難以承受

class ResBlock(nn.Module):

def __init__(self, n_chans):

super(ResBlock, self).__init__()

self.conv = nn.Conv2d(n_chans, n_chans, kernel_size=3, padding=1)

self.batch_norm = nn.BatchNorm2d(num_features=n_chans)

def forward(self, x):

out = self.conv(x)

out = self.batch_norm(out)

out = torch.relu(out)

return out + x

輸入 [177]：

class Net(nn.Module):

def __init__(self, n_chans1=32, n_blocks=10):

super(Net, self).__init__()

self.n_chans1 = n_chans1

self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)

self.conv3 = nn.Conv2d(n_chans1, n_chans1, kernel_size=3, padding=1)

self.resblocks = nn.Sequential(* [ResBlock(n_chans=n_chans1)] * n_blocks)

self.fc1 = nn.Linear(n_chans1 * 8 * 8, 32)

self.fc2 = nn.Linear(32, 2)

def forward(self, x):

out = F.max_pool2d(torch.relu(self.conv1(x)), 2)

out = self.resblocks(out)

out = F.max_pool2d(torch.relu(self.conv3(out)), 2)

out = F.max_pool2d(torch.relu(self.conv3(out)), 2)

out = out.view(-1, self.n_chans1 * 8 * 8)

out = torch.relu(self.fc1(out))

out = self.fc2(out)

return out

model = Net(n_chans1=32, n_blocks=5)

讓我們來顯示模型大小：

輸入 [178]：

model = Net()

numel_list = [p.numel() for p in model.parameters() if p.requires_grad == True]

sum(numel_list), numel_list

輸出 [178]：

(85090, [864, 32, 9216, 32, 9216, 32, 32, 32, 65536, 32, 64, 2])

簡單且聰明的竅門來檢查圖片 shape 的不匹配和錯誤：訓練模型前先執行正向運行來進行檢查：

輸入 [180]：

model(mydataset[0][0].unsqueeze(0))

# 需要解壓縮才能添加維度并對批次進行仿真

輸出 [180]：

tensor([[0.7951, 0.6417]], grad_fn=)

成功了！

模型訓練

雖然這并非本文的目標，但既然有了模型，何不試試訓練一下，更何況 Pytorch 還免費提供了 DataLoader。

DataLoader 的任務是通過靈活的采樣策略對來自數據集的 mini-batch 進行采樣。將自動把數據集打亂，然后再加載 mini-batch。如需獲取參考信息，請訪問 https://pytorch.org/docs/stable/data.html

輸入 [181]：

device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')

print("Training on device {}.".format(device))

Training on device cpu.

輸入 [182]：

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=64, shuffle=False) # 注：此處無需亂序

輸入 [183]：

def training_loop(n_epochs, optimizer, model, loss_fn, train_loader):

for epoch in range(1, n_epochs + 1):

loss_train = 0.0

for imgs, labels in train_loader:

outputs = model(imgs)

loss = loss_fn(outputs, labels)

optimizer.zero_grad()

loss.backward()

optimizer.step()

loss_train += loss.item()

if epoch == 1 or epoch % 5 == 0:

print('{} Epoch {}, Training loss {}'.format(

datetime.datetime.now(), epoch, float(loss_train)))

輸入 [184]：

model = Net()

# 預訓練的模型 models_data_path = './raw_data/models' model.load_state_dict(torch.load(models_data_path + '/cats_dogs.pt'))

輸入 [185]：

optimizer = optim.SGD(model.parameters(), lr=1e-2)

loss_fn = nn.CrossEntropyLoss()

training_loop(

n_epochs = 20,

optimizer = optimizer,

model = model,

loss_fn = loss_fn,

train_loader = train_loader,

)

2020-09-15 19:33:03.105620 Epoch 1, Training loss 224.0338312983513

2020-09-15 20:01:35.993491 Epoch 5, Training loss 153.11289536952972

2020-09-15 20:36:51.486071 Epoch 10, Training loss 113.09166505932808

2020-09-15 21:11:37.375586 Epoch 15, Training loss 85.17814277857542

2020-09-15 21:46:05.792975 Epoch 20, Training loss 59.60428727790713

輸入 [189]：

for loader in [train_loader, valid_loader]:

correct = 0

total = 0

with torch.no_grad():

for imgs, labels in loader:

outputs = model(imgs)

_, predicted = torch.max(outputs, dim=1)

total += labels.shape[0]

correct += int((predicted == labels).sum())

print("Accuracy: %f" % (correct / total))

Accuracy: 0.956756

Accuracy: 0.830800

性能一般，但目的只是為了測試組織為 Python 對象的數據集是否有效，并測試我們能否訓練一般模型。

此外還需要注意，為了能夠以我的 CPU 來加速訓練，所有圖像都降采樣到 64x64。

輸入 [187]：

models_data_path = './raw_data/models'

torch.save(model.state_dict(), models_data_path + '/cats_dogs.pt')

輸入 [ ]：

# 如需加載先前保存的模型

model = Net()

model.load_state_dict(torch.load(models_data_path + 'cats_dogs.pt'))

附錄

認識 DIM

理解 pytorch sum 或 mean 中的“dim”的方法是，它會折疊所指定的維度。因此，當它折疊維度 0（行），它會變為僅 1 行（它在整列范圍內進行操作）。

輸入 [ ]：

a = torch.randn(2, 3)

a

輸入 [ ]：

torch.mean(a)

輸入 [ ]：

torch.mean(a, dim=0) # now collapsing rows, only one row will result

輸入 [ ]：

torch.mean(a, dim=1) # now collapsing columns, only one column will remain

審核編輯 黃昊宇