PyTorch深度学习（二）：线性回归和实现

PyTorch深度学习（二）：线性回归和实现

---

一、线性回归概述

什么是回归问题？

• 有监督学习分为两类，即分类和回归问题，预测某一事物属于哪一类别，属于分类问题，如：猫狗分类；而当需要预测的内容是一个连续的值，属于回归问题，如：预测房价

什么是线性回归？

• 线性回归是回归问题的一种，当输出值与输入值之间满足线性关系时，即满足方程：$h(x)=w_1{x}_1+w_2{x}_2+...+w_n{x}_n+w_0(b)$，称为线性回归
• 在二维平面中，它表现为一条直线，在多维空间中，它表现为一个超平面
• 在构建这个超平面时，我们需要使预测值与真实值之间的误差最小化
  

符号约定：

符号	含义
$m$	训练集中样本的数量
$n$	特征的数量
$x$	样本的特征变量/输入变量
$y$	样本的目标变量/输出变量
$(x,y)$	训练集中的样本：$(输入变量,输出变量)$
$(x^{(i)},y^{(i)})$	代表第 $i$ 个观察样本的特征和输出
$h$	代表学习算法的解决方案或函数，也称为假设(hypothesis)
$\hat{y}=h(x)$	代表预测值

例如：

$$x^{(2)}=\left[\begin{array}{c}162.2\\ 31\\ 8\\ 118\end{array}\right]，y^{(2)}=37000，x_2^{(2)}=31，x_3^{(2)}=8$$

线性模型可以看作是一个单层神经网络（单层全连接层）：

---

二、构建线性模型和优化算法(Optimal)

构建线性模型的核心问题是找到：$h(x)=w_1{x}_1+w_2{x}_2+...+w_n{x}_n+w_0(b)$ 中的 $\mathbf{w}(w_1,w_2,...,w_n)$ 和 $w_0(b)$

为了方便计算，可以设 $x_0=1$，则方程变为：$h(x)=w_0{x}_0+w_1{x}_1+w_2{x}_2+...+w_n{x}_n={\mathbf{w}}^T\cdot \mathbf{x}=⟨\mathbf{w},\mathbf{x}⟩$

$w_i$ 的取值越大，线性模型越复杂

损失函数(Loss Function)：

对学习结果的度量，度量单样本预测的错误程度，损失函数值越小，模型就越好

