PyTorch深度学习：60分钟入门

---

本教程的目的:

• 更高层级地理解PyTorch的Tensor库以及神经网络。
• 训练一个小的神经网络来对图像进行分类。

本教程以您拥有一定的numpy基础的前提下展开

Note: 务必确认您已经安装了 torch 和 torchvision 两个包。

这是一个基于Python的科学计算包，其旨在服务两类场合：

• 替代numpy发挥GPU潜能
• 一个提供了高度灵活性和效率的深度学习实验性平台

我们开搞

pytorch基础入门

（一）tensors

张量是一种特殊的数据结构，与数组矩阵类似，在pytoch中，使用tensors对模型的输入和输出进行编码

import torch 
import numpy as np

1.tensor 初始化

# 直接数据
data=[[1,2],[3,4]]
x_data=torch.tensor(data)

# numpy 数组
np_array=np.array(data)
x_np=torch.from_numpy(np_array)

# 从另一个tensor
x_ones=torch.ones_like(x_data)#保留shape,datatype
print(f'ones tensor:\n{x_ones}\n')
x_rands=torch.rand_like(x_data,dtype=torch.float)#保留shape
print(f'random tensor:\n{x_rands}\n')

ones tensor:
tensor([[1, 1],
        [1, 1]])

random tensor:
tensor([[0.3272, 0.3049],
        [0.3315, 0.8603]])

shape是tensor维度

shape=(2,3,)
rand_tensor=torch.rand(shape)
ones_tensor=torch.ones(shape)
zeros_tensor=torch.zeros(shape)
print(rand_tensor)
print(ones_tensor)
print(zeros_tensor)

tensor([[0.3955, 0.7930, 0.1733],
        [0.3849, 0.5444, 0.3754]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[0., 0., 0.],
        [0., 0., 0.]])

2.tensor 性质

shape,datatype,device(存储位置）

tensor=torch.rand(3,4)
print(tensor.shape,'\n',tensor.dtype,'\n',tensor.device)

torch.Size([3, 4]) 
 torch.float32 
 cpu

3.tensor 运算

转置、索引、切片、数学运算、线性代数、随机采样

# 索引和切片
tensor=torch.ones(4,4)
tensor[:,1]=0
print(tensor)

tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

# 连接
t1=torch.cat([tensor,tensor,tensor],dim=1)
t1

tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],
        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])

# 数字乘
tensor.mul(tensor)
tensor*tensor
# 矩阵乘
tensor.matmul(tensor.T)
tensor@tensor.T

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

# 就地操作_
print(tensor)
tensor.add_(4)
print(tensor)

tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])
tensor([[5., 4., 5., 5.],
        [5., 4., 5., 5.],
        [5., 4., 5., 5.],
        [5., 4., 5., 5.]])

4.bridge numpy

# tensor-->numpy
t=torch.ones(5)
print(f't:{t}')
n=t.numpy()
print(f'n:{n}')

t:tensor([1., 1., 1., 1., 1.])
n:[1. 1. 1. 1. 1.]

# tensor变化会在numpy中反应
t.add_(1)
print(t)
print(n)

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

# numpy-->tensor
n=np.ones(5)
t=torch.from_numpy(n)
np.add(n,1,out=n)
print(t)
print(n)

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

（二）torch.autograd

pytorch自动差分引擎，可为神经网络训练提供支持

1.usage in pytorch

import ssl
ssl._create_default_https_context = ssl._create_unverified_context

import torch,torchvision
model=torchvision.models.resnet18(pretrained=True)
data=torch.rand(1,3,64,64)
labels=torch.rand(1,1000)
prediction=model(data)#forward
loss=(prediction-labels).sum()#loss function
loss.backward()#backward
optim=torch.optim.SGD(model.parameters(),lr=1e-2,momentum=0.9)#lr学习率
optim.step()#初始化梯度下降

2.differentiation in autograd

import torch
#requires_grad=True:every operation on them should be tracked.
a=torch.tensor([2.,3.],requires_grad=True)
b=torch.tensor([6.,4.],requires_grad=True)

#a,b是NN参数，Q是误差
Q=3*a**3-b**2

external_grad=torch.tensor([1,1])
#Q.backward:计算Q对a,b的gradients并储存在tensor.grad中
Q.backward(gradient=external_grad)
print(a.grad)
print(b.grad)

tensor([36., 81.])
tensor([-12.,  -8.])

3.computational graph

autograd保留DAG（有向无环图，包含函数对象）中的所有数据（tensors)和操作

1.前向传播：计算结果tensor，记录gradient function（leaves–root)

2.反向传播：计算每个参数的梯度并保存在tensor.grad中，链式法则(root–leaves)

x=torch.rand(5,5)
y=torch.rand(5,5)
z=torch.rand((5,5),requires_grad=True)
a=x+y
print(a.requires_grad)
b=x+z
print(b.requires_grad)

False
True

frozen parameters:不计算梯度的参数，减少计算量

from torch import nn,optim
model=torchvision.models.resnet18(pretrained=True)
#frozen 所有的参数除了function的权重和偏差
for param in model.parameters():
    param.requires_grad=False
model.fc=nn.Linear(512,10)
optimizer=optim.SGD(model.parameters(),lr=1e-2, momentum=0.9)

（三）神经网络

torch.nn包构建神经网络

神经网络训练步骤：

1.定义神经网络（包含一些需要学习的参数/权重）

2.遍历输入数据集

3.通过网络处理输入

4.计算损失函数

5.网络参数梯度反向传播

6.通常使用简单的更新规则来更新网络的权重：weight = weight - learning_rate * gradient

1.define network

(1)Containers:

• Module:所有神经网络模型的基类

(2)Convolution Layers:

• nn.Conv2d:Applies a 2D convolution over an input signal composed of several input planes

(3)Linear Layers

• nn.Linear:Applies a linear transformation to the incoming data(y=wx+b)
  

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, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5*5 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 specify with a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = torch.flatten(x, 1) # flatten all dimensions except the batch dimension
        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(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=400, out_features=120, bias=True)
  (fc2): Linear(in_features=120, out_features=84, bias=True)
  (fc3): Linear(in_features=84, out_features=10, bias=True)
)

只需要定义forward函数，就可以使用autograd自定义backward函数

模型学习参数由net.parameters()返回

params = list(net.parameters())
print(len(params))
print(params[0].size())#卷积层1的权重
#print(params)

10
torch.Size([6, 1, 5, 5])

input = torch.randn(1,1,32,32)
out = net(input)
print(out)

