训练分类器

现在我们已经知道如何定义网络结构，计算损失以及更新网络权重了，那么，

如何准备数据？

一般来说，处理图像、文本、语音或视频数据，我们可以直接使用Python的标准包将数据加载成numpy数组，然后将它转成torch.*Tensor。

• 对于图片数据，可以使用Pillow，OpenCV；
• 对于音频数据，可以使用scipy和librosa。
• 对于文本数据，可以使用基于原生Python或Cython的加载方式，或者使用NLTK和SpaCy包。

特别针对视觉处理，PyTorch提供了torchvision这个包，能够加载常用的数据集，比如ImageNet，CIFAR10，MNIST等，并且还有图像转换功能，我们可以使用这两个包来实现这些功能：torchvision.datasets，torch.utils.data.DataLoader。

这样就为我们提供了极大的便利而不需要编写样板代码。

这里我们将使用CIFAR10数据集，包含这些类别：“airplane”，“automobile”，“bird”，”cat“，”deer“，”dog“，”frog“，”horse“，”ship“，”truck“，图片大小为3 * 32 * 32，即3通道的32 * 32图像。

训练图像分类器

1. 使用torchvision加载、归一化CIFAR10训练、测试数据
2. 定义卷积神经网络
3. 定义损失函数
4. 使用训练数据训练网络
5. 使用测试数据测试网络

1. 加载、归一化CIFAR10

使用torchvision能非常便捷地加载CIFAR10。

1
2
3
4
5
1import torch

2import torchvision

3import torchvision.transforms as transforms

4

5

torchvision数据集的输出是PILImage类型的数据，范围[0,1]。然后我们将数据归一化到[-1,1]。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1transform = transforms.Compose(

2    [transforms.ToTensor(),

3     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

4

5trainset = torchvision.datasets.CIFAR10(root='./data', train=True,

6                                        download=True, transform=transform)

7trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,

8                                          shuffle=True, num_workers=2)

9

10testset = torchvision.datasets.CIFAR10(root='./data', train=False,

11                                       download=True, transform=transform)

12testloader = torch.utils.data.DataLoader(testset, batch_size=4,

13                                         shuffle=False, num_workers=2)

14

15classes = ('plane', 'car', 'bird', 'cat',

16           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

17

18

1
2
3
4
1Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz

2Files already downloaded and verified

3

4

我们先来看几张图片：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1import matplotlib.pyplot as plt

2import numpy as np

3

4# 显示图像函数

5

6

7def imshow(img):

8    img = img / 2 + 0.5     # 去归一化

9    npimg = img.numpy()

10    plt.imshow(np.transpose(npimg, (1, 2, 0)))

11    plt.show()

12

13

14# 随机获取训练图像

15dataiter = iter(trainloader)

16images, labels = dataiter.next()

17

18# 显示图像

19imshow(torchvision.utils.make_grid(images))

20# print labels

21print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

22

23

1
2
3
1plane truck   car  ship

2

3

2. 定义卷积神经网络

这里使用之前介绍的网络结构，但是将原本的1通道输入改成3通道输入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
1import torch.nn as nn

2import torch.nn.functional as F

3

4

5class Net(nn.Module):

6    def __init__(self):

7        super(Net, self).__init__()

8        self.conv1 = nn.Conv2d(3, 6, 5)

9        self.pool = nn.MaxPool2d(2, 2)

10        self.conv2 = nn.Conv2d(6, 16, 5)

11        self.fc1 = nn.Linear(16 * 5 * 5, 120)

12        self.fc2 = nn.Linear(120, 84)

13        self.fc3 = nn.Linear(84, 10)

14

15    def forward(self, x):

16        x = self.pool(F.relu(self.conv1(x)))

17        x = self.pool(F.relu(self.conv2(x)))

18        x = x.view(-1, 16 * 5 * 5)

19        x = F.relu(self.fc1(x))

20        x = F.relu(self.fc2(x))

21        x = self.fc3(x)

22        return x

23

24

25net = Net()

26

27

3. 定义损失函数和优化器

使用交叉熵损失和带动量的SGD:

1
2
3
4
5
6
1import torch.optim as optim

2

3criterion = nn.CrossEntropyLoss()

4optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

5

6

4. 训练网络

这里就是很有趣的地方啦，只需要简单的遍历数据集，将数据送给网络并且进行优化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
1for epoch in range(2):  # 多次遍历数据集

2

3    running_loss = 0.0

4    for i, data in enumerate(trainloader, 0):

5        # 获得图像输入

6        inputs, labels = data

7

8        # 梯度归零

9        optimizer.zero_grad()

10

11        # 前向传播，反向传播，更新参数

12        outputs = net(inputs)

13        loss = criterion(outputs, labels)

14        loss.backward()

15        optimizer.step()

16

17        # 打印训练信息

18        running_loss += loss.item()

19        if i % 2000 == 1999:    # 每 2000 个batch打印一次

20            print('[%d, %5d] loss: %.3f' %

21                  (epoch + 1, i + 1, running_loss / 2000))

22            running_loss = 0.0

23

24print('Finished Training')

25

26

在GPU上训练网络

类似于将tensor放到GPU上，网络也同样能放到GPU上。
现在我们将第1块可用的CUDA设备定义为device：

1
2
3
4
5
6
7
1device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

2

3# 如果机器上有CUDA设备，那么这里应该会打印出对应的CUDA设备:

4

5print(device)

6

7

1
2
3
1cuda:0

2

3

然后使用下面的方法，将会递归遍历所有的模块，将它们的参数，缓存都转成CUDA tensor。

1
2
3
1net.to(device)

2

3

记住同时也要将输入等也放到device设备上：

1
2
3
1inputs, labels = inputs.to(device), labels.to(device)

2

3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1[1,  2000] loss: 2.225

2[1,  4000] loss: 1.894

3[1,  6000] loss: 1.676

4[1,  8000] loss: 1.568

5[1, 10000] loss: 1.513

6[1, 12000] loss: 1.468

7[2,  2000] loss: 1.424

8[2,  4000] loss: 1.360

9[2,  6000] loss: 1.348

10[2,  8000] loss: 1.336

11[2, 10000] loss: 1.310

12[2, 12000] loss: 1.289

13Finished Training

14

15

5. 使用测试数据测试网络

我们在数据集上迭代训练了2次，现在我们要看看网络是否学习到了东西。

我们需要使用网络的输出来得到预测的类别，并且和ground-truth进行对比，，如果预测正确，我们将这个样本加入正确预测的列表中。

现在和之前一样，我们看看测试数据：

1
2
3
4
5
6
7
8
1dataiter = iter(testloader)

2images, labels = dataiter.next()

3

4# print images

5imshow(torchvision.utils.make_grid(images))

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

7

8

1
2
3
1GroundTruth:    cat  ship  ship plane

2

3

现在我们来看看网络的预测结果：

1
2
3
1outputs = net(images)

2

3

网络的输出是这10个类的置信度，一个类的置信度越高，说明网络认为图片属于这一类的可能性越大。所以我们获取最大置信度的类的下标：

1
2
3
4
5
6
1_, predicted = torch.max(outputs, 1)

2

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

4                              for j in range(4)))

