机器学习&&深度学习——线性回归的从零开始实现

虽然现在的深度学习框架几乎可以自动化实现下面的工作，但从零开始实现可以更了解工作原理，方便我们自定义模型、自定义层或自定义损失函数。

import random
import torch
from d2l import torch as d2l

生成数据集

根据带有噪声的线性模型构造一个人造数据集。任务是使用这个数据集来恢复模型的参数。我们使用低维数据，可以更容易地进行可视化。
在下面代码中，我们生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。我们的数据集是一个1000×2的矩阵X。
$$\begin{gathered} 使用线性模型参数w=[2,-3.4{]}^T、b=4.2和噪声项\delta 生成数据集及标签： \\ y=Xw+b+\delta \end{gathered}$$
其中，δ可以视为模型预测和标签时的潜在观测误差。在这里我们认为标准假设成立，即δ服从均值为0的正态分布。为简化问题，将标准差设为0.01。下面的代码生成合成数据集：

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+δ"""
    # 生成均值为0，标准差为1（标准正态分布）且大小1000*2的数据集
    X = torch.normal(0, 1, (num_examples, len(w)))
    # 生成y函数，生成1000*1的矩阵
    y = torch.matmul(X, w) + b
    # 再加上服从均值为0的正态分布的δ
    y += torch.normal(0, 0.01, y.shape)
    return X, y.reshape((-1, 1))

true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)

其中，features中每一行都包含一个二维数据样本，labels中每一行都包含一个一维标签值（一个标量）。

print('features:', features[0], '\nlabel:', labels[0])

结果：

features: tensor([-0.5829, -0.2094])
label: tensor([3.7491])

通过生成第二个特征features[:, 1]和labels的散点图，可以直观看出两者之间的线性关系：

d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
d2l.plt.show()

读取数据集

训练模型时，要对数据集进行遍历，每次抽取一小批量样本，并使用它们来更新模型。因此，需要定义一个函数，该函数能打乱数据集中的样本并以小批量方式获取数据。
在下面代码中，定义一个data_iter函数，接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。每个小批量包含一组特征和标签。

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))  # 0到999的顺序
    random.shuffle(indices)  # 这些样本是随机读取的，没有特定顺序
    for i in range(0, num_examples, batch_size):
        batch_indices = torch.tensor(
            indices[i: min(i+batch_size, num_examples)]  # 随机取样
        )
        yield features[batch_indices], labels[batch_indices]
        # yield返回一个可以用来迭代for循环的生成器，而不是直接return

通常我们会利用CPU并行运算的优势，处理合理大小的“小批量”。每个样本都可以并行进行模型计算，且每个样本损失函数的梯度也可以被并行计算。
可以直观感受一下小批量运算：读取第一个小批量数据样本并打印：

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

结果：

tensor([[-1.0186, 1.8338],
[ 0.6455, 1.1226],
[-0.5020, 0.2105],
[ 1.3583, 0.6979],
[ 0.3024, -0.8929],
[ 0.4045, -0.4207],
[ 0.5201, -0.3263],
[ 0.6037, -0.1332],
[ 1.6171, 0.2449],
[-0.6540, 1.0338]])
tensor([[-4.0795],
[ 1.6835],
[ 2.5014],
[ 4.5346],
[ 7.8678],
[ 6.4298],
[ 6.3537],
[ 5.8528],
[ 6.6194],
[-0.6216]])

当我们进行迭代时，我们会连续地获得不同的小批量，直到遍历完整个数据集。但上面实现的迭代执行效率很低，可能会出问题。在深度学习框架中实现的内置迭代器效率要高得多，它可以处理存储在文件中的数据和数据流提供的数据

初始化模型参数

通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重，并将偏置初始化为0：

w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

在初始化参数后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。每次更新都需要计算损失函数关于模型参数的梯度，有了这个梯度就可以向减小损失的方向来更新每个参数

定义模型

定义模型，就要将模型的输入和参数同模型的输出关联起来。
而要计算线性模型的输出，只需要计算输入特征X与模型权重w的矩阵-向量乘法后再加上偏置b。（Xw是一个向量，而b是标量）当我们用一个向量加上一个标量时，标量会加到向量的每个分量上（广播机制）：

def linreg(X, w, b):  #@save
    """线性回归模型"""
    return torch.matmul(X, w) + b

定义损失函数

要计算损失函数的梯度，自然要先定义损失函数，下面定义了平方损失函数：

def squared_loss(y_hat, y):  #@save
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

定义优化算法

线性回归是有解析解的，但是其他模型基本没有，因此还是用随机梯度下降法来进行优化。
在每一步中，使用数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来朝着减小损失的方向来更新参数。
下面就是随机梯度下降更新的函数，该函数接受模型参数集合、学习速率和批量大小作为输入。每一步更新的大小由学习率lr决定。因为我们计算的损失是一个批量样本的综合，因此用批量大小batch_size来规范步长，这样步长大小就不会取决于我们对批量大小的选择：

def sgd(params, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()

其中，torch.no_grad()是上下文管理器，用来指定在其内部的代码块中不进行梯度计算。当不需要计算梯度时，使用该上下文管理器可以提高代码执行效率。

训练

在每次迭代中，我们读取一小批训练样本，并通过我们的模型来获得一组预测。计算完损失后，我们开始反向传播，存储每个参数的梯度。最后调用优化算法sgd来更新模型参数。
概括一下，就是执行下面的循环：
1、初始化参数
2、重复一下训练，直到完成：
$$\begin{gathered} 计算梯度g\leftarrow {\partial }_{(w,b)}\frac{1}{|B|}\sum _{i\in B}l(x^{(i)},y^{(i)},w,b) \\ 更新参数(w,b)\leftarrow (w,b)-\eta g \end{gathered}$$
在每个迭代周期中，我们使用deta_iter函数遍历整个数据集，并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。这里的迭代周期个数num_epoches和学习率lr都是超参数，分别设为3和0.03。（超参数设置很麻烦，现在忽略细节）

batch_size = 10
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)  # X和y的小批量损失
        # 因为l形状是(batch_size,1)，不是标量
        # l中所有元素加起来再计算关于[w,b]的梯度
        l.sum().backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

结果：

epoch 1, loss 0.040672
epoch 2, loss 0.000146
epoch 3, loss 0.000047

事实上，真实参数和通过训练得到的参数很接近：

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

结果：

w的估计误差: tensor([ 0.0006, -0.0002], grad_fn=)
b的估计误差: tensor([0.0004], grad_fn=)