tensor([[ 0.0735, -0.0377,  0.1258, -0.0828, -0.0173, -0.0726, -0.0875, -0.0256,
         -0.0797,  0.0959]], grad_fn=<AddmmBackward0>)

使用随机梯度将所有参数和反向传播的梯度缓冲区归零

net.zero_grad
out.backward(torch.randn(1,10))

torch.nn仅支持小批量。 整个torch.nn包仅支持作为微型样本而不是单个样本的输入。例如，nn.Conv2d采用nSamples x nChannels x Height x Width的4D张量

目前为止看到的类：

• torch.Tensor：一个多维数组，支持backward()的自动微分操作，保存张量梯度
• nn.Module：神经网络模块，封装参数
• nn.Parameter：一种张量，将其分配为Module的属性时，自动注册为参数
• autograd.Function：实现自动微分操作的正向和反向定义，每个Tensor操作都会创建至少一个Function节点，该节点连接到创建Tensor的函数，并且编码其历史记录。

2.loss function

损失函数采用（输出，目标）作为输入，并计算一个值估计输出与目标之间的距离，nn包有好几种不同的损失函数，简单的如nn.MSELoss，计算均方误差

output = net(input)
target = torch.randn(10)#只是用于例子
target = target.view(1,-1)#使其与输出保持相同shape
criterion = nn.MSELoss()
loss = criterion(output,target)
print(loss)

tensor(0.4356, grad_fn=<MseLossBackward0>)

使用.grad_fn属性向后跟随loss，将得到一个计算图，调用loss.backward()时，整个图被微分，图中具有requires_grad=True的所有张量将随梯度累积其.grad张量

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

<MseLossBackward0 object at 0x7fef4965df10>
<AddmmBackward0 object at 0x7fef4965d3a0>
<AccumulateGrad object at 0x7fef4965df10>

3.Backprop

反向传播，只需要loss.backward()，在此之前先清除现有梯度，否则梯度将累计到现在的梯度中

net.zero_grad() # 清除梯度

print('conv1的前偏差梯度')
print(net.conv1.bias.grad)

loss.backward()

print('conv1的后偏差梯度')
print(net.conv1.bias.grad)

conv1的前偏差梯度
tensor([0., 0., 0., 0., 0., 0.])
conv1的后偏差梯度
tensor([ 0.0124,  0.0051, -0.0029, -0.0088,  0.0048,  0.0012])

4.Update the weights

最简单的更新规则是随机梯度下降（SGD）

• weight = weight - learning_rate * gradient

learning_rate = 0.01
for f in net.parameters():
    f.data.sub_(f.grad.data*learning_rate)

但是使用神经网络时，可能需要用到不用的更新规则，如SGD，Nesterov-SGD，Adam，RMSProp等，使用torch.optim包可实现所有方法

import torch.optim as optim

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

# 在training loop里
optimizer.zero_grad() # 将梯度缓冲区手动设置为0
output = net(input)
loss = criterion(output,target)
loss.backward()
optimizer.step()
print(net.conv1.bias.grad)

tensor([ 0.0119,  0.0050, -0.0034, -0.0109,  0.0049, -0.0009])

Pytorch入门

Tensors

Tensors和numpy中的ndarrays较为相似, 与此同时Tensor也能够使用GPU来加速运算。

from __future__ import print_function
import torch
x = torch.Tensor(5, 3)  # 构造一个未初始化的5*3的矩阵
x = torch.rand(5, 3)  # 构造一个随机初始化的矩阵
x # 此处在notebook中输出x的值来查看具体的x内容
x.size()

#NOTE: torch.Size 事实上是一个tuple, 所以其支持相关的操作*
y = torch.rand(5, 3)

#此处 将两个同形矩阵相加有两种语法结构
x + y # 语法一
torch.add(x, y) # 语法二

# 另外输出tensor也有两种写法
result = torch.Tensor(5, 3) # 语法一
torch.add(x, y, out=result) # 语法二
y.add_(x) # 将y与x相加

# 特别注明：任何可以改变tensor内容的操作都会在方法名后加一个下划线'_'
# 例如：x.copy_(y), x.t_(), 这俩都会改变x的值。

#另外python中的切片操作也是资次的。
x[:,1] #这一操作会输出x矩阵的第二列的所有值

阅读材料：

100+ Tensor的操作，包括换位、索引、切片、数学运算、线性算法和随机数等等。

详见：torch - PyTorch 0.1.9 documentation

Numpy桥

将Torch的Tensor和numpy的array相互转换简直就是洒洒水啦。注意Torch的Tensor和numpy的array会共享他们的存储空间，修改一个会导致另外的一个也被修改。

# 此处演示tensor和numpy数据结构的相互转换
a = torch.ones(5)
b = a.numpy()

# 此处演示当修改numpy数组之后,与之相关联的tensor也会相应的被修改
a.add_(1)
print(a)
print(b)

# 将numpy的Array转换为torch的Tensor
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)

# 另外除了CharTensor之外，所有的tensor都可以在CPU运算和GPU预算之间相互转换
# 使用CUDA函数来将Tensor移动到GPU上
# 当CUDA可用时会进行GPU的运算
if torch.cuda.is_available():
    x = x.cuda()
    y = y.cuda()
    x + y

PyTorch中的神经网络

接下来介绍pytorch中的神经网络部分。PyTorch中所有的神经网络都来自于autograd包

首先我们来简要的看一下，之后我们将训练我们第一个的神经网络。

Autograd: 自动求导

autograd 包提供Tensor所有操作的自动求导方法。
这是一个运行时定义的框架，这意味着你的反向传播是根据你代码运行的方式来定义的，因此每一轮迭代都可以各不相同。

以这些例子来讲，让我们用更简单的术语来看看这些特性。

autograd.Variable 这是这个包中最核心的类。 它包装了一个Tensor，并且几乎支持所有的定义在其上的操作。一旦完成了你的运算，你可以调用 .backward()来自动计算出所有的梯度。

你可以通过属性 .data 来访问原始的tensor，而关于这一Variable的梯度则集中于 .grad 属性中。

还有一个在自动求导中非常重要的类 Function。

Variable 和 Function 二者相互联系并且构建了一个描述整个运算过程的无环图。每个Variable拥有一个 .creator 属性，其引用了一个创建Variable的 Function。(除了用户创建的Variable其 creator 部分是 None)。

