动手学PyTorch知识点汇总

2.2 数据操作

在PyTorch中，torch.Tensor是存储和变换数据的主要工具。Tensor和Numpy的多维数组非常类似。然而，Tensor提供GPU计算和自动求梯度等更多功能，这些使得Tensor更加适合深度学习。

‘tensor’这个单词一般可翻译为“张量”，张量可以看作是一个多维数组。标量可以看作0维数组，向量可以看作1维张量，矩阵可以看作是二维张量。

2.2.1 创建Tensor

创建一个5×35\times35×3的未初始化的Tensor：

x=torch.empty(5,3)

创建一个5×35\times35×3的随机初始化的tensor：

x=torch.rand(5,3)

创建一个5×35\times35×3的long型全0的tensor：

x=torch.zeros(5,3,dtype=torch.long)

创建一个对角线都是1，其他全是0的4×44\times44×4矩阵（即单位矩阵）：

x=torch.eye(4)

直接根据数据创建：

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

还可以通过现有的tensor来创建，此方法会默认重用输入tensor的一些属性，例如数据类型，除非自定义数据类型：

#返回的tensor默认具有相同的torch.dtype和torch.device
x=x.new_ones(5,3,dtype=torch.float64)#指定新的数据类型
x=torch.randn_like(x,dtype=torch.float)

我们可以通过shape或size()来获取Tensor的形状：

print(x.size())
print(x.shape)

返回值就是一个tuple，支持所有tuple操作。

2.2.2 操作

本小节介绍Tensor的各种操作。

2.2.2.1 算术操作

在PyTorch中，同一种操作可能有很多种形式，以下用加法作为例子：

形式一：

y=torch.rand(5,3)
print(x+y)

形式二：

print(torch.add(x,y))

还可指定输出：

result=torch.empty(5,3)
torch.add(x,y,out=result)
print(result)

形式三：inplace

# adds x to y
y.add_(x)
print(y)

2.2.2.2 索引

我们还可以使用类似NumPy的索引操作来访问Tensor的一部分，需要注意的是：索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改。

y=x[0,:]
y+=1
print(y)
#两次的输出结果相同，因为源tensor也被改了
print(x[0,:])

2.2.2.3 改变形状

我们可以使用view()来改变Tensor的形状：

y=x.view(15)
z=x.view(-1,5)
print(x.size(),y.size(),z.size())

输出：

注意view()返回的新tensor与源tensor共享内容（其实是同一个tensor），也即更改其中的一个，另外一个也会跟着改变。（顾名思义，view仅仅是改变了对这个张量的观察角度）

如果我们想返回一个真正的新副本（即不共享内存），那么PyTorch还提供了一个reshape()可以改变形状，但是此函数并不能保证返回的是其拷贝，所以不推荐使用。推荐先用clone创造一个副本然后再使用view。

x_cp=x.clone().view(15)
x-=1
print(x)
print(x_cp)

两次的输出不同。（注意，使用clone还有一个好处就是会被记录在计算图中，即梯度回传到副本时也会传到源Tensor）

另外一个常用的函数就是item()，它可以将一个标量Tensor转换成一个Python number：

x=torch.randn(1)
print(x)
print(x.item())

3.1 线性回归

3.1.1 线性回归的基本要素

3.1.1.1 模型定义

3.1.1.2 模型训练

（1）训练数据
（2）损失函数
（3）优化算法
当模型和损失函数较为简单时，上面的误差最小化问题的解可以直接用公式表达出来。这类解叫做解析解（analytical solution）。本节使用的线性回归和平方误差刚好属于这个范畴。然而，大多数深度学习模型并没有解析解，只能通过优化算法有限次迭代模型参数来尽可能降低损失函数的值。这类解叫做数值解（numerical solution）

3.1.1.3 模型预测

3.1.2 线性回归的表示方法

3.1.2.1 神经网络图

3.1.2.2 矢量计算表达式

广义上讲，当数据样本数为nnn，特征数为ddd时，线性回归的矢量计算表达式为：

