PyTorch基础

1. 引言

PyTorch是Facebook团队于2017年1月发布的一个深度学习框架，虽然晚于TensorFlow、Keras等框架，但自发布之日起，其关注度就在不断上升，目前在GitHub上的热度已超过Theano、Caffe、MXNet等框架。

PyTorch是一个建立在Torch库之上的Python包，旨在加速深度学习应用。它提供一种类似Numpy的抽象方法来表征张量（或多维数组），可以利用GPU来加速训练。由于PyTorch采用了动态计算图（Dynamic Computational Graph）结构，且基于tape的Autograd系统的深度神经网络。其他很多框架，比如TensorFlow（TensorFlow2.0也加入了动态网络的支持）、Caffe、CNTK、Theano等，采用静态计算图。使用PyTorch，通过一种称为Reverse-mode auto-differentiation（反向模式自动微分）的技术，可以零延迟或零成本地任意改变你的网络的行为。
Torch是PyTorch中的一个重要包，它包含了多维张量的数据结构以及基于其上的多种数学操作。
自2015年谷歌开源TensorFlow以来，深度学习框架之争越来越激烈，全球多个看重AI研究与应用的科技巨头均在加大这方面的投入。PyTorch从2017年年初发布以来，可谓是异军突起，短时间内取得了一系列成果，成为明星框架。

PyTorch由4个主要的包组成：

$\cdot$torch：类似于Numpy的通用数组库，可将张量类型转换为torch.cuda.TensorFloat，并在GPU上进行计算；

$\cdot$torch.autograd：用于构建计算图形并自动获取梯度的包；

$\cdot$torch.nn：具有共享层和损失函数的神经网络库；

$\cdot$torch.optim：具有通用优化算法（如SGD、Adam等）的优化包。

2. Numpy与Tensor

上一内容介绍了Numpy，了解到其存取数据非常方便，而且还拥有大量的函数，所以深得数据处理、机器学习者喜爱。这节内容将介绍PyTorch的Tensor，它可以是零维（又称为标量或一个数）、一维、二维及多维的数组。Tensor自称为神经网络界的Numpy，它与Numpy相似，二者可以共享内存，且之间的转换非常方便和高效。不过它们也有不同之处，最大的区别就是Numpy会把ndarray放在CPU中进行加速运算，而由Torch产生的Tensor会放在GPU中进行加速运算（假设当前环境有GPU）。

2.1 创建Tensor

创建Tensor的方法有很多，可以从列表或ndarray等类型进行构建，也可根据指定的形状构建。常见的创建Tensor的方法可参考表1。

表1 常见的创建Tensor的方法

import torch
#根据list数据生成Tensor
torch.Tensor([1,2,3,4,5,6])
#根据指定形状生成Tensor
torch.Tensor(2,3)
#根据给定的数组生成Tensor
t=torch.Tensor([[1,2,3],[4,5,6]])
#查看Tensor的形状
t.size()
#shape与size()等价
t.shape
#根据已有形状创建Tensor
torch.Tensor(t.size())

#生成一个单位矩阵
torch.eye(2,2)
#自动生成全是0的矩阵
torch.zeros(2,3)
#根据规则生成数据
torch.linspace(1,10,4)
#生成满足均匀分布随机数
torch.rand(2,3)
#生成满足标准分布随机数
torch.randn(2,3)
#返回所给数据形状相同，值全为0的张量
torch.zeros_like(torch.rand(2,3))

2.2 修改Tensor形状

在处理数据、构建网络层等过程中，经常需要了解Tensor的形状、修改Tensor的形状。与修改Numpy的形状类似，修改Tenor的形状也有很多类似函数，具体可参考表2。

表2 常用修改Tensor形状的函数

#生成一个形状为2x3的矩阵
x = torch.randn(2, 3)
#查看矩阵的形状
x.size()   #结果为torch.Size([2, 3])
#查看x的维度
x.dim()    #结果为2
#把x变为3x2的矩阵
x.view(3,2)
#把x展平为1维向量
y=x.view(-1)  
y.shape
#添加一个维度
z=torch.unsqueeze(y,0)
#查看z的形状
z.size()   #结果为torch.Size([1, 6])
#计算Z的元素个数
z.numel()   #结果为6