如果你想要进行求导计算，你可以在Variable上调用.backward()。 如果Variable是一个标量（例如它包含一个单元素数据），你无需对backward()指定任何参数，然而如果它有更多的元素，你需要指定一个和tensor的形状想匹配的grad_output参数。

from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad = True)
y = x + 2
y.creator

# y 是作为一个操作的结果创建的因此y有一个creator 
z = y * y * 3
out = z.mean()

# 现在我们来使用反向传播
out.backward()

# out.backward()和操作out.backward(torch.Tensor([1.0]))是等价的
# 在此处输出 d(out)/dx
x.grad

最终得出的结果应该是一个全是4.5的矩阵。设置输出的变量为o。我们通过这一公式来计算：

$o=\frac{1}{4}{\sum }_i{z}_i$o = \frac{1}{4}\sum_i z_i，$z_i=3(x_i+2{)}^2$z_i = 3(x_i+2)^2，$z_i{|}_{x_i=1}=27$z_i\bigr\rvert_{x_i=1} = 27，因此，$\frac{\partial o}{\partial x_i}=\frac{3}{2}(x_i+2)$\frac{\partial o}{\partial x_i} = \frac{3}{2}(x_i+2)，最后有$\frac{\partial o}{\partial x_i}{|}_{x_i=1}=\frac{9}{2}=4.5$\frac{\partial o}{\partial x_i}\bigr\rvert_{x_i=1} = \frac{9}{2} = 4.5

你可以使用自动求导来做许多疯狂的事情。

x = torch.randn(3)
x = Variable(x, requires_grad = True)
y = x * 2
while y.data.norm() < 1000:
    y = y * 2
gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
y.backward(gradients)
x.grad

阅读材料：

你可以在这读更多关于Variable 和 Function的文档: pytorch.org/docs/autograd.html

神经网络

使用 torch.nn 包可以进行神经网络的构建。

现在你对autograd有了初步的了解，而nn建立在autograd的基础上来进行模型的定义和微分。

nn.Module中包含着神经网络的层，同时forward(input)方法能够将output进行返回。

举个例子，来看一下这个数字图像分类的神经网络。

这是一个简单的前馈神经网络。 从前面获取到输入的结果，从一层传递到另一层，最后输出最后结果。

一个典型的神经网络的训练过程是这样的：

• 定义一个有着可学习的参数（或者权重）的神经网络

• 对着一个输入的数据集进行迭代:

• 用神经网络对输入进行处理

• 计算代价值 (对输出值的修正到底有多少)

• 将梯度传播回神经网络的参数中

• 更新网络中的权重

• 通常使用简单的更新规则: weight = weight + learning_rate * gradient

让我们来定义一个神经网络:

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(1, 6, 5) # 1 input image channel, 6 output channels, 5x5 square convolution kernel
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1   = nn.Linear(16*5*5, 120) # an affine operation: y = Wx + b
        self.fc2   = nn.Linear(120, 84)
        self.fc3   = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2)) # Max pooling over a (2, 2) window
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) # If the size is a square you can only specify a single number
        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()
net

'''神经网络的输出结果是这样的
Net (
  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear (400 -> 120)
  (fc2): Linear (120 -> 84)
  (fc3): Linear (84 -> 10)
)
'''

仅仅需要定义一个forward函数就可以了，backward会自动地生成。

你可以在forward函数中使用所有的Tensor中的操作。

模型中可学习的参数会由net.parameters()返回。

params = list(net.parameters())
print(len(params))
print(params[0].size()) # conv1's .weight

input = Variable(torch.randn(1, 1, 32, 32))
out = net(input)
'''out 的输出结果如下
Variable containing:
-0.0158 -0.0682 -0.1239 -0.0136 -0.0645  0.0107 -0.0230 -0.0085  0.1172 -0.0393
[torch.FloatTensor of size 1x10]
'''

net.zero_grad() # 对所有的参数的梯度缓冲区进行归零
out.backward(torch.randn(1, 10)) # 使用随机的梯度进行反向传播

注意: torch.nn 只接受小批量的数据
整个torch.nn包只接受那种小批量样本的数据，而非单个样本。 例如，nn.Conv2d能够结构一个四维的TensornSamples x nChannels x Height x Width。
如果你拿的是单个样本，使用input.unsqueeze(0)来加一个假维度就可以了。

复习一下前面我们学到的：

• torch.Tensor - 一个多维数组
• autograd.Variable - 改变Tensor并且记录下来操作的历史记录。和Tensor拥有相同的API，以及backward()的一些API。同时包含着和张量相关的梯度。
• nn.Module - 神经网络模块。便捷的数据封装，能够将运算移往GPU，还包括一些输入输出的东西。
• nn.Parameter - 一种变量，当将任何值赋予Module时自动注册为一个参数。
• autograd.Function - 实现了使用自动求导方法的前馈和后馈的定义。每个Variable的操作都会生成至少一个独立的Function节点，与生成了Variable的函数相连之后记录下操作历史。

到现在我们已经明白的部分:

• 定义了一个神经网络。
• 处理了输入以及实现了反馈。

仍然没整的:

• 计算代价。
• 更新网络中的权重。

一个代价函数接受（输出，目标）对儿的输入，并计算估计出输出与目标之间的差距。

nn package包中一些不同的代价函数.

一个简单的代价函数：nn.MSELoss计算输入和目标之间的均方误差。

举个例子:

output = net(input)
target = Variable(torch.range(1, 10))  # a dummy target, for example
criterion = nn.MSELoss()
loss = criterion(output, target)
'''loss的值如下
Variable containing:
 38.5849
[torch.FloatTensor of size 1]
'''

现在，如果你跟随loss从后往前看，使用.creator属性你可以看到这样的一个计算流程图：

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d  
      -> view -> linear -> relu -> linear -> relu -> linear 
      -> MSELoss
      -> loss

因此当我们调用loss.backward()时整个图通过代价来进行区分，图中所有的变量都会以.grad来累积梯度。

# For illustration, let us follow a few steps backward
print(loss.creator) # MSELoss
print(loss.creator.previous_functions[0][0]) # Linear
print(loss.creator.previous_functions[0][0].previous_functions[0][0]) # ReLU

'''
<torch.nn._functions.thnn.auto.MSELoss object at 0x7fe8102dd7c8>
<torch.nn._functions.linear.Linear object at 0x7fe8102dd708>
<torch.nn._functions.thnn.auto.Threshold object at 0x7fe8102dd648>
'''

# 现在我们应当调用loss.backward(), 之后来看看 conv1's在进行反馈之后的偏置梯度如何
net.zero_grad() # 归零操作
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
Variable containing:
 0
 0
 0
 0
 0
 0
