本文章来源于对李沐动手深度学习
代码以及原理的理解,并且由于李沐老师的代码能力很强,以及视频中讲解代码的部分较少,所以这里将代码进行尽量逐行详细解释
并且由于pytorch的语法有些小伙伴可能并不熟悉,所以我们会采用逐行解释+小实验的方式来给大家解释代码
tips:本文需要下载d2l包,大家可以按照以下指令下载
pip install d2l
导入模块
%matplotlib inline
import random
import torch
from d2l import torch as d2l
这里如果有报错说模块不存在的话,可以自行pip install下载
生成数据集
这一次我们的任务是线性回归,所以为了简单起见,我们根据带有噪声的线性模型构造一个人造数据集。而我们的任务是通过我们生成的人造数据集来恢复这个模型的参数
我们会生成1000个样本的数据集,每个样本包含从标准正太分布中采样的两个特征
y
=
X
w
+
b
+
ϵ
y = Xw + b + \epsilon
y=Xw+b+ϵ
其中
ϵ
\epsilon
ϵ表示模型预测和标签时候的潜在误差,也就是我们俗称的噪声,并且满足
ϵ
−
N
(
0
,
0.0
1
2
)
\epsilon- N(0,0.01^2)
ϵ−N(0,0.012)
生成人工数据集
def synthetic_data(w, b, num_examples): #@save
"""生成y=Xw+b+噪声"""
X = torch.normal(0, 1, (num_examples, len(w)))
y = torch.matmul(X, w) + b
y += torch.normal(0, 0.01, y.shape)
return X, y.reshape((-1, 1))
对于这一段代码,让我们难以理解的无非就是torch.normal
和torch.matmul
两个函数了,这两个函数我们会在下面的小实验部分进行讲解,我们暂时跳过这两个函数,我们可以发现这个函数其实主要是为了生成一个人工数据集
并且采用的方式是找到满足满足我们给定w和b的参数,并且添加一个均值为0,标准差为0.01的一个噪声,将噪声和我们原本正确的y进行组合,也就得到了我们的标签
小实验
我们可以针对这两个函数做个小实验
x = torch.normal(0,1,size=(2,3))
x
>>> tensor([[-0.7975, -0.0837, 0.7249],
[-0.2106, -0.2072, -2.9369]])
我们可以看出torch.normal
函数是生成一个均值为0,方差为1,并且size为两行三列的一个tensor数据类型
y = torch.normal(0,1,size=(3,2))
y
>>> tensor([[ 0.1762, -2.0809],
[ 1.1579, -0.5423],
[ 0.5573, -0.4598]])
z = torch.matmul(x,y)
z
>>> tensor([[ 0.1665, 1.3716],
[-1.9135, 1.9008]])
从下面的这个就不难看出,torch.matmul
函数是做两个矩阵的乘法,我们可以看到x是一个2×3的矩阵,y是一个3×2的矩阵,所以矩阵乘法出来的z矩阵应该是和一个2×2的矩阵,我们可以稍微验证一下元素是否正确,就用z矩阵的第一行第一列个元素进行验证:
−
0.7975
∗
0.1762
+
−
0.0837
∗
1.1579
+
0.7249
∗
0.5573
-0.7975*0.1762 + -0.0837*1.1579 + 0.7249*0.5573
−0.7975∗0.1762+−0.0837∗1.1579+0.7249∗0.5573的值正好等于0.1665
设置正确的w和b
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
在这个代码里面,我们调用上面的函数,我们假定需要恢复的参数就是w = [2,-3.4]
b = 4.2
注意,[features中的每一行都包含一个二维数据样本, labels中的每一行都包含一维标签值(一个标量)]
因为我们的w是一个1×2的一个矩阵,代表着一个样本有两个特征
训练集可视化
d2l.set_figsize()
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1);
数据迭代器/小批量梯度下降
def data_iter(bach_size,features,labels):
nums_examples = len(features)
indices = list(range(nums_examples)) # 生成index
# shuffle函数打乱顺序,以便于随机小批量抽取
random.shuffle(indices)
for i in range(0,nums_examples,batch_size):
batch_indices = torch.tensor(indices[i:min(i+batch_size,nums_examples)]) # 进行抽取,每次抽取batch_size个元素,并且不可以超过边界
yield features[batch_indices],labels[batch_indices]
batch_size = 10
for X,y in data_iter(batch_size,features,labels):
print(X,'\n',y)
break
逐行理解代码/小实验
小实验1
nums_examples = len(features)
这一段代码可以让得到features的个数,我们可以做一个小实验
我们根据上下文的代码,可以找到features的定义在synthetic_data
函数中,我们可以找到相关的代码,并且进行打印
features,labels = synthetic_data(true_w,true_b,1000)
print(len(features))
>>> 1000
通过这个小实验,我们可以发现在我们的这个代码的features就是我们设置的1000,也就是说我们具有1000个训练样本
小实验二
indices = list(range(nums_examples)) # 生成index
# shuffle函数打乱顺序,以便于随机小批量抽取
random.shuffle(indices)
在这个小部分里面,可能让我们有一定理解困难的地方在于我们为什么要生成indices这个参数
因为在这里我们需要实现的是一个小批量的梯度下降,所以我们需要对所有的数据进行一个随机抽取一个小批量的数据,于是我们采用的方式是随机抽取这些数据的下标,这样我们后面直接索引下标就可以索引到随机的数据了
小实验三
for i in range(0,nums_examples,batch_size):
batch_indices = torch.tensor(indices[i:min(i+batch_size,nums_examples)]) # 进行抽取,每次抽取batch_size个元素,并且不可以超过边界
yield features[batch_indices],labels[batch_indices]
这一小段的代码不难理解,也就是我们利用上面随机找出来的下标,对这些数据进行索引,也许有的小伙伴不是特别理解yield的用法,在这里我也不详细展开了,我们可以把它理解成一个迭代器
初始化权重
w = torch.normal(0,0.01,size=(2,1),requires_grad = True) # 由于特征是(1,2)的,所以w是(2,1)
b = torch.zeros(1,requires_grad=True)
这一段代码是利用torch.normal
来生成一个均值为0,标准差为0.01,大小规格为(2,1)的w,以及大小为一个标量的b
需要解释的是有关于requires_grad
的参数选项,这个参数在torch里面我们称呼它为自动求导,下面我们对自动求导操作进行解释
自动求导小实验
所谓自动求导,也就是在我们训练模型的时候需要做的梯度下降操作里面,计算梯度的操作。我们来做一个小实验来看看自动求导是实现了一个怎么样的功能
首先我们已经知道常数的梯度一定是0,于是我们可以做以下操作:
import torch
x = torch.arange(4.0)
x
>>> tensor([0., 1., 2., 3.])
x.requires_grad_(True)
x.grad
>>> None
接下来,我们用一个函数来试试自动求导
y
=
x
T
x
−
−
−
(
1
)
d
y
d
x
=
2
x
2
−
−
−
(
2
)
y = x^Tx---(1) \\\\ \frac{dy}{dx} = 2x^2---(2)
y=xTx−−−(1)dxdy=2x2−−−(2)
并且我们利用上面的例子
x
=
[
0
,
1
,
2
,
3
]
x =[0 ,1 ,2 ,3]
x=[0,1,2,3] 于是我们可以自己先动手计算一下x和x之间的内积,也就是
0
2
+
1
2
+
2
2
+
3
2
=
1
+
4
+
9
=
14
0^2+1^2+2^2+3^2=1+4+9=14
02+12+22+32=1+4+9=14
import torch
x = torch.arange(4.0)
y = 2*torch.dot(x,x)
>>> 28 # 这个结果没有问题,和我们预想的结果是一样的
y.backward()
x.grad()
>>> tensor([ 0., 4., 8., 12.])
接下来我们就来解释一下上面这段代码是在做一个怎么样的东西,首先我们利用y.backward()
来确定是对y函数来呈现梯度计算,然后相对于x的每一个维度算出来的导数都会存在于x.grad()
中,我们可以利用数学验证来进行验证,我们利用(2)公式可以计算到y的导数是
x
2
x^2
x2,所以当x为[0,1,2,3]的时候,它的导数应该是[0,1,4,6],然后我们还有系数2,也就是导数为[0,4,8,12],与代码运行结果一样
定义线性回归模型
def linreg(X,w,b):
# 线性回归模型,这里实际上也就是在求预测的y
return torch.matmul(X,w)+b
这里的代码解释性不多,我们只需要了解线性回归的公式即可也就是如下
y
=
X
w
+
b
y = Xw+b
y=Xw+b
定义损失函数
def squared_loss(y_hat,y,batch_size):
# 均方误差
return (y_hat - y.reshape(y_hat.shape))**2 / 2*batch_size
这里我们定义损失函数的公式如下
L
o
s
s
=
1
2
b
a
t
c
h
s
i
z
e
∑
n
=
1
N
(
y
^
−
y
)
2
Loss=\frac{1}{2batchsize}\sum_{n=1}^\N (\widehat{y}-y)^2
Loss=2batchsize1n=1∑N(y
−y)2
定义梯度下降函数
def sgd(params,lr,batch_size): # lr是学习率
with torch.no_grad():
for param in params:
param -= lr*param.grad
param.grad.zero_()
我们这里采用的是随机梯度下降算法,后面我们还会说很多梯度下降的算法,也就是
w
=
w
−
α
∂
L
o
s
s
∂
w
w = w - \alpha\frac{\partial Loss}{\partial w}
w=w−α∂w∂Loss
b参数也是同理
需要注意的是,我们每一次sgd的时候都需要做一次param.grad.zero_()
这是因为torch模块不会帮我们把梯度清零,如果不清零的话,会导致每一次的梯度进行累加
实现训练
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss
for epoch in range(num_epochs):
for X,y in data_iter(batch_size,features,labels):
l = loss(net(X,w,b),y) # 将预测的y和真实的y做一个损失函数
l.sum().backward()
sgd([w,b],lr,batch_size)
with torch.no_grad():
train_1 = loss(net(features,w,b),labels)
print(f'epoch:{epoch+1},loss:{float(train_1.mean())}')
>>> epoch:1,loss:5.127940312377177e-05
epoch:2,loss:5.1275070291012526e-05
epoch:3,loss:5.1159211579943076e-05