y^=Xw+b\widehat{y}=Xw+by=Xw+b （1）

其中模型输出y^∈Rn×1\widehat{y}\in\mathbb{R}^{n\times1}y∈Rn×1，批量数据样本特征X∈Rn×dX\in\mathbb{R}^{n\times d}X∈Rn×d，权重w∈Rd×1w\in\mathbb{R}^{d\times1}w∈Rd×1，偏差b∈Rb\in\mathbb{R}b∈R。相应地，批量数据样本标签y∈Rn×1y\in\mathbb{R}^{n\times1}y∈Rn×1。设模型参数θ=[w1,w2,b]T\theta=[w_1,w_2,b]^Tθ=[w1,w2,b]T，我们可以重写损失函数为：

ℓ(θ)=12n(y^−y)T(y^−y)\ell(\theta)=\frac{1}{2n}(\widehat{y}-y)^T(\widehat{y}-y)ℓ(θ)=2n1(y−y)T(y−y) （12）

3.2 线性回归的从零开始实现

3.2.1 生成数据集

画图：

def use_svg_display():#用矢量图表示display.set_matplotlib_formats('svg')def set_figure(figsize=(3.5,2.5)):use_svg_display()#设置图的尺寸plt.rcParams['figure.figsize']=figsize#在../d2lzh_pytorch里面添加上面两个函数后就可以这样导入
#import sys
#sys.path.append("..")
#from d2lzh_pytorch improt *set_figure()
plt.scatter(features[:,1].numpy(),labels.numpy(),1)

3.2.2 读取数据

在训练模型的时候，我们需要遍历数据集并不断读取小批量数据样本（SGD）。这里我们定义一个函数：它每次返回batch_size个随机样本的特征和标签。

#本函数已保存在d2lzh包中方便以后使用
def data_iter(batch_size,features,labels):num_examples=len(features)indices=list(range(num_examples))#打乱样本的读取顺序random.shuffle(indices)for i in range(0,num_examples,batch_size):#最后一次可能不足一个batchj=torch.LongTensor(indices[i:min(i+batch_size,num_examples)])yield features.index_select(0,j),labels.index_select(0,j)

读取第一个小批量数据样本并打印：

batch_size=10
for X,y in data_iter(batch_size, features, labels):print(X,y)break

3.2.3 初始化模型参数

我们将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化为0

w=torch.tensor(np.random.normal(0,0.01,(num_inputs,1)),dtype=torch.float32)
b=torch.zeros(1,dtype=torch.float32)

之后的模型训练中，需要对这些参数求梯度来迭代参数的值，因此我们要让它们的requires_grad=True

w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

3.2.4 定义模型

注意，这里使用mm函数做矩阵乘法

#本函数已保存在d2lzh_pytorch包中方便以后使用
def linreg(X,w,b):return torch.mm(X,w)+b

3.2.5 定义损失函数