[torch.FloatTensor of size 6]

conv1.bias.grad after backward
Variable containing:
 0.0346
-0.0141
 0.0544
-0.1224
-0.1677
 0.0908
[torch.FloatTensor of size 6]
'''

现在我们已经了解如何使用代价函数了。

阅读材料：

神经网络包中包含着诸多用于神经网络的模块和代价函数，带有文档的完整清单在这里：torch.nn - PyTorch 0.1.9 documentation

只剩下一个没学了:

• 更新网络的权重

最简单的更新的规则是随机梯度下降法(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, etc.

我们构建了一个小的包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中的数组，之后再转换为torch.*Tensor。

• 图像的话，可以用Pillow, OpenCV。
• 声音处理可以用scipy和librosa。
• 文本的处理使用原生Python或者Cython以及NLTK和SpaCy都可以。

特别的对于图像，我们有torchvision这个包可用,其中包含了一些现成的数据集如：Imagenet, CIFAR10, MNIST等等。同时还有一些转换图像用的工具。 这非常的方便并且避免了写样板代码。

本教程使用CIFAR10数据集。 我们要进行的分类的类别有：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。 这个数据集中的图像都是3通道，32x32像素的图片。

下面是对torch神经网络使用的一个实战练习。

训练一个图片分类器

我们要按顺序做这几个步骤：

1. 使用torchvision来读取并预处理CIFAR10数据集
2. 定义一个卷积神经网络
3. 定义一个代价函数
4. 在神经网络中训练训练集数据
5. 使用测试集数据测试神经网络

1. 读取并预处理CIFAR10

使用torchvision读取CIFAR10相当的方便。

import torchvision
import torchvision.transforms as transforms


# torchvision数据集的输出是在[0, 1]范围内的PILImage图片。
# 我们此处使用归一化的方法将其转化为Tensor，数据范围为[-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')
'''注：这一部分需要下载部分数据集 因此速度可能会有一些慢 同时你会看到这样的输出

