Pytorch教程（四）：训练分类器TRAINING A CLASSIFIER
在前三篇中，已经了解了如何定义神经网络，计算损耗并更新网络的权重。
现在大家可能在想
数据呢？
通常，当大家必须处理图像，文本，音频或视频数据时，可以使用将数据加载到numpy数组中的标准python包。然后，可以将此数组转换为torch.*Tensor。
- 对于图像，有用的软件包如Pillow，OpenCV
- 对于音频，请使用scipy和librosa等软件包
- 对于文本，基于Python或Cython的原始加载，或者NLTK和SpaCy很有用
具体地，对于视觉，我们已经创建了一个叫做 torchvision，其中有对普通数据集如Imagenet，CIFAR10，MNIST等和用于图像数据的transformers，即，数据装载机 torchvision.datasets和torch.utils.data.DataLoader。
这提供了极大的便利，并且避免了编写样板代码。
在本教程中，我们将使用CIFAR10数据集。它具有以下类别：“飞机”，“汽车”，“鸟”，“猫”，“鹿”，“狗”，“青蛙”，“马”，“船”，“卡车”。CIFAR-10中的图像尺寸为3x32x32，即尺寸为32x32像素的3通道彩色图像。
训练一个图像分类器
我们将按顺序执行以下步骤：
- 使用以下命令加载和标准化CIFAR10训练和测试数据集
torchvision - 定义卷积神经网络
- 定义损失函数
- 根据训练数据训练网络
- 在测试数据上测试网络
1.加载并标准化CIFAR10
使用torchvision，非常容易加载CIFAR10
import torch import torchvision import torchvision.transforms as transforms
torchvision数据集的输出是[0，1]范围的PILImage图像。我们将它们转换为归一化范围[-1，1]的张量。.. 注意：
If running on Windows and you get a BrokenPipeError, try setting
the num_worker of torch.utils.data.DataLoader() to 0.
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 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)))
输出：
plane truck car cat
2.定义卷积神经网络
从之前“神经网络”部分复制神经网络，然后对其进行修改以获取3通道图像（而不是定义的1通道图像）。
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.定义损失函数和优化器
让我们使用分类交叉熵Cross-Entropy损失和带有动量的SGD。
import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
4.训练网络
这是事情开始变得有趣的时候。我们只需要遍历数据迭代器，然后将输入feed到网络并进行优化即可。
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')
输出：
[1, 2000] loss: 2.247 [1, 4000] loss: 1.880 [1, 6000] loss: 1.701 [1, 8000] loss: 1.607 [1, 10000] loss: 1.545 [1, 12000] loss: 1.490 [2, 2000] loss: 1.423 [2, 4000] loss: 1.384 [2, 6000] loss: 1.353 [2, 8000] loss: 1.329 [2, 10000] loss: 1.331 [2, 12000] loss: 1.292 Finished Training
让我们快速保存我们训练完的模型：
PATH = './cifar_net.pth' torch.save(net.state_dict(), PATH)
有关保存PyTorch模型的更多详细信息，请参见此处。
5.在测试数据上测试网络
我们已经在训练数据集中对网络进行了2次训练。但是我们需要检查网络是否学到了什么。
我们将通过预测神经网络输出的类别标签并根据实际情况进行检查来进行检查。如果预测正确，则将样本添加到正确预测列表中。
好的，第一步。让我们显示测试集中的图像以使其熟悉。
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
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类的energies。一个类别的energies越高，网络就认为该图像属于特定类别。因此，让我们获得最高energies的指数：
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
输出：
Predicted: cat ship ship ship
结果似乎还不错。
让我们看一下网络在整个数据集上的表现。
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: 54 %
看起来比偶然更好，准确率是10％（从10个班级中随机选择一个班级）。好像网络学到了一些东西。
嗯，哪些类的表现良好，哪些类的表现不佳：
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 : 51 % Accuracy of car : 56 % Accuracy of bird : 44 % Accuracy of cat : 31 % Accuracy of deer : 49 % Accuracy of dog : 61 % Accuracy of frog : 51 % Accuracy of horse : 67 % Accuracy of ship : 70 % Accuracy of truck : 61 %
好的，那下一步呢？
我们如何在GPU上运行这些神经网络？
在GPU上训练
就像将Tensor转移到GPU上一样，大家也将神经网络转移到GPU上。
如果我们有可用的CUDA，首先让我们将设备定义为第一个可见的cuda设备：
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:0
本节的其余部分假定这device是CUDA设备。
然后，这些方法将递归遍历所有模块，并将其参数和缓冲区转换为CUDA张量：
net.to(device)
请记住，大家还必须将每一步的输入和目标inputs and targets也发送到GPU：
inputs, labels = data[0].to(device), data[1].to(device)
与CPU相比，为什么我没有注意到MASSIVE加速？因为网络真的很小。
可以尝试增加网络的宽度（第一个参数2 nn.Conv2d和第二个参数1 nn.Conv2d–它们必须是相同的数字），看看会得到什么样的加速。
实现的目标：
- 全面了解PyTorch的Tensor库和神经网络。
- 训练一个小型神经网络对图像进行分类
在多个GPU上训练
如果大家想使用所有GPU来获得更大的大规模加速，请查看可选：数据并行性。
接下来，给大家介绍一下租用GPU做实验的方法，我们是在智星云租用的GPU，使用体验很好。具体大家可以参考：智星云官网： http://www.ai-galaxy.cn/，淘宝店：https://shop36573300.taobao.com/公众号: 智星AI
参考文献：
https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py
https://github.com/pytorch/tutorials/blob/master/beginner_source/blitz/cifar10_tutorial.py
https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html
https://pytorch.org/docs/stable/notes/serialization.html