【PyTorch v1.1.0文档研习】60分钟快速上手

本教程的目标是：

总体上理解 PyTorch 的张量库和神经网络
训练一个小的神经网络来进行图像分类

PyTorch 是个啥？

这是基于 Python 的科学计算包，其目标是：

替换 NumPy，发挥 GPU 的作用
一个提供最大灵活性和速度的深度学习研究平台

起步

PyTorch 中的 Tensor 类似于 NumPy 中的 ndarray（这一点类似于 TensorFlow），只不过张量可以充分利用 GPU 来进行加速计算。

 from __future__ import print_function

 import torch

构建一个 5*3 的矩阵：

 x = torch.empty(5, 3)

 print(x)

tensor([[7.0976e+22, 1.8515e+28, 4.1988e+07],

        [3.0357e+32, 2.7224e+20, 7.7782e+31],

        [4.7429e+30, 1.3818e+31, 1.7225e+22],

        [1.4602e-19, 1.8617e+25, 1.1835e+22],

        [4.3066e+21, 6.3828e+28, 1.4603e-19]])

直接通过数据来构建张量：

 x = torch.tensor([5.5, 3])

 print(x)

tensor([5.5000, 3.0000])

还可以根据已有张量来创建张量。这个方法会重用输入张量的属性（例如 dtype）。

 x = x.new_ones(5, 3, dtype=torch.double)  # new_* methods take in sizes

 print(x)

 x = torch.randn_like(x, dtype=torch.float)  # override dtype!

 print(x)                                    # result has the same size

tensor([[., ., .],

        [., ., .],

        [., ., .],

        [., ., .],

        [., ., .]], dtype=torch.float64)

tensor([[ 0.4845, -1.2227, -1.2535],

        [ 0.2278,  0.9922,  0.5871],

        [-1.8249,  0.6308,  1.0100],

        [ 0.0126,  0.0591, -0.6153],

        [ 0.1847, -1.8002,  0.7629]])

获取张量的大小：

 print(x.size())

torch.Size([, ])

注意：torch.Size 对象实际上是元组，支持所有元组操作。

运算

PyTorch 支持多种运算语法（类似于 TensorFlow），下面我们看看各种加法的运算。

加法语法 1：

 y = torch.rand(5, 3)

 print(x + y)

tensor([[ 1.2256, -0.4395, -0.4990],

        [ 0.4846,  1.7138,  1.0470],

        [-1.3466,  0.7643,  1.0811],

        [ 0.4865,  0.7320, -0.4655],

        [ 0.5111, -1.0667,  1.2088]])

加法语法 2：

 print(torch.add(x, y))

tensor([[ 1.2256, -0.4395, -0.4990],

        [ 0.4846,  1.7138,  1.0470],

        [-1.3466,  0.7643,  1.0811],

        [ 0.4865,  0.7320, -0.4655],

        [ 0.5111, -1.0667,  1.2088]])

输出张量作为参数的加法：

 result = torch.empty(5, 3)

 torch.add(x, y, out=result)

 print(result)

tensor([[ 1.2256, -0.4395, -0.4990],

        [ 0.4846,  1.7138,  1.0470],

        [-1.3466,  0.7643,  1.0811],

        [ 0.4865,  0.7320, -0.4655],

        [ 0.5111, -1.0667,  1.2088]])

就地（in-place）的加法：

 y.add_(x)

 print(y)

tensor([[ 1.2256, -0.4395, -0.4990],

        [ 0.4846,  1.7138,  1.0470],

        [-1.3466,  0.7643,  1.0811],

        [ 0.4865,  0.7320, -0.4655],

        [ 0.5111, -1.0667,  1.2088]])

注意：所有让张量就地发生变化的运算都会在后面加上 _（例如：x.copy_(y)、x.t_()）。

随时可以使用类似于 Numpy 的索引操作。

 print(x[:, 1])

tensor([-1.2227,  0.9922,  0.6308,  0.0591, -1.8002])

如果需要改变张量的形状，使用 torch.view：

 x = torch.randn(4, 4)

 y = x.view(16)

 z = x.view(-1, 8)  # -1 所在的维度通过推断得出

 print(x.size(), y.size(), z.size())

torch.Size([, ]) torch.Size([]) torch.Size([, ])

如果张量只有一个元素，可以通过 .item() 直接获取 Python 数值。

 x = torch.randn(1)

 print(x)

 print(x.item())

tensor([0.2206])

0.22063039243221283

