學習目标
- 了解分類器的任務和資料樣式
- 掌握如何用Pytorch實作一個分類器
分類器任務和資料介紹
- 構造一個将不同圖像進行分類的神經網絡分類器, 對輸入的圖檔進行判别并完成分類.
- 本案例采用CIFAR10資料集作為原始圖檔資料.
CIFAR10資料集介紹: 資料集中每張圖檔的尺寸是3 * 32 * 32, 代表彩色3通道
CIFAR10資料集總共有10種不同的分類, 分别是"airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck".
CIFAR10資料集的樣例如下圖所示:
訓練分類器的步驟
- 1: 使用torchvision下載下傳CIFAR10資料集
- 2: 定義卷積神經網絡
- 3: 定義損失函數
- 4: 在訓練集上訓練模型
- 5: 在測試集上測試模型
1: 使用torchvision下載下傳CIFAR10資料集
導入torchvision包來輔助下載下傳資料集
import torch
import torchvision
import torchvision.transforms as transforms 下載下傳資料集并對圖檔進行調整, 因為torchvision資料集的輸出是PILImage格式, 資料域在[0, 1]. 我們将其轉換為标準資料域[-1, 1]的張量格式.
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck') 輸出結果:
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Extracting ./data/cifar-10-python.tar.gz to ./data
Files already downloaded and verified - 注意:
- 如果你是在Windows系統下運作上述代碼, 并且出現報錯資訊 "BrokenPipeError", 可以嘗試将torch.utils.data.DataLoader()中的num_workers設定為0.
展示若幹訓練集的圖檔
# 導入畫圖包和numpy
import matplotlib.pyplot as plt
import numpy as np
# 建構展示圖檔的函數
def imshow(img):
img = img / 2 + 0.5
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# 從資料疊代器中讀取一張圖檔
dataiter = iter(trainloader)
images, labels = dataiter.next()
# 展示圖檔
imshow(torchvision.utils.make_grid(images))
# 列印标簽label
print(' '.join('%5s' % classes[labels[j]] for j in range(4))) 輸出圖檔結果:
輸出标簽結果:
bird truck cat cat - 2: 定義卷積神經網絡
仿照2.1節中的類來構造此處的類, 唯一的差別是此處采用3通道3-channel
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net() - 3: 定義損失函數
采用交叉熵損失函數和随機梯度下降優化器.
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) - 4: 在訓練集上訓練模型
采用基于梯度下降的優化算法, 都需要很多個輪次的疊代訓練.
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# data中包含輸入圖像張量inputs, 标簽張量labels
inputs, labels = data
# 首先将優化器梯度歸零
optimizer.zero_grad()
# 輸入圖像張量進網絡, 得到輸出張量outputs
outputs = net(inputs)
# 利用網絡的輸出outputs和标簽labels計算損失值
loss = criterion(outputs, labels)
# 反向傳播+參數更新, 是标準代碼的标準流程
loss.backward()
optimizer.step()
# 列印輪次和損失值
running_loss += loss.item()
if (i + 1) % 2000 == 0:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training') 輸出結果:
[1, 2000] loss: 2.227
[1, 4000] loss: 1.884
[1, 6000] loss: 1.672
[1, 8000] loss: 1.582
[1, 10000] loss: 1.526
[1, 12000] loss: 1.474
[2, 2000] loss: 1.407
[2, 4000] loss: 1.384
[2, 6000] loss: 1.362
[2, 8000] loss: 1.341
[2, 10000] loss: 1.331
[2, 12000] loss: 1.291
Finished Training 儲存模型:
# 首先設定模型的儲存路徑
PATH = './cifar_net.pth'
# 儲存模型的狀态字典
torch.save(net.state_dict(), PATH) - 5: 在測試集上測試模型
第一步, 展示測試集中的若幹圖檔
dataiter = iter(testloader)
images, labels = dataiter.next()
# 列印原始圖檔
imshow(torchvision.utils.make_grid(images))
# 列印真實的标簽
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4))) 輸出圖檔結果:
輸出标簽結果:
GroundTruth: cat ship ship plane 第二步, 加載模型并對測試圖檔進行預測
# 首先執行個體化模型的類對象
net = Net()
# 加載訓練階段儲存好的模型的狀态字典
net.load_state_dict(torch.load(PATH))
# 利用模型對圖檔進行預測
outputs = net(images)
# 共有10個類别, 采用模型計算出的機率最大的作為預測的類别
_, predicted = torch.max(outputs, 1)
# 列印預測标簽的結果
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4))) 輸出結果:
Predicted: cat ship ship plane 接下來看一下在全部測試集上的表現
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total)) 輸出結果:
Accuracy of the network on the 10000 test images: 53 % 分析結果: 對于擁有10個類别的資料集, 随機猜測的準确率是10%, 模型達到了53%, 說明模型學到了真實的東西.
為了更加細緻地看一下模型在哪些類别上表現更好, 在哪些類别上表現更差, 我們分類别的進行準确率計算.
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i])) 輸出結果:
Accuracy of plane : 62 %
Accuracy of car : 62 %
Accuracy of bird : 45 %
Accuracy of cat : 36 %
Accuracy of deer : 52 %
Accuracy of dog : 25 %
Accuracy of frog : 69 %
Accuracy of horse : 60 %
Accuracy of ship : 70 %
Accuracy of truck : 48 % 在GPU上訓練模型
- 為了真正利用Pytorch中Tensor的優秀屬性, 加速模型的訓練, 我們可以将訓練過程轉移到GPU上進行.
首先要定義裝置, 如果CUDA是可用的則被定義成GPU, 否則被定義成CPU.
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device) 輸出結果:
cuda:0 當訓練模型的時候, 隻需要将模型轉移到GPU上, 同時将輸入的圖檔和标簽頁轉移到GPU上即可.
# 将模型轉移到GPU上
net.to(device)
# 将輸入的圖檔張量和标簽張量轉移到GPU上
inputs, labels = data[0].to(device), data[1].to(device)