torch.view与torch.reshpae的异同
1）reshape()可以由torch.reshape()，也可由torch.Tensor.reshape()调用。但view()只可由torch.Tensor.view()来调用；
2）对于一个将要被view的Tensor，新的size必须与原来的size与stride兼容。否则，在view之前必须调用contiguous()方法；
3）同样也是返回与input数据量相同，但形状不同的Tensor。若满足view的条件，则不会copy，若不满足，则会copy；
4）如果你只想重塑张量，请使用torch.reshape。如果你还关注内存使用情况并希望确保两个张量共享相同的数据，请使用torch.view。

2.3 索引操作

Tensor的索引操作与Numpy类似，一般情况下索引结果与源数据共享内存。从Tensor获取元素除了可以通过索引，也可以借助一些函数，常用的选择函数可参考表3。

表3 常用索引操作函数

设置一个随机种子
torch.manual_seed(100) 
#生成一个形状为2x3的矩阵
x = torch.randn(2, 3)
#根据索引获取第1行，所有数据
x[0,:]
#获取最后一列数据
x[:,-1]
#生成是否大于0的Byter张量
mask=x>0
#获取大于0的值
torch.masked_select(x,mask)
#获取非0下标,即行，列索引
torch.nonzero(mask)
#获取指定索引对应的值,输出根据以下规则得到
#out[i][j] = input[index[i][j]][j]  # if dim == 0
#out[i][j] = input[i][index[i][j]]  # if dim == 1
index=torch.LongTensor([[0,1,1]])
torch.gather(x,0,index)
index=torch.LongTensor([[0,1,1],[1,1,1]])
a=torch.gather(x,1,index)
#把a的值返回到一个2x3的0矩阵中
z=torch.zeros(2,3)
z.scatter_(1,index,a)

2.4 广播机制

广播机制是向量运算的重要技巧。除了Numpy支持广播机制外，PyTorch也支持广播机制。

import torch
import numpy as np
A = np.arange(0, 40, 10).reshape(4, 1)
B = np.arange(0, 3)
#把ndarray转换为Tensor
A1=torch.from_numpy(A)  #形状为4x1
B1=torch.from_numpy(B)  #形状为3
#Tensor自动实现广播
C=A1+B1
#我们可以根据广播机制，手工进行配置
#根据规则1，B1需要向A1看齐，把B变为（1, 3）
B2=B1.unsqueeze(0)  #B2的形状为1x3
#使用expand函数重复数组，分别的4x3的矩阵
A2=A1.expand(4, 3)
B3=B2.expand(4, 3)
#然后进行相加,C1与C结果一致
C1=A2+B3

2.5 逐元素操作

与Numpy一样，Tensor也有逐元素操作（Element-Wise），且操作内容相似，但使用函数可能不尽相同。大部分数学运算都属于逐元素操作，其输入与输出的形状相同。常见的逐元素操作可参考表4。

表4 常见逐元素操作

这些操作均会创建新的Tensor，如果需要就地操作，可以使用这些方法的下划线版本，例如abs_。

t = torch.randn(1, 3)
t1 = torch.randn(3, 1)
t2 = torch.randn(1, 3)
#t+0.1*(t1/t2)
torch.addcdiv(t, 0.1, t1, t2)
#计算sigmoid
torch.sigmoid(t)
#将t限制在[0,1]之间
torch.clamp(t,0,1)
#t+2进行就地运算
t.add_(2)

2.6 归并操作

归并操作顾名思义，就是对输入进行归并或合计等操作，这类操作的输入输出形状一般并不相同，而且往往是输入大于输出形状。归并操作可以对整个Tensor，也可以沿着某个维度进行归并。常见的归并操作可参考表5。

表5 常见归并操作

归并操作一般涉及一个dim参数，指定沿哪个维进行归并。另一个参数是keepdim，说明输出结果中是否保留维度1，缺省情况是False，即不保留。

#生成一个含6个数的向量
a=torch.linspace(0,10,6)
#使用view方法，把a变为2x3矩阵
a=a.view((2,3))
#沿y轴方向累加，即dim=0
b=a.sum(dim=0)   #b的形状为[3]
#沿y轴方向累加，即dim=0,并保留含1的维度
b=a.sum(dim=0,keepdim=True) #b的形状为[1,3]

2.7 比较操作

比较操作一般是进行逐元素比较，有些是按指定方向比较。常用的比较函数可参考表6。

表6 常用的比较函数

