训练一个分类器
关于数据
一般情况下处理图像、文本、音频和视频数据时，可以使用标准的 Python 包来加载数据到一个 Numpy 数组中，然后把这个数组转换成 torch.*Tensor。
- 图像可以使用
Pillow,OpenCV - 音频可以使用
scipy,librosa - 文本可以使用原始
Python和Cpython来加载，或者使用NLTK或SpaCy处理
对于图像任务，可以调用 torchvision 包，它包含了处理一些基本图像数据集的方法。这些数据集包括 Imagenet, CIFAR10, MNIST 等。除了数据加载之外，torchvision 还包含了图像转换器，torchvison.datasets 和 torch.utils.data.DataLoader。
torchvision 包不仅提供了巨大的便利，也避免了代码的重复。
在这个教程中，我们使用 CIFAR10 数据集，它有如下 10 个类别：'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'。CIFAR-10 的图像都是 3x32x32 大小的，即 3 个颜色通道，32x32 像素。
训练一个图像分类器
依次按照下列顺序进行：
- 使用
torchvision加载和归一化 CIFAR10 训练集和测试集 - 定义一个卷积神经网络
- 定义损失函数
- 在训练集上训练网络
- 在测试集上测试网络
读取和归一化 CIFAR10
使用 torchvision 可以非常容易地加载 CIFAR10。
import torch
import torchvision
import torchvision.transforms as transforms
torchvision 的输出是 [0,1] 的 PILImage 图像，我们把它转换为归一化范围为 [-1,1] 的张量。
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)
# 加载测试数据集
testset = torchvision.datasets.CIFAR10(
root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(
testset, batch_size=4, shuffle=False)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
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)))
# 获取随机数据
dataiter = iter(trainloader)
images, labels = dataiter.next()
# 展示图像
imshow(torchvision.utils.make_grid(images))
# 显示图像标签
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
cat deer frog bird
定义一个卷积神经网络
从之前的神经网络一节复制神经网络代码，并修改为输入 3 通道图像。
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()
定义损失函数和优化器
我们使用交叉熵作为损失函数，使用带动量的随即梯度下降
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
训练网络
迭代训练，将数据输入给网络，进行正向传播，反向传播和参数优化。
for epoch in range(5):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# 获取输入
inputs, labels = data
# 梯度置 0
optimizer.zero_grad()
# 正向传播，反向传播，参数优化
outpus = net(inputs)
loss = criterion(outpus, labels)
loss.backward()
optimizer.step()
# 打印状态信息
running_loss += loss.item()
if i % 2000 == 1999: # 每 2000 批次打印一次
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
[1, 2000] loss: 2.167
[1, 4000] loss: 1.843
[1, 6000] loss: 1.666
[1, 8000] loss: 1.578
[1, 10000] loss: 1.510
[1, 12000] loss: 1.460
[2, 2000] loss: 1.406
[2, 4000] loss: 1.343
[2, 6000] loss: 1.356
[2, 8000] loss: 1.328
[2, 10000] loss: 1.290
[2, 12000] loss: 1.279
[3, 2000] loss: 1.213
[3, 4000] loss: 1.187
[3, 6000] loss: 1.200
[3, 8000] loss: 1.195
[3, 10000] loss: 1.181
[3, 12000] loss: 1.176
[4, 2000] loss: 1.116
[4, 4000] loss: 1.090
[4, 6000] loss: 1.111
[4, 8000] loss: 1.092
[4, 10000] loss: 1.101
[4, 12000] loss: 1.097
[5, 2000] loss: 1.000
[5, 4000] loss: 1.010
[5, 6000] loss: 1.037
[5, 8000] loss: 1.045
[5, 10000] loss: 1.037
[5, 12000] loss: 1.039
Finished Training
dataiter = iter(testloader)
images, labels = dataiter.next()
# 显示图片
imshow(torchvision.utils.make_grid(images))
print('GroudTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
GroudTruth: cat ship ship plane
让我们看看神经网络认为以上图片是什么。
outputs = net(images)
输出是 10 个标签的能量。一个类别的能量越大，神经网络越认为它是这个类别。所以我们需要将高能量的标签作为最后的结果。
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
Predicted: ship 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, 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: 60 %
统计每一个分类下的准确率。
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
outpus = net(images)
_, predicted = torch.max(outpus, 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 : 65 %
Accuracy of car : 69 %
Accuracy of bird : 53 %
Accuracy of cat : 33 %
Accuracy of deer : 46 %
Accuracy of dog : 56 %
Accuracy of frog : 65 %
Accuracy of horse : 65 %
Accuracy of ship : 77 %
Accuracy of truck : 77 %
下一步？
我们如何在 GPU 上运行神经网络呢？
在 GPU 上训练
把一个神经网络移动到 GPU 上训练就像把一个 Tensor 转换 GPU 上一样简单。并且这个操作会递归遍历有所模块，并将其参数和缓冲区转换为 CUDA 张量。
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# 确认我们电脑支持 CUDA，显示 CUDA 信息
print(device)
cuda:0
本节的其余部分假定 device 是 CUDA 设备。
然后这些方法将递归遍历所有模块并将模块的参数和缓冲区转换成 CUDA 张量：
net.to(device)
记住：inputs, targets 和 images 也要转换。
inputs, labels = inputs.to(device), labels.to(device)
为什么我们没注意到 GPU 的速度提升很多？那是因为网络非常的小。
实践：
尝试增加你的网络的宽度（第一个 nn.Conv2d 的第 2 个参数，第二个 nn.Conv2d 的第一个参数，它们需要是相同的数字），看看你得到了什么样的加速。
实现的目标:
- 深入了解了 PyTorch 的张量库和神经网络
- 训练了一个小网络来分类图片