损失函数名称	损失函数定义
0-1损失函数	$$Loss(y^{(i)},h(x^{(i)}))=\{\begin{array}{ll}1,& h(x^{(i)})\ne y^{(i)}\\ 0,& h(x^{(i)})=y^{(i)}\end{array}$$
平方损失函数	$$Loss(y^{(i)},h(x^{(i)}))=(y^{(i)}-h(x^{(i)}){)}^2$$
绝对损失函数	$$Loss(y^{(i)},h(x^{(i)}))=\mid y^{(i)}-h(x^{(i)})\mid$$
对数损失函数/对数似然损失函数	$$Loss(y^{(i)},P(y^{(i)}\mid x_i))=-logP((y^{(i)}\mid x^{(i)}))$$

代价函数： 度量对所有样本集预测值的平均误差，常用的代价函数包括均方误差、均方根误差、平均绝对误差等

代价函数常常采用均方误差 $\text{MSE}$： $\text{MSE}=\frac{1}{m}{\sum }_{i=1}^m(y^{(i)}-\widehat{y^{(i)}}{)}^2$，为方便计算，常定义为：$J(\mathbf{w})=\frac{1}{2m}{\sum }_{i=1}^m(y^{(i)}-\widehat{y^{(i)}}{)}^2$

目标：要找到一组 $\mathbf{w}(w_0,w_1,w_2,...,w_n)$，使得 $\text{MSE}$ 具有最小值：$mi{n}_w(\frac{1}{m}{\sum }_{i=1}^m(y^{(i)}-\widehat{y^{(i)}}{)}^2)$，那么，该如何寻找这一组 $\mathbf{w}$ 呢？

1.最小二乘法(LSM)

很显然，代价函数 $J(\mathbf{w})=\frac{1}{2m}{\sum }_{i=1}^m(\widehat{y^{(i)}}-y^{(i)}{)}^2$ 是一个二次函数，即它是一个凸函数，具有最小值

以二维 $\mathbf{w}(w_0,w_1)$ 为例，由不同的 $(w_0,w_1)$ 可以得到不同的代价值，且代价函数可以找到最小值，如图所示：

如果想要找到最小值，我们只需对代价函数求偏导，并令偏导数为 $0$（最小值点），对凸函数来说是可以找到解析解的：
$$令\frac{\partial J(w_0,w_1)}{\partial w_0}=\frac{1}{m}\sum _{i=1}^m(w_0+w_1{x}^{(i)}-y^{(i)})=0$$

$$令\frac{\partial J(w_0,w_1)}{\partial w_1}=\frac{1}{m}\sum _{i=1}^m{x}^{(i)}(w_0+w_1{x}^{(i)}-y^{(i)})=0$$

$$解得：w_0=\frac{1}{m}\sum _{i=1}^m(y^{(i)}-w_1{x}^{(i)})，w_1=\frac{{\sum }_{i=1}^m{y}^{(i)}(x^{(i)}-\overline{x})}{{\sum }_{i=1}^n(x^{(i)}{)}^2-\frac{1}{m}({\sum }_{i=1}^m{x}^{(i)}{)}^2}$$

2.梯度下降

梯度： 它是一个矢量，对一元函数来说，梯度就是函数的导数；对多元函数来说，多元函数 $f(x)$ 在某一点处的梯度表示 $f(x)$ 在该点处的最大方向导数，其方向为具有最大增长率的方向，那么梯度的反方向就是函数值下降率最大的方向

梯度下降的目标仍然是希望找到代价函数 $J(w_0,w_1,...,w_n)$ 的最小值，比 $\text{LSM}$ 更好的是，梯度下降法可以应用于更一般的函数，而不只是凸函数

利用梯度下降，我们可以在代价函数的某一点处开始，根据梯度的反方向，逐渐修改 $(w_0,w_1,...,w_n)$，来使代价函数值逐渐减小

梯度下降的数学定义：

$w=(w_0,w_1,...,w_n)$，里面第 $i$ 个元素用 $w_i$ 来表示，则：

$$\underset{\text{不断重复，直到收敛}}{\underbrace{w_i=w_i-\alpha \frac{\partial }{\partial w_i}J(w_0,w_1,...,w_n)，\text{for i=0 to i=n}}}$$

• $w_i$：表示对 $w$ 中的第 $i$ 个自变量进行更新，在一个循环内，所有对 $w_i$ 的更新必须是同步的
  注：$w_i$ 值不是立刻更新，而是当计算完所有 $w_i$ 的更新值后再同时统一赋值，或者说计算和更新的过程都是同步的
• $\alpha$：表示学习率，它反映了每次更新 $w_i$ 值的跨度率
• $\frac{\partial }{\partial w_i}J(w_0,w_1,...,w_n)$：表示代价函数对 $w$ 中的 $w_i$ 进行偏微分
• $\alpha \frac{\partial }{\partial w_i}J(w_0,w_1,...,w_n)$：表示每次更新的步长
• 因为梯度下降需要确定在代价函数中的某一个点处开始执行，因此需要给定一初始值，通常取 $w_0,w_1,...,w_n=0$ 开始

上述公式表明：

• 如果代价函数对 $w_i$ 的偏微分小于零，表示沿着 $w_i$ 的正方向会使代价函数变小，因此我们可以选择增大 $w_i$ 的值，具体增大 $-\alpha \frac{\partial }{\partial w_i}J(w_0,w_1,...,w_n)$；
• 如果代价函数对 ${\omega }_i$ 的偏微分大于零，表示沿着 ${\omega }_i$ 的正方向会使代价函数变大，因此我们可以选择减小 $w_i$ 的值，具体减小 $\alpha \frac{\partial }{\partial w_i}J(w_0,w_1,...,w_n)$
• 如果代价函数对 $w_i$ 的偏微分等于零，则修正项为零，则不需要修改 $w_i$ 的值
• 现在我们讨论学习率 $\alpha$：如果 $\alpha$ 太高可能导致无法找到合适解（左图），如果 $\alpha$ 太低可能导致学习速度过于缓慢（右图）
  

梯度下降法具有三种模式，即批量梯度下降、随机梯度下降和小批量梯度下降

2.1 批量梯度下降(BGD)

批量梯度下降在计算代价函数的梯度时，考虑了所有的训练样本，代价函数：$J(\mathbf{w})=\frac{1}{2m}{\sum }_{j=1}^m(\widehat{y^{(j)}}-y^{(j)}{)}^2$，$m$ 为样本个数，因此 $w_i$ 为：
$$w_i=w_i-\alpha \frac{1}{m}\sum _{j=1}^m{x}_i^{(j)}\left(\widehat{y^{(j)}}-y^{(j)}\right)=w_i-\alpha \frac{1}{m}\sum _{j=1}^m{x}_i^{(j)}\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(j)}\right)$$

