在以前的教程中，你已经知道如何定义神经网络，计算损失以及更新网络权重。现在你可能会想， [quote] [b]数据怎么办[/b] [/quote] 一般来说，当你处理图像、文本、音频或视频数据时，[b]你可以使用标准的python包来将数据载入到numpy数组中。然后你可以将这个数组转化为torch.Tensor。[/b] [list] []对于图像，诸如Pillow, OpenCV这些包很好用。[/] []对于音频，可以使用scipy和librosa。[/] []对于文本，要么使用原始的Python或Cython载入方式，要么使用NLTK和SpaCy。[/] [/list] 特别的对于vision，我们创建了一个叫做[b]torchvision[/b]的包，它有一些常用数据集（Imagenet, CIFAR10, MNIST等）的数据载入器，以及图像的数据转换器, [b]torchvision.datasets和torch.utils.data.DataLoader[/b]。

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

在本教程中，我们使用CIFAR10数据集。它有10个类别：[b]‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR10中的图像尺寸在3x32x32[/b]，即3通道彩色图像，32x32像素大小。 CIFAR-10是多伦多大学提供的图片数据库，图片分辨率压缩至32x32，一共有10种图片分类，均进行了标注。适合监督式学习。 [attach]18[/attach] [quote] [b]训练一个图像分类器[/b] [/quote] 我们将按顺序完成以下步骤： [list] []载入和规范化CIFAR10的训练和测试集，使用torchvision[/] []定义一个卷积神经网络[/] []定义损失函数[/] []在训练集上进行训练[/] []在测试集上测试网络[/] [/list]

[b]1. 载入和规范化CIFAR10[/b]

使用[b]torchvision[/b]，载入CIFAR10非常简单。[code]import torch import torchvision import torchvision.transforms as transforms[/code] [b]torchvision datasets[/b]的输出时范围在[0, 1]的PILImage图像。我们将它们转换为规范区间[-1, 1]的Tensor。[code]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=True, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')[/code] 输出：[code]Downloading http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz Files already downloaded and verified[/code]让我们展示一些训练图像。[code]import matplotlib.pyplot as plt import numpy as np

functions to show image

def imshow(img): img = img / 2 + 0.5 # unnormalize npimg = img.numpy() plt.imshow(np.transpose(npimg, (1, 2, 0)))

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)))[/code] 输出： [attach]17[/attach] [b]2. 定义一个卷积神经网络[/b] 复制在神经网络那一节的神经网络，将其更改为3通道图像输入（而不是原始的单通道输入）。[code]from torch.autograd import Variable 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()

[/code] [b]3. 定义损失函数和优化器[/b]

让我们来使用分类交叉熵和带有动量的SGD[code]import torch.optim as optim

criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)[/code][b]4. 训练网络[/b][code]for epoch in range(10): # loop over the dataset multiple times running_loss = 0.0 for i, data in enumerate(trainloader, 0):

get the input

    inputs, labels = data

    # wrap time in Variable
    inputs, labels = Variable(inputs), Variable(labels)

    # 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.data[0]
    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')[/code]输出：[code][1, 2000] loss: 1.184 [1, 4000] loss: 1.206 [1, 6000] loss: 1.186 [1, 8000] loss: 1.162 [1, 10000] loss: 1.195 [1, 12000] loss: 1.165 [2, 2000] loss: 1.095 [2, 4000] loss: 1.076 [2, 6000] loss: 1.086 [2, 8000] loss: 1.092 [2, 10000] loss: 1.060 [2, 12000] loss: 1.110 [3, 2000] loss: 0.999 [3, 4000] loss: 1.005 [3, 6000] loss: 1.016 [3, 8000] loss: 1.016 [3, 10000] loss: 1.017 [3, 12000] loss: 1.023 [4, 2000] loss: 0.922 [4, 4000] loss: 0.933 [4, 6000] loss: 0.959 [4, 8000] loss: 0.975 [4, 10000] loss: 0.985 [4, 12000] loss: 0.968 [5, 2000] loss: 0.861 [5, 4000] loss: 0.908 [5, 6000] loss: 0.911 [5, 8000] loss: 0.932 [5, 10000] loss: 0.920 [5, 12000] loss: 0.919 [6, 2000] loss: 0.839 [6, 4000] loss: 0.853 [6, 6000] loss: 0.887 [6, 8000] loss: 0.891 [6, 10000] loss: 0.890 [6, 12000] loss: 0.876 [7, 2000] loss: 0.819 [7, 4000] loss: 0.808 [7, 6000] loss: 0.831 [7, 8000] loss: 0.852 [7, 10000] loss: 0.842 [7, 12000] loss: 0.869 [8, 2000] loss: 0.761 [8, 4000] loss: 0.784 [8, 6000] loss: 0.808 [8, 8000] loss: 0.827 [8, 10000] loss: 0.841 [8, 12000] loss: 0.860 [9, 2000] loss: 0.731 [9, 4000] loss: 0.758 [9, 6000] loss: 0.801 [9, 8000] loss: 0.784 [9, 10000] loss: 0.831 [9, 12000] loss: 0.817 [10, 2000] loss: 0.723 [10, 4000] loss: 0.733 [10, 6000] loss: 0.775 [10, 8000] loss: 0.763 [10, 10000] loss: 0.802 [10, 12000] loss: 0.799 Finished Training[/code][b]5. 在测试数据上测试网络[/b]