x=torch.linspace(0,10,6).view(2,3)
#求所有元素的最大值
torch.max(x)   #结果为10
#求y轴方向的最大值
torch.max(x,dim=0)  #结果为[6,8,10]
#求最大的2个元素
torch.topk(x,1,dim=0)  #结果为[6,8,10],对应索引为tensor([[1, 1, 1])

2.8 矩阵操作

机器学习和深度学习中存在大量的矩阵运算，常用的算法有两种：一种是逐元素乘法，另外一种是点积乘法。PyTorch中常用的矩阵函数可参考表7。

表7 常用矩阵函数

1）Torch的dot与Numpy的dot有点不同，Torch中的dot是对两个为1D张量进行点积运算，Numpy中的dot无此限制；
2）mm是对2D的矩阵进行点积，bmm对含batch的3D矩阵进行点积运算；
3）转置运算会导致存储空间不连续，需要调用contiguous方法转为连续。

a=torch.tensor([2, 3])
b=torch.tensor([3, 4])
torch.dot(a,b)  #运行结果为18
x=torch.randint(10,(2,3))
y=torch.randint(6,(3,4))
torch.mm(x,y)
x=torch.randint(10,(2,2,3))
y=torch.randint(6,(2,3,4))
torch.bmm(x,y)

2.9 PyTorch与Numpy比较

PyTorch与Numpy有很多类似的地方，并且有很多相同的操作函数名称，或虽然函数名称不同但含义相同；当然也有一些虽然函数名称相同，但含义不尽相同。有些很容易混淆，Numpy与Pytorch函数的一些主要区别可参考表8。

表8 Pytorch与Numpy函数对照表

3. 使用Tensor及Autograd实现机器学习

在神经网络中，一个重要内容就是进行参数学习，而参数学习离不开求导，那么PyTorch是如何进行求导的呢？
现在大部分深度学习架构都有自动求导的功能，PyTorch也不例外，torch.autograd包就是用来自动求导的。Autograd包为张量上所有的操作提供了自动求导功能，而torch.Tensor和torch.Function为Autograd的两个核心类，它们相互连接并生成一个有向无环图（DAG）。

本节将使用PyTorch的autograd自动求导包及对应的Tensor，利用自动反向传播来求梯度，无须手工计算梯度。

1）导入需要的库。

import torch
import numpy as np
from matplotlib import pyplot as plt

2）生成训练数据，并可视化数据分布情况。

t.manual_seed(100) 
dtype = t.float
#生成x坐标数据，x为tenor，需要把x的形状转换为100x1
x = t.unsqueeze(torch.linspace(-1, 1, 100), dim=1) 
#生成y坐标数据，y为tenor，形状为100x1，另加上一些噪声
y = 3*x.pow(2) +2+ 0.2*torch.rand(x.size())   
# 画图，把tensor数据转换为numpy数据
plt.scatter(x.numpy(), y.numpy())
plt.show()

3）初始化权重参数。

# 随机初始化参数，参数w、b为需要学习的，故需requires_grad=True
w = t.randn(1,1, dtype=dtype,requires_grad=True)
b = t.zeros(1,1, dtype=dtype, requires_grad=True) 

4）训练模型。

lr =0.001 # 学习率

for ii in range(800):
    # 前向传播，并定义损失函数loss
    y_pred = x.pow(2).mm(w) + b
    loss = 0.5 * (y_pred - y) ** 2
    loss = loss.sum()

    # 自动计算梯度，梯度存放在grad属性中
    loss.backward()

    # 手动更新参数，需要用torch.no_grad()，使上下文环境中切断自动求导的计算
    with t.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad

    # 梯度清零
        w.grad.zero_()
        b.grad.zero_()

5）可视化训练结果。

plt.plot(x.numpy(), y_pred.detach().numpy(),'r-',label='predict')#predict
plt.scatter(x.numpy(), y.numpy(),color='blue',marker='o',label='true') # true data
plt.xlim(-1,1)
plt.ylim(2,6)  
plt.legend()
plt.show()

print(w, b)

运行结果：
tensor([[2.9648]], requires_grad=True) tensor([[2.1145]], requires_grad=True)

4. PyTorch神经网络工具箱

4.1 神经网络核心组件

