【动手学深度学习v2】学习笔记03：线性回归、基础优化算法、线性回归实现

Myth丶恋晨 2023-10-09 14:42 49阅读 0赞

[前文回顾：线性代数、矩阵计算、自动求导][Link 1]

#### 文章目录 ####

*  一、线性回归
 *   *  1.1 线性模型
     *  1.2 流程
     *   *  1.2.1 损失函数
         *  1.2.2 训练数据
         *  1.2.3 参数学习
         *  1.2.4 显式解
     *  1.3 总结
 *  二、基础优化算法
 *   *  2.1 梯度下降
     *  2.2 小批量随机梯度下降
     *  2.3 总结
 *  三、线性回归的从零开始实现
 *   *  3.1 导入的库
     *  3.2 数据集
     *   *  3.2.1 构造数据集
         *  3.2.2 展示数据集
     *  3.3 从零开始实现
     *   *  3.3.1 生成小批量
         *  3.3.2 模型和初始化模型参数
         *  3.3.3 定义损失函数
         *  3.3.4 定义优化方法
         *  3.3.5 训练过程
         *  3.3.6 分析
 *  四、线性回归的简洁实现
 *   *  4.1 用到的函数
     *  4.2 导入库并生成数据集
     *  4.3 读取数据
     *  4.4 模型的定义
     *  4.5 损失函数
     *  4.6 优化方法
     *  4.7 训练过程

## 一、线性回归 ##

### 1.1 线性模型 ###

给定n维输入  x ⃗ = \[ x 1 , x 2 , ⋯   , w n \] T \\vec\{x\}=\[x\_1, x\_2, \\cdots, w\_n\]^T x=\[x1,x2,⋯,wn\]T  
线性模型有一个**n维权重**和一个**标准偏差**  
 w ⃗ = \[ w 1 , w 2 , ⋯   , w n \] T , b \\vec\{w\} = \[w\_1, w\_2, \\cdots, w\_n\]^T, \\qquad b w=\[w1,w2,⋯,wn\]T,b输出时输入的加权和  
 y = w 1 x 1 + w 2 x 2 + ⋯ + w n x n + b y = w\_1 x\_1 + w\_2 x\_2 + \\cdots + w\_n x\_n + b y=w1x1\+w2x2\+⋯\+wnxn\+b向量版本：  y = ⟨ w ⃗ , x ⃗ ⟩ + b y=\\langle \\vec\{w\}, \\vec\{x\} \\rangle + b y=⟨w,x⟩\+b

线性模型可以看做是**单层神经网络**。因为只有输入层和权重相关。  
![线性模型][fb9e3ebfede3454a813c8e0cb9691afb.png]

### 1.2 流程 ###

#### 1.2.1 损失函数 ####

我们需要比较真实值和预估值，例如房屋售价和估价。  
假设 y y y是真实值， y ^ \\hat\{y\} y^是估计值，我们可以比较**平方损失**：  
 l ( y , y ^ ) = 1 2 ( y − y ^ ) 2 l(y, \\hat\{y\})=\\frac\{1\}\{2\}(y-\\hat\{y\})^2 l(y,y^)=21(y−y^)2

#### 1.2.2 训练数据 ####

收集一些数据点来决定参数值（权重和偏差），例如过去6个月卖的房子。这些数据点称为**训练数据**，通常越多越好。  
假设我们有n个样本，记  
 X = \[ x 1 ⃗ , x 2 ⃗ , ⋯   , x n ⃗ \] T y ⃗ = \[ y 1 , y 2 , ⋯   , y n \] T X = \[\\vec\{x\_1\}, \\vec\{x\_2\}, \\cdots, \\vec\{x\_n\}\]^T \\qquad \\vec\{y\} = \[y\_1, y\_2, \\cdots , y\_n\]^T X=\[x1,x2,⋯,xn\]Ty=\[y1,y2,⋯,yn\]T

#### 1.2.3 参数学习 ####

**训练损失**  
 l ( X , y ⃗ , w ⃗ , b ) = 1 2 n ∑ i = 1 n ( y i − ⟨ x i ⃗ , w ⃗ ⟩ − b ) 2 = 1 2 n ∣ ∣ y ⃗ − X w ⃗ − b ∣ ∣ 2 l(X, \\vec\{y\}, \\vec\{w\}, b) = \\frac\{1\}\{2n\}\\sum\_\{i=1\}^\{n\}(y\_i-\\langle \\vec\{x\_i\}, \\vec\{w\} \\rangle - b)^2 = \\frac\{1\}\{2n\}||\\vec\{y\} - X \\vec\{w\} - b||^2 l(X,y,w,b)=2n1i=1∑n(yi−⟨xi,w⟩−b)2=2n1∣∣y−Xw−b∣∣2上式就是我们的损失函数了，我们的目标是找到值  w ⃗ , b \\vec\{w\},b w,b 使损失函数值最小。  