特点：

• 计算梯度的每一步都基于完整训练集
• 训练集规模庞大时算法速度很慢
• 特征数量多时，比标准方程快得多
• 适合样本数规模适中，特征规模很大的数据集

2.2 随机梯度下降(SGD)

随机梯度下降每一次更新 $\omega$ 时，随机选择一个训练样本来计算代价函数的梯度，设选择了第 $j$ 个训练样本：
$$w_i=w_i-\alpha \frac{1}{m}{x}_i^{(j)}\left(\widehat{y^{(j)}}-y^{(j)}\right)=w_i-\alpha x_i^{(j)}\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(j)}\right)$$

特点：

• 计算速度更快
• 成本函数的下降变得不规则，但总体是下降的
• 最终会接近最小值（还会反弹）

批量梯度下降（左图），随机梯度下降（右图）：

2.3 小批量随机梯度下降(MBGD)

小批量梯度下降结合了（一）(二）各自的优点，既不使用所有样本，也不使用单个样本，而是随机选择小批量样本

每次计算代价函数时使用 $b$ 个样本，其中 $k$ 表示第 $k(k<m)$ 个样本：
$$w_i=w_i-\alpha \frac{1}{b}\sum _{j=1}^b{x}_i^{(k)}\left(\widehat{y^{(k)}}-y^{(k)}\right)=w_i-\alpha \frac{1}{b}\sum _{j=1}^b{x}_i^{(k)}\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(k)}\right)$$

• $b=1$（随机梯度下降，SGD）
• $b=m$（批量梯度下降，BGD）
• $b=\text{batch\_size}$，通常是 $2$ 的指数倍，常见的有 $32,64,128$ 等（小批量梯度下降，MBGD）

其性能介于随机和批量之间，其中，选择的批量数不能太小，这样会导致每次计算量太小，不适合并行来最大利用计算资源，批量数也不能太大，这样会导致内存消耗增加，浪费计算

梯度下降存在的缺陷：

• 缺陷1：可能只找到局部最优解
  解决方法：多次实验，并随机设置初始点（超参数），线性回归的 $\text{MSE}$ 代价函数只有一个最小值
• 缺陷2：对属性尺度敏感，即在属性尺度大的维度上下降得更快，尺度小的维度上下降缓慢
  解决方法：属性缩放

属性缩放：

（一）归一化（最大-最小规范化）：
$$x^{\prime }=\frac{x-x_{min}}{x_{max}-x_{min}}$$

将数据映射到 $[0,1]$ 区间内，数据归一化的目的是使得各特征对目标变量的影响一致，会将特征数据进行伸缩变化，所以数据归一化是会改变特征数据分布的

（二）Z-Score 标准化：
$$x^{\prime }=\frac{x-\mu }{\sigma }$$

$$其中{\sigma }^2=\frac{1}{m}\sum _{i=1}^m(x^{(i)}{)}^2，\mu =\frac{1}{m}\sum _{i=1}^m{x}^{(i)}$$

处理后的数据均值为 $0$，方差为 $1$，数据标准化为了不同特征之间具备可比性，经过标准化变换之后的特征数据分布没有发生改变

