文章目录

• 前言
• 一、线性回归
• • 1.1. 线性回归的基本元素
  • • 1.1.1. 线性模型
    • 1.1.2. 损失函数
    • 1.1.3. 解析解
    • 1.1.4. 随机梯度下降
    • 1.1.5. 用模型进行预测
  • 1.2. 向量化加速
  • 1.3. 正态分布与平方损失
  • 1.4. 从线性回归到深度网络
• 二、线性回归的从零开始实现
• • 2.1. 生成数据集
  • 2.2. 读取数据集
  • 2.3. 初始化模型参数
  • 2.4. 定义模型
  • 2.5. 定义损失函数
  • 2.6. 定义优化算法
  • 2.7. 训练
• 三、线性回归的简洁实现
• • 3.1. 生成数据集
  • 3.2. 读取数据集
  • 3.3. 定义模型
  • 3.4. 初始化模型参数
  • 3.5. 定义损失函数
  • 3.6. 定义优化算法
  • 3.7. 训练
• 总结

前言

书接上章，当预备知识有一定了解后，接下来将进入神经网络的学习，而本章主要介绍一下最简单的人工神经网络——线性神经网络。
参考书：
《动手学深度学习》

一、线性回归

1.1. 线性回归的基本元素

1.1.1. 线性模型

$$\hat{y}=w_1{x}_1+...+w_d{x}_d+b.$$

将所有特征放到向量$\mathbf{x}$中，并将所有权重放到向量$\mathbf{w}$中，我们可以用点积形式来简洁地表达模型：

$$\hat{y}={\mathbf{w}}^{\top }\mathbf{x}+b.$$

上式向量$\mathbf{x}$对应于单个数据样本的特征。
用符号表示的矩阵$\mathbf{X}$ ，可以很方便地引用我们整个数据集的$n$个样本。其中，$\mathbf{X}$的每一行是一个样本，每一列是一种特征。

对于特征集合$\mathbf{X}$，预测值$\hat{\mathbf{y}}$，可以通过矩阵-向量乘法表示为：

$$\hat{\mathbf{y}}=\mathbf{Xw}+b$$

1.1.2. 损失函数

回归问题中最常用的损失函数是平方误差函数。当样本$i$的预测值为${\hat{y}}^{(i)}$，其相应的真实标签为$y^{(i)}$时，
平方误差可以定义为以下公式：

$$l^{(i)}(\mathbf{w},b)=\frac{1}{2}{\left({\hat{y}}^{(i)}-y^{(i)}\right)}^2.$$

为了度量模型在整个数据集上的质量，我们需计算在训练集$n$个样本上的损失均值（也等价于求和）。

$$L(\mathbf{w},b)=\frac{1}{n}\sum _{i=1}^n{l}^{(i)}(\mathbf{w},b)=\frac{1}{n}\sum _{i=1}^n\frac{1}{2}{\left({\mathbf{w}}^{\top }{\mathbf{x}}^{(i)}+b-y^{(i)}\right)}^2.$$

在训练模型时，我们希望寻找一组参数（${\mathbf{w}}^{\ast },b^{\ast }$），
这组参数能最小化在所有训练样本上的总损失。如下式：

$${\mathbf{w}}^{\ast },b^{\ast }=\underset{\mathbf{w},b}{\mathrm{argmin}}L(\mathbf{w},b).$$

1.1.3. 解析解

首先，我们将偏置$b$合并到参数$\mathbf{w}$中，合并方法是在包含所有参数的矩阵中附加一列。
我们的预测问题是最小化$\Vert \mathbf{y}-\mathbf{Xw}{\Vert }^2$。
这在损失平面上只有一个临界点，这个临界点对应于整个区域的损失极小值点。
将损失关于$\mathbf{w}$的导数设为0，得到解析解：

$${\mathbf{w}}^{\ast }=({\mathbf{X}}^{\top }\mathbf{X}{)}^{-1}{\mathbf{X}}^{\top }\mathbf{y}.$$

1.1.4. 随机梯度下降

梯度下降（gradient descent）的方法，几乎可以优化所有深度学习模型。（它通过不断地在损失函数递减的方向上更新参数来降低误差）

因为梯度下降在每次更新参数之前，我们必须遍历整个数据集。执行极慢。所以通常采用小批量随机梯度下降

1. 在每次迭代中，我们首先随机抽样一个固定数量样本的小批量$\mathcal{B}$，

2. 然后，我们计算小批量的平均损失关于模型参数的导数（也可以称为梯度）。