**最小化损失来学习参数**  
 w ⃗ ∗ , b ⃗ ∗ = a r g    m i n w ⃗ , b    l ( X , y ⃗ , w ⃗ , b ) \\vec\{w\}^\*, \\vec\{b\}^\* = arg\\;\\mathop\{min\}\\limits\_\{\\vec\{w\}, b\}\\;l(X, \\vec\{y\}, \\vec\{w\}, b) w∗,b∗=argw,bminl(X,y,w,b)

#### 1.2.4 显式解 ####

> 由于是线性模型，所以会有显式解。这也是唯一一个有最优解的模型，之后的所有模型都不会有最优解了。

首先，将偏差加入权重  
 X ← \[ W , 1 ⃗ \] w ⃗ ← \[ w ⃗ b \] X \\leftarrow \\begin\{bmatrix\}W, \\vec\{1\}\\end\{bmatrix\} \\qquad \\vec\{w\} \\leftarrow \\begin\{bmatrix\}\\vec\{w\} \\\\ b\\end\{bmatrix\} X←\[W,1\]w←\[wb\]将偏差加入权重之后，我们的预测就等于 X w ⃗ X\\vec\{w\} Xw，即  y ^ = X w ⃗ \\hat\{y\}=X\\vec\{w\} y^=Xw。  
 l ( X , y ⃗ , w ⃗ ) = 1 2 n ∣ ∣ y ⃗ − X w ⃗ ∣ ∣ 2 l(X, \\vec\{y\}, \\vec\{w\}) = \\frac\{1\}\{2n\}||\\vec\{y\}-X\\vec\{w\}||^2 l(X,y,w)=2n1∣∣y−Xw∣∣2 ∂ ∂ w ⃗ l ( X , y ⃗ , w ⃗ ) = 1 n ( y ⃗ − X w ⃗ ) T X \\frac\{\\partial\}\{\\partial \\vec\{w\}\}l(X, \\vec\{y\}, \\vec\{w\}) = \\frac\{1\}\{n\}(\\vec\{y\}-X\\vec\{w\})^TX ∂w∂l(X,y,w)=n1(y−Xw)TX  
损失是凸函数，在梯度等于0时取最优解，所以最优解满足：  
 ∂ ∂ w ⃗ l ( X , y ⃗ , w ⃗ ) = 0 \\frac\{\\partial\}\{\\partial \\vec\{w\}\}l(X, \\vec\{y\}, \\vec\{w\})=0 ∂w∂l(X,y,w)=0 ⇔ 1 n ( y ⃗ − X w ⃗ ) T X = 0 \\Leftrightarrow \\frac\{1\}\{n\}(\\vec\{y\}-X\\vec\{w\})^TX=0 ⇔n1(y−Xw)TX=0 ⇔ w ⃗ ∗ = ( X T X ) − 1 X y ⃗ \\Leftrightarrow \\vec\{w\}^\*=(X^TX)^\{-1\}X\\vec\{y\} ⇔w∗=(XTX)−1Xy

### 1.3 总结 ###

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

## 二、基础优化算法 ##

### 2.1 梯度下降 ###

挑选一个初始值 W ⃗ 0 \\vec\{W\}\_0 W0，之后不断更新 W ⃗ 0 \\vec\{W\}\_0 W0，使其接近最优解。  
设置重复迭代参数  t = 1 , 2 , 3 ⋯ t=1, 2, 3 \\cdots t=1,2,3⋯  
 W ⃗ t = W ⃗ t − 1 − η ∂ l ∂ W ⃗ t − 1 \\vec\{W\}\_t = \\vec\{W\}\_\{t-1\} - \\eta \\frac\{\\partial l\}\{\\partial \\vec\{W\}\_\{t-1\}\} Wt=Wt−1−η∂Wt−1∂l

*   ∂ l ∂ W ⃗ t − 1 \\frac\{\\partial l\}\{\\partial \\vec\{W\}\_\{t-1\}\} ∂Wt−1∂l：损失函数关于 ∂ W ⃗ t − 1 \\partial \\vec\{W\}\_\{t-1\} ∂Wt−1的**梯度**，沿梯度方向将增加损失函数值。
 *   η \\eta η：**学习率**，即步长的超参数，表示沿着负梯度方向上一次走的距离。
 *  通过 ∂ l ∂ W ⃗ t − 1 \\frac\{\\partial l\}\{\\partial \\vec\{W\}\_\{t-1\}\} ∂Wt−1∂l和 η \\eta η，我们可以沿着梯度下降最快的方向，一步步地得到最小的梯度值。  
    ![c77657123a384ed091b7101e01140d57.png_pic_center][]