3.正则化

当特征不足或者现有特征与样本标签的相关性不强时，模型容易出现欠拟合，通过挖掘组合特征等新的特征，往往能够取得更好的效果

简单模型的学习能力较差，通过增加模型的复杂度可以使模型拥有更强的拟合能力，如：在线性模型中添加高次项，使得线性模型变为曲线，又比如在神经网络模型中增加网络层数或神经元个数等，但模型过于复杂容易出现过拟合

而正则化就是是用来防止过拟合的，在经验风险上加上与模型复杂度有关的正则化项或惩罚项，但当模型出现欠拟合现象时，则需要有针对性地减小正则化系数

线性回归模型的两种正则化项：

3.1 岭回归(Ridge Regression)——$L_2$范数正则化

$$J(\mathbf{w})=\frac{1}{2m}\sum _{i=1}^m{\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(i)}\right)}^2+\frac{1}{2}\lambda \sum _{j=1}^n{w}_j^2，(\lambda >0)$$

$w_i$ 的取值越大，线性模型越复杂，其中 ${\sum }_{j=1}^n{w}_j^2$ 正是度量了线性模型的复杂度，为使代价函数 $J(\mathbf{w})$ 更小，应使 $\lambda {\sum }_{j=1}^n{w}_j^2$ 尽量小，使 $\mathbf{w}(w_0,w_1,w_2,...,w_n)$ 中的元素尽量小（接近零）

$$\frac{\partial }{\partial w_i}J(\mathbf{w})=\frac{1}{m}\sum _{j=1}^m{x}_i^{(j)}\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(j)}\right)+\lambda w_i，(\lambda >0)$$

3.2 套索回归(Lasso Regression)——$L_1$范数正则化

$$J(\mathbf{w})=\frac{1}{2m}\sum _{i=1}^m{\left(⟨\mathbf{w},\mathbf{x}⟩-y^{(i)}\right)}^2+\lambda \sum _{j=1}^n\mid w_j\mid ，(\lambda >0)$$

在套索回归中，通过 ${\sum }_{j=1}^n\mid w_j\mid$ $L_1$ 范数度量了线性模型的复杂度，为使代价函数 $J(\mathbf{w})$ 更小，应使 $\lambda {\sum }_{j=1}^n\mid w_j\mid$ 尽量小，使 $\mathbf{w}(w_0,w_1,w_2,...,w_n)$ 中的元素尽量小（接近零）

注：$\text{Lasso}$ 回归的代价函数 $J(\mathbf{w})$ 不是连续可导的（带绝对值），无法直接应用梯度下降

---

三、手动构建线性回归模型

导入所需的库：

%matplotlib inline
import random  # 用于随机梯度下降、随机初始化权重
import torch

1.制作人工数据集

首先，构造一个带有噪声的线性模型（人造数据集），我们使用线性模型参数 $\mathbf{w}={\left[\begin{array}{cc}2& -3.4\end{array}\right]}^T$，$b(w_0)=4.2$ 和噪声项 $ϵ$ 生成数据集及其标签：$\mathbf{y}=\mathbf{x}\mathbf{w}+b+ϵ$