Numpy Bridge

PyTorch 张量和 Numpy 数组之间可以很容易地进行转换。

如果 Tensor 运行在 CPU 上，那么 Tensor 和 NumPy 数组可以共享同一内存。改变内存中的数值会同时影响到 Tensor 和 Numpy 数组。

将 Tensor 转换为 NumPy 数组

 a = torch.ones(5)

 print(a)

 b = a.numpy()

 print(b)

 a.add_(1)

 print(a)

 print(b)

tensor([., ., ., ., .])

[. . . . .]

tensor([., ., ., ., .])

[. . . . .]

将 NumPy 数组转换为 Tensor

 import numpy as np

 a = np.ones(5)

 b = torch.from_numpy(a)

 np.add(a, 1, out=a)

 print(a)

 print(b)

[. . . . .]

tensor([., ., ., ., .], dtype=torch.float64)

CUDA 张量

使用 .to 方法，张量可以移动到任何设备上（如 CUDA）。

 # let us run this cell only if CUDA is available

 # We will use ``torch.device`` objects to move tensors in and out of GPU

 if torch.cuda.is_available():

     device = torch.device('cuda')  # 一个 CUDA 设备对象

     y = torch.ones_like(x, device=device)  # 直接在 GPU 上创建一个张量

     x = x.to(device)                       # 或者使用 .to('cuda')

     z = x + y

     print(z)

     print(z.to('cpu', torch.double))       # to 也可以同时修改 dtype

tensor([-0.0786], device='cuda:0')

tensor([-0.0786], dtype=torch.float64)

AUTOGRAD：自动求导

在所有 PyTorch 的神经网络中，最核心的就是 autograd 包。我们首先简单了解一下它，其后我们会训练一个自己的神经网络。

autograd 包对于张量的运算提供了自动求导功能。

张量

torch.Tensor 是该包的核心类。如果你设定它的属性 .requires_grad 为 True，那么它会追踪张量的所有运算。结束运算时，调用 .backward() 可以自动计算所有的梯度。该张量的梯度会聚合到 .grad 属性中。

如果需要停止追踪，你需要调用 .detach() 将张量对计算历史解绑，避免后续计算的追踪。

除了上面的方法，你还可以把代码块封装在 with torch.no_grad(): 中。这在评估模型时非常有用，因为模型可能会有 require_grad=True 的参数，但是我们并不需要它们的梯度。

自动求导的实现中，还有一个类非常重要：Function。

Tensor 和 Function 相互关联，构建一张非循环的图，这张图编码了完整的计算历史。每个张量有一个 .grad_fn 属性来引用一个创建该张量的 Function。

如果你需要计算导数，可以调用 Tensor 的 .backward() 方法。

创建一个 requires_grad=True 的张量：

 x = torch.ones(2, 2, requires_grad=True)

 print(x)

tensor([[., .],

        [., .]], requires_grad=True)

进行张量运算：

 y = x + 2

 print(y)

tensor([[., .],

        [., .]], grad_fn=<AddBackward0>)

y 是运算的结果，因此它有 grad_fn 属性。

 print(y.grad_fn)

<AddBackward0 object at 0x7f3287a29390>

进行更多运算：

 z = y * y * 3

 out = z.mean()

 print(z, out)

tensor([[., .],

        [., .]], grad_fn=<MulBackward0>) tensor(., grad_fn=<MeanBackward0>)

.requires_grad_(...) 会原地改变当前张量的 requires_grad 标记。

 a = torch.randn(2, 2)

 a = ((a * 3) / (a - 1))

 print(a.requires_grad)

 a.requires_grad_(True)

 print(a.requires_grad)

 b = (a * a).sum()

 print(b.grad_fn)

False

True

<SumBackward0 object at 0x7f3287a18908>

梯度

让我们进行后馈操作。由于 out 包含一个标量，out.backward() 等价于 out.backward(torch.tensor(1.))。

 out.backward()

打印梯度 d(out)/dx：

 print(x)

 print(out)

 print(x.grad)

tensor([[., .],

        [., .]], requires_grad=True)

tensor(., grad_fn=<MeanBackward0>)

tensor([[4.5000, 4.5000],

        [4.5000, 4.5000]])

我们来验证一下这个结果。我们计算的梯度是 $\frac{\partial out}{\partial x_i}$，而

$$out = \frac{1}{4}\sum z_{i}$$

并且

$$z_i=3\times y^2=3\times(x+2)^2$$

因此