**选择学习率不能太大，也不能太小。**

*  如果学习率太小，每一次的步长将会很小，梯度下降的速度会大幅下降。
 *  如果学习率太大，梯度可能会一直在震荡，并没有真正的下降。  
    ![过大或过小][50e873497caa4befa8833cc0db7b8fc2.png]

### 2.2 小批量随机梯度下降 ###

在深度学习中，我们很少直接使用梯度下降，通常会采用小批量梯度下降。  
这是因为在整个训练集上算梯度的时间成本太高，一个深度神经网络模型可能需要数分钟至数小时。  
我们可以随机采样b个样本 i 1 , i 2 , ⋯   , i b i\_1, i\_2, \\cdots, i\_b i1,i2,⋯,ib来计算近似损失：  
 1 b ∑ i ∈ I b l ( x ⃗ i , y i , w ⃗ ) \\frac\{1\}\{b\} \\sum\_\{i \\in I\_b\}l(\\vec\{x\}\_i, y\_i, \\vec\{w\}) b1i∈Ib∑l(xi,yi,w)其中，b是**批量大小**，是深度学习中的另一个重要的超参数。  
同样地，**批量大小不能太小，也不能太大**。

*  如果批量大小太小，每次计算量太小，不适合并行来最大利用计算资源。
 *  如果批量大小太大，则内存消耗增加；浪费计算，例如：如果所有样本都是相同的。

### 2.3 总结 ###

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

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

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

### 3.1 导入的库 ###

本文使用的编辑器为PyCharm，文中代码已针对PyCharm和jupyter的区别进行了修改。下面的代码中，jupyter可以使用`%matplotlib inline`来内嵌绘图；在PyCharm中使用这句代码则会报错，本文通过`plt.show()`来展示绘图。

# %matplotlib inline
    import torch
    import matplotlib.pyplot as plt
    import random
    from d2l import torch as d2l

### 3.2 数据集 ###

#### 3.2.1 构造数据集 ####

这里我们采用自己构造的一个简单数据集。根据带有噪声的线性模型构造一个人造数据集。我们使用线性模型参数 w ⃗ = \[ 2 − 3.4 \] T \\vec\{w\}=\\begin\{bmatrix\}2 & -3.4\\end\{bmatrix\}^T w=\[2−3.4\]T、 b = 4.2 b=4.2 b=4.2和噪声项 ε \\varepsilon ε生成数据集及其标签：  
 y ⃗ = X w ⃗ + b + ε \\vec\{y\}=X\\vec\{w\}+b+\\varepsilon y=Xw\+b\+ε

# 生成数据集函数
    def synthetic_data(w, b, num_examples):
        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)

#### 3.2.2 展示数据集 ####

features中的每一行都包含一个二维数据样本，labels中的每一行都包含一个一维标签值（一个标量）  
我们可以通过绘图来形象地看到我们的训练样本。

# 展示数据集
    print('features: ', features[0], '\nlabels: ', labels[0])
    d2l.set_figsize()
    d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1)
    plt.show()

![数据集][58dc70b1340749d685c270d06abde147.png]

### 3.3 从零开始实现 ###

#### 3.3.1 生成小批量 ####