def synthetic_data(w, b, num_examples):  
    """生成 y = xw + b + 噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))  # 生成服从 μ=0，σ=1 正态分布的随机值
    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:10], '\n','labels:', labels[0:10])  # 查看生成的结果

分析调用 features, labels = synthetic_data(true_w, true_b, 1000)：

传入参数：$\mathbf{w}=\left[\begin{array}{cc}2& -3.4\end{array}\right]，b(w_0)=4.2$，$\mathtt{n}\mathtt{u}\mathtt{m}\_\mathtt{e}\mathtt{x}\mathtt{a}\mathtt{m}\mathtt{p}\mathtt{l}\mathtt{e}\mathtt{s}=1000（样本数）$

1. X = torch.normal(0, 1, (num_examples, len(w))) 生成了服从 $\mu =0,\sigma =1$ 正态分布的随机值张量，作为样本的输入：
   $$\mathbf{X}={\left[\begin{array}{cc}{x}_1^{(1)}& x_2^{(1)}\\ x_1^{(2)}& x_2^{(2)}\\ ⋮& ⋮\\ x_1^{(1000)}& x_2^{(1000)}\end{array}\right]}_{1000\times 2}，\mathtt{n}\mathtt{u}\mathtt{m}\_\mathtt{e}\mathtt{x}\mathtt{a}\mathtt{m}\mathtt{p}\mathtt{l}\mathtt{e}\mathtt{s}=1000，\mathtt{l}\mathtt{e}\mathtt{n}(\mathtt{w})=2$$

2. y = torch.matmul(X, w) + b 形成与 $X$ 具有线性关系的因变量 $\mathbf{y}$，作为样本的输出，即：
   $$\mathbf{y}=⟨\mathbf{X},\mathbf{w}⟩+b=\left[\begin{array}{cc}{x}_1^{(1)}& x_2^{(1)}\\ x_1^{(2)}& x_2^{(2)}\\ ⋮& ⋮\\ x_1^{(1000)}& x_2^{(1000)}\end{array}\right]\left[\begin{array}{c}2\\ -3.4\end{array}\right]+b={\left[\begin{array}{c}2x_1^{(1)}-3.4x_2^{(1)}+b\\ 2x_1^{(2)}-3.4x_2^{(2)}+b\\ ⋮\\ 2x_1^{(1000)}-3.4x_2^{(1000)}+b\end{array}\right]}_{1000\times 1}={\left[\begin{array}{c}{y}^{(1)}\\ y^{(2)}\\ ⋮\\ y^{(1000)}\end{array}\right]}_{1000\times 1}$$
   注意：返回的是 $\mathtt{s}\mathtt{h}\mathtt{a}\mathtt{p}\mathtt{e}=(1000)$ 的张量，需要进行 $\mathtt{r}\mathtt{e}\mathtt{s}\mathtt{h}\mathtt{a}\mathtt{p}\mathtt{e}(-1,1)$

3. y += torch.normal(0, 0.01, y.shape) 分别为 $\mathbf{y}$ 中的每一项加入了 $\mu =0,\sigma =0.01$ 的高斯白噪声

查看前十个数据集，每个样本包含一个二维 $\mathtt{f}\mathtt{e}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{e}\mathtt{s}$：$\mathbf{x}({\mathbf{x}}_1,{\mathbf{x}}_2)$ 和一个输出值 $\mathtt{l}\mathtt{a}\mathtt{b}\mathtt{e}\mathtt{l}\mathtt{s}$：

# 绘制散点图，进一步观察数据集，散点大小为 20，边界为黑色边界
plt.scatter(features[:, 0], labels, label = 'x1', s=20, edgecolor="black")
plt.scatter(features[:, 1], labels, label = 'x2', s=20, edgecolor="black")
"""
注意，有些版本需要从计算图上分离出来，并将tensor转换为numpy数组，才能绘图

