目前为止，我们已经看到了如何定义网络，计算损失，并更新网络的权重。所以你现在可能会想

数据应该怎么办呢？

通常来说，当必须处理图像、文本、音频或视频数据时，可以使用python标准库将数据加载到numpy数组里。然后将这个数组转化成torch.*Tensor

  • 对于图片，有 Pillow，OpenCV 等包可以使用
  • 对于音频，有 scipy 和 librosa 等包可以使用
  • 对于文本，不管是原生 python 的或者是基于 Cython 的文本，可以使用 NLTK 和SpaCy

特别对于视觉方面，我们有一个包，名字叫torchvision，其中包含了针对Imagenet、CIFAR10、MNIST 等常用数据集的数据加载器 (data loaders），还有对图像数据转换的操作，即torchvision.datasets和torch.utils.data.DataLoader

这提供了极大的便利，可以避免编写样板代码。

在这个教程中，我们将使用CIFAR10数据集，它有如下的分类：“飞机”，“汽车”，“鸟”，“猫”，“鹿”，“狗”，“青蛙”，“马”，“船”，“卡车”等。在CIFAR-10里面的图片数据大小是3x32x32，即：三通道彩色图像，图像大小是32x32像素

训练一个图像分类器

我们将按顺序做以下步骤：

  1. 通过torchvision加载CIFAR10里面的训练和测试数据集，并对数据进行标准化
  2. 定义卷积神经网络
  3. 定义损失函数
  4. 利用训练数据训练网络
  5. 利用测试数据测试网络

1. 加载并标准化CIFAR10

使用torchvision加载 CIFAR10 超级简单

1
2
3
import torch
import torchvision
import torchvision.transforms as transforms

torchvision 数据集加载完后的输出是范围在[0,1]之间的 PILImage。我们将其标准化为范围在[-1,1]之间的张量

1
2
3
4
5
6
7
8
9
10
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')

正常输出为

1
2
Files already downloaded and verified
Files already downloaded and verified

现在让我们可视化部分训练数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import matplotlib.pyplot as plt
import numpy as np
# 输出图像的函数
def imshow(img):
    img = img / 2 + 0.5     # unnormalize(归一化)
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()
# 随机获取训练图片
dataiter = iter(trainloader)
images,labels = next(dataiter)
# 显示图片
imshow(torchvision.utils.make_grid(images))
# 打印图片标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

正常输出应为四幅图片和其分别对应的标签，例如

1
car   car  deer   cat

2. 定义一个卷积神经网络

将之前神经网络章节定义的神经网络拿过来，并将其修改成输入为3通道图像(替代原来定义的单通道图像）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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. 定义损失函数和优化器

我们使用多分类的交叉熵损失函数和随机梯度下降优化器(使用 momentum ）

1
2
3
4
import torch.optim as optim

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

4. 训练网络

事情开始变得有趣了。我们只需要遍历我们的数据迭代器，并将输入“喂”给网络和优化函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
for epoch in range(10):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        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')

正常输出应该是带有loss损失函数的，例如（这里我调大了通道数，训练可能稍微有些缓慢）

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
[1,  2000] loss: 2.184
[1,  4000] loss: 1.824
[1,  6000] loss: 1.636
[1,  8000] loss: 1.563
[1, 10000] loss: 1.491
[1, 12000] loss: 1.436
[2,  2000] loss: 1.384
[2,  4000] loss: 1.340
[2,  6000] loss: 1.318
[2,  8000] loss: 1.323
[2, 10000] loss: 1.291
[2, 12000] loss: 1.250
[3,  2000] loss: 1.193
[3,  4000] loss: 1.186
[3,  6000] loss: 1.201
[3,  8000] loss: 1.196
[3, 10000] loss: 1.166
[3, 12000] loss: 1.152
[4,  2000] loss: 1.098
[4,  4000] loss: 1.095
[4,  6000] loss: 1.090
[4,  8000] loss: 1.099
[4, 10000] loss: 1.089
[4, 12000] loss: 1.091
[5,  2000] loss: 1.002
[5,  4000] loss: 1.024
[5,  6000] loss: 1.021
[5,  8000] loss: 1.035
[5, 10000] loss: 1.035
[5, 12000] loss: 1.033
[6,  2000] loss: 0.945
[6,  4000] loss: 0.945
[6,  6000] loss: 0.971
[6,  8000] loss: 1.003
[6, 10000] loss: 0.988
[6, 12000] loss: 0.985
[7,  2000] loss: 0.903
[7,  4000] loss: 0.918
[7,  6000] loss: 0.917
[7,  8000] loss: 0.937
[7, 10000] loss: 0.968
[7, 12000] loss: 0.957
[8,  2000] loss: 0.846
[8,  4000] loss: 0.881
[8,  6000] loss: 0.883
[8,  8000] loss: 0.883
[8, 10000] loss: 0.910
[8, 12000] loss: 0.933
[9,  2000] loss: 0.825
[9,  4000] loss: 0.829
[9,  6000] loss: 0.844
[9,  8000] loss: 0.875
[9, 10000] loss: 0.870
[9, 12000] loss: 0.886
[10,  2000] loss: 0.767
[10,  4000] loss: 0.809
[10,  6000] loss: 0.822
[10,  8000] loss: 0.858
[10, 10000] loss: 0.867
[10, 12000] loss: 0.864
Finished Training

通道数越大，不代表损失函数越精确

损失函数可能会下降的很少，甚至稍微有些提升

让我们赶紧保存已训练得到的模型：

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

这里可以看到更多PyTorch保存模型的细节

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

我们已经在训练集上训练了2遍网络。但是我们需要检查网络是否学到了一些东西。

我们将通过预测神经网络输出的标签来检查这个问题，并和正确样本进行 ( ground-truth）对比。如果预测是正确的，我们将样本添加到正确预测的列表中。

第一步，让我们展示测试集中的图像来熟悉一下

1
2
3
4
5
6
dataiter = iter(testloader) # 返回testloader的迭代器
images, labels = next(dataiter) # 返回迭代器的下一个项目(即返回图片和其标签)

# 输出图片
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

正常输出应为四张图片以及对应的标签，例如

1
GroundTruth:    cat  ship  ship plane

下一步，让我们加载保存的模型（注意：在这里保存和加载模型不是必要的，我们只是为了解释如何去做这件事）

1
2
3
4
net = Net()
net.load_state_dict(torch.load(PATH)) # 加载指定路径的模型的训练参数
# load_state_dict()方法的作用不是加载原有的神经网络模型
# 而是将之前训练好的神经网络模型的参数拿过来，加载到新的模型上

如果看到以下输出则代表参数成功加载进模型了

1
<All keys matched successfully>

注意：

出于兼容性原因，我们不会直接保存模块，而是只保存模块的状态字典

Python模块有一个函数load_state_dict()用于从状态字典恢复模块的状态

状态字典首先需要从其文件当中加载，先使用touch.load()然后使用load_state_dict()恢复状态

即使是自定义模块和包含其他模块的模块也有状态指令，并且可以使用这种模式

现在让我们看看神经网络认为上面的例子是:

1
2
outputs = net(images)
print(outputs) # 现在输出量值

正常的输出应该会显示Tensor的值，例如

1
2
3
4
5
6
7
8
tensor([[-1.9038, -2.4608,  0.1396,  5.1749,  0.2595,  3.0504,  2.0038, -2.2711,
         -1.9779, -1.8703],
        [ 4.2985,  6.3200, -3.6053, -2.4771, -4.3081, -4.7875, -2.6892, -4.0748,
         10.2082,  2.8919],
        [ 3.1402,  2.0311, -1.6575, -1.0766, -0.4774, -2.7408, -1.1004, -3.0295,
          4.4200,  2.3434],
        [ 5.9030,  0.7771,  1.5197, -1.5948,  1.6807, -2.9044, -2.7248, -3.2480,
          1.6971,  0.6191]], grad_fn=<AddmmBackward0>)

输出是10个类别的量值(也就是前面界定的10种图像)。一个类的值越高，网络就越认为这个图像属于这个特定的类。让我们得到最高量值的下标/索引

1
2
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

正常输出应该为四个标签，按可能性大小排列

1
Predicted:    cat  ship  ship plane

结果看起开非常好，让我们看看网络在整个数据集上的表现

1
2
3
4
5
6
7
8
9
10
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))

正常的输出应该为对于测试图片的准确度

1
Accuracy of the network on the 10000 test images: 62 %

这比随机选取(即从10个类中随机选择一个类，正确率是10%）要好很多。看来网络确实学到了一些东西

那么哪些是表现好的类呢？哪些是表现的差的类呢？我们需要输出类的预测结果的准确度，然后进行评估

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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: # 遍历训练集当中的数据(testloader是训练集)
        images,labels = data # 获取图像和图像对应的标签
        outputs = net(images) # 将图片传给神经网络去识别
        _, predicted = torch.max(outputs, 1) # 返回输入张量所有元素的最大值(即得出神经网络的判断结果)
        c = (predicted == labels).squeeze() # 移除数组中维度为1的维度
        for i in range(4):
            label = labels[i] # 读取正确的标签
            # 返回可遍历的(键, 值) 元组数组,即判断神经网络是否判断正确,并归类至相应的类别
            class_correct[label] += c[i].item()
            class_total[label] += 1 # 总样本数量计数+1
for i in range(10):
    print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))

正常的输出应该是各个标签对应的分类准确度，例如

1
2
3
4
5
6
7
8
9
10
Accuracy of plane : 64 %
Accuracy of   car : 81 %
Accuracy of  bird : 50 %
Accuracy of   cat : 53 %
Accuracy of  deer : 55 %
Accuracy of   dog : 52 %
Accuracy of  frog : 66 %
Accuracy of horse : 52 %
Accuracy of  ship : 76 %
Accuracy of truck : 66 %

那么接下来，我们怎么在 GPU 上运行神经网络呢？

在GPU上训练

与将一个张量传递给 GPU 一样，可以这样将神经网络转移到 GPU 上

如果我们有 cuda 可用的话，让我们首先定义第一个设备为可见 cuda 设备：

1
2
3
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)

如果输出为以下输出，则表明cuda可用

1
cuda:0

我们输出的是cuda:0，所以我们的cuda可用

然后这些方法将递归遍历所有模块，并将它们的参数和缓冲区转换为CUDA张量：

1
net.to(device)

正常的输出应该是net网络对应的各层和通道等配置，例如

1
2
3
4
5
6
7
8
Net(
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

请记住，我们不得不将输入和目标在每一步都送入GPU：

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

为什么我们感受不到与CPU相比的巨大加速？因为我们的网络实在是太小了。

尝试一下：加宽你的网络(注意第一个nn.Conv2d的第二个参数和第二个nn.Conv2d的第一个参数要相同，因为第一个的输出channel数量要和第二个的输入channel数量相同），看看能获得多少加速

已实现的目标：

  • 在更高层次上理解 PyTorch 的 Tensor 库和神经网络
  • 训练一个小的神经网络做图片分类

在多GPU上训练

如果希望使用您所有GPU获得更大的加速，请查看Optional: Data Parallelism

接下来做什么？