3. 最后，我们将梯度乘以一个预先确定的正数$\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).$$

对于平方损失和仿射变换，我们可以明确地写成如下形式：

$$\begin{array}{rl}\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{array}$$

1.1.5. 用模型进行预测

1.2. 向量化加速

import time
import numpy as np
import torch
from d2l import torch as d2l
n = 10000
a = torch.ones([n])
b = torch.ones([n])
# print(a.numel())

#我们定义一个计时器
class Timer:  #@save
    """记录多次运行时间"""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        """启动计时器"""
        self.tik = time.time()

    def stop(self):
        """停止计时器并将时间记录在列表中"""
        self.times.append(time.time() - self.tik)
        return self.times[-1]

    def avg(self):
        """返回平均时间"""
        return sum(self.times) / len(self.times)

    def sum(self):
        """返回时间总和"""
        return sum(self.times)

    def cumsum(self):
        """返回累计时间"""
        return np.array(self.times).cumsum().tolist()


c = torch.zeros(n)
timer = Timer()
#我们使用for循环，每次执行一位的加法
for i in range(n):
    c[i] = a[i] + b[i]
print(f'{timer.stop():.5f} sec')

#使用重载的+运算符来计算按元素的和
timer.start()
d = a + b
print(f"{timer.stop():.5f} sec")




#结果：
0.10190 sec
0.00000 sec

结果很明显，第二种方法比第一种方法快得多。向量化代码通常会带来数量级的加速。

1.3. 正态分布与平方损失

简单的说，若随机变量$x$具有均值$\mu$和方差${\sigma }^2$（标准差$\sigma$），其正态分布概率密度函数如下：

$$p(x)=\frac{1}{\sqrt{2\pi {\sigma }^2}}\exp \left(-\frac{1}{2{\sigma }^2}(x-\mu {)}^2\right).$$

#正态分布与平方损失
def normal(x,mu,sigma):
    p = 1/np.sqrt(2*math.pi*sigma**2)
    return p * np.exp(-0.5 /sigma**2 * (x-mu)**2)
# 再次使用numpy进行可视化
x = np.arange(-7, 7, 0.01)

# 均值和标准差对
params = [(0, 1), (0, 2), (3, 1)]
d2l.plot(x, [normal(x, mu, sigma) for mu, sigma in params], xlabel='x',
         ylabel='p(x)', figsize=(6.5, 4.5),
         legend=[f'mean {mu}, std {sigma}' for mu, sigma in params])
d2l.plt.show()

如图，改变均值会产生沿$x$轴的偏移，增加方差将会分散分布、降低其峰值。

均方误差损失函数（简称均方损失）可以用于线性回归的一个原因是：
我们假设了观测中包含噪声，其中噪声服从正态分布。
噪声正态分布如下式:

$$y={\mathbf{w}}^{\top }\mathbf{x}+b+ϵ,$$

其中，$ϵ\sim \mathcal{N}(0,{\sigma }^2)$。

因此，我们现在可以写出通过给定的$\mathbf{x}$观测到特定$y$的似然：

$$P(y\mid \mathbf{x})=\frac{1}{\sqrt{2\pi {\sigma }^2}}\exp \left(-\frac{1}{2{\sigma }^2}(y-{\mathbf{w}}^{\top }\mathbf{x}-b{)}^2\right).$$

现在，根据极大似然估计法，参数$\mathbf{w}$和$b$的最优值是使整个数据集的似然最大的值：

$$P(\mathbf{y}\mid \mathbf{X})=\prod _{i=1}^{n}p(y^{(i)}|{\mathbf{x}}^{(i)}).$$

根据极大似然估计法选择的估计量称为极大似然估计量。

由于历史原因，优化通常是说最小化而不是最大化。我们可以改为最小化负对数似然$-\log P(\mathbf{y}\mid \mathbf{X})$。

$$-\log P(\mathbf{y}\mid \mathbf{X})=\sum _{i=1}^n\frac{1}{2}\log (2\pi {\sigma }^2)+\frac{1}{2{\sigma }^2}{\left(y^{(i)}-{\mathbf{w}}^{\top }{\mathbf{x}}^{(i)}-b\right)}^2.$$

现在我们只需要假设$\sigma$是某个固定常数就可以忽略第一项，
因为第一项不依赖于$\mathbf{w}$和$b$。
现在第二项除了常数$\frac{1}{{\sigma }^2}$外，其余部分和前面介绍的均方误差是一样的。
幸运的是，上面式子的解并不依赖于$\sigma$。
因此，在高斯噪声的假设下，最小化均方误差等价于对线性模型的极大似然估计。