定义一个`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

#### 3.3.2 模型和初始化模型参数 ####

读取了数据集之后，我们要定义**初始化模型参数**和**模型**。  
我们将权重`w`随机初始化成均值为0、方差为0.01的正态分布。同时，因为我们要计算梯度，故设置参数`requires_grad=True`。

# 定义初始化模型参数
    w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
    b = torch.zeros(1, requires_grad=True)
    
    # 定义模型
    def linreg(X, w, b):
        """ 线性回归模型 """
        return torch.matmul(X, w) + b

#### 3.3.3 定义损失函数 ####

我们采用**均方损失函数**。因为`y`和`y_hat`可能是行向量或者列向量，所以我们用`reshape()`方法将它们修改成同样的形状。

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

#### 3.3.4 定义优化方法 ####

我们采用**SGD优化方法**。SGD优化方法的输入需要给定所有的**参数（包括w和b）**、**学习率**和**批量大小**。

# 定义优化方法
    def sgd(params, lr, batch_size):
        """ 小批量随机梯度下降 """
        with torch.no_grad():   # 更新的时候，不要进行梯度计算
            for param in params:
                param -= lr * param.grad / batch_size
                param.grad.zero_()

#### 3.3.5 训练过程 ####

# 训练过程
    lr = 0.03           # 学习率
    num_epochs = 3      # 整个数据扫3遍
    net = linreg        # 模型
    loss = squard_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_1 = loss(net(features, w, b), labels)
    		print(f'epoch {
          epoch + 1}, loss {
          float(train_1.mean()):f}')

#### 3.3.6 分析 ####

由于我们使用的是自己构造的数据集，可以看到真实的参数，故我们可以比较真实参数和通过训练学到的参数来评估训练的成功程度。

# 比较真实参数和通过训练学到的参数来评估训练的成功程度
    print(f'w的估计误差：{
          true_w - w.reshape(true_w.shape)}')
    print(f'b的估计误差：{
          true_b - b}')

## 四、线性回归的简洁实现 ##

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

### 4.1 用到的函数 ###

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>功能</th> 
   <th>参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>data.TensorDataset()</code></td> 
   <td>用来对tensor进行打包</td> 
   <td>输入数据必须是tensor类型</td> 
  </tr> 
  <tr> 
   <td><code>data.DataLoader()</code></td> 
   <td>用来实现批量数据的迭代</td> 
   <td><code>dataset</code>：数据集<br><code>batch_size</code>：批量大小<br><code>shuffle</code>：洗牌</td> 
  </tr> 
  <tr> 
   <td><code>iter()</code></td> 
   <td>生成迭代器<br>一次能返回一个元素</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><code>next()</code></td> 
   <td>返回迭代器的下一个项目</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><code>nn.Linear()</code></td> 
   <td>设置网络中的全连接层</td> 
   <td><code>in_features</code>：输入张量的形状<br><code>out_features</code>：输出张量的形状</td> 
  </tr> 
  <tr> 
   <td><code>nn.Sequential</code></td> 
   <td>是一个Sequential容器</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><code>nn.MSELoss()</code></td> 
   <td>均分损失函数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><code>torch.optim.SGD()</code></td> 
   <td>随机梯度下降算法</td> 
   <td><code>params</code>：待优化参数的迭代器<br><code>lr</code>：学习率</td> 
  </tr> 
 </tbody> 
</table>

### 4.2 导入库并生成数据集 ###

import numpy as np
    import torch
    from torch import nn
    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)

### 4.3 读取数据 ###

我们可以调用框架中现有的API来读取数据。

def load_array(data_arrays, batch_size, is_train=True):
        """ 构造一个PyTorch数据迭代器 """
        dataset = data.TensorDataset(*data_arrays)
        return data.DataLoader(dataset, batch_size, shuffle=is_train)
    
    # 调用框架中现有的API来读取数据
    batch_size = 10
    data_iter = load_array((features, labels), batch_size)
    next(iter(data_iter))

### 4.4 模型的定义 ###

使用框架的预定义好的层，并初始化模型参数。  
我们使用`nn.Linear()`方法来构造一个线性层，并把这个层放到`nn.Sequential()`容器中。  
之后，我们可以通过`net[0]`来访问到这个层，通过`net[0].weight`来访问这个层的权重`w`，因此可以通过`net[0].weight.data.normal_(0, 0.01)`来将线性层的权重的值替换为正态分布的值。  
而`net[0].bias`则是线性层的偏差，我们通过`net[0].bias.data.fill_(0)`将这个线性层的偏差设置为0。

# 使用框架的预定义好的层
    net = nn.Sequential(nn.Linear(2, 1))
    
    # 初始化模型参数
    net[0].weight.data.normal_(0, 0.01)
    net[0].bias.data.fill_(0)

### 4.5 损失函数 ###

我们的损失函数依然采用均方误差，使用`MSELoss`类。均方误差也成为平方范数（ L 2 L\_2 L2范数）。

loss = nn.MSELoss()

### 4.6 优化方法 ###

实例化`SGD`实例。

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

### 4.7 训练过程 ###

# 训练过程
    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}')

[下一篇：【动手学深度学习v2李沐】学习笔记04：Softmax回归、损失函数、图片分类数据集、详细代码实现][v2_04_Softmax]

[Link 1]: https://blog.csdn.net/weixin_45800258/article/details/126781209
[fb9e3ebfede3454a813c8e0cb9691afb.png]: https://img-blog.csdnimg.cn/fb9e3ebfede3454a813c8e0cb9691afb.png
[c77657123a384ed091b7101e01140d57.png_pic_center]: https://img-blog.csdnimg.cn/c77657123a384ed091b7101e01140d57.png#pic_center
[50e873497caa4befa8833cc0db7b8fc2.png]: https://img-blog.csdnimg.cn/50e873497caa4befa8833cc0db7b8fc2.png
[58dc70b1340749d685c270d06abde147.png]: https://img-blog.csdnimg.cn/58dc70b1340749d685c270d06abde147.png
[v2_04_Softmax]: https://blog.csdn.net/weixin_45800258/article/details/126824826