神经网络看起来很复杂，节点很多，层数多，参数更多。但核心部分或组件不多，把这些组件确定后，这个神经网络基本就确定了。这些核心组件包括：
1）层：神经网络的基本结构，将输入张量转换为输出张量。
2）模型：层构成的网络。
3）损失函数：参数学习的目标函数，通过最小化损失函数来学习各种参数。
4）优化器：如何使损失函数最小，这就涉及优化器。
当然这些核心组件不是独立的，它们之间，以及它们与神经网络其他组件之间有密切关系。为便于读者理解，我们可以把这些关键组件及相互关系，用图1表示。

图1 神经网络关键组件及相互关系示意图

多个层链接在一起构成一个模型或网络，输入数据通过这个模型转换为预测值，然后损失函数把预测值与真实值进行比较，得到损失值（损失值可以是距离、概率值等），该损失值用于衡量预测值与目标结果的匹配或相似程度，优化器利用损失值更新权重参数，从而使损失值越来越小。这是一个循环过程，当损失值达到一个阀值或循环次数到达指定次数，循环结束。

4.2 神经网络工具箱nn

前面我们使用Autograd及Tensor实现机器学习实例时，需要做不少设置，如对叶子节点的参数requires_grad设置为True，然后调用backward，再从grad属性中提取梯度。对于大规模的网络，Autograd太过于底层和烦琐。为了简单、有效解决这个问题，nn是一个有效工具。在nn工具箱中有两个重要模块：nn.Model、nn.functional。

nn中的大多数层（Layer）在functional中都有与之对应的函数。nn.functional中函数与nn.Module中的Layer的主要区别是后者继承Module类，会自动提取可学习的参数。而nn.functional更像是纯函数。两者功能相同，且性能也没有很大区别，那么如何选择呢？像卷积层、全连接层、Dropout层等因含有可学习参数，一般使用nn.Module，而激活函数、池化层不含可学习参数，可以使用nn.functional中对应的函数。

4.2.1 nn.Module

nn.Module是nn的一个核心数据结构，它可以是神经网络的某个层（Layer），也可以是包含多层的神经网络。在实际使用中，最常见的做法是继承nn.Module，生成自己的网络/层。nn中已实现了绝大多数层，包括全连接层、损失层、激活层、卷积层、循环层等，这些层都是nn.Module的子类，能够自动检测到自己的Parameter，并将其作为学习参数，且针对GPU运行进行了cuDNN优化。

4.2.2 nn.functional

nn中的层，一类是继承了nn.Module，其命名一般为nn.Xxx（第一个是大写），如nn.Linear、nn.Conv2d、nn.CrossEntropyLoss等。另一类是nn.functional中的函数，其名称一般为nn.funtional.xxx，如nn.funtional.linear、nn.funtional.conv2d、nn.funtional.cross_entropy等。从功能来说两者相当，基于nn.Moudle能实现的层，使用nn.funtional也可实现，反之亦然，而且性能方面两者也没有太大差异。不过在具体使用时，两者还是有区别，主要区别如下：

1）nn.Xxx继承于nn.Module，nn.Xxx需要先实例化并传入参数，然后以函数调用的方式调用实例化的对象并传入输入数据。它能够很好地与nn.Sequential结合使用，而nn.functional.xxx无法与nn.Sequential结合使用。
2）nn.Xxx不需要自己定义和管理weight、bias参数；而nn.functional.xxx需要自己定义weight、bias参数，每次调用的时候都需要手动传入weight、bias等参数，不利于代码复用。
3）Dropout操作在训练和测试阶段是有区别的，使用nn.Xxx方式定义Dropout，在调用model.eval()之后，自动实现状态的转换，而使用nn.functional.xxx却无此功能。

总的来说，两种功能都是相同的，但PyTorch官方推荐：具有学习参数的（例如，conv2d,linear,batch_norm)采用nn.Xxx方式。没有学习参数的（例如，maxpool、loss func、activation func）等根据个人选择使用nn.functional.xxx或者nn.Xxx方式。

4.3 优化器

PyTorch常用的优化方法都封装在torch.optim里面，其设计很灵活，可以扩展为自定义的优化方法。所有的优化方法都是继承了基类optim.Optimizer，并实现了自己的优化步骤。最常用的优化算法就是梯度下降法及其各种变种，这类优化算法通过使用参数的梯度值更新参数。

使用优化器的一般步骤为：

