本文参考PyTorch官网的教程，分为五个基本模块来介绍PyTorch。为了避免文章过长，这五个模块分别在五篇博文中介绍。

Part1：PyTorch简单知识

Part2：PyTorch的自动梯度计算

Part3：使用PyTorch构建一个神经网络

Part4：训练一个神经网络分类器

Part5：数据并行化

本文是关于Part4的内容。

Part4：训练一个神经网络分类器

前面已经介绍了定义神经网络，计算损失和更新权重，这里介绍训练神经网络分类器。

1关于数据

通常，当你需要处理图像、文本、饮品或者视频数据，你可以使用标准的python包将数据导入到numpy的array中。之后，你可以将array转换到torch.*Tensor。

（1）对于图像，Pillow、OpenCV等包非常有用。

（2）对于音频，scipy和librosa等包非常好。

（3）对于文本，原始Python或基于Cython的加载，或者NLTK和SpaCy都是有用的。

尤其对于视觉，我们创建了一个叫做torchvision的包，包含了对于常用数据集（如ImageNet，CIFAR10，MNIST等）的数据加载器和对于images、viz的数据转换器，torchvision.datasets和torch.utils.data.DataLoader。

在该教程中，我们使用CIFAR10数据集。它含有这些类：‘airplane’，‘automobile’，‘bird’，‘cat’，‘deer’，‘dog’，‘frog’，‘horse’，‘ship’，‘truck’。这些图像的尺寸是3*32*32，即3通道的彩色图像，尺寸为32*32。

2训练图像分类器

我们按照如下步骤：

（1）使用torchvision导入并且正规化CIFAR10的训练集和测试集

（2）定义一个卷积神经网络

（3）定义一个损失函数

（4）在测试数据上训练该网络

（5）在测试数据上测试该网络

2.1导入和正规化CIFAR10

使用torchvision，加载CIFAR10很容易。

importtorchimporttorchvisionimporttorchvision.transformsastransforms

torchvision数据集的输出是［0，1］区间的PILImage。我们把这些图像转换到［-1，1］区间的Tensor。

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')

我们来显示一些训练图像。

importmatplotlib.pyplotaspltimportnumpyasnp#functionstoshowanimagedefimshow(img):img=img/2+0.5#unnormalizenpimg=img.numpy()plt.imshow(np.transpose(npimg,(1,2,0)))#getsomerandomtrainingimagesdataiter=iter(trainloader)images,labels=dataiter.next()#showimagesimshow(torchvision.utils.make_grid(images))#printlabelsprint(''.join('%5s'%classes[labels[j]]forjinrange(4)))

2.2定义卷积神经网络

定义一个适用于3通道图像的卷积神经网络。

fromtorch.autogradimportVariableimporttorch.nnasnnimporttorch.nn.functionalasFclassNet(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)defforward(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)returnxnet=Net()

2.3定义损失函数和优化器

使用分类交叉熵损失和带有动量的随机梯度下降。

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

2.4训练网络

我们只需要在数据上迭代，把输入数据交给网络并且优化即可。

forepochinrange(2):#loopoverthedatasetmultipletimesrunning_loss=0.0fori,datainenumerate(trainloader,0):#gettheinputsinputs,labels=data#wraptheminVariableinputs,labels=Variable(inputs),Variable(labels)#zerotheparametergradientsoptimizer.zero_grad()#forward+backward+optimizeoutputs=net(inputs)loss=criterion(outputs,labels)loss.backward()optimizer.step()#printstatisticsrunning_loss+=loss.data[0]ifi%2000==1999:#printevery2000mini-batchesprint('[%d,%5d]loss:%.3f'%(epoch+1,i+1,running_loss/2000))running_loss=0.0print('FinishedTraining')

预期输出：

[1,2000]loss:2.191

[1,4000]loss:1.866

[1,6000]loss:1.696

[1,8000]loss:1.596

[1,10000]loss:1.502

[1,12000]loss:1.496

[2,2000]loss:1.422

[2,4000]loss:1.370

[2,6000]loss:1.359

[2,8000]loss:1.321

[2,10000]loss:1.311

[2,12000]loss:1.275

FinishedTraining

2.5在测试数据上测试网络

我们已经训练了一个网络。现在对其在测试数据上测试。第一步，显示一个来自测试集的图像。

dataiter=iter(testloader)images,labels=dataiter.next()#printimagesimshow(torchvision.utils.make_grid(images))print('GroundTruth:',''.join('%5s'%classes[labels[j]]forjinrange(4)))

预期输出：

GroundTruth:catshipshipplane

使用训练好的网络来预测这些图像应该属于哪类。

outputs=net(Variable(images))

输出的是关于10个类别的能量值。哪个类别能量值高，网络就认为图像属于哪一类。因此我们需要获取最高能量值的索引。

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

预期输出：

Predicted:catshipcarplane

现在看一下网络在整个数据集上的表现。

correct=0total=0fordataintestloader:images,labels=dataoutputs=net(Variable(images))_,predicted=torch.max(outputs.data,1)total+=labels.size(0)correct+=(predicted==labels).sum()print('Accuracyofthenetworkonthe10000testimages:%d%%'%(100*correct/total))

预期输出：

Accuracyofthenetworkonthe10000testimages:54%

这看起来比偶然准确率（10%）要好。看起来，训练有一定效果。

看一下哪些类别表现好，哪些表现不好。

class_correct=list(0.foriinrange(10))class_total=list(0.foriinrange(10))fordataintestloader:images,labels=dataoutputs=net(Variable(images))_,predicted=torch.max(outputs.data,1)c=(predicted==labels).squeeze()foriinrange(4):label=labels[i]class_correct[label]+=c[i]class_total[label]+=1foriinrange(10):print('Accuracyof%5s:%2d%%'%(classes[i],100*class_correct[i]/class_total[i]))

预期输出：

Accuracyofplane:60%

Accuracyofcar:46%

Accuracyofbird:44%

Accuracyofcat:35%

Accuracyofdeer:38%

Accuracyofdog:43%

Accuracyoffrog:57%

Accuracyofhorse:76%

Accuracyofship:71%

Accuracyoftruck:74%

3在GPU上训练

下面这句话会递归遍历全部的模块并且将它们的参数和缓冲区转到CUDAtensors。

net.cuda()

记住，还需要在每一步将输入和目标值发送到GPU。

inputs,labels=Variable(inputs.cuda()),Variable(labels.cuda())

当网络非常大而复杂的时候，这种加速是非常明显的。