1、线性回归基本概念

回归（regression）是能为一个或多个自变量与因变量之间关系建模的一类方法。在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。

给定一个数据集，我们的目标是寻找模型的权重和偏置，使得根据模型做出的预测大体符合数据里的真实价格。输出的预测值由输入特征通过线性模型的仿射变换决定，仿射变换由所选权重和偏置确定。

当我们的输入包含 $d$ 个特征时，我们将预测结果 $\hat{y}$ （通常使用“尖角”符号表示 $y$ 的估计值）表示为：
$\hat{y} = w_1x+...+w_dx_d+b$

将所有特征放到向量 $x\in\mathbb{R^d}$ 中，并将所有权重放到向量 $x\in\mathbb{R^d}$ 中，我们可以用点积形式来简洁地表达模型：
$\hat{y}=\bold{w^Tx}+b$

对于特征集合 $\bold{X}$ ，预测值 $\hat{y}\in\mathbb{R^n}$ 可以通过矩阵-向量乘法表示为：
$\hat{y}=\bold{Xw}+b$

参考文章：3.1. 线性回归

2、线性回归的从零开始实现

导入包

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

1. 生成数据集

首先，构建一个线性模型，这个线性模型中会加上噪声干扰。在下面的代码中，我们生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中采样的2个特征。我们的合成数据集是一个矩阵 𝐗∈ℝ1000×2。

我们使用线性模型参数 $\mathbf{w} = [2, -3.4]^\top$ 、 $b = 4.2$
和噪声项 $\epsilon$ 生成数据集及其标签：
$\mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon.$

$\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)}(\mathbf{w}, b) = \frac{1}{2} \left(\hat{y}^{(i)} - y^{(i)}\right)^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）。

在每次迭代中，我们首先随机抽样一个小批量 $\mathcal{B}$ ，它是由固定数量的训练样本组成的。
然后，我们计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。
最后，我们将梯度乘以一个预先确定的正数 $\eta$ ，并从当前参数的值中减掉。

我们用下面的数学公式来表示这一更新过程（ $\partial$ 表示偏导数）：

$(\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).$

总结一下，算法的步骤如下：
（1）初始化模型参数的值，如随机初始化；
（2）从数据集中随机抽取小批量样本且在负梯度的方向上更新参数，并不断迭代这一步骤。
对于平方损失和仿射变换，我们可以明确地写成如下形式:

$\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}$

在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来，朝着减少损失的方向更新我们的参数。

下面的函数实现小批量随机梯度下降更新。该函数接受模型参数集合、学习速率和批量大小作为输入。每一步更新的大小由学习速率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来更新模型参数。

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

初始化参数
重复以下训练，直到完成
- 计算梯度 $\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)$
- 更新参数 $(\mathbf{w}, b) \leftarrow (\mathbf{w}, b) - \eta \mathbf{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$ 范数。默认情况下，它返回所有样本损失的平均值。

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)