（1）建立优化器实例
导入optim模块，实例化SGD优化器，这里使用动量参数momentum（该值一般在（0,1）之间），是SGD的改进版，效果一般比不使用动量规则的要好。

import torch.optim as optim
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)

以下步骤在训练模型的for循环中。

（2）向前传播
把输入数据传入神经网络Net实例化对象model中，自动执行forward函数，得到out输出值，然后用out与标记label计算损失值loss。

out = model(img)
loss = criterion(out, label)

（3）清空梯度
缺省情况梯度是累加的，在梯度反向传播前，先需把梯度清零。

optimizer.zero_grad()

（4）反向传播
基于损失值，把梯度进行反向传播。

loss.backward()

（5）更新参数
基于当前梯度（存储在参数的.grad属性中）更新参数。

optimizer.step()

动态修改学习率参数

修改参数的方式可以通过修改参数optimizer.params_groups或新建optimizer。新建optimizer比较简单，optimizer十分轻量级，所以开销很小。但是新的优化器会初始化动量等状态信息，这对于使用动量的优化器（momentum参数的SGD）可能会造成收敛中的震荡。所以，这里直接采用修改参数optimizer.params_groups。
optimizer.param_groups：长度1的list，optimizer.param_groups[0]：长度为6的字典，包括权重参数、lr、momentum等参数。

len(optimizer.param_groups[0])
运行结果：
6

动态修改学习率参数示例：

for epoch in range(num_epoches):
#动态修改参数学习率
    if epoch%5==0:
        optimizer.param_groups[0]['lr']*=0.1
        print(optimizer.param_groups[0]['lr'])
    for img, label in train_loader:
######

4.4 神经网络构建实例

使用PyTorch构建神经网络使用的主要工具（或类）及相互关系如图2所示。如4.2节所述，构建网络层可基于Module类或函数（nn.functional）。

图2 PyTorch实现神经网络的主要工具及相互关系

下面将利用神经网络完成对手写数字进行识别的实例，来说明如何借助nn工具箱来实现一个神经网络，并对神经网络有个直观了解。主要步骤有：

1）利用PyTorch内置函数mnist下载数据集；
2）利用torchvision对数据进行预处理，调用torch.utils建立一个数据迭代器；
3）可视化源数据；
4）利用nn工具箱构建神经网络模型；
5）实例化模型，并定义损失函数及优化器；
6）训练模型；
7）可视化结果。

神经网络的结构如图3所示，使用两个隐含层，每层激活函数为ReLU，最后使用torch.max(out,1)找出张量out最大值对应索引作为预测值。

图3 实例使用的神经网络结构图

4.4.1 数据准备

（1）导入模块

import numpy as np
import torch
# 导入 PyTorch 内置的 mnist 数据
from torchvision.datasets import mnist 
#导入预处理模块
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
#导入nn及优化器
import torch.nn.functional as F
import torch.optim as optim
from torch import nn
#导入画图库
import matplotlib.pyplot as plt

（2）定义超参数

train_batch_size = 64
test_batch_size = 128
learning_rate = 0.01
num_epoches = 20
lr = 0.01
momentum = 0.5

（3）下载数据并对数据进行预处理

#定义预处理函数，这些预处理依次放在Compose函数中。
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize([0.5], [0.5])])
#下载数据，并对数据进行预处理
train_dataset = mnist.MNIST('./data', train=True, transform=transform, download=True)
test_dataset = mnist.MNIST('./data', train=False, transform=transform)
#dataloader是一个可迭代对象，可以想迭代器一样使用。
train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)

1）transforms.Compose可以把一些转换函数组合在一起；
2）Normalize([0.5],[0.5])对张量进行归一化，这里两个0.5分别表示对张量进行归一化的全局平均值和方差。因图像是灰色的只有一个通道，如果有多个通道，需要有多个数字，如3个通道，应该是Normalize([m1,m2,m3],[n1,n2,n3])；
3）download参数控制是否需要下载，如果./data目录下已有MNIST，可选择False；
4）用DataLoader得到生成器，这可节省内存；
5）shuffle=True表示对数据进行打乱操作。

4.4.2 可视化源数据

examples = enumerate(test_loader)
batch_idx, (example_data, example_targets) = next(examples)

fig = plt.figure()
for i in range(6):
  plt.subplot(2,3,i+1)
  plt.tight_layout()
  plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
  plt.title("Ground Truth: {}".format(example_targets[i]))
  plt.xticks([])
  plt.yticks([])
