PyTorch real benefits from entry to four of proficiency - convolution neural network CIFAR-10 image classification

In this tutorial, we will use CIFAR10 data sets. It has the category: "airplane", "car", "bird", "Cats", "deer", "dog", "frog", "horse", "boat", "truck." The image size is CIFAR-10 3x32x32, i.e., 3 channel color image size is 32x32 pixels.

We will in the following order:
1. torchvision load and regulate CIFAR10 training and testing data sets
2. Define a convolutional neural network
3. Define loss function
4. The training data to train the network
5. The network test on the test data 

1.

import torch
import torchvision
import torchvision.transforms as transforms

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')

Out:

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

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

Out:

car  deer  bird   car

2.

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):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')



Out:

[1,  2000] loss: 2.247
[1,  4000] loss: 1.899
[1,  6000] loss: 1.702
[1,  8000] loss: 1.574
[1, 10000] loss: 1.504
[1, 12000] loss: 1.489
[2,  2000] loss: 1.401
[2,  4000] loss: 1.391
[2,  6000] loss: 1.353
[2,  8000] loss: 1.332
[2, 10000] loss: 1.309
[2, 12000] loss: 1.291
Finished Training

Save the model training

PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)

5.

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]))



Out:

Accuracy of plane : 62 %
Accuracy of   car : 66 %
Accuracy of  bird : 40 %
Accuracy of   cat : 42 %
Accuracy of  deer : 59 %
Accuracy of   dog : 32 %
Accuracy of  frog : 46 %
Accuracy of horse : 64 %
Accuracy of  ship : 75 %
Accuracy of truck : 63 %

 Just like you put a tensor transferred to the GPU as you put neural network transferred to the GPU.
Let's first define our equipment is first visible cuda equipment, if we have cuda are available:

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

# Assuming that we are on a CUDA machine, this should print a CUDA device:

print(device)




Out:

cuda:0

 These methods will then recursively through all modules, and converting the parameter and the buffer is CUDA tensor, and remember the input transfer to the GPU

net.to(device)
inputs, labels = data[0].to(device), data[1].to(device)

GPU acceleration will not find, because the network of small-scale