基于Pytorch深度学习——线性回归

本文章来源于对李沐动手深度学习代码以及原理的理解，并且由于李沐老师的代码能力很强，以及视频中讲解代码的部分较少，所以这里将代码进行尽量逐行详细解释
并且由于pytorch的语法有些小伙伴可能并不熟悉，所以我们会采用逐行解释+小实验的方式来给大家解释代码

tips:本文需要下载d2l包，大家可以按照以下指令下载

pip install d2l

导入模块

%matplotlib inline
import random
import torch
from d2l import torch as d2l

这里如果有报错说模块不存在的话，可以自行pip install下载

生成数据集

这一次我们的任务是线性回归，所以为了简单起见，我们根据带有噪声的线性模型构造一个人造数据集。而我们的任务是通过我们生成的人造数据集来恢复这个模型的参数
我们会生成1000个样本的数据集，每个样本包含从标准正太分布中采样的两个特征
$$y=Xw+b+ϵ$$
其中$ϵ$表示模型预测和标签时候的潜在误差，也就是我们俗称的噪声，并且满足
$$ϵ-N(0,0.01^2)$$

生成人工数据集

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\ast 0.1762+-0.0837\ast 1.1579+0.7249\ast 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

接下来，我们用一个函数来试试自动求导
$$\begin{gathered} y=x^{T}x---(1) \\ \frac{dy}{dx}=2x^2---(2) \end{gathered}$$
并且我们利用上面的例子$x=[0,1,2,3]$ 于是我们可以自己先动手计算一下x和x之间的内积，也就是$0^2+1^2+2^2+3^2=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为[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=Xw+b$$

定义损失函数

def squared_loss(y_hat,y,batch_size):
    # 均方误差
    return (y_hat - y.reshape(y_hat.shape))**2 / 2*batch_size

这里我们定义损失函数的公式如下
$$Loss=\frac{1}{2batchsize}\sum _{n=1}^{\mathbb{N}}(\hat{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-\alpha \frac{\partial Loss}{\partial w}$$
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