深度学习入门之线性回归(PyTorch)

https://courses.d2l.ai/zh-v2/

线性回归

引入

如何在美国买房

房价预测

一个简化模型

• 假设1：影响房价的关键因素是卧室个数，卫生间个数，和居住面积，记为$x_1,x_2,x_3$
• 假设2：成交价是关键因素的加权和
  $$y=w_1{x}_1+w_2{x}_2+w_3{x}_3+b$$
  权重和偏差的实际值在后面决定
• 给定 n 维输入 $x=[x_1,x_2,...,x_n{]}^T$
• 线性模型有一个 n 维权重和一个标量偏差
  $$w=[w_1,w_2,...,w_n{]}^T,b$$
• 输出是输入的加权和
  $$y=w_1{x}_1+w_2{x}_2+...+w_n{x}_n+b$$
  向量版本：$y=<w,x>+b$

线性模型可以看做是单层神经网络

o1

x1

x2

...

xd

神经网络源于神经科学

模型设计

衡量预估质量

• 比较真实值与预估值，例如房屋售价和估价
• 假设 y 是真实值，$\hat{y}$是估计值，我们可以比较
  $$\theta (y,\hat{y})=\frac{1}{2}(y-\hat{y}{)}^2$$
  这个叫做平方损失

训练数据

• 收集一些数据点来决定参数值（权重和偏差），例如过去6个月卖的房子
• 这被称之为训练数据
• 通常越多越好
• 假设我们有 n 个样本，记
  $X=[x_1,x_2,...,x_n{]}^{T}y=[y_1,y_2,...,y_n]$

同样也是列向量
每一个 yi 就是一个实数的数值

参数学习

• 训练损失
  $$\theta (\mathbf{X},\mathbf{y},\mathbf{w},b)=\frac{1}{2n}\sum _{i=1}^n(y_i-<x_i,w>-b{)}^2=\frac{1}{2n}||\mathbf{y}-\mathbf{X}\mathbf{w}-b|{|}^2$$

1/2 来自于我们的损失函数，1/n 意味着我们要求平均

• 最小化损失来学习参数
  $${\mathbf{w}}^{\ast },{\mathbf{b}}^{\ast }=argmi{n}_{w,b}\theta (\mathbf{X},\mathbf{y},\mathbf{w},b)$$

显示解

这是一个为数不多有最优解的模型

总结

• 线性回归是对n维输入的加权，外加偏差
• 使用平方损失来衡量预测值和真实值的差异
• 线性回归有显示解
• 线性回归可以看做是单层神经网络

基础优化方法

梯度下降

• 挑选一个初始值 $w_0$
• 重复迭代参数t=1,2,3
  $w_t=w_{t-1}-\eta \frac{\partial \theta }{\partial w_{t-1}}$
• 沿梯度方向将增加损失函数值
• 学习率：步长的超参数
  

选择学习率

不能太小，计算梯度是整个模型中最贵的事情
不能太大，使得一直震荡

小批量随机梯度下降

• 在整个训练集上算梯度太贵
  • 一个深度神经网络模型可能需要数分钟至数小时
• 我们可以随机采用 b 个样本$i_1,i_2,...,i_b$来近似损失
  $$\frac{1}{\mathbf{b}}\sum _{\mathbf{i}\in {\mathbf{I}}_{\mathbf{b}}}\theta ({\mathbf{x}}_{\mathbf{i}},{\mathbf{y}}_{\mathbf{i}},\mathbf{w})$$
• b 是批量大小，另一个重要的超参数

选择批量大小

总结

• 梯度下降通过不断沿着反梯度方向更新参数求解
• 小批量随机梯度下降时深度学习默认的求解算法
• 两个重要的超参数是批量大小和学习率

线性回归从零开始实现

我们将从零开始实现整个方法，包括数据流水线、模型、损失函数和小批量随机梯度下降器

导入头文件

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

如果没有 d2l包，使用 pip install d2l 下载

random 随机梯度下降和随机初始化我们的权重

构造数据集

根据带有噪声的线性模型构造一个人造数据集。我们使用线性模型参数 $w=[2,-3.4{]}^T$ 、$b=4.2$ 和噪声项 ϵ 生成数据集及其标签：
$$y=Xw+b+ϵ.$$

def synthetic_data(w, b, num_examples):
	"""生成 y = Xw + b + 噪声。 """
	X = torch.normal(0, 1, (num_examples, len(w))	# 生成均值为0，方差为1的随机数，大小就是n，列数就是w的长度。
	y = torch.matmul(X, w) + b
	y += torch.normal(0, 0.01, y.shape)
	return X, y.reshape((-1, 1))	# 将 x,y 做成列向量返回

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([ 1.4505, -0.4573])
label: tensor([8.6602])

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

把特征的第一列
detach()在某些PyTorch中，需要将其从计算图中剥离出来，才能转换到detach中

读取数据集

定义一个data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。 每个小批量包含一组特征和标签。

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):
        batch_indices = torch.tensor(indices[i:min(i+batch_size, num_examples)])
        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