plt.scatter(features[:, 0].detach().numpy(), labels.detach().numpy(), label = 'x1')
plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), label = 'x2')
"""
plt.legend()

2.实现小批量随机抽样

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)])
        print('indices[{:},{:}]'.format(i, i + 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)

batch_size = 10 定义批量数大小为 $10$，则可以以 $10$ 个样本为一组，分成 $100$ 组，再随机抽样

分析调用 data_iter(batch_size, features, labels)：

传入参数 $\mathtt{b}\mathtt{a}\mathtt{t}\mathtt{c}\mathtt{h}\_\mathtt{s}\mathtt{i}\mathtt{z}\mathtt{e}=10$，即每次小批量梯度下降的批量数为 $10$，$\mathtt{f}\mathtt{e}\mathtt{a}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{e}\mathtt{s}:(1000,2)$，$\mathtt{l}\mathtt{a}\mathtt{b}\mathtt{e}\mathtt{l}\mathtt{s}:(1000,1)$

1. num_examples = len(features) 统计样本数，样本数为 $1000$
2. indices = list(range(num_examples)) 生成从 $0$ 到 $999$ 的顺序整数列表
3. random.shuffle(indices) 将数组 indices 顺序随机打乱
4. for i in range(0, num_examples, batch_size): 从 $0$ 到 $999$ 每隔 $10$ 步取一个 $i$
5. 在 batch_indices = torch.tensor(indices[i:min(i + batch_size, num_examples)]) 中：
   indices[i:i + batch_size] 表示每次从乱序数组中取 $10$ 个作为一个小批量；
   min(i + batch_size, num_examples) 是为了防止取数时超出乱序数组的右边界（这里似乎没必要）；
   torch.tensor 将每次得到的 $10$ 个随机数作为张量，如：$\mathtt{t}\mathtt{e}\mathtt{n}\mathtt{s}\mathtt{o}\mathtt{r}([96,731,147,654,2,341,455,214,203,81])$
6. features[batch_indices], labels[batch_indices]，用张量在 features 和 labels 中可以分别取到 $10$ 个样本
7. yield 是 Python 的迭代器，是一种函数的返回值，每当函数运行到 yield 关键字时，都会返回一组数据，保留函数运行节点并退出函数运行，在下次调用时，将从上一保留的节点继续运行函数，可以多次调用该函数，得到不同的返回值

利用 for 循环，会多次调用 data_iter() 函数，根据迭代器依次返回 $100$ 组小批量样本，每个小批量为 $10$，这里仅展示一组

3.初始化模型

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

# 给定模型的超参数（初始值）
w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

4.定义损失函数和优化算法

损失函数：

def squared_loss(y_hat, y):  
    """使用均方误差损失函数"""
    return (y_hat - y.reshape(y_hat.shape))**2 / 2

参数：$\mathtt{y}\_\mathtt{h}\mathtt{a}\mathtt{t}$、$\mathtt{y}$ 分别代表预测值 $\hat{y}$ 和真实值 $y$

1. y.reshape(y_hat.shape)：虽然 $\hat{y}$ 和 $y$ 可能都只是一个元素，但为了统一起见，将 $y$ 统一形状
2. 这里不进行求和，即不考虑 $\frac{1}{m}{\sum }_{i=1}^m$

优化算法：

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

参数：$\mathtt{p}\mathtt{a}\mathtt{r}\mathtt{a}\mathtt{m}\mathtt{s}$ 代表一个包含 $\mathbf{w}$ 和 $b$ 的列表（即需要更新的参数），$\mathtt{l}\mathtt{r}$ 代表学习率

1. for param in params: 这里的运算将不放入计算图
2. param -= lr * param.grad 即代表 $w_i=w_i-\frac{\partial }{\partial w_i}J(w_1,w_2,b)$
3. param.grad.zero_() 梯度清零，这样下一次计算梯度的时候就不会和上一次计算相关了

5.训练过程

lr = 0.03  				# 学习率为 0.03
num_epochs = 3  		# 训练次数为 3
net = linreg			# net 引用 linreg
loss = squared_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)  			# 计算小批量的损失
        (l.sum() / batch_size).backward()  	# 计算梯度
        sgd([w, b], lr)  					# 梯度下降，更新参数
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)  # 每个 epoch 打印一次损失值
        print('epoch {:}, loss {:f}'.format(epoch + 1, float(train_l.mean())))

主函数解释：

net(X, w, b) 返回值为：
$$\mathtt{r}\mathtt{e}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{n}=\left[\begin{array}{cc}{x}_1^{(1)}& x_2^{(1)}\\ x_1^{(2)}& x_2^{(2)}\\ ⋮& ⋮\\ x_1^{(10)}& x_2^{(10)}\end{array}\right]\left[\begin{array}{c}{w}_1\\ w_2\end{array}\right]+b=\left[\begin{array}{c}{w}_1{x}_1^{(1)}+w_2{x}_2^{(1)}+b\\ w_1{x}_1^{(2)}+w_2{x}_2^{(2)}+b\\ ⋮\\ w_1{x}_1^{(10)}+w_2{x}_2^{(10)}+b\end{array}\right]=\left[\begin{array}{c}{\hat{y}}^{(1)}\\ {\hat{y}}^{(2)}\\ ⋮\\ {\hat{y}}^{(10)}\end{array}\right]$$

l = loss(net(X, w, b), y) 的返回值为：
$$\mathtt{r}\mathtt{e}\mathtt{t}\mathtt{u}\mathtt{r}\mathtt{n}=\frac{1}{2}{\left(\left[\begin{array}{c}{\hat{y}}^{(1)}\\ {\hat{y}}^{(2)}\\ ⋮\\ {\hat{y}}^{(10)}\end{array}\right]-\left[\begin{array}{c}{y}^{(1)}\\ y^{(2)}\\ ⋮\\ y^{(10)}\end{array}\right]\right)}^2=\left[\begin{array}{c}los{s}^{(1)}\\ los{s}^{(2)}\\ ⋮\\ los{s}^{(10)}\end{array}\right]$$

由于 $J(\mathbf{w})=\frac{1}{2\times 10}{\sum }_{j=1}^{10}(\widehat{y^{(j)}}-y^{(j)}{)}^2$，而这里是样本各自的损失，因此下一步需要先求和，除以 $\mathtt{b}\mathtt{a}\mathtt{t}\mathtt{c}\mathtt{h}\_\mathtt{s}\mathtt{i}\mathtt{z}\mathtt{e}$，再求梯度

(l.sum() / batch_size).backward() 进行的操作是：
$$J(\mathbf{w})=\left(\left[\begin{array}{c}los{s}^{(1)}\\ los{s}^{(2)}\\ ⋮\\ los{s}^{(10)}\end{array}\right].\mathtt{s}\mathtt{u}\mathtt{m}()\right)\frac{1}{\mathtt{b}\mathtt{a}\mathtt{t}\mathtt{c}\mathtt{h}\_\mathtt{s}\mathtt{i}\mathtt{z}\mathtt{e}}=\frac{1}{2\times 10}\sum _{j=1}^{10}(\widehat{y^{(j)}}-y^{(j)}{)}^2$$

$$J(\mathbf{w}).\mathtt{b}\mathtt{a}\mathtt{c}\mathtt{k}\mathtt{w}\mathtt{a}\mathtt{r}\mathtt{d}()⟹\frac{\partial J(\mathbf{w})}{\partial w_i}=\left[\begin{array}{c}\frac{\partial J(\mathbf{w})}{\partial w_1}\\ \frac{\partial J(\mathbf{w})}{\partial w_2}\\ \frac{\partial J(\mathbf{w})}{\partial b}\end{array}\right]$$

sgd([w, b], lr) 则实现了参数的更新

训练效果：

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

发现 $w_1$、$w_2$ 误差分别为 $-0.0002$、$0.0002$，$b$ 的误差为 $0.0002$，误差较小

---

四、利用PyTorch函数简洁实现线性回归

1.PyTorch数据集处理模块

导入所需的库：

import torch.utils as data  # 包含一些数据处理的模块

train_ids = data.TensorDataset(tuple) 将 数据data 和 标签label 张量进行打包，打包后通过 DataLoader() 函数获取数据
$$\mathtt{d}\mathtt{a}\mathtt{t}\mathtt{a}={\left[\begin{array}{cccc}{x}_1^{(1)}& x_2^{(1)}& \cdots & x_n^{(1)}\\ x_1^{(2)}& x_2^{(2)}& \cdots & x_n^{(2)}\\ ⋮& ⋮& \ddots & ⋮\\ x_1^{(i)}& x_2^{(i)}& \cdots & x_n^{(i)}\end{array}\right]}_{i\times n}，\mathtt{l}\mathtt{a}\mathtt{b}\mathtt{e}\mathtt{l}=\left[\begin{array}{c}{y}^{(1)}\\ y^{(2)}\\ ⋮\\ y^{(i)}\end{array}\right]$$
在维度上，$\mathtt{d}\mathtt{a}\mathtt{t}\mathtt{a}$ 的样本数 $i$ 必须与 $\mathtt{l}\mathtt{a}\mathtt{b}\mathtt{e}\mathtt{l}$ 的个数对应

data_iter = data.DataLoader(dataset=train_ids, batch_size, shuffle=False, num_workers) 可以每次随机读取时取 batch_size 个小批量数据

得到的 data_iter 是一个对象，可以通过 for...in... 来进行访问，且每个轮次访问的结果都是随机的

train_ids 从 TensorDataset() 函数中返回的对象
batch_size 每次获取数据样本时的批量数
shuffle 决定是否打乱数据集，default=False
num_workers 读取数据的进程个数，当数据量较大时，可以使用多个进程来读取数据

next(iter(data_iter)) 访问下一个批量

例如：

import torch.utils.data as data
import torch

train_data = torch.tensor([[1, 1, 1],
                           [2, 2, 2],
                           [3, 3, 3],
                           [4, 4, 4],
                           [5, 5, 5],
                           [6, 6, 6]])
train_label = torch.tensor([100, 200, 300, 400, 500, 600])


# 打包数据集
train_ids = data.TensorDataset(train_data, train_label)
# 返回的对象可通过切片来查看
print(train_ids[0:3])
print('=' * 100)
# 也可循环读取数据
for train_data, train_label in train_ids:
    print(train_data, train_label)
print('=' * 100)


# DataLoader 获取数据
data_iter = data.DataLoader(dataset = train_ids, batch_size = 2, shuffle = True)
# 可以通过 for in 来遍历 data_iter，并且每次访问 data_iter 的结果都不一样
print('第一次访问：')
for x, y in data_iter:
    print(x, y)
print('第二次访问：')
for x, y in data_iter:
    print(x, y)
print('=' * 100)


# 通过调用 next(iter()) 可以获取下一个批量
for i in range(3):
    print(next(iter(data_iter)))

2.实现流程

导入所需的库：

import numpy as np
import torch
import torch.utils as data  # 包含一些数据处理的模块

仍然以相同的方法生成一个人工数据集：

def synthetic_data(w, b, num_examples):  
    """生成 y = xw + b + 噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))  # 生成服从 μ=0，σ=1 正态分布的随机值
    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)