我们已经在训练集上训练了10轮。但是我们需要检查网络是否有学到什么。

我们可以通过检测预测的类别标签，再与真实标签进行对比。如果预测是对的，我们将这个样本加到分类正确的列表中。

Okay，第一步。让我们先展示一些测试数据集中的图像。[code]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)))[/code]输出：

[cifar_test_1]

再来看一下神经网络认为这些样本是什么。

输出是10个类别的能量。一个类别能量越高，网络就更多地认为图像是这个特定的类别。因此，让我们获取最高能量类别的索引。[code]outputs = net(Variable(images))

_, predicted = torch.max(outputs.data, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j][0]] for j in range(4)))[/code]输出：[code]Predicted: horse plane horse frog[/code]结果看起来不错。

让我们再来看看网络在整个数据集上的性能。[code]correct = 0 total = 0 for data in testloader: images, labels = data outputs = net(Variable(images)) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))[/code]输出：[code]Accuracy of the network on the 10000 test images: 63 %[/code]这个结果看起来远比随机抽取要好，随机抽取的概率为10%。看起来网络确实学到了一些东西。

那么，有哪些类别表现优秀，哪些类别表现不佳呢？[code]class_correct = list(0. for i in range(10)) classtotal = list(0. for i in range(10)) for data in testloader: images, labels = data outputs = net(Variable(images)) , predicted = torch.max(outputs.data, 1) c = (predicted == labels).squeeze() for i in range(4): label = labels [i] class_correct[label] += c [i] class_total[label] += 1

for i in range(10): print('Accuracy of %5s: %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))[/i][/i][/i][/i][/i][/code][i][i][i][i][i][i][i][i][i][i]输出：[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][code][i][i][i][i][i]Accuracy of plane: 59 % Accuracy of car: 73 % Accuracy of bird: 51 % Accuracy of cat: 46 % Accuracy of deer: 51 % Accuracy of dog: 54 % Accuracy of frog: 76 % Accuracy of horse: 69 % Accuracy of ship: 78 % Accuracy of truck: 72 %[/i][/i][/i][/i][/i][/code]Okay，还有什么要说明的？

如何在GPU上面运行这个神经网络？

在GPU上训练

与你如何将Tensor转移到GPU上类似，你可以将神经网络转移到GPU上。这将递归的遍历所有的模块并将它们的参数和缓存转化为CUDA tensors。net.cuda()[code]net.cuda()[/code]记住，你还必须在每一步将输入和结果数据传输到GPU上：[code]inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())[/code]为什么我没有注意到相比CPU的巨大的加速？因为你的神经网络非常小。

训练：试着增加你的网络宽度（将第一个[b]nn.Conv@d[/b]增广2，将第二个[b]nn.Conv2d[/b]增广1 - 它们需要相同的数量），看看你的网络提速了多少。

[b]目标达成：[/b] [list] []理解Pytorch的Tensor库以及高层次的神经网络[/] []训练一个小的神经网络来分类图像[/] [/list]