Downloading http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Extracting tar file
Done!
Files already downloaded and verified
'''

我们来从中找几张图片看看。

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

# show some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# print images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s'%classes[labels[j]] for j in range(4)))

结果是这样的：

2. 定义一个卷积神经网络

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

3. 定义代价函数和优化器

criterion = nn.CrossEntropyLoss() # use a Classification Cross-Entropy loss
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

4. 训练网络

事情变得有趣起来了。 我们只需一轮一轮迭代然后不断通过输入来进行参数调整就行了。

for epoch in range(2): # loop over the dataset multiple times
    
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data
        
        # wrap them 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')
'''这部分的输出结果为
[1,  2000] loss: 2.212
[1,  4000] loss: 1.892
[1,  6000] loss: 1.681
[1,  8000] loss: 1.590
[1, 10000] loss: 1.515
[1, 12000] loss: 1.475
[2,  2000] loss: 1.409
[2,  4000] loss: 1.394
[2,  6000] loss: 1.376
[2,  8000] loss: 1.334
[2, 10000] loss: 1.313
[2, 12000] loss: 1.264
Finished Training
'''

我们已经训练了两遍了。 此时需要测试一下到底结果如何。

通过对比神经网络给出的分类和已知的类别结果，可以得出正确与否，如果预测的正确，我们可以将样本加入正确预测的结果的列表中。

好的第一步，让我们展示几张照片来熟悉一下。

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

结果是这样的：

好的，接下来看看神经网络如何看待这几个照片。

outputs = net(Variable(images))

# the outputs are energies for the 10 classes. 
# Higher the energy for a class, the more the network 
# thinks that the image is of the particular class

# So, let's get the index of the highest energy
_, predicted = torch.max(outputs.data, 1)

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

'''输出结果为
Predicted:    cat plane   car plane
'''

结果看起来挺好。

看看神经网络在整个数据集上的表现结果如何。

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

'''输出结果为
Accuracy of the network on the 10000 test images: 54 %
'''

看上去这玩意输出的结果比随机整的要好，随机选择的话从十个中选择一个出来，准确率大概只有10%。

看上去神经网络学到了点东西。

嗯。。。那么到底哪些类别表现良好又是哪些类别不太行呢？

class_correct = list(0. for i in range(10))
class_total = 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]))

'''输出结果为
Accuracy of plane : 73 %
Accuracy of   car : 70 %
Accuracy of  bird : 52 %
Accuracy of   cat : 27 %
Accuracy of  deer : 34 %
Accuracy of   dog : 37 %
Accuracy of  frog : 62 %
Accuracy of horse : 72 %
Accuracy of  ship : 64 %
Accuracy of truck : 53 %
'''

好吧，接下来该怎么搞了？

我们该如何将神经网络运行在GPU上呢？

在GPU上进行训练

就像你把Tensor传递给GPU进行运算一样，你也可以将神经网络传递给GPU。

这一过程将逐级进行操作，直到所有组件全部都传递到GPU上。

net.cuda()

'''输出结果为
Net (
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (pool): MaxPool2d (size=(2, 2), stride=(2, 2), dilation=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear (400 -> 120)
  (fc2): Linear (120 -> 84)
  (fc3): Linear (84 -> 10)
)
'''

记住，每一步都需要把输入和目标传给GPU。

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

我为什么没有进行CPU运算和GPU运算的对比呢？因为神经网络实在太小了，其中的差距并不明显。

目标达成：

• 在更高层级上理解PyTorch的Tensor库和神经网络。
• 训练一个小的神经网络。

pytorch官方教程（详细版）

（一）Datasets & DataLoaders

处理数据样本的代码可能会变得凌乱，难以维护；理想情况下，我们希望数据集代码与模型训练代码分离，以获得更好的可读性和模块性。PyTorch提供了两种数据原语：torch.utils.data.DataLoader和torch.utils.data.Dataset，允许你使用预加载的数据集以及自己的数据。Dataset 存储样本及其相应的标签，DataLoader将Dataset封装成一个迭代器以便轻松访问样本。PyTorch域库提供了许多预加载的数据集（比如FashionMNIST），属于torch.utils.data.Dataset的子类，并实现指定于特定数据的功能。它们可以用于原型和基准测试你的模型。

加载数据集

这是一个从TorchVision中加载Fashion-MNIST数据集的例子，Fashion MNIST是Zalando文章图片的数据集，包含60000个训练示例和10000个测试示例。每个示例包括一个28×28的灰度图像和一个来自10个类别之一的相关标签。加载FashionMNIST需要以下参数

• root：训练/测试数据存储路径
• train：指定训练或测试数据集
• download=True：如果在“根目录”中不可用，则从internet下载数据
• transform 和target_transform指定特征和标签变换

import torch
from torch.utils.data import Dataset
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt


train_data = datasets.FashionMNIST(root='data',train=True,download=True,transform=ToTensor())

test_data = datasets.FashionMNIST(root='data',train=False,download=True,transform=ToTensor())

迭代和可视化数据集

我们可以像列表一样手动索引Datasets：train_data[index]。使用matplotlib可视化一些训练数据样本

labels_map = {
    0: "T-Shirt",
    1: "Trouser",
    2: "Pullover",
    3: "Dress",
    4: "Coat",
    5: "Sandal",
    6: "Shirt",
    7: "Sneaker",
    8: "Bag",
    9: "Ankle Boot",}
figure = plt.figure(figsize=(8,8))
cols,rows = 3,3
for i in range(1,cols * rows + 1):
    sample_index = torch.randint(len(train_data),size=(1,)).item() # 获取随机索引
    img,label = train_data[sample_index] # 找到随机索引下的图像和标签
    figure.add_subplot(rows,cols,i) # 增加子图，add_subplot面向对象，subplot面向函数
    plt.title(labels_map[label])
    plt.axis("off") # 关闭坐标轴
    plt.imshow(img.squeeze(),cmap='gray') # 对图像进行处理,cmap颜色图谱
plt.show() # 显示图像

创建自定义数据集文件

自定义数据集类必须包含三个函数：__init__, __len__,和 __getitem__。比如图像存储在img_dir目录里，标签分开存储在一个CSV 文件annotations_file

import os
import pandas as pd
from torchvision.io import read_image

class CustomImageDataset(Dataset):
    def __init__(self,annotations_file,img_dir,transform = None,target_transform = None):
        self.img_labels = pd.read_csv(annotations_file)
        self.img_dir = img_dir
        self.transform = transform
        self.traget_transform = target_transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        # iloc[:,:]切片，左闭右开，iloc[idx,0]取idx行0列元素
        # os.path.join路径连接
        img_path = os.path.join(self.img_dir,self.img_labels.iloc[idx,0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx,1]
        if self.transform:
            image = self.transform(image)
        if self.traget_transform:
            label = self.traget_transform(label)
        return image,label

init

__init__函数在实例化Dataset对象时运行一次。我们初始化包含图像、注释文件和两种转换的目录。labels.csv文件内容如下：

tshirt1.jpg, 0
tshirt2.jpg, 0
......
ankleboot999.jpg, 9

def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
    self.img_labels = pd.read_csv(annotations_file)
    self.img_dir = img_dir
    self.transform = transform
    self.target_transform = target_transform

len

__len__函数返回数据集中的样本数

def __len__(self):
    return len(self.img_labels)

getitem

__getitem__函数加载和返回数据集中给定索引idx位置的一个样本。基于索引，它识别图像在磁盘上的位置，使用read_image将其转换为张量，从self.img_labelscsv数据中检索相应的标签。调用其上的变换函数（如果适用），并以元组形式返回张量图像和相应标签。

def __getitem__(self, idx):
    img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
    image = read_image(img_path)
    label = self.img_labels.iloc[idx, 1]
    if self.transform:
        image = self.transform(image)
    if self.target_transform:
        label = self.target_transform(label)
    return image, label

---

使用DataLoaders预备训练数据

Dataset一次检索一个样本的数据集特征和标签，在训练模型时，我们通常希望以“小minibatches”的方式传递样本，在每个epoch重新排列数据以减少模型过度拟合，并使用Python的multiprocessing加速数据检索。DataLoader 是一个迭代器能实现上面功能

from torch.utils.data import DataLoader
# shuffle如果设置为True，则会在每个epoch重新排列数据
train_dataloader = DataLoader(train_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

通过DataLoader进行迭代

已经将数据加载到DataLoader，能够迭代遍历数据集，每次迭代都会返回批量（batch_size=64）的train_features和train_labels，设置了shuffle=True，在我们迭代所有batches之后，数据被洗牌（以便对数据加载顺序进行更细粒度的控制）

train_features,train_labels = next(iter(train_dataloader))
print(f'feature batch shape:{train_features.size()}')
print(f'label batch shape:{train_labels.size()}')
img = train_features[0].squeeze()
label = train_labels[0]
plt.imshow(img,cmap='gray')
plt.show()
print(f'label:{label}')

feature batch shape:torch.Size([64, 1, 28, 28])
label batch shape:torch.Size([64])

label:4

---

（二）Transforms

数据并不总是以训练机器学习算法所需的最终处理形式出现。我们使用transforms对数据进行一些操作，使其适合训练。所有的TorchVision数据集都有两个参数transform（修正特征），target_transform（修正标签），torchvision.transforms模块提供了几种常用的转换。
FashionMNIST特征是PIL图像形式, 标签是整数。为了训练，需要把特征作为归一化张量，标签作为一个one-hot编码张量。使用ToTensor 和Lambda实现

import torch
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

ds = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
)

ToTensor( )

ToTensor将一个PIL image或者NumPy 数组ndarray变成浮点型张量FloatTensor，在[0,1]范围内缩放图像的像素强度值

Lambda Transforms

Lambda transforms应用任何用户定义的Lambda函数，此处定义了一个函数将整数变成one-hot编码张量，首先创建一个大小为10（标签数）的全0张量，然后调用scatter_ 在标签y的索引位置上将值修改为1

target_transform = Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1))

Tensor.scatter_(dim, index, src, reduce=None)在dim维度上，找到index对应的元素，将值换成src

print(torch.zeros(10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(3), value=1))

tensor([0., 0., 0., 1., 0., 0., 0., 0., 0., 0.])

---

（三）构建神经网络

使用pytorch构建神经网络进行FashionMNIST数据集中的图像分类

import os
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('using {} device'.format(device))

using cpu device

定义神经网络类

继承nn.Module构建神经网络，包括两个部分

• __init__：定义网络层
• forward：执行前向传播

class network(nn.Module):
    def __init__(self):
        super(network, self).__init__()
        self.flatten = nn.Flatten() # 将连续范围的维度拉平成张量
        self.layers = nn.Sequential(
            nn.Linear(28*28,512),
            nn.ReLU(),
            nn.Linear(512,512),
            nn.ReLU(),
            nn.Linear(512,10))
    def forward(self,x):
        x = self.flatten(x) # 输入到网络中的是（batch_size,input)
        values = self.layers(x)
        return values

torch.nn.Flatten(start_dim=1, end_dim=- 1)默认只保留第一维度

• start_dim：first dim to flatten (default = 1).

• end_dim：last dim to flatten (default = -1).

# torch.nn.Flatten示例
input = torch.randn(32,1,5,5)
m = nn.Flatten()
output = m(input)
print(output.size())
m1 = nn.Flatten(0,2)
print(m1(input).size())

torch.Size([32, 25])
torch.Size([160, 5])

创建一个network实例并移动到 device，输出结构

model = network().to(device)
print(model)

network(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (layers): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)

遍历输入数据，执行模型前向传播，不用直接调用forward

x = torch.rand(2,28,28,device=device)
value = model(x)
print(value)
print(value.size())
pred_probab = nn.Softmax(dim=1)(value)
print(pred_probab)
y_pred = pred_probab.argmax(1)
print(f'predicted class:{y_pred}')

tensor([[-0.0355,  0.0948, -0.1048,  0.0802,  0.0177,  0.0038, -0.0281, -0.0767,
          0.0303, -0.1290],
        [-0.0238,  0.1298, -0.0700,  0.0861,  0.0168, -0.0418, -0.0421, -0.0772,
          0.0369, -0.1391]], grad_fn=<AddmmBackward0>)
torch.Size([2, 10])
tensor([[0.0977, 0.1113, 0.0912, 0.1097, 0.1030, 0.1016, 0.0984, 0.0938, 0.1043,
         0.0890],
        [0.0986, 0.1149, 0.0941, 0.1100, 0.1027, 0.0968, 0.0968, 0.0935, 0.1048,
         0.0878]], grad_fn=<SoftmaxBackward0>)
predicted class:tensor([1, 1])

torch.nn.Softmax(dim=None)softmax归一化

# torch.nn.Softmax示例
m = nn.Softmax(dim=1)
input = torch.randn(2,3)
print(input)
output = m(input)
print(output)

tensor([[-0.5471,  1.3495,  1.5911],
        [-0.0185, -0.1420, -0.0556]])
tensor([[0.0619, 0.4126, 0.5254],
        [0.3512, 0.3104, 0.3384]])

---

模型结构层

拆解模型中的层次，观察输入和输出

原始输入

input_image = torch.rand(3,28,28)
print(input_image.size())

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

nn.Flatten

将2维的28✖️28图像变成784像素值，batch维度（dim=0）保留

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.size())

torch.Size([3, 784])

nn.Linear

线性转换

layer1 = nn.Linear(in_features=28*28,out_features=20)
hidden1 = layer1(flat_image)
print(hidden1.size( ))

torch.Size([3, 20])

nn.ReLU

非线性修正单元（激活函数）

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")
print(hidden1.size())

Before ReLU: tensor([[ 0.4574, -0.5313, -0.4628, -0.9403, -0.7630,  0.1807, -0.2847, -0.2741,
          0.0954,  0.2327,  0.4603,  0.0227, -0.1299, -0.2346, -0.1800,  0.9115,
         -0.0870, -0.0171, -0.0064,  0.0540],
        [ 0.0888, -0.6782, -0.2557, -0.6717, -0.4488,  0.1024, -0.3013, -0.3186,
         -0.1338,  0.3944,  0.0704,  0.1429,  0.0521, -0.3326, -0.3113,  0.6518,
         -0.0978, -0.0721, -0.3396,  0.4712],
        [ 0.1781,  0.0885, -0.4775, -0.5661, -0.0099,  0.2617, -0.2678, -0.1444,
          0.1345,  0.3259,  0.3984,  0.2392,  0.0529, -0.0349, -0.3266,  0.7488,
         -0.3498,  0.1157,  0.0126,  0.3502]], grad_fn=<AddmmBackward0>)


After ReLU: tensor([[0.4574, 0.0000, 0.0000, 0.0000, 0.0000, 0.1807, 0.0000, 0.0000, 0.0954,
         0.2327, 0.4603, 0.0227, 0.0000, 0.0000, 0.0000, 0.9115, 0.0000, 0.0000,
         0.0000, 0.0540],
        [0.0888, 0.0000, 0.0000, 0.0000, 0.0000, 0.1024, 0.0000, 0.0000, 0.0000,
         0.3944, 0.0704, 0.1429, 0.0521, 0.0000, 0.0000, 0.6518, 0.0000, 0.0000,
         0.0000, 0.4712],
        [0.1781, 0.0885, 0.0000, 0.0000, 0.0000, 0.2617, 0.0000, 0.0000, 0.1345,
         0.3259, 0.3984, 0.2392, 0.0529, 0.0000, 0.0000, 0.7488, 0.0000, 0.1157,
         0.0126, 0.3502]], grad_fn=<ReluBackward0>)
torch.Size([3, 20])

nn.Sequential

nn.Sequential 是一个模块的有序容纳器，数据按照定义的顺序传递给所有模块

seq_modules = nn.Sequential(flatten,layer1,nn.ReLU(),nn.Linear(20,10))
input_image = torch.randn(3,28,28)
values1 = seq_modules(input_image)
print(values1)

tensor([[ 0.2472,  0.2597, -0.0157,  0.3206, -0.0073,  0.1631,  0.2956,  0.0561,
          0.2993,  0.1807],
        [-0.0782,  0.1838, -0.0215,  0.2395, -0.0804, -0.0021,  0.0883, -0.0698,
          0.1463, -0.0151],
        [-0.1162,  0.0673, -0.2301,  0.1612, -0.1472, -0.0447,  0.0671, -0.2915,
          0.3176,  0.2391]], grad_fn=<AddmmBackward0>)

nn.Softmax

神经网络的最后一个线性层返回原始值在[-\infty, \infty]，经过nn.Softmax模块，输出值在[0, 1]，代表了每个类别的预测概率，dim参数表示改维度的值总和为1

softmax = nn.Softmax(dim=1)
pred_probab1 = softmax(values1)
print(pred_probab1)

tensor([[0.1062, 0.1075, 0.0816, 0.1143, 0.0823, 0.0976, 0.1115, 0.0877, 0.1119,
         0.0994],
        [0.0884, 0.1148, 0.0935, 0.1214, 0.0882, 0.0954, 0.1044, 0.0891, 0.1106,
         0.0941],
        [0.0872, 0.1048, 0.0778, 0.1151, 0.0845, 0.0937, 0.1048, 0.0732, 0.1346,
         0.1244]], grad_fn=<SoftmaxBackward0>)

模型参数

使用parameters()和named_parameters()能获取每层的参数,包括weight和bias

print(f'model structure:{model}\n')

for name,param in model.named_parameters():
    print(f'layer:{name}|size"{param.size()}|param:{param[:2]}\n')

#print(model.parameters())

model structure:network(
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (layers): Sequential(
    (0): Linear(in_features=784, out_features=512, bias=True)
    (1): ReLU()
    (2): Linear(in_features=512, out_features=512, bias=True)
    (3): ReLU()
    (4): Linear(in_features=512, out_features=10, bias=True)
  )
)

layer:layers.0.weight|size"torch.Size([512, 784])|param:tensor([[ 0.0122, -0.0204, -0.0185,  ..., -0.0196,  0.0257, -0.0084],
        [-0.0066, -0.0195, -0.0199,  ..., -0.0175, -0.0007,  0.0003]],
       grad_fn=<SliceBackward0>)

layer:layers.0.bias|size"torch.Size([512])|param:tensor([0.0086, 0.0104], grad_fn=<SliceBackward0>)

layer:layers.2.weight|size"torch.Size([512, 512])|param:tensor([[-0.0306, -0.0408,  0.0062,  ...,  0.0289, -0.0164,  0.0099],
        [ 0.0015,  0.0052,  0.0182,  ...,  0.0431, -0.0174,  0.0049]],
       grad_fn=<SliceBackward0>)

layer:layers.2.bias|size"torch.Size([512])|param:tensor([-0.0337,  0.0294], grad_fn=<SliceBackward0>)

layer:layers.4.weight|size"torch.Size([10, 512])|param:tensor([[ 0.0413,  0.0015,  0.0388,  ...,  0.0347,  0.0160,  0.0221],
        [-0.0010,  0.0031,  0.0421,  ..., -0.0226,  0.0340, -0.0220]],
       grad_fn=<SliceBackward0>)

layer:layers.4.bias|size"torch.Size([10])|param:tensor([0.0210, 0.0243], grad_fn=<SliceBackward0>)

---

（四）自动差分 torch.autograd

训练神经网络使用最频繁的算法是反向传播back propagation，参数(model weights)根据损失函数的梯度gradient进行调整。为了计算梯度，pytorch内置了
差分引擎torch.autograd，支持任何一个计算图的梯度计算，以最简单的单层神经网络为例，输入x，参数w和b和一些损失函数，

import torch

x = torch.ones(5)  # 输入张量
y = torch.zeros(3)  # 预期输出
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)
z = torch.matmul(x, w)+b
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)
print(loss)

tensor(2.2890, grad_fn=<BinaryCrossEntropyWithLogitsBackward0>)

张量，函数，计算图

代码定义了如下的计算图 computational graph:

w 和 b 是需要优化的参数，因此需要计算这些变量各自对损失函数的梯度，设置张量的requires_grad属性

可以在创建一个张量的时候设置requires_grad的值，或者之后使用x.requires_grad_(True)方法，用在张量上实现前向传播和反向传播的函数是类Function的实例，反向传播函数存储在张量的grad_fn属性上

print(f'gradient function for z={z.grad_fn}\n')
print(f'gradient function for loss={loss.grad_fn}\n')

gradient function for z=<AddBackward0 object at 0x7fb47069aa30>

gradient function for loss=<BinaryCrossEntropyWithLogitsBackward0 object at 0x7fb47069a250>

计算梯度

为了优化网络参数的权重，需要计算x 和 y固定值下损失函数对各参数的导数 ∂ l o s s ∂ w \frac{\partial loss}{\partial w} ∂w∂loss和 ∂ l o s s ∂ b \frac{\partial loss}{\partial b} ∂b∂loss ，为了计算这些导数，需要调用loss.backward()，通过w.grad和b.grad获取梯度值

loss.backward()
print(w.grad)
print(b.grad)

tensor([[0.3263, 0.0754, 0.3122],
        [0.3263, 0.0754, 0.3122],
        [0.3263, 0.0754, 0.3122],
        [0.3263, 0.0754, 0.3122],
        [0.3263, 0.0754, 0.3122]])
tensor([0.3263, 0.0754, 0.3122])

只能获取计算图叶子节点的grad属性，其requires_grad设置为true，对于其它节点，梯度不可获取；出于性能原因，只能在给定的图形上使用“backward”进行一次梯度计算。如果要在同一个图上执行好几次“backward”调用，将“retain_graph=True”传递给“backward”调用

禁用梯度跟踪

设置requires_grad=True的张量会追踪计算历史并且支持梯度计算，但是某些情况下，不需要这么做，比如模型已经完成训练后，将其应用在输入数据上，只需执行前向传播_forward_，可以通过torch.no_grad()阻止跟踪计算

z = torch.matmul(x,w) + b
print(z.requires_grad)

with torch.no_grad():
    z = torch.matmul(x,w) + b
print(z.requires_grad)

True
False

另一种有同样效果的方法是对张量使用detach()

z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad)

False

禁用梯度跟踪有以下原因：

• 将神经网络中的一些参数标记为frozen parameters，在微调预训练网络中比较常见
• 只进行前向传播中加速计算speed up computations，没有梯度跟踪的向量计算更高效

计算图Computational Graphs

从概念上讲，autograd在由函数对象组成的有向无环图（DAG）中记录数据（张量）和所有执行的操作（以及生成的新张量）。在这个DAG中，叶是输入张量，根是输出张量。通过从根到叶追踪此图，可以使用链式规则自动计算梯度
在前向传播中，autograd自动做两件事：

• 运行请求的操作以计算结果张量
• 在DAG中保留操作的梯度函数_gradient function_

DAG根的.backward()被调用时，autograd ：

• 依照每个.grad_fn计算梯度
• 将其累计到各自张量的.grad属性中
• 使用链式规则传播到叶张量

DAGs are dynamic in PyTorch，图表是从头开始创建的，在调用.backward()后，autograd开始填充新图形，这也是模型中能使用控制流语句的原因，在每次迭代，都可以改变形状，大小和操作

（五）优化模型参数

有了模型和数据后需要通过优化参数进行模型训练，验证和测试。训练模型是一个迭代的过程，每次迭代（也叫一个_epoch_），模型会对输出进行预测，计算预测误差(loss)，收集误差对各参数的导数。使用梯度下降优化这些参数。

之前数据加载和神经网络代码：

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda

train_data = datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor()
)

test_data = datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor()
)

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.layers = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10),
        )

    def forward(self, x):
        x = self.flatten(x)
        values = self.layers(x)
        return values

model = NeuralNetwork()

超参数Hyperparameters

超参数是可调整的参数，用来控制模型优化过程，不同的超参数值能影响模型训练和收敛速度

定义如下的超参数用于训练：

• Number of Epochs：迭代次数
• Batch Size：参数更新前通过网络传播的数据样本数量
• Learning Rate：学习率

learning_rate = 1e-3
batch_size = 64
epochs = 5

优化循环Optimization Loop

一旦设定了超参数，可以通过一个优化循环来训练和优化我们的模型。优化循环的每次迭代称为epoch。每个epoch包括两个主要的部分：

• The Train Loop：迭代训练数据集，并尝试收敛到最佳参数。
• The Validation/Test Loop：迭代测试数据集，检查模型性能是否正在改善。

loss function

当面对一些训练数据时，我们未经训练的网络可能不会给出正确的答案。损失函数衡量获得的结果与目标值的不同程度，我们希望在训练过程中最小化损失函数。为了计算损失，我们使用给定数据样本的输入进行预测，并将其与真实数据标签值进行比较。

普通的损失函数包括适合回归任务的nn.MSELoss（均方误差），适合分类的nn.NLLLoss（负对数似然），nn.CrossEntropyLoss结合了nn.LogSoftmax和nn.NLLLoss。此处使用nn.CrossEntropyLoss

# 初始化损失函数
loss_fn = nn.CrossEntropyLoss()

Optimizer

优化是在每个训练步骤中调整模型参数以减少模型误差的过程。优化算法定义了该过程的执行方式（在本例中使用随机梯度下降）。所有优化逻辑都封装在优化器对象中。这里使用SGD优化器；此外，pytorch中有许多不同的优化器，例如ADAM和RMSProp，它们可以更好地用于不同类型的模型和数据。

# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

训练循环中，优化主要有三个步骤：

• 调用optimizer.zero_grad()重置模型参数的梯度，梯度默认会累积，为了阻止重复计算，在每次迭代都会清零
• 调用loss.backward()进行反向传播
• 一旦有了梯度，就调用optimizer.step()来调整各参数值

训练循环和测试循环

定义train_loop训练优化，定义test_loop评估模型在测试集的表现

def train_loop(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset) # 训练集数据总量
    for number, (x, y) in enumerate(dataloader):
        # number迭代次数，每次迭代输入batch=64的张量(64,1,28,28)
        # 计算预测和误差
        pred = model(x)
        loss = loss_fn(pred, y)

        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if number % 100 == 0:
            # 每迭代100次，输出当前损失函数值及遍历进度
            loss, current = loss.item(), number * len(x) # current当前已经遍历的图像数,len(x)=batch_size
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test_loop(dataloader, model, loss_fn):
    size = len(dataloader.dataset) # 测试集总量
    num_batches = len(dataloader) # 最大迭代次数
    test_loss, correct = 0, 0

    with torch.no_grad():
        for x, y in dataloader:
            pred = model(x)
            test_loss += loss_fn(pred, y).item()
            # 输出如：test_loss=torch.tensor(1.0873)
            # pred.argmax(1)返回值最大值对应的位置，sum()求批量的正确数
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()

    test_loss /= num_batches # 单次迭代的误差总和/总迭代次数=平均误差
    correct /= size # 单次迭代的正确数总和/数据总量=准确率
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

print(len(train_dataloader.dataset))
print(len(train_dataloader))
print(len(test_dataloader.dataset))
print(len(test_dataloader))
x,y = next(iter(train_dataloader))
print(len(x))
print(x.size())
print(y.size())

60000
938
10000
157
64
torch.Size([64, 1, 28, 28])
torch.Size([64])

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

epochs = 2
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(train_dataloader, model, loss_fn, optimizer)
    test_loop(test_dataloader, model, loss_fn)
print("Done!")

Epoch 1
-------------------------------
loss: 1.040251  [    0/60000]
loss: 1.070957  [ 6400/60000]
loss: 0.869483  [12800/60000]
loss: 1.033000  [19200/60000]
loss: 0.908716  [25600/60000]
loss: 0.930925  [32000/60000]
loss: 0.973219  [38400/60000]
loss: 0.913604  [44800/60000]
loss: 0.960071  [51200/60000]
loss: 0.904625  [57600/60000]
Test Error: 
 Accuracy: 67.1%, Avg loss: 0.911718 

Epoch 2
-------------------------------
loss: 0.952776  [    0/60000]
loss: 1.005409  [ 6400/60000]
loss: 0.788150  [12800/60000]
loss: 0.969153  [19200/60000]
loss: 0.852390  [25600/60000]
loss: 0.862806  [32000/60000]
loss: 0.920238  [38400/60000]
loss: 0.863878  [44800/60000]
loss: 0.903000  [51200/60000]
loss: 0.858517  [57600/60000]
Test Error: 
 Accuracy: 68.3%, Avg loss: 0.859433 

Done!

（六）保存和加载模型

最后了解如何通过保存、加载和运行模型预测来保持模型状态。torchvision.models子包包含用于处理不同任务的模型定义，包括：图像分类、像素语义分割、对象检测、实例分割、人物关键点检测、视频分类和光流。

import torch
import torchvision.models as models

保存和加载模型权重

pytorch将学习的参数存储在内部状态字典中，叫做state_dict，这些能通过torch.save方法被保留

# vgg16是一种图像分类的模型结构
import ssl
ssl._create_default_https_context = ssl._create_unverified_context

model = models.vgg16(pretrained=True) # 以vgg16模型为例
torch.save(model.state_dict(), 'model_weights.pth')

要加载模型权重，需要先创建同一模型的实例，然后使用load_state_dict()方法加载参数

model = models.vgg16() # 不指定 pretrained=True,也就是不加载默认参数
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

在预测前一定要先调用model.eval()方法来设置dropout和batch normalization层为评估模型，否则会导致不一致的预测结果

保存和加载模型

加载模型权重时，我们需要首先实例化模型类，因为该类定义了网络的结构。为了将这个类的结构与模型一起保存，可以将model（而不是model.state_dict（））传递给保存的函数：

torch.save(model, 'model.pth')

加载模型：

model = torch.load('model.pth')

这种方法在序列化模型时使用Python的pickle模块，因此它依赖于加载模型时可用的实际类定义。