通过 $\mathtt{t}\mathtt{o}\mathtt{r}\mathtt{c}\mathtt{h}.\mathtt{u}\mathtt{t}\mathtt{i}\mathtt{l}\mathtt{s}.\mathtt{d}\mathtt{a}\mathtt{t}\mathtt{a}$ 模块处理数据集

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

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

下面我们将使用 PyTorch 的神经网络 (Neural Network-NN) 库：$\mathtt{t}\mathtt{o}\mathtt{r}\mathtt{c}\mathtt{h}.\mathtt{n}\mathtt{n}$，我们以后再着重介绍这个库

# 导入相关库
import torch.nn as nn
# nn.Linear() 指的是线性层（全连接层），两个参数分别是输入节点个数和输出节点个数
# 2个节点表示有两个权重 w 和一个偏差 b，1个节点表示输出一个值
# nn.Sequential() 是一个容器，可以将一系列操作进行打包，方便复用
net = nn.Sequential(nn.Linear(2, 1))

# 初始化模型参数，weight 表示权重，bias 表示偏差
# net[0] 表示容器中的第一个操作
net[0].weight.data.normal_(0, 0.01)  	# 使用正态分布 normal_() 原地替换
net[0].bias.data.fill_(0)  				# 用全零原地替换 fill_(0)

定义代价函数，使用均方误差代价函数，定义优化算法：

loss = nn.MSELoss()  # 引用均方误差代价函数

# 训练器：随机梯度下降，每次训练样本使用小批量，学习率为 0.03
# net.parameters() 获取容器中的所有参数：w1、w2、b
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

开始训练模型：

num_epochs = 3  # 训练次数为 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()			# 更新所有参数：w1、w2、b
    l = loss(net(features), labels)  # 一次训练结束，计算损失值
    print('epoch {}, loss {:f}'.format(epoch + 1, l))

查看误差：

w = net[0].weight.data
print('w的估计误差:', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差:', true_b - b)

---

参考资料：
[1]Search 动手学深度学习课程
[2]机器学习-第二章：回归.pdf，黄海广