本节将通过一个实战案例来详细介绍如何使用PyTorch进行深度学习模型的开发。我们将使用CIFAR-10图像数据集来训练一个卷积神经网络。
神经网络训练的一般步骤如图5-3所示。
（1）加载数据集，并做预处理。
（2）预处理后的数据分为Feature和Label两部分，Feature 送到模型里面，Label被当作ground-truth。
（3）Model接收Feature作为Input，并通过一系列运算，向外输出 predict。
（4）建立一个损失函数 Loss，Loss 的函数值是为了表示 predict 与 ground-truth 之间的差距。
（5）建立 Optimizer 优化器，优化的目标就是 Loss 函数，让它的取值尽可能最小，Loss越小代表 Model 预测的准确率越高。
（6）Optimizer 优化过程中，Model 根据规则改变自身参数的权重，这是一个反复循环和持续的过程，直到Loss值趋于稳定，不能再取得更小的值。
数据集的加载可以自行编写代码，但如果是基于学习目的的话，那么把精力放在编写这个步骤的代码上面会让人十分无聊，好在PyTorch 提供了非常方便的包torchvision。torchvison提供了dataloader来加载常见的MNIST、CIFAR-10、ImageNet 等数据集，也提供了transform对图像进行变换、正则化和可视化。
在本项目中，我们的目的是用 PyTorch 创建基于 CIFAR-10 数据集的图像分类器。CIFAR-10图像数据集共有60 000幅彩色图像，这些图像是32×32的，分为10个类，分别是airplane、automobile、bird、cat等，每类6 000幅图，如图5-4所示。这里面有50 000幅训练图像，10 000幅测试图像。
首先，加载数据并进行预处理。我们将使用torchvision包来下载CIFAR-10数据集，并使用transforms模块对数据进行预处理。主要用来进行数据增强，为了防止训练出现过拟合，通常在小型数据集上，通过随机翻转图片、随机调整图片的亮度来增加训练时数据集的容量。但是，测试的时候，并不需要对数据进行增强。运行代码后，会自动下载数据集。
接下来，定义卷积神经网络模型。在这个网络模型中，我们使用nn.Module来定义网络模型，然后在__init__方法中定义网络的层，最后在forward方法中定义网络的前向传播过程。在PyTorch中可以通过继承nn.Module来自定义神经网络，在init()中设定结构，在forward()中设定前向传播的流程。因为PyTorch可以自动计算梯度，所以不需要特别定义反向传播。
定义好神经网络模型后，还需要定义损失函数（Loss）和优化器（Optimizer）。在这里采用 cross-entropy-loss函数作为损失函数，采用 Adam 作为优化器，当然SGD也可以。
一切准备就绪后，开始训练网络，这里训练10次（可以增加训练次数，提高准确率）。在训练过程中，首先通过网络进行前向传播得到输出，然后计算输出与真实标签的损失，接着通过后向传播计算梯度，最后使用优化器更新模型参数。训练完成后，我们需要在测试集上测试网络的性能。这可以让我们了解模型在未见过的数据上的表现如何，以评估其泛化能力。
完整代码如下：
#############cifar-10-pytorch.py####################
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch
import torchvision
import torchvision.transforms as transforms
import torch.optim as optim
# torchvision输出的是PILImage，值的范围是[0, 1]
# 我们将其转换为张量数据，并归一化为[-1, 1]
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5)),
])
# 训练集，将相对目录./data下的cifar-10-batches-py文件夹中的全部数据
# （50 000幅图片作为训练数据）加载到内存中
# 若download为True，则自动从网上下载数据并解压
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
# 将训练集的50 000幅图片划分成12 500份，每份4幅图，用于mini-batch输入
# shffule=True在表示不同批次的数据遍历时，打乱顺序。num_workers=2表示使用两个子进程来加载数据
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# 下面的代码只是为了给小伙伴们展示一个图片例子，让大家有个直观感受
# functions to show an image
import matplotlib.pyplot as plt
import numpy as np
# matplotlib inline
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
class Net(nn.Module):
# 定义Net的初始化函数，这个函数定义了该神经网络的基本结构
def __init__(self):
super(Net, self).__init__()
# 复制并使用Net的父类的初始化方法，即先运行nn.Module的初始化函数
self.conv1 = nn.Conv2d(3, 6, 5)
# 定义conv1函数是图像卷积函数：输入为3张特征图
# 输出为 6幅特征图， 卷积核为5×5的正方形
self.conv2 = nn.Conv2d(6, 16, 5)
# 定义conv2函数的是图像卷积函数：输入为6幅特征图，输出为16幅特征图
# 卷积核为5×5的正方形
self.fc1 = nn.Linear(16 * 5 * 5, 120)
# 定义fc1（fullconnect）全连接函数1为线性函数：y = Wx + b
# 并将16×5×5个节点连接到120个节点上
self.fc2 = nn.Linear(120, 84)
# 定义fc2（fullconnect）全连接函数2为线性函数：y = Wx + b
# 并将120个节点连接到84个节点上
self.fc3 = nn.Linear(84, 10)
# 定义fc3（fullconnect）全连接函数3为线性函数：y = Wx + b
# 并将84个节点连接到10个节点上
# 定义该神经网络的向前传播函数，该函数必须定义
# 一旦定义成功，向后传播函数也会自动生成（autograd）
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# 输入x经过卷积conv1之后，经过激活函数ReLU
# 使用2×2的窗口进行最大池化，然后更新到x
x = F.max_pool2d(F.relu(self.conv2(x)), 2)
# 输入x经过卷积conv2之后，经过激活函数ReLU
# 使用2×2的窗口进行最大池化，然后更新到x
x = x.view(-1, self.num_flat_features(x))
# view函数将张量x变形成一维的向量形式
# 总特征数并不改变，为接下来的全连接作准备
x = F.relu(self.fc1(x))
# 输入x经过全连接1，再经过ReLU激活函数，然后更新x
x = F.relu(self.fc2(x))
# 输入x经过全连接2，再经过ReLU激活函数，然后更新x
x = self.fc3(x)
# 输入x经过全连接3，然后更新x
return x
# 使用num_flat_features函数计算张量x的总特征量
# 把每个数字都作一个特征，即特征总量
# 比如x是4×2×2的张量，那么它的特征总量就是16
def num_flat_features(self, x):
size = x.size()[1:]
# 这里为什么要使用[1:]，是因为PyTorch只接受批输入
# 也就是说一次性输入好几幅图片，那么输入数据张量的维度自然上升到了4维
# 【1:】让我们把注意力放在后3维上面
# x.size() 会 return [nSamples, nChannels, Height, Width]。
# 只需要展开后三项成为一个一维的张量
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# 使用SGD（随机梯度下降）优化，学习率为0.001，动量为0.9
if __name__ == '__main__':
for epoch in range(10):
running_loss = 0.0
# enumerate(sequence, [start=0])，i是序号，data是数据
for i, data in enumerate(trainloader, 0):
inputs, labels = data
# data的结构是：[4×3×32×32的张量，长度为4的张量]
inputs, labels = Variable(inputs), Variable(labels)
# 把input数据从tensor转为variable
optimizer.zero_grad()
# 将参数的grad值初始化为0
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
# 将output和labels使用交叉熵计算损失
loss.backward() # 反向传播
optimizer.step() # 用SGD更新参数
# 每2000批数据打印一次平均loss值
running_loss += loss.item()
# loss本身为Variable类型
# 要使用data获取其张量，因为其为标量，所以取0 或使用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')
# 测试集，将相对目录./data下的cifar-10-batches-py文件夹中的全部数据
# （10 000幅图片作为测试数据）加载到内存中
# 若download为True，则自动从网上下载数据并解压
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
# 将测试集的10 000幅图片划分成2500份，每份4幅图，用于mini-batch输入
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(Variable(images))
# print outputs.data
# print(outputs.data)
# print(labels)
value, predicted = torch.max(outputs.data,
1)
# outputs.data是一个4x10张量
# 将每一行的最大的那一列的值和序号各自组成一个一维张量返回
# 第一个是值的张量，第二个是序号的张量
# label.size(0) 是一个数
total += labels.size(0)
correct += (predicted == labels).sum()
# 两个一维张量逐行对比，相同的行记为1，不同的行记为0
# 再利用sum()求总和，得到相同的个数
print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
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]))
运行结果如下：
Files already downloaded and verified
Files already downloaded and verified
Files already downloaded and verified
[1, 2000] loss: 2.165
[1, 4000] loss: 1.834
[1, 6000] loss: 1.667
[1, 8000] loss: 1.566
[1, 10000] loss: 1.532
[1, 12000] loss: 1.462
Files already downloaded and verified
Files already downloaded and verified
[2, 2000] loss: 1.403
[2, 4000] loss: 1.380
[2, 6000] loss: 1.325
[2, 8000] loss: 1.281
[2, 10000] loss: 1.304
[2, 12000] loss: 1.262
Files already downloaded and verified
Files already downloaded and verified
[3, 2000] loss: 1.230
[3, 4000] loss: 1.221
[3, 6000] loss: 1.181
[3, 8000] loss: 1.147
[3, 10000] loss: 1.175
[3, 12000] loss: 1.147
Files already downloaded and verified
Files already downloaded and verified
[4, 2000] loss: 1.120
[4, 4000] loss: 1.110
[4, 6000] loss: 1.079
[4, 8000] loss: 1.064
[4, 10000] loss: 1.090
[4, 12000] loss: 1.068
Files already downloaded and verified
Files already downloaded and verified
[5, 2000] loss: 1.039
[5, 4000] loss: 1.030
[5, 6000] loss: 1.009
[5, 8000] loss: 0.990
[5, 10000] loss: 1.021
[5, 12000] loss: 1.007
Files already downloaded and verified
Files already downloaded and verified
[6, 2000] loss: 0.975
[6, 4000] loss: 0.971
[6, 6000] loss: 0.947
[6, 8000] loss: 0.937
[6, 10000] loss: 0.963
[6, 12000] loss: 0.953
Files already downloaded and verified
Files already downloaded and verified
[7, 2000] loss: 0.930
[7, 4000] loss: 0.923
[7, 6000] loss: 0.902
[7, 8000] loss: 0.891
[7, 10000] loss: 0.928
[7, 12000] loss: 0.911
Files already downloaded and verified
Files already downloaded and verified
[8, 2000] loss: 0.881
[8, 4000] loss: 0.890
[8, 6000] loss: 0.864
[8, 8000] loss: 0.868
[8, 10000] loss: 0.896
[8, 12000] loss: 0.875
Files already downloaded and verified
Files already downloaded and verified
[9, 2000] loss: 0.846
[9, 4000] loss: 0.870
[9, 6000] loss: 0.836
[9, 8000] loss: 0.834
[9, 10000] loss: 0.851
[9, 12000] loss: 0.847
Files already downloaded and verified
Files already downloaded and verified
[10, 2000] loss: 0.816
[10, 4000] loss: 0.835
[10, 6000] loss: 0.797
[10, 8000] loss: 0.805
[10, 10000] loss: 0.841
[10, 12000] loss: 0.809
Finished Training
Files already downloaded and verified
Files already downloaded and verified
Files already downloaded and verified
Accuracy of the network on the 10000 test images: 61 %
Files already downloaded and verified
Files already downloaded and verified
Accuracy of plane : 58 %
Accuracy of car : 72 %
Accuracy of bird : 41 %
Accuracy of cat : 51 %
Accuracy of deer : 55 %
Accuracy of dog : 44 %
Accuracy of frog : 66 %
Accuracy of horse : 72 %
Accuracy of ship : 80 %
Accuracy of truck : 69 %
在这段代码中，我们在整个测试集上测试网络，并打印出网络在测试集上的准确率。通过这种详细且实践性的方式介绍了PyTorch的使用，包括张量操作、自动求导机制、神经网络创建、数据处理、模型训练和测试。我们利用PyTorch从头到尾完成了一个完整的神经网络训练流程，并在 CIFAR-10数据集上测试了网络的性能。在这个过程中，我们深入了解了PyTorch提供的强大功能。
本文节选自《PyTorch深度学习与企业级项目实战》，获出版社和作者授权发布。
