使用Pytorch訓練分類器詳解（附python演練）

import torch
import torchvision
import torchvision.transformsastransforms

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 Files already downloaded and verified

import matplotlib.pyplot as plt
import numpy as np

# 影像顯示函式
defimshow(img):
    img = img /2+0.5     # 非標準的（unnormalized）
    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))

# 列印類標
print(' '.join('%5s'% classes[labels[j]] for j inrange(4)))

cat   car   dog   cat

import torch.nn as nn
import torch.nn.functional as F

classNet(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)

    defforward(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()

import torch.optim as optim

criterion = nn.CrossEntropyLoss()optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9）

for epoch inrange(2):  # 多次迴圈遍歷資料集
    running_loss =0.0
    for i, data inenumerate(trainloader, 0):
        # 獲取輸入
        inputs, labels = data

        # 引數梯度置零
        optimizer.zero_grad()

        # 前向+ 反向 + 優化
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 輸出統計       
running_loss += loss.item()

        if i %2000==1999:    # 每2000 mini-batchs輸出一次                                  print('[%d, %5d] loss: %.3f'%
                  (epoch +1, i +1, running_loss /2000))

            running_loss =0.0

print('Finished Training')

[1,  2000] loss: 2.211
[1,  4000] loss: 1.837
[1,  6000] loss: 1.659
[1,  8000] loss: 1.570
[1, 10000] loss: 1.521
[1, 12000] loss: 1.451
[2,  2000] loss: 1.411
[2,  4000] loss: 1.393
[2,  6000] loss: 1.348
[2,  8000] loss: 1.340
[2, 10000] loss: 1.363
[2, 12000] loss: 1.320

Finished Training

dataiter =iter(testloader)images, labels = dataiter.next()

# 列印圖片
imshow(torchvision.utils.make_grid(images))

print('GroundTruth: ', ' '.join('%5s'% classes[labels[j]] for j inrange(4)))

GroundTruth:    cat  ship  ship plane

outputs = net(images)

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

print('Predicted: ', ' '.join('%5s'% classes[predicted[j]]

                              for j inrange(4)))

Predicted:    cat   car   car  ship

correct =0total =0with 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 %

class_correct =list(0.for i inrange(10))class_total =list(0.for i inrange(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 inrange(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] +=1
 
for i inrange(10):

    print('Accuracy of %5s : %2d %%'% (
        classes[i], 100* class_correct[i] / class_total[i]))

Accuracy of plane : 52 %
Accuracy of   car : 73 %
Accuracy of  bird : 34 %
Accuracy of   cat : 54 %
Accuracy of  deer : 48 %
Accuracy of   dog : 26 %
Accuracy of  frog : 68 %
Accuracy of horse : 51 %
Accuracy of  ship : 63 %
Accuracy of truck : 60 %

device = torch.device("cuda:0"if torch.cuda.is_available() else"cpu")

# 假設在一臺CUDA機器上執行，那麼這裡將輸出一個CUDA裝置號：
print(device)

cuda:0

net.to(device)

inputs, labels = inputs.to(device), labels.to(device)