tensor([[-0.9078, -0.8015],
[ 0.7613, -0.5579],
[ 0.0397, -0.6770],
[ 1.0952, -1.7670],
[-0.9198, -1.1321],
[ 0.9789, 1.2506],
[ 0.0314, -1.5331],
[-0.2363, -1.2308],
[-0.7801, -1.0363],
[-1.4833, -1.8535]])
tensor([[ 5.1170],
[ 7.6031],
[ 6.5763],
[12.4095],
[ 6.2220],
[ 1.9141],
[ 9.4718],
[ 7.9104],
[ 6.1609],
[ 7.5246]])

没有 break 的话，会执行 1000/10=100 次，因为 for 没有跳出条件

设置模型

定义 初始化模型参数

w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)	# normal 正态分布
b = torch.zeros(1, requires_grad=True)

定义模型

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

定义损失函数

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

除以2是为了在后面求导的时候消去
注意这里没有求均值，就直接加起来了

定义优化函数

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

• 上面没有除以batch_size，所以就在下面除了。
• 我们计算的损失是一个批量样本的总和，所有我们用批量大小（batch_size）来归一化步长，这样步长大小就不会取决于我们对批量大小的选择。
• PyTorch 会不断的累计变量的梯度，所以每更新一次参数，我们就要让其梯度清零。

训练

在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。 计算完损失后，我们开始反向传播，存储每个参数的梯度。 最后，我们调用优化算法sgd来更新模型参数。

概括一下，我们将执行以下循环：

初始化参数

重复以下训练，直到完成

计算梯度

更新参数

在每个迭代周期（epoch）中，我们使用data_iter函数遍历整个数据集， 并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。 这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。 设置超参数很棘手，需要通过反复试验进行调整。

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}')

l是向量，每个元素表示一个样本的误差除以批量数，求和是平均误差

print字符串前面加f表示格式化字符串

w = 2
print('%.2f' %w)
print(f'w = {w:.2f}')

2.00
w = 2.00

验证

因为我们使用的是自己合成的数据集，所以我们知道真正的参数是什么。 因此，我们可以通过比较真实参数和通过训练学到的参数来评估训练的成功程度。 事实上，真实参数和通过训练学到的参数确实非常接近。

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

w的估计误差: tensor([4.1199e-04, 2.9087e-05], grad_fn=)
b的估计误差: tensor([0.0002], grad_fn=)

注意，我们不应该想当然地认为我们能够完美地求解参数。 在机器学习中，我们通常不太关心恢复真正的参数，而更关心如何高度准确预测参数。 幸运的是，即使是在复杂的优化问题上，随机梯度下降通常也能找到非常好的解。 其中一个原因是，在深度网络中存在许多参数组合能够实现高度精确的预测。

线性回归的简洁实现

生成数据集

通过使用深度学习框架来简洁地实现 线性回归模型 生成数据集

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

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

读取数据集

我们可以调用框架中现有的API来读取数据。 我们将features和labels作为API的参数传递，并通过数据迭代器指定batch_size。 此外，布尔值is_train表示是否希望数据迭代器对象在每个迭代周期内打乱数据。

def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

batch_size = 10
data_iter = load_array((features, labels), batch_size)

TensorDataset：把输入的两类数据进行一一对应；
DataLoader：重新排序
* 元组拆包符号，表示对 list 解开入参

这里我们使用iter构造Python迭代器，并使用next从迭代器中获取第一项。

next(iter(data_iter))

[tensor([[-0.4029, 0.1229],
[ 0.7648, -0.5334],
[-1.4805, -0.4086],
[-1.3591, -1.6593],
[-0.5733, 0.7504],
[ 0.8677, -0.5437],
[ 0.5396, 1.8577],
[ 0.7859, 0.4730],
[-0.2203, 2.4962],
[ 0.2515, -0.2374]]),
tensor([[ 2.9878],
[ 7.5485],
[ 2.6326],
[ 7.1093],
[ 0.5252],
[ 7.7728],
[-1.0352],
[ 4.1356],
[-4.7182],
[ 5.5096]])]

定义模型

使用框架预定义好的层

\quad 我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。 在下面的例子中，我们的模型只包含一个层，因此实际上不需要Sequential。 但是由于以后几乎所有的模型都是多层的，在这里使用Sequential会让你熟悉“标准的流水线”。