#本函数已保存在d2lzh_pytorch包中方便以后使用
#注意这里返回的是向量，另外，pytorch里的MSELoss并没有除以2
def squared_loss(y_hat,y):return (y_hat-y.view(y_hat.size())**2/2

3.2.6 定义优化算法

以下的sgd函数实现了小批量随机梯度下降算法，注意这里的自动求梯度模块计算得来的梯度是一个批量样本的梯度和，我们需要将它除以批量大小来得到平均值：

#本函数已保存在d2lzh_pytorch包中方便以后使用
def sgd(params,lr,batch_size):for param in params:param.data-=lr*param.grad/batch_size

3.2.7 训练模型

训练中我们将多次迭代模型参数。在每次迭代中，我们根据当前读取的小批量数据样本（特征X和标签y），通过调用反向函数backward计算小批量梯度，并调用优化算法sgd迭代模型参数。由于之前设置批量大小batch_size为10，每个小批量的损失l的形状为(10,1)。由于变量l并不是一个标量，所以我们可以调用.sum()将其求和得到一个标量，再运行l.backward()得到该变量有关模型参数的梯度。注意在每次更新完参数后不要忘了将参数的梯度清零。

在一个迭代周期（epoch）中，我们将完整遍历一遍data_iter函数，并对训练数据集中所有样本都使用一次（假设样本数能被批量大小整除）。这里的迭代周期个数num_epoches和学习率lrlrlr都是超参数，分别设为3和0.03。

lr=0.03
num_epochs=3
net=linreg
loss=squared_lossfor epoch in range(num_epochs):for X,y in data_iter(batch_size,features,labels):l=loss(net(X,w,b),y).sum()l.backward()sgd([w,b],lr,batch_size)w.grad.data.zero_()b.grad.data.zero_()train_l=loss(net(features,w,b),labels)print('epoch %d, loss %f' % (epoch+1,train_l.mean().item()))

输出：
比较学到的参数和用来生成训练集的真实参数：

print(true_w,'\n',w)
print(true_b,'\n',b)

输出：

全部代码如下：

import torch
import numpy as np
import random
from matplotlib import pyplot as plt
from IPython import displaytorch.set_default_tensor_type(torch.DoubleTensor)
batch_size=10
num_inputs=2
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=torch.from_numpy(np.random.normal(0,1,(num_examples,num_inputs)))
labels=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
labels+=torch.from_numpy(np.random.normal(0,0.01,size=labels.size()))'''
def use_svg_display():display.set_matplotlib_formats('svg')
def set_figsize(figsize=(3.5, 2.5)):use_svg_display()plt.rcParams['figure.figsize'] = figsize
set_figsize()
plt.scatter(features[:, 1].numpy(), labels.numpy(), 1)
plt.savefig('test.png')
'''def data_iter(batch_size, features, labels):num_examples = len(features)indices = list(range(num_examples))random.shuffle(indices) for i in range(0, num_examples, batch_size):j = torch.LongTensor(indices[i: min(i + batch_size,num_examples)]) yield features.index_select(0, j), labels.index_select(0,j)w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)))
b = torch.zeros(1)w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)'''
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)
'''def linreg(X, w, b): return torch.mm(X, w) + bdef squared_loss(y_hat, y): return (y_hat - y.view(y_hat.size())) ** 2 / 2def sgd(params,lr,batch_size):for param in params:param.data-=lr*param.grad/batch_sizelr=0.03
num_epochs=3
net=linreg
loss=squared_lossfor epoch in range(num_epochs):for X,y in data_iter(batch_size,features,labels):l=loss(net(X,w,b),y).sum()l.backward()sgd([w,b],lr,batch_size)w.grad.data.zero_()b.grad.data.zero_()train_l=loss(net(features,w,b),labels)print(true_w,'\n',w)
print(true_b,'\n',b)

3.3 线性回归的简洁实现

3.3.1 生成数据集

生成数据集的方式和3.2相同

3.3.2 读取数据

PyTorch提供了data包来读取数据。由于data常用作变量名，我们将导入的data模块用Data代替。在每一次迭代中，我们将随机读取包含10个数据样本的小批量。

#将训练数据的特征和标签组合
dataset=Data.TensorDataset(features,labels)
#随机读取小批量
data_iter=Data.DataLoader(dataset,batch_size,shuffle=True)

3.3.3 定义模型

首先，导入torch.nn模块。这里’nn’是neural network的缩写，这个模块定义了大量神经网络的层。nn的核心数据结构是Module，它是一个抽象概念，既可以表示神经网络中的某个层，也可以表示一个包含很多层的神经网络。在实际使用中，最常见的做法是继承nn.Module，撰写自己的网络。一个nn.Module实例应该包含一些层以及返回输出的前向传播forward方法，下面给出如何利用nn.Module实现一个线性回归模型。

class LinearNet(nn.Module):def __init__(self,n_feature):super(LinearNet,self).__init__()self.linear=nn.Linear(n_feature,1)def forward(self,x):y=self.linear(x)return ynet=LinearNet(num_inputs)
#使用print可以打印出网络的结构
print(net)