$$\frac{\partial out}{\partial x_i}=\frac{\partial out}{\partial z_i}\frac{\partial z_i}{\partial x_i}=\frac{1}{4}\times 6(x+2)=\frac{3(x+2)}{2}$$

由于 $x_i=1$，代入可以得到

$$\frac{\partial out}{\partial x_i}|_{i=1}=4.5$$

我们在从矩阵的意义上去理解：如果有一个向量函数 $\vec{y}=f(\vec{x})$，那么 $\vec{y}$ 对于 $\vec{x}$ 的梯度是一个 Jacobian 矩阵：

大体上讲，torch.autograd 就是计算向量-Jacobian矩阵的内积的引擎。给定 $v=(v_1, v_2, ..., v_m)^T$，计算内积 $J^Tv$。如果 v 正好是标量函数的梯度 $l=g(\vec y)$，即 $v=(\frac{\partial l}{\partial y_1}, ...,\frac{\partial l}{\partial y_m})^T$，那么这个向量-Jacobian矩阵的内积就等于 $l$ 对于 $\vec x$ 的导数：

下面看一个向量-Jacobian内积的例子：

 x = torch.randn(3, requires_grad=True)

 y = x * 2

 while y.data.norm() < 1000:

     y = y * 2

 print(y)

tensor([-886.5914,   41.8782, 1542.3958], grad_fn=<MulBackward0>)

现在由于 y 不是标量，torch.autograd 不能直接计算整个 Jacobian 矩阵。但是如果希望求得向量-Jacobian的内积，可以向 backward 传入一个向量参数。

 v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)

 y.backward(v)

 print(x.grad)

tensor([4.0960e+02, 4.0960e+03, 4.0960e-01])

可以用 with torch.no_grad(): 来封装代码块：

 print(x.requires_grad)

 print((x ** 2).requires_grad)

 with torch.no_grad():

     print((x ** 2).requires_grad)

True

True

False

神经网络

我们可以使用 torch.nn 包来构建神经网络。

nn 依赖于 autograd 来定义模型并且对模型求导。nn.Module 包含神经网络层以及一个 forward(input) 方法返回输出。

例如下面分类数字图片的神经网络：

这是一个简单的前馈神经网络。一个神经网络的传统训练方法是：

定义含有一些可以学习的参数（或权重）的神经网络。
遍历一个输入数据集。
将输入向前传入神经网络。
计算损失。
向后传播梯度到神经网络的参数。
更新神经网络的参数，通常使用简单的更新规则： weight = weight - learning_rate * gradient

定义神经网络

 import torch

 import torch.nn as nn

 import torch.nn.functional as F

 class Net(nn.Module):

     def __init__(self):

         super(Net, self).__init__()

         # 1 input image channel, 6 output channels, 3x3 square convolution

         # kernel

         self.conv1 = nn.Conv2d(1, 6, 3)

         self.conv2 = nn.Conv2d(6, 16, 3)

         # an affine operation: y = Wx + b

         self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension

         self.fc2 = nn.Linear(120, 84)

         self.fc3 = nn.Linear(84, 10)

     def forward(self, x):

         # Max pooling over a (2, 2) window

         x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))

         # If the size is a square you can only specify a single number

         x = F.max_pool2d(F.relu(self.conv2(x)), 2)

         x = x.view(-1, self.num_flat_features(x))

         x = F.relu(self.fc1(x))

         x = F.relu(self.fc2(x))

         x = self.fc3(x)

         return x

     def num_flat_features(self, x):

         size = x.size()[1:]  # all dimensions except the batch dimension

         num_features = 1

         for s in size:

             num_features *= s

         return num_features

 net = Net()

 print(net)

Net(

  (conv1): Conv2d(, , kernel_size=(, ), stride=(, ))

  (conv2): Conv2d(, , kernel_size=(, ), stride=(, ))

  (fc1): Linear(in_features=, out_features=, bias=True)

  (fc2): Linear(in_features=, out_features=, bias=True)

  (fc3): Linear(in_features=, out_features=, bias=True)

)

这里我们定义了 forward 函数，而 backward 函数（计算梯度）可以使用 autograd 自动定义。

学习好的模型参数可以通过 net.parameters() 返回。

 params = list(net.parameters())

 print(len(params))

 print(params[0].size())  # conv1's .weight

torch.Size([, , , ])

接下来我们尝试随机的 32*32 输入（LeNet 所设置的输入大小是 32*32）。

 input = torch.randn(1, 1, 32, 32)

 out = net(input)

 print(out)

