學習目標
- 了解分類器的任務和數據樣式
- 掌握如何用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/ target=_blank class=infotextkey>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)
