1、线性回归基本概念
回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。
给定一个数据集，我们的目标是寻找模型的权重和偏置， 使得根据模型做出的预测大体符合数据里的真实价格。 输出的预测值由输入特征通过线性模型的仿射变换决定，仿射变换由所选权重和偏置确定。
当我们的输入包含
d
d
d 个特征时，我们将预测结果
y
^
\hat{y}
y^（通常使用“尖角”符号表示
y
y
y 的估计值）表示为：
y
^
=
w
1
x
+
.
.
.
+
w
d
x
d
+
b
\hat{y} = w_1x+...+w_dx_d+b
y^=w1x+...+wdxd+b
将所有特征放到向量
x
∈
R
d
x\in\mathbb{R^d}
x∈Rd 中， 并将所有权重放到向量
x
∈
R
d
x\in\mathbb{R^d}
x∈Rd中， 我们可以用点积形式来简洁地表达模型：
y
^
=
w
T
x
+
b
\hat{y}=\bold{w^Tx}+b
y^=wTx+b
对于特征集合
X
\bold{X}
X，预测值
y
^
∈
R
n
\hat{y}\in\mathbb{R^n}
y^∈Rn 可以通过矩阵-向量乘法表示为：
y
^
=
X
w
+
b
\hat{y}=\bold{Xw}+b
y^=Xw+b
参考文章：3.1. 线性回归
2、线性回归的从零开始实现
导入包
%matplotlib inline
import random
import torch
from d2l import torch as d2l
1. 生成数据集
首先，构建一个线性模型，这个线性模型中会加上噪声干扰。在下面的代码中，我们生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征。 我们的合成数据集是一个矩阵 𝐗∈ℝ1000×2。
我们使用线性模型参数
w
=
[
2
,
−
3.4
]
⊤
\mathbf{w} = [2, -3.4]^\top
w=[2,−3.4]⊤、
b
=
4.2
b = 4.2
b=4.2
和噪声项
ϵ
\epsilon
ϵ生成数据集及其标签：
y
=
X
w
+
b
+
ϵ
.
\mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon.
y=Xw+b+ϵ.
ϵ
\epsilon
ϵ：模型预测和标签时的潜在观测误差。
在这里我们认为标准假设成立，即
ϵ
\epsilon
ϵ 服从均值为0的正态分布。为了简化问题，我们将标准差设为0.01。
def synthetic_data(w, b, num_examples): #@save
"""生成y=Xw+b+噪声"""
X = torch.normal(0, 1, (num_examples, len(w))) # 生成均值为0，方差为1的正态分布数据，数据的规格为 num_examples×len(w)，即样本数量×特征数量
y = torch.matmul(X, w) + b # y = wx + b
y += torch.normal(0, 0.01, y.shape) # 生成一个规格大小与y相同的正态分布数据作为噪声
return X, y.reshape((-1, 1))
使用定义的函数生成数据
# 真实的w和b的值
true_w = torch.tensor([2, -3.4])
true_b = 4.2
# 以真实的w和b的值为参数，生成1000个数据
features, labels = synthetic_data(true_w, true_b, 1000)
# 查看生成的数据，其中features相当于生成的X数据，labels相当于生成的Y数据
print('features:', features[0],'\nlabel:', labels[0])
# 通过生成第二个特征`features[:, 1]`和`labels`的散点图，可以直观观察到两者之间的线性关系。
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1);
2. 读取数据集
在下面的代码中，我们定义一个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_size读取从0~num_examples的数据
batch_indices = torch.tensor(
indices[i: min(i + batch_size, num_examples)]) # 使用min()控制读取时候不越界
yield features[batch_indices], labels[batch_indices]
通常，我们利用GPU并行运算的优势，处理合理大小的“小批量”。 每个样本都可以并行地进行模型计算，且每个样本损失函数的梯度也可以被并行计算。 GPU可以在处理几百个样本时，所花费的时间不比处理一个样本时多太多。
我们直观感受一下小批量运算：读取第一个小批量数据样本并打印。 每个批量的特征维度显示批量大小和输入特征数。 同样的，批量的标签形状与batch_size相等。
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
当我们运行迭代时，我们会连续地获得不同的小批量，直至遍历完整个数据集。 上面实现的迭代对教学来说很好，但它的执行效率很低，可能会在实际问题上陷入麻烦。 例如，它要求我们将所有数据加载到内存中，并执行大量的随机内存访问。 在深度学习框架中实现的内置迭代器效率要高得多， 它可以处理存储在文件中的数据和数据流提供的数据。
3. 初始化模型参数
在我们开始用小批量随机梯度下降优化我们的模型参数之前，我们需要先有一些参数。在下面的代码中，我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重，并将偏置初始化为0。
# 初始化w和b准备
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
在初始化参数之后，我们的任务是更新这些参数，直到这些参数足够拟合我们的数据。 每次更新都需要计算损失函数关于模型参数的梯度。 有了这个梯度，我们就可以向减小损失的方向更新每个参数。
4. 定义模型
接下来，我们必须定义模型，将模型的输入和参数同模型的输出关联起来。
def linreg(X, w, b): #@save
"""线性回归模型"""
return torch.matmul(X, w) + b
5. 定义损失函数
因为需要计算损失函数的梯度，所以我们应该先定义损失函数，在这里我们使用平方损失函数。
l
(
i
)
(
w
,
b
)
=
1
2
(
y
^
(
i
)
−
y
(
i
)
)
2
.
l^{(i)}(\mathbf{w}, b) = \frac{1}{2} \left(\hat{y}^{(i)} - y^{(i)}\right)^2.
l(i)(w,b)=21(y^(i)−y(i))2.
def squared_loss(y_hat, y): #@save
"""均方损失"""
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2 # 在这里没有除以总数变成均值，在调用时候会除以。
y.reshape(y_hat.shape)：将y转化为与y_hat相同的规格。
6. 定义优化算法
尽管线性回归有解析解，但本书中的其他模型却没有。这里我们介绍小批量随机梯度下降（SGD）。
在每次迭代中，我们首先随机抽样一个小批量
B
\mathcal{B}
B，它是由固定数量的训练样本组成的。
然后，我们计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。
最后，我们将梯度乘以一个预先确定的正数
η
\eta
η，并从当前参数的值中减掉。
我们用下面的数学公式来表示这一更新过程（ ∂ \partial ∂表示偏导数）：
( w , b ) ← ( w , b ) − η ∣ B ∣ ∑ i ∈ B ∂ ( w , b ) l ( i ) ( w , b ) . (\mathbf{w},b) \leftarrow (\mathbf{w},b) - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b). (w,b)←(w,b)−∣B∣ηi∈B∑∂(w,b)l(i)(w,b).
总结一下，算法的步骤如下：
（1）初始化模型参数的值，如随机初始化；
（2）从数据集中随机抽取小批量样本且在负梯度的方向上更新参数，并不断迭代这一步骤。
对于平方损失和仿射变换，我们可以明确地写成如下形式:
w ← w − η ∣ B ∣ ∑ i ∈ B ∂ w l ( i ) ( w , b ) = w − η ∣ B ∣ ∑ i ∈ B x ( i ) ( w ⊤ x ( i ) + b − y ( i ) ) , b ← b − η ∣ B ∣ ∑ i ∈ B ∂ b l ( i ) ( w , b ) = b − η ∣ B ∣ ∑ i ∈ B ( w ⊤ x ( i ) + b − y ( i ) ) . \begin{aligned} \mathbf{w} &\leftarrow \mathbf{w} - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_{\mathbf{w}} l^{(i)}(\mathbf{w}, b) = \mathbf{w} - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \mathbf{x}^{(i)} \left(\mathbf{w}^\top \mathbf{x}^{(i)} + b - y^{(i)}\right),\\ b &\leftarrow b - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_b l^{(i)}(\mathbf{w}, b) = b - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \left(\mathbf{w}^\top \mathbf{x}^{(i)} + b - y^{(i)}\right). \end{aligned} wb←w−∣B∣ηi∈B∑∂wl(i)(w,b)=w−∣B∣ηi∈B∑x(i)(w⊤x(i)+b−y(i)),←b−∣B∣ηi∈B∑∂bl(i)(w,b)=b−∣B∣ηi∈B∑(w⊤x(i)+b−y(i)).
在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来，朝着减少损失的方向更新我们的参数。
下面的函数实现小批量随机梯度下降更新。该函数接受模型参数集合、学习速率和批量大小作为输入。每一步更新的大小由学习速率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_() # 梯度清0
7. 训练
现在我们已经准备好了模型训练所有需要的要素，可以实现主要的训练过程部分了。理解这段代码至关重要，因为从事深度学习后，相同的训练过程几乎一遍又一遍地出现。
在每次迭代中，我们读取一小批量训练样本，并通过我们的模型来获得一组预测。计算完损失后，我们开始反向传播，存储每个参数的梯度。最后，我们调用优化算法sgd来更新模型参数。
概括一下，我们将执行以下循环：
- 初始化参数
- 重复以下训练，直到完成
- 计算梯度 g ← ∂ ( w , b ) 1 ∣ B ∣ ∑ i ∈ B l ( x ( i ) , y ( i ) , w , b ) \mathbf{g} \leftarrow \partial_{(\mathbf{w},b)} \frac{1}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} l(\mathbf{x}^{(i)}, y^{(i)}, \mathbf{w}, b) g←∂(w,b)∣B∣1∑i∈Bl(x(i),y(i),w,b)
- 更新参数 ( w , b ) ← ( w , b ) − η g (\mathbf{w}, b) \leftarrow (\mathbf{w}, b) - \eta \mathbf{g} (w,b)←(w,b)−ηg
在每个迭代周期（epoch）中，我们使用data_iter函数遍历整个数据集，并将训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设为3和0.03。设置超参数很棘手，需要通过反复试验进行调整。
lr = 0.03 # 设置学习率
num_epochs = 3 # 数据集训练次数
net = linreg # 将模型和损失函数分别用net和loss表示便于后期替换
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}')
用真实的w和b与预测的w和b进行对比
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')
* 完整代码
%matplotlib inline
import random
import torch
from d2l import torch as d2l
# 生成数据集
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))
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
print('features:', features[0],'\nlabel:', labels[0])
# 设置绘图
d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1);
# 读取数据集
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
# 初始化模型参数
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
# 定义模型
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
# 定义优化算法
def sgd(params, lr, batch_size): #@save
"""小批量随机梯度下降"""
with torch.no_grad():
for param in params:
param -= lr * param.grad / batch_size
param.grad.zero_()
# 训练
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}')
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')
参考文章：3.2. 线性回归的从零开始实现
3、线性回归的简洁实现
使用pytorch内置函数进行实现
1. 生成数据集
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)
2. 读取数据集
def load_array(data_arrays, batch_size, is_train=True): #@save
"""构造一个PyTorch数据迭代器"""
dataset = data.TensorDataset(*data_arrays) # 采用TensorDataset用于将多个张量作为输入，并将它们打包成一个数据集。*用于将data_arrays进行解析
return data.DataLoader(dataset, batch_size, shuffle=is_train) # 加载数据集
batch_size = 10
data_iter = load_array((features, labels), batch_size) # 返回了一个迭代器
next(iter(data_iter)) # 使用iter构造Python迭代器，并使用next从迭代器中获取第一项
DataLoader是torch.utils.data中的一个类，它可以用来加载数据集。
DataLoader的函数是
__init__，它有以下几个参数：
- dataset：数据集，需要是一个继承自torch.utils.data.Dataset的类。
- batch_size：每个batch的大小。
- shuffle：是否对数据进行洗牌。
- num_workers：开启的子进程个数，用于多进程加速数据加载。
- collate_fn：用于将每个样本打包成batch的函数。
参考文章：Dataset和DataLoader基本使用方法与数据集切分函数
3. 定义模型
对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。 我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。
在PyTorch中，全连接层在Linear类中定义。 值得注意的是，我们将两个参数传递到nn.Linear中。 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1)) # 定义了一个线性层神经网络（y=wx+b）
4. 初始化模型参数
在使用net之前，我们需要初始化模型参数。 如在线性回归模型中的权重和偏置。 深度学习框架通常有预定义的方法来初始化参数。 在这里，我们指定每个权重参数应该从均值为0、标准差为0.01的正态分布中随机采样， 偏置参数将初始化为零。
net[0].weight.data.normal_(0, 0.01) # 使用均值为0方差为0.01的数据填充第一个图层中的weight
net[0].bias.data.fill_(0) # 使用0填充第一个图层中的bias
5. 定义损失函数
计算均方误差使用的是MSELoss类，也称为平方 L 2 L_2 L2范数。 默认情况下，它返回所有样本损失的平均值。
loss = nn.MSELoss()
6. 定义优化算法
小批量随机梯度下降算法是一种优化神经网络的标准工具， PyTorch在optim模块中实现了该算法的许多变种。 当我们实例化一个SGD实例时，我们要指定优化的参数 （可通过net.parameters()从我们的模型中获得）以及优化算法所需的超参数字典。 小批量随机梯度下降只需要设置lr值，这里设置为0.03。
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
7. 训练
在每个迭代周期里，我们将完整遍历一次数据集（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) # net(X)生成预测值，计算预测值与真实值之间的损失值
trainer.zero_grad() # 优化器更新模型参数前，先让之前的梯度清0
l.backward() # 反向传播计算梯度
trainer.step() # 更新模型参数
l = loss(net(features), labels) # 计算每轮的训练效果并在下面展示出来
print(f'epoch {epoch + 1}, loss {l:f}')
# 对比预测的权重与真实权重之间的差异
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)
* 完整代码
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
from torch import nn # nn是神经网络的缩写
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)
# 读取数据集
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)
next(iter(data_iter)) # 构造python迭代器后输出内容
# 定义模型
net = nn.Sequential(nn.Linear(2, 1))
# 初始化模型参数
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
# 定义损失函数
loss = nn.MSELoss()
# 定义优化算法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
# 训练
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()
trainer.step()
l = loss(net(features), labels)
print(f'epoch {epoch + 1}, loss {l:f}')
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)
- 注：
- 如果将小批量的总损失替换为小批量损失的平均值，需要减小学习率，否则会使得梯度值放大为原来的num_example倍，导致容易出现在最优解附近震荡的情况 降低学习效果
参考文章：3.2. 线性回归的从零开始实现
2175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