事实上我们还可以用nn.Sequential来更加方便地搭建网络，Sequantial是一个有序的容器，网络层将按照在传入Sequential的顺序依次被添加到计算图中。

net=nn.Sequential(nn.Linear(num_inputs,1))

net=nn.Sequential()
net.add_module('linear',nn.Linear(num_inputs,1))

查看网络结构：

net=nn.Sequential()
net.add_module('linear',nn.Linear(num_inputs,1))

输出结果：

可以通过net.parameters()来查看模型所有的可学习参数，此函数将返回一个生成器。

for param in net.parameters():print(param)

输出：

作为一个单层神经网络，线性回归输出层的神经元和输入层中各个输入完全连接。因此，线性回归的输出层又叫做全连接层。

注意，torch.nn仅支持一个batch的样本，不支持单个样本输入，如果只有单个样本，可以使用input.unsqueeze(0)来添加一维。

3.3.4 初始化模型参数

我们可以通过torch.nn.init.normal_将权重参数每个元素初始化为随机采样于均值为0、标准差为0.01的正态分布。偏差会初始化为零。

init.normal_(net[0].weight,mean=0,std=0.01)
init.constant_(net[0].bias,val=0)

3.3.5 定义损失函数

PyTorch在nn模块中提供了各种损失函数

loss=nn.MSELoss()

3.3.6 定义优化算法

torch.optim模块提供了很多常用的优化算法比如SGD、Adam和RMSProp等。下面我们创建一个用于net所有参数的优化器实例，并指定学习率为0.03的小批量随机梯度下降（SGD）为优化算法。

optimizer=optim.SGD(net.parameters(),lr=0.03)
print(optimizer)

输出：

我们还可以为不同⼦⽹络设置不同的学习率，这在finetune时经常⽤到。例：