plt.show()

4.4.3 模型构建

（1）构建网络

class Net(nn.Module):
    """
    使用sequential构建网络，Sequential()函数的功能是将网络的层组合到一起
    """
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
        super(Net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d (n_hidden_2))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))

    def forward(self, x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x

（2）实例化网络

#检测是否有可用的GPU，有则使用，否则使用CPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#实例化网络
model = Net(28 * 28, 300, 100, 10)
model.to(device)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)

4.4.4 模型训练

这里使用for循环进行迭代，其中包括对训练数据的训练模型，然后用测试数据的验证模型。

（1）模型训练

# 开始训练
losses = []
acces = []
eval_losses = []
eval_acces = []

for epoch in range(num_epoches):
    train_loss = 0
    train_acc = 0
    #将module设置为训练模式
    model.train()
	#动态修改参数学习率
    if epoch%5==0:
        optimizer.param_groups[0]['lr']*=0.1
    for img, label in train_loader:
        img=img.to(device)
        label = label.to(device)
        img = img.view(img.size(0), -1)
        # 前向传播
        out = model(img)
        loss = criterion(out, label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录误差
        train_loss += loss.item()
        # 计算分类的准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        train_acc += acc

    losses.append(train_loss / len(train_loader))
    acces.append(train_acc / len(train_loader))
    # 在测试集上检验效果
    eval_loss = 0
    eval_acc = 0
	# 将模型改为预测模式（会将所有的training属性设置为False）
    model.eval()
    for img, label in test_loader:
        img=img.to(device)
        label = label.to(device)
        img = img.view(img.size(0), -1)
        out = model(img)
        loss = criterion(out, label)
        # 记录误差
        eval_loss += loss.item()
        # 记录准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        eval_acc += acc

    eval_losses.append(eval_loss / len(test_loader))
    eval_acces.append(eval_acc / len(test_loader))
    print('epoch: {}, Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'
          .format(epoch, train_loss / len(train_loader), train_acc / len(train_loader), 
                     eval_loss / len(test_loader), eval_acc / len(test_loader)))

迭代结果：

epoch:0, Train Loss:0.9885, Train Acc:0.7987, Test Loss:0.5235, Test Acc:0.9073
epoch:1, Train Loss:0.4622, Train Acc:0.9034, Test Loss:0.3412, Test Acc:0.9277
epoch:2, Train Loss:0.3403, Train Acc:0.9208, Test Loss:0.2666, Test Acc:0.9376
epoch:3, Train Loss:0.2761, Train Acc:0.9335, Test Loss:0.2217, Test Acc:0.9458
epoch:4, Train Loss:0.2379, Train Acc:0.9410, Test Loss:0.1946, Test Acc:0.9511
epoch:5, Train Loss:0.2174, Train Acc:0.9467, Test Loss:0.1922, Test Acc:0.9510
epoch:6, Train Loss:0.2137, Train Acc:0.9482, Test Loss:0.1891, Test Acc:0.9517
epoch:7, Train Loss:0.2120, Train Acc:0.9475, Test Loss:0.1872, Test Acc:0.9529
epoch:8, Train Loss:0.2091, Train Acc:0.9487, Test Loss:0.1843, Test Acc:0.9530
epoch:9, Train Loss:0.2067, Train Acc:0.9491, Test Loss:0.1831, Test Acc:0.9530
epoch:10, Train Loss:0.2043, Train Acc:0.9498, Test Loss:0.1841, Test Acc:0.9540
epoch:11, Train Loss:0.2046, Train Acc:0.9498, Test Loss:0.1826, Test Acc:0.9545
epoch:12, Train Loss:0.2037, Train Acc:0.9497, Test Loss:0.1814, Test Acc:0.9542
epoch:13, Train Loss:0.2038, Train Acc:0.9494, Test Loss:0.1813, Test Acc:0.9537
epoch:14, Train Loss:0.2044, Train Acc:0.9500, Test Loss:0.1805, Test Acc:0.9547
epoch:15, Train Loss:0.2034, Train Acc:0.9497, Test Loss:0.1828, Test Acc:0.9536
epoch:16, Train Loss:0.2026, Train Acc:0.9508, Test Loss:0.1815, Test Acc:0.9533
epoch:17, Train Loss:0.2025, Train Acc:0.9504, Test Loss:0.1838, Test Acc:0.9536
epoch:18, Train Loss:0.2034, Train Acc:0.9501, Test Loss:0.1827, Test Acc:0.9542
epoch:19, Train Loss:0.2034, Train Acc:0.9505, Test Loss:0.1804, Test Acc:0.9528

该神经网络的结构比较简单，只用了两层，也没有使用Dropout层，迭代20次，测试准确率达到98%左右，效果还可以。不过，还是有提升空间，如果采用cnn、Dropout等层，应该还可以提升模型性能。

（2）可视化训练及测试损失值

plt.title('trainloss')
plt.plot(np.arange(len(losses)), losses)
plt.legend(['Train Loss'], loc='upper right')
plt.show()

5. PyTorch数据处理工具箱

上节利用PyTorch的torchvision、data等包，下载及预处理MNIST数据集。数据下载和预处理是机器学习、深度学习实际项目中耗时又重要的任务，尤其是数据预处理，关系到数据质量和模型性能，往往要占据项目的大部分时间。好在PyTorch为此提供了专门的数据下载、数据处理包，使用这些包，可极大地提高我们的开发效率及数据质量。

PyTorch涉及数据处理（数据装载、数据预处理、数据增强等）主要工具包及相互关系如图4所示。

图4 PyTorch主要数据处理工具

图4的左边是torch.utils.data工具包，它包括以下4个类。

1）Dataset：是一个抽象类，其他数据集需要继承这个类，并且覆写其中的两个方法（_getitem、len__）；
2）DataLoader：定义一个新的迭代器，实现批量（batch）读取，打乱数据（shuffle）并提供并行加速等功能；
3）random_split：把数据集随机拆分为给定长度的非重叠的新数据集；
4）*sampler：多种采样函数。

图4中间是PyTorch可视化处理工具（Torchvision），其是PyTorch的一个视觉处理工具包，独立于PyTorch，需要另外安装。它包括4个类，各类的主要功能如下。

1）datasets：提供常用的数据集加载，设计上都是继承自torch.utils.data.Dataset，主要包括MMIST、CIFAR10/100、ImageNet和COCO等；
2）models：提供深度学习中各种经典的网络结构以及训练好的模型（如果选择pretrained=True），包括AlexNet、VGG系列、ResNet系列、Inception系列等；
3）transforms：常用的数据预处理操作，主要包括对Tensor及PIL Image对象的操作；
4）utils：含两个函数，一个是make_grid，它能将多张图片拼接在一个网格中；另一个是save_img，它能将Tensor保存成图片。

5.1 utils.data

utils.data包括Dataset和DataLoader。torch.utils.data.Dataset为抽象类，自定义数据集需要继承这个类，并实现两个函数，一个是__len__，另一个是__getitem，前者提供数据的大小（size），后者通过给定索引获取数据和标签。\getitem__一次只能获取一个数据，所以需要通过torch.utils.data.DataLoader来定义一个新的迭代器，实现batch读取。下面定义一个简单的数据集，然后通过具体使用Dataset及DataLoader，获得一个直观的认识。

（1）导入需要的模块。

import torch
from torch.utils import data
import numpy as np

（2）定义获取数据集的类。

该类继承基类Dataset，自定义一个数据集及对应标签。

class TestDataset(data.Dataset):#继承Dataset
    def __init__(self):
        self.Data=np.asarray([[1,2],[3,4],[2,1],[3,4],[4,5]])#一些由2维向量表示的数据集
        self.Label=np.asarray([0,1,0,1,2])#这是数据集对应的标签

    def __getitem__(self, index):
        #把numpy转换为Tensor
        txt=torch.from_numpy(self.Data[index])
        label=torch.tensor(self.Label[index])
        return txt,label 

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

（3）获取数据集中数据。

Test=TestDataset()
print(Test[2])  #相当于调用__getitem__(2)
print(Test.__len__())

输出结果：

(tensor([2, 1]), tensor(0))
5

以上数据以tuple返回，每次只返回一个样本。实际上，Dateset只负责数据的抽取，调用一次__getitem__只返回一个样本。如果希望批量处理（batch），还要同时进行shuffle和并行加速等操作，可选择DataLoader。DataLoader的格式为：

data.DataLoader(
    dataset,
    batch_size=1,
    shuffle=False,
    sampler=None,
    batch_sampler=None,
    num_workers=0,
    collate_fn=<function default_collate at 0x7f108ee01620>,
    pin_memory=False,
    drop_last=False,
    timeout=0,
    worker_init_fn=None,
)

主要参数说明：

dataset：加载的数据集；
batch_size：批大小；
shuffle：是否将数据打乱；
sampler：样本抽样；
num_workers：使用多进程加载的进程数，0代表不使用多进程；
collate_fn：如何将多个样本数据拼接成一个batch，一般使用默认的拼接方式即可；
pin_memory：是否将数据保存在pin memory区，pin memory中的数据转到GPU会快一些；
drop_last：dataset中的数据个数可能不是batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃。

test_loader = data.DataLoader(Test,batch_size=2,shuffle=False,num_workers=0)
for i,traindata in enumerate(test_loader):
    print('i:',i)
    Data,Label=traindata
    print('data:',Data)
    print('Label:',Label)

运行结果：

i: 0
data: tensor([[1, 2],
        [3, 4]])
Label: tensor([0, 1])
i: 1
data: tensor([[2, 1],
        [3, 4]])
Label: tensor([0, 1])
i: 2
data: tensor([[4, 5]])
Label: tensor([2])

可以看出，这是批量读取，可以像使用迭代器一样使用它，比如对它进行循环操作。不过由于它不是迭代器，我们可以通过iter命令将其转换为迭代器。

dataiter=iter(test_loader)
imgs,labels=next(dataiter)

5.2 torchvision

如图4所示，torchvision有4个功能模块：model、datasets、transforms和utils，上文中使用datasets下载了一些经典数据集，本节介绍如何使用datasets的ImageFolder处理数据集，以及如何使用transforms对数据进行预处理、增强等。

5.2.1 ImageFolder

当文件依据标签处于不同文件下时，如：
─── data
├── zhangliu
│ ├── 001.jpg
│ └── 002.jpg
├── wuhua
│ ├── 001.jpg
│ └── 002.jpg
……………..
可以利用torchvision.datasets.ImageFolder来直接构造出dataset：

loader = datasets.ImageFolder(path, transform=None)
loader = data.DataLoader(dataset)

ImageFolder会将目录中的文件夹名自动转化成序列，当DataLoader载入时，标签自动就是整数序列了。

5.2.2 transforms

transforms提供了对PIL Image对象和Tensor对象的常用操作。

（1）对PIL Image的常见操作

Scale/Resize：调整尺寸，长宽比保持不变；
CenterCrop、RandomCrop、RandomSizedCrop：裁剪图片，CenterCrop和RandomCrop在crop时是固定size，RandomResizedCrop则是random size的crop；
Pad：填充；
ToTensor：把一个取值范围是[0,255]的PIL.Image转换成Tensor。形状为（H,W,C）的Numpy.ndarray转换成形状为[C,H,W]，取值范围是[0,1.0]的torch.FloatTensor；
RandomHorizontalFlip：图像随机水平翻转，翻转概率为0.5；
RandomVerticalFlip：图像随机垂直翻转；
ColorJitter：修改亮度、对比度和饱和度。

（2）对Tensor的常见操作

Normalize：标准化，即，减均值，除以标准差；
ToPILImage：将Tensor转为PIL Image。

如果要对数据集进行多个操作，可通过Compose将这些操作像管道一样拼接起来，类似于nn.Sequential。

transforms.Compose([
    #将给定的 PIL.Image 进行中心切割，得到给定的 size，
    #size 可以是 tuple，(target_height, target_width)。
    #size 也可以是一个 Integer，在这种情况下，切出来的图片形状是正方形。            
    transforms.CenterCrop(10),
    #切割中心点的位置随机选取
    transforms.RandomCrop(20, padding=0),
    #把一个取值范围是 [0, 255] 的 PIL.Image 或者 shape 为 (H, W, C) 的 numpy.ndarray，
    #转换为形状为 (C, H, W)，取值范围是 [0, 1] 的 torch.FloatTensor
    transforms.ToTensor(),
    #规范化到[-1,1]
    transforms.Normalize(mean = (0.5, 0.5, 0.5), std = (0.5, 0.5, 0.5))
])

本内容旨在为读者提供PyTorch的一些主要基础内容，仅包含PyTorch完整内容的一部分，欲学习更多PyTorch相关内容，请查看：https://pytorch.org/docs/stable/index.html