1.4. 从线性回归到深度网络

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

2.1. 生成数据集

ϵ可以视为模型预测和标签时的潜在观测误差。 在这里我们认为标准假设成立，即ϵ服从均值为0的正态分布。 为了简化问题，我们将标准差设为0.01。 下面的代码生成合成数据集：

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)
#features中的每一行都包含一个二维数据样本， labels中的每一行都包含一维标签值（一个标量）
print('features:', features[0],'\nlabel:', labels[0])
#可视化线性关系（第二个特征和标签值的散点图）
# d2l.set_figsize()
d2l.plt.scatter(features[:, 1].detach().numpy(), labels.detach().numpy(), 1)
d2l.plt.show()


#结果：
features: tensor([-0.5307,  1.2137]) 
label: tensor([-0.9951])

2.2. 读取数据集

#读取数据集：
def data_iter(bath_size,features,labels):
    num_examples = len(features) #获取数据集的总样本数量
    indices = list(range(num_examples))
    random.shuffle(indices) #将样本索引列表打乱
    
    #这些样本是随机读取的，没有特定的顺序
    for i in range(0,num_examples,bath_size):
        bath_indices = torch.tensor(indices[i:min(i+bath_size,num_examples)])
        yield features[bath_indices],labels[bath_indices]

#查看
bath_size = 10
for X ,y in data_iter(bath_size,features,labels):
    print(X,"\n",y)
    break

2.3. 初始化模型参数

#初始化参数
w = torch.normal(0,0.01,size=(2,1),requires_grad= True)
b  =torch.zeros(1,requires_grad=True)

2.4. 定义模型

#定义模型
def linreg(X,w,b):
    #线性回归模型
    return torch.matmul(X,w) +b  #或用torch.mv()

2.5. 定义损失函数

#定义损失函数
def squared_loss(y_hat,y):
    #均方损失
    return (y_hat - y.reshape(y_hat.shape))**2 / 2

2.6. 定义优化算法

#定义优化算法：
def sgd(params,lr,bath_size):
    #小批量随机梯度下降
    with torch.no_grad():
        for param in params:
            param -= lr *param.grad /bath_size #梯度反方向传播
            param.grad.zero_()

2.7. 训练

#训练
"""
执行以下循环：
初始化参数
重复以下训练，直到完成
计算梯度
更新参数
"""

lr = 0.03 #学习率
num_epochs = 3 #迭代轮数
net = linreg #线性模型
loss = squared_loss  #损失函数

for epoch in range(num_epochs):
    for X,y in data_iter(bath_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,bath_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}')




#结果：
epoch1,loss 0.033319
epoch2,loss 0.000119
epoch3,loss 0.000048
w的估计误差: tensor([ 0.0004, -0.0006], grad_fn=<SubBackward0>)
b的估计误差: tensor([0.0005], grad_fn=<RsubBackward1>)

三、线性回归的简洁实现

3.1. 生成数据集

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)

3.2. 读取数据集

取数据集
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)


#print(next(iter(data_iter)))  #从迭代器中获取第一项。

3.3. 定义模型

# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))  #2表示输入特征的维度，1表示输出特征的维度

3.4. 初始化模型参数

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


#结果：
tensor([[-8.8769e-03, -2.7674e-05]])
tensor([0.])
Linear(in_features=2, out_features=1, bias=True)
Sequential(
  (0): Linear(in_features=2, out_features=1, bias=True)
)

3.5. 定义损失函数

loss = nn.MSELoss()

3.6. 定义优化算法

#定义优化算法:
trainer = torch.optim.SGD(net.parameters(),lr= 0.03)

3.7. 训练

• 通过调用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()  #根据损失值进行反向传播，计算模型参数的梯度。
        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)


#结果：
epoch 1, loss 0.000213
epoch 2, loss 0.000100
epoch 3, loss 0.000099
w的估计误差： tensor([3.5274e-04, 3.2663e-05])
b的估计误差： tensor([9.5367e-07])

总结

本章根据书本知识，详细介绍了线性神经网络中的线性回归原理，并从零开始展示了线性回归的代码实现，以及在pytorch深度学习框架下更简洁的线性回归代码实现。接下来将进入softmax回归的讲解。

靖康耻，犹未雪；臣子恨，何时灭？驾长车，踏破贺兰山缺…

–2023-9-18 进阶篇