optimizer =optim.SGD([# 如果对某个参数不指定学习率，就使⽤最外层的默认学习率{'params': net.subnet1.parameters()}, # lr=0.03{'params': net.subnet2.parameters(), 'lr': 0.01}], lr=0.03)

调整学习率的方式主要有两种。⼀种是修改 optimizer.param_groups 中对应的学习率，另⼀种是更简单也是较为推荐的做法——新建优化器，由于optimizer⼗分轻量级，构建开销很⼩，故⽽可以构建新的optimizer。但是后者对于使⽤动量的优化器（如Adam），会丢失动量等状态信息，可能会造成损失函数的收敛出现震荡等情况。

# 调整学习率
for param_group in optimizer.param_groups:param_group['lr'] *= 0.1 # 学习率为之前的0.1倍

3.3.7 训练模型

在训练模型时，我们通过调⽤ optim 实例的 step 函数来迭代模型参数。按照⼩批量随机梯度下降的定义，我们在 step 函数中指明批量⼤⼩，从⽽对批量中样本梯度求平均。

num_epochs=3
for epoch in range(1,num_epochs+1):for X,y in data_iter:output=net(X)l=loss(output,y.view(-1,1))optimizer.zero_grad()l.backward()optimizer.step()print('epoch %d,loss: %f' % (epoch,l.item()))

输出：

下面比较学到的模型参数和真实的模型参数，我们从net获得需要的层，并访问其权重weight和偏差bias：

dense=net[0]
print(true_w,dense.weight)
print(true_b,dense.bias)

3.4 SOFTMAX回归

线性回归模型适⽤于输出为连续值的情景。在另⼀类情景中，模型输出可以是⼀个像图像类别这样的离散值。对于这样的离散值预测问题，我们可以使⽤诸如softmax回归在内的分类模型。和线性回归不同，softmax回归的输出单元从⼀个变成了多个，且引⼊了softmax运算使输出更适合离散值的预测和训练。本节以softmax回归模型为例，介绍神经⽹络中的分类模型。

3.4.1 分类问题

考虑⼀个简单的图像分类问题，其输⼊图像的⾼和宽均为2像素，且⾊彩为灰度。这样每个像素值都可以⽤⼀个标量表示。我们将图像中的4像素分别记为x1,x2,x3,x4x_1,x_2,x_3,x_4x1,x2,x3,x4 。假设训练数据集中图像的真实标签为狗、猫或鸡（假设可以⽤4像素表示出这3种动物），这些标签分别对应离散值。

我们通常使⽤离散的数值来表示类别，例如。如此，⼀张图像的标签为1、2和3这3个数值中的⼀个。虽然我们仍然可以使⽤回归模型来进⾏建模，并将预测值就近定点化到1、2和3这3个离散值之⼀，但这种连续值到离散值的转化通常会影响到分类质量。因此我们⼀般使⽤更加适合离散值输出的模型来解决分类问题。

3.4.2 SOFTMAX回归模型

softmax回归跟线性回归⼀样将输⼊特征与权重做线性叠加。与线性回归的⼀个主要不同在于，softmax回归的输出值个数等于标签⾥的类别数。因为⼀共有4种特征和3种输出动物类别，所以权重包含12个标量（带下标的www）、偏差包含3个标量（带下标的bbb），且对每个输⼊o1,o2,o3o_1,o_2,o_3o1,o2,o3计算这3个输出：

下图用神经网络图描述了上面的计算：

既然分类问题需要得到离散的预测输出，⼀个简单的办法是将输出值oio_ioi当作预测类别是的置信度，并将值最⼤的输出所对应的类作为预测输出，即输出argmax⁡ioiarg\max\limits_{i}o_iargimaxoi 。例如，如果o1,o2,o3o_1,o_2,o_3o1,o2,o3分别为0.1，10，0.1，由于o2o_2o2最大，那么预测类别为2，其代表猫。

然⽽，直接使⽤输出层的输出有两个问题。⼀⽅⾯，由于输出层的输出值的范围不确定，我们难以直观上判断这些值的意义。例如，刚才举的例⼦中的输出值10表示“很置信”图像类别为猫，因为该输出值是其他两类的输出值的100倍。但如果o1=o3=103o_1=o_3=10^3o1=o3=103，那么输出值10却⼜表示图像类别为猫的概率很低。另⼀⽅⾯，由于真实标签是离散值，这些离散值与不确定范围的输出值之间的误差难以衡量。

softmax运算符解决了以上两个问题，它通过下式将输出值变换成值为正且和为1的概率分布：

3.4.3 单样本分类的矢量计算表达式

3.4.4 小批量样本分类的矢量计算表达式

3.4.5 交叉熵损失函数

3.4.6 模型预测及评价

在训练好softmax回归模型后，给定任⼀样本特征，就可以预测每个输出类别的概率。通常，我们把预测概率最⼤的类别作为输出类别。如果它与真实类别（标签）⼀致，说明这次预测是正确的。

完整代码如下：

import torch
import numpy as np
import random
import torch.utils.data as Data
import torch.nn as nn
from torch.nn import init
import torch.optim as optimtorch.set_default_tensor_type(torch.DoubleTensor)
batch_size=10
num_inputs=2
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=torch.from_numpy(np.random.normal(0,1,(num_examples,num_inputs)))
labels=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
labels+=torch.from_numpy(np.random.normal(0,0.01,size=labels.size()))dataset=Data.TensorDataset(features,labels)
data_iter=Data.DataLoader(dataset,batch_size,shuffle=True)net=nn.Sequential()
net.add_module('linear',nn.Linear(num_inputs,1))loss=nn.MSELoss()init.normal_(net[0].weight,mean=0,std=0.01)
init.constant_(net[0].bias,val=0)optimizer=optim.SGD(net.parameters(),lr=0.03)num_epochs=3
for epoch in range(1,num_epochs+1):for X,y in data_iter:output=net(X)l=loss(output,y.view(-1,1))optimizer.zero_grad()l.backward()optimizer.step()dense=net[0]
print(true_w,dense.weight)
print(true_b,dense.bias)

3.5 图像分类数据集（FASHION-MNIST）

本节我们将使⽤torchvision包，它主要由以下⼏部分构成：

torchvision.datasets：⼀些加载数据的函数及常⽤的数据集接⼝
torchvision.models：包含常⽤的模型结构（含预训练模型），例如AlexNet、VGG、ResNet等
torchvision.transforms：常⽤的图⽚变换，例如裁剪、旋转等
torchvision.utils：其他的⼀些有⽤的⽅法

3.5.1 获取数据集

下⾯，我们通过torchvision的 torchvision.datasets 来下载这个数据集。第⼀次调⽤时会⾃动从⽹上获取数据。我们通过参数 train 来指定获取训练数据集或测试数据集（testing data set）。测试数据集也叫测试集（testing set），只⽤来评价模型的表现，并不⽤来训练模型。

另外我们还指定了参数 transform = transforms.ToTensor() 使所有数据转换为 Tensor ，如果不进⾏转换则返回的是PIL图⽚。 transforms.ToTensor() 将尺⼨为 (H x W x C) 且数据位于[0, 255]的PIL 图⽚或者数据类型为 np.uint8 的 NumPy 数组转换为尺⼨为 (C x H x W) 且数据类型为 torch.float32 且位于[0.0, 1.0]的 Tensor。

注意：由于像素值为 0 到 255 的整数，所以刚好是 uint8 所能表示的范围，包括transforms.ToTensor() 在内的⼀些关于图⽚的函数就默认输⼊的是uint8型，若不是，可能不会报错但的可能得不到想要的结果。所以，如果⽤像素值(0-255整数)表示图⽚数据，那么⼀律将其类型设置成uint8 ，避免不必要的bug。

mnist_train =
torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',
train=True, download=True, transform=transforms.ToTensor())
mnist_test =
torchvision.datasets.FashionMNIST(root='~/Datasets/FashionMNIST',
train=False, download=True, transform=transforms.ToTensor())

上⾯的 mnist_train 和 mnist_test 都是 torch.utils.data.Dataset 的⼦类，所以我们可以⽤ len() 来获取该数据集的⼤⼩，还可以⽤下标来获取具体的⼀个样本。训练集中和测试集中的每个类别的图像数分别为6,000和1,000。因为有10个类别，所以训练集和测试集的样本数分别为60,000和10,000。

print(type(mnist_train))
print(len(mnist_train),len(mnist_test))

输出结果如下：

我们可以通过下标来访问任意一个样本：

feature, label = mnist_train[0]

变量 feature 对应⾼和宽均为28像素的图像。由于我们使⽤了 transforms.ToTensor() ，所以每个像素的数值为[0.0, 1.0]的32位浮点数。需要注意的是， feature 的尺⼨是 (C x H x W) 的，⽽不是 (Hx W x C)。第⼀维是通道数，因为数据集中是灰度图像，所以通道数为1。后⾯两维分别是图像的⾼和宽。

Fashion-MNIST中⼀共包括了10个类别，分别为t-shirt（T恤）、trouser（裤⼦）、pullover（套衫）、dress（连⾐裙）、coat（外套）、sandal（凉鞋）、shirt（衬衫）、sneaker（运动鞋）、bag（包）和ankle boot（短靴）。以下函数可以将数值标签转成相应的⽂本标签。

3.7 SOFTMAX回归的简洁实现

3.7.1 获取和读取数据

3.7.2 定义和初始化模型

数据返回的每个batch样本 x 的形状为(batch_size, 1, 28, 28), 所以我们要先⽤ view() 将 x 的形状转换成(batch_size, 784)才送⼊全连接层

3.7.3 SOFTMAX和交叉熵损失函数

分开定义softmax运算和交叉熵损失函数可能会造成数值不稳定。因此，PyTorch提供了一个包括softmax运算和交叉熵损失计算的函数。它的数值稳定性更好。