5

6

1
2
3
1Predicted:   frog  ship   car plane

2

3

结果看起来还不错。

现在来看看网络在整个测试数据集上的表现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1correct = 0

2total = 0

3with torch.no_grad():

4    for data in testloader:

5        images, labels = data

6        outputs = net(images)

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

8        total += labels.size(0)

9        correct += (predicted == labels).sum().item()

10

11print('Accuracy of the network on the 10000 test images: %d %%' % (

12    100 * correct / total))

13

14

1
2
3
1Accuracy of the network on the 10000 test images: 55 %

2

3

这看起来比随机猜的结果要好多了，随机猜测的准确率为10%，所以看起来网络学习到了一些东西。

那么，我们现在想看看网络在哪些类别上分类准确，哪些又没那么好：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1class_correct = list(0. for i in range(10))

2class_total = list(0. for i in range(10))

3with torch.no_grad():

4    for data in testloader:

5        images, labels = data

6        outputs = net(images)

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

8        c = (predicted == labels).squeeze()

9        for i in range(4):

10            label = labels[i]

11            class_correct[label] += c[i].item()

12            class_total[label] += 1

13

14

15for i in range(10):

16    print('Accuracy of %5s : %2d %%' % (

17        classes[i], 100 * class_correct[i] / class_total[i]))

18

19

1
2
3
4
5
6
7
8
9
10
11
12
1Accuracy of plane : 52 %

2Accuracy of   car : 68 %

3Accuracy of  bird : 39 %

4Accuracy of   cat : 26 %

5Accuracy of  deer : 46 %

6Accuracy of   dog : 46 %

7Accuracy of  frog : 62 %

8Accuracy of horse : 80 %

9Accuracy of  ship : 76 %

10Accuracy of truck : 64 %

11

12