tensor([[-0.0236, -0.0104,  0.0173, -0.1874, -0.0613, -0.0162, -0.1466,  0.1535,

          0.0596, -0.0320]], grad_fn=<AddmmBackward>)

在进一步学习之前，这里再回顾一下你看过的类。

torch.Tensor：支持自动求导运算（backward()）的多维数组。同时它也保存着梯度信息。
nn.Module：神经网络模块。可以很容易地封装参数、放到 GPU 进行运算、导出和加载等。
nn.Parameter：某种张量，当赋值为 Module 的属性时，可以自动注册为参数。
autograd.Function：实现自动求导运算的前馈和后馈的定义。每个 Tensor 运算会创建至少一个 Function 节点（创建该 Tensor 的函数）。

到目前为止，我们讲解了：

定义一个神经网络
处理输入并且调用后馈运算

我们还需要：

计算损失（loss）
更新神经网络的权重

损失函数

损失函数接收输入的 (output, target) 对，计算出 output 与 target 之间的差值。

在 nn 包中有很多不同的损失函数。最简单的是 nn.MSELoss，计算出两者的均方误差。

 output = net(input)

 target = torch.randn(10)  # a dummy target, for example

 target = target.view(1, -1)  # make it the same shape as output

 criterion = nn.MSELoss()

 loss = criterion(output, target)

 print(loss)

tensor(0.6006, grad_fn=<MseLossBackward>)

我们可以查看反向传播的各层的运算：

 print(loss.grad_fn)  # MSELoss

 print(loss.grad_fn.next_functions[0][0])  # Linear

 print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

<MseLossBackward object at 0x7f3280404588>

<AddmmBackward object at 0x7f32804047f0>

<AccumulateGrad object at 0x7f3280404588>

反向传播

我们使用 loss.backward() 进行误差的反向传播。但是你需要清除现有的梯度，否则梯度会已存在的梯度上累积。

我们调用 loss.backward()，并且观察 conv1 的偏差的梯度的变化。

 net.zero_grad()  # zeroes the gradient buffers of all parameters

 print('conv1.bias.grad before backward')

 print(net.conv1.bias.grad)

 loss.backward()

 print('conv1.bias.grad after backward')

 print(net.conv1.bias.grad)

conv1.bias.grad before backward

None

conv1.bias.grad after backward

tensor([ 3.5922e-03,  7.0686e-03,  3.9444e-03,  1.1225e-02, -5.1291e-03,

        -6.0605e-05])

权重的更新

实践中最简单的更新方法是随机梯度下降（Stochastic Gradient Descent, SGD）：

weight = weight - learning_rate * gradient

我们可以用简单的 Python 代码来实现：

 learning_rate = 0.01

 for f in net.parameters():

     f.data.sub_(f.grad.data * learning_rate)

然而，使用神经网络的时候，你可能会使用不同的更新方法（SGD、Nesterov-SGD、Adam、RMSProp 等）。为了满足这方面的需求，PyTorch 构建了一个包：torch.optim 实现了所有这些方法。

 import torch.optim as optim

 # create your optimizer

 optimizer = optim.SGD(net.parameters(), lr=0.01)

 # in your training loop:

 optimizer.zero_grad()  # zero the gradient buffers

 output = net(input)

 loss = criterion(output, target)

 loss.backward()

 optimizer.step()  # Does the update

训练一个分类器

前面我们已经可以定义神经网络、计算损失并且更新神经网络的权重了。

那么什么是数据？

通常，当处理图像、文本、音频或者视频数据时，你可以使用标准 Python 包来将数据加载为 Numpy 数组。接着你可以把 NumPy 数组转换为 torch.*Tensor。

对于图片，可能使用 Pillow/OpenCV 这些包
对于音频，可能使用 scipy/librosa 这些包
对于文本，可以使用 Python/Cython/NLTK/SpaCy 进行处理

对于计算机视觉，PyTorch 提供了一个叫 torchvision 的包，可以加载常见的数据集（imagenet/CIFAR10/MNIST 等），对图片进行数据转换。

在这里，我们会使用 CIFAR10 数据集。它有这几个种类：airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck。CIFAR-10 的图片大小都是 3*32*32。

训练图片分类器

我们的步骤是这样的：

使用 torchvision 加载并且标准化 CIFAR10 的训练接和数据集。
定义一个卷积神经网络。
定义损失函数。
在训练集上训练神经网络。
在测试集上训练神经网络。