\quad 在PyTorch中，全连接层在Linear类中定义。 值得注意的是，我们将两个参数传递到nn.Linear中。 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。

# nn是神经网络的缩写
from torch import nn

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

初始化模型参数

\quad 在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 深度学习框架通常有预定义的方法来初始化参数。 在这里，我们指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样， 偏置参数将初始化为零。
\quad 正如我们在构造nn.Linear时指定输入和输出尺寸一样， 现在我们能直接访问参数以设定它们的初始值。 我们通过net[0]选择网络中的第一个图层， 然后使用weight.data和bias.data方法访问参数。 我们还可以使用替换方法normal_和fill_来重写参数值。

net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

tensor([0.])

定义损失函数

计算均方误差使用的是MSELoss类，也称为平方 $L_2$ 范数。 默认情况下，它返回所有样本损失的平均值。

loss = nn.MSELoss()

定义优化算法

小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 当我们实例化一个SGD实例时，我们要指定优化的参数 （可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。 小批量随机梯度下降只需要设置lr值，这里设置为0.03。

trainer = torch.optim.SGD(net.parameters(), lr=0.03)

L1 范数就是算数差，L2范数就是平方差
SGD：stochastic gradient descent 随机梯度下降

训练

通过深度学习框架的高级API来实现我们的模型只需要相对较少的代码。 我们不必单独分配参数、不必定义我们的损失函数，也不必手动实现小批量随机梯度下降。 当我们需要更复杂的模型时，高级API的优势将大大增加。 当我们有了所有的基本组件，训练过程代码与我们从零开始实现时所做的非常相似。

回顾一下：在每个迭代周期里，我们将完整遍历一次数据集（train_data）， 不停地从中获取一个小批量的输入和相应的标签。 对于每一个小批量，我们会进行以下步骤:

通过调用net(X)生成预测并计算损失l（前向传播）。

通过进行反向传播来计算梯度。

通过调用优化器来更新模型参数。

为了更好的衡量训练效果，我们计算每个迭代周期后的损失，并打印它来监控训练过程。

num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X) ,y)
        trainer.zero_grad()
        l.backward()	# PyTorch 已经帮我们做了sum，不需要我们自己去做了
        trainer.step()	# 更新权重和偏差
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {l:f}')

epoch 1, loss 0.000334
epoch 2, loss 0.000100
epoch 3, loss 0.000100

QA

1. 对学生党比较便宜的平台？
   Google Colab
2. 为什么用平方损失，不用绝对差值？
   绝对差值在零点的时候导数会有一点难求
   实际上没啥区别
3. 损失需要求平均嘛？
   不求平均的话，梯度数值会比较大。。
   如果用随机梯度下降的话，可以把学习率除个n。
   除以n，可以使学习率比较好调，不受样本参数大小影响。
4. 物理实验中经常使用 n-1 代替 n 求误差，这里求误差可以用 n-1 代替 n 嘛？
   除谁都没关系，我们不关心。我们关心的只是最小化损失。

物理中除以 n-1，是为了让样本的期望等于总体期望。这里最小化损失，无所谓。

5. 如何找一个合适的学习率？
   5.1 找到一个对学习率不那么敏感的算法，比如说Adam，这种比较smooth。
   5.2 可以通过合理的参数初始化
6. batchsize 是否会最终影响模型结果？
   batchsize 其实越小越好。
   因为随机梯度下降理论上会带来噪音，但噪音对于深度神经网络是一件好事情，防止过拟合。
7. 过拟合和欠拟合情况下，学习率和批次如何进行调整？
   理论上学习率和批量大小不会影响到最后的收敛结果，但实际上由于误差，会有一点影响。
8. 针对batchsize大小的数据集进行网络训练的时候，网络中每个参数更新时减去的梯度是batchsize中每个样本对应参数梯度求和后取得的平均值嘛？
   是的，梯度是一个线性的，损失函数是每个样本相加，等价于每个样本求梯度取均值。
9. detach()的作用？
   所有的运算子会自动加入到计算图求梯度，detach可以把不需要求梯度的运算分离。
10. 这里使用生成器生成数据有什么优势，相比return？
    不需要把所有的 batch 生成好，Python习惯用iter
11. 如果样本大小不是批量数的整数倍，需要随机剔除多余的样本吗？
    11.1 保留
    11.2 舍弃
    11.3 从下一个 epoch 中补全
12. 外层 for 循环最后一行 l=loss(net(), labels)就是为了print吗？这里的梯度要不要清零？
    因为我们只让它forward，没有backward，更新梯度，所以不需要梯度清零。