1. 加载并标准化 CIFAR10

使用 torchvision，要加载 CIFAR10 很容易。

 import torch

 import torchvision

 import torchvision.transforms as transforms

torchvision 数据集的输出是范围 0~1 的 PIL 图片。我们将它标准化，范围 -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, 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')

下面显示部分训练图片：

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

2. 定义卷积神经网络

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

 print(net)

Net(

  (conv1): Conv2d(, , kernel_size=(, ), stride=(, ))

  (pool): MaxPool2d(kernel_size=, stride=, padding=, dilation=, ceil_mode=False)

  (conv2): Conv2d(, , kernel_size=(, ), stride=(, ))

  (fc1): Linear(in_features=, out_features=, bias=True)

  (fc2): Linear(in_features=, out_features=, bias=True)

  (fc3): Linear(in_features=, out_features=, bias=True)

)

3. 定义损失函数和优化器

我们使用分类交叉熵和动量 SGD。

 import torch.optim as optim

 criterion = nn.CrossEntropyLoss()

 optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4. 训练网络

 %%time

 for epoch in range(4):  # 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')

[,  ] loss: 2.223

[,  ] loss: 1.949

[,  ] loss: 1.754

[,  ] loss: 1.622

[, ] loss: 1.544

[, ] loss: 1.496

[,  ] loss: 1.412

[,  ] loss: 1.386

[,  ] loss: 1.373

[,  ] loss: 1.335

[, ] loss: 1.327

[, ] loss: 1.295

[,  ] loss: 1.221

[,  ] loss: 1.239

[,  ] loss: 1.255

[,  ] loss: 1.193

[, ] loss: 1.186

[, ] loss: 1.203

[,  ] loss: 1.126

[,  ] loss: 1.140

[,  ] loss: 1.120

[,  ] loss: 1.122

[, ] loss: 1.112

[, ] loss: 1.114

Finished Training

CPU times: user 3min 34s, sys: 45.6 s, total: 4min 20s

Wall time: 4min 49s

5. 在测试集上测试网络

我们对神经网络训练了 2 次，接下来要看一下该网络是否学习到了东西。

首先展示测试集的几张图片。

接下来让我们看一下神经网络认为这几张图片是啥。

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

 print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

Predicted:    cat  ship plane   car

结果看起来还凑合。

接下来我们看一下在整个测试集上神经网络表现得如何。

 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  test images:  %

再看看每个分类下的表现：

 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 :  %

Accuracy of   car :  %

Accuracy of  bird :  %

Accuracy of   cat :  %

Accuracy of  deer :  %

Accuracy of   dog :  %

Accuracy of  frog :  %

Accuracy of horse :  %

Accuracy of  ship :  %

Accuracy of truck :  %

在 GPU 上进行训练

就像之前我们把张量放到 GPU 上一样，我们需要把神经网络也放在 GPU。

如果我们有 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:

查看可以使用的 GPU 数量：

 print(torch.cuda.device_count())

然后注意把模型和输入数据放入 GPU 进行训练：

 %%time

 net.to(device)

 for epoch in range(4):  # 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

         inputs, labels = inputs.to(device), labels.to(device)

         # 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.225

[1,  4000] loss: 1.895

[1,  6000] loss: 1.678

[1,  8000] loss: 1.565

[1, 10000] loss: 1.508

[1, 12000] loss: 1.467

[2,  2000] loss: 1.393

[2,  4000] loss: 1.349

[2,  6000] loss: 1.319

[2,  8000] loss: 1.317

[2, 10000] loss: 1.322

[2, 12000] loss: 1.255

[3,  2000] loss: 1.191

[3,  4000] loss: 1.200

[3,  6000] loss: 1.230

[3,  8000] loss: 1.190

[3, 10000] loss: 1.162

[3, 12000] loss: 1.167

[4,  2000] loss: 1.096

[4,  4000] loss: 1.102

[4,  6000] loss: 1.089

[4,  8000] loss: 1.099

[4, 10000] loss: 1.092

[4, 12000] loss: 1.066

Finished Training

CPU times: user 2min 27s, sys: 20.2 s, total: 2min 47s

Wall time: 3min 33s

加速效果跟神经网络的大小有关系，不适用 GPU 需要 4 分 49 秒，我们的 GPU 版本消耗时间 3 分 33 秒。我们目前的神经网络还比较小，因此加速效果并不是非常大。

巴特西