PyTorch | 实现机器学习（线性回归）_pytorch 线性回归 反向求导

一、使用 Numpy 实现机器学习

\qquad 首先，给出一个数组 $x$，然后基于表达式 $y=3x^2+2$，加上一些噪音数据到达另一组数据 $y$。

\qquad 然后，构建一个机器学习模型，学习表达式 $y=w{x}^2+b$ 的两个参数 $w、b$。利用数组 $x$，$y$ 的数据为训练数据。

\qquad 最后，采用梯度下降法，通过多次迭代，学习到 $w、b$ 的值。

$具体步骤如下：$

1.1 导入需要的库

# -*- coding:utf-8 -*-
import numpy as np
# 调用matplotlib.pyplot的绘图函数plot()进行绘图的时候，或者生成一个figure画布的时候，可以直接python console里生成图像
%matplotlib inline
from matplotlib import pyplot as plot
1
2
3
4
5

1.2 生成输入数据 x 及目标数据 y

# 设置随机数种子，生成同一份数据，以便用多种方法进行比较
np.random.seed(100)
x = np.linspace(-1,1,100).reshape(100,1)
# 为数据加入噪声 0.2 * np.random.rand(x.size).reshape(100,1)
y = 3 * np.power(x,2) + 2 + 0.2 * np.random.rand(x.size).reshape(100,1)
1
2
3
4
5

1.3 查看 x、y 数据分布情况

# 画图
plt.scatter(x,y)
plt.show()
1
2
3

1.4 初始化权重参数

# 随机初始化参数
w = np.random.rand(1,1)
b = np.random.rand(1,1)
1
2
3

1.5 训练模型

• 定义损失函数，假设批量大小为 $100$：$$Loss=\frac{1}{2}\sum _{i=1}^{100}(w{x}_i^2+b-y_i{)}^2$$
• 对损失函数求导：$$\begin{gathered} \frac{\partial Loss}{\partial w}=\sum _{i=1}^{100}(w{x}_i^2+b-y_i)x_i^2 \\ \frac{\partial Loss}{\partial b}=\sum _{i=1}^{100}(w{x}_i^2+b-y_i) \end{gathered}$$
• 利用梯度下降法学习参数，学习率为 $lr$。$$\begin{gathered} w=w-lr\ast \frac{\partial Loss}{\partial w} \\ b=b-lr\ast \frac{\partial Loss}{\partial b} \end{gathered}$$
• 用代码实现上面这些表达式：

  lr = 0.001 # 学习率
  # 迭代 800 次
  for i in range(800):
     # 前向传播
     y_pred = np.power(x,2) * w + b
     # 定义损失函数
     loss = 0.5 * (y_pred - y) ** 2
     loss = loss.sum()
     # 计算梯度
     grad_w = np.sum((y_pred - y) * np.power(x,2))
     grad_b = np.sum((y_pred - y))
     # 使用梯度下降法，是loss最小
     w -= lr * grad_w
     b -= lr * grad_b
  y_pred = np.power(x,2) * w + b
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

1.6 可视化训练结果

plt.plot(x,y_pred,'r-',label='predict')
plt.scatter(x,y,color='blue',marker='o',label='true')
plt.xlim(-1,1)
plt.ylim(2,6)
plt.legend()
plt.show()
print(w,b)
1
2
3
4
5
6
7

二、使用 Tensor 及 Autograd 实现机器学习

\qquad 使用 $PyTorch$ 的自动求导包 $autograd$ 便可利用自动反向传播来求梯度 。

2.1 导入需要的库

# 导入需要的库
import torch
%matplotlib inline
from matplotlib import pyplot as plt
1
2
3
4

2.2 生成训练数据，并可视化数据分布情况

# 生成训练数据，并可视化数据分布情况
torch.manual_seed(100)
# 生成x坐标数据，x为tensor，需要把x的形状转换为 100 x 1
x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1)
# 生成y坐标数据，y为tensor，形状为 100 x 1，另加上一些噪声
y = 3 * x.pow(2) + 2 + 0.2 * torch.rand(x.size())
# 画图，把tensor数据转换为numpy数据
plt.scatter(x.numpy(),y.numpy())
plt.show()
1
2
3
4
5
6
7
8
9

2.3 初始化权重参数

# 随机初始化参数，参数w、b为需要学习的，故需requires_grad=True
w = torch.randn(1,1,dtype=torch.float,requires_grad=True)
b = torch.randn(1,1,dtype=torch.float,requires_grad=True)
1
2
3

2.4 训练模型

lr = 0.001 # 学习率
for i in range(800):
    # 前向传播
    y_pred = x.pow(2).mm(w) + b
    # 定义损失函数
    loss = 0.5 * (y_pred - y) ** 2
    loss = loss.sum()
    # 自动计算梯度，梯度存放在grad属性中
    loss.backward()
    # 手动更新参数，需要用torch.，使上下文环境中切断自动求导的计算
    # 强制之后的内容不进行计算图构建，节省了内存空间
    with torch.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad
    # 梯度清零
    w.grad.zero_()
    b.grad.zero_()
y_pred = x.pow(2).mm(w) + b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.5 可视化训练结果

# 涉及到梯度反向传播的tensor变量不能够直接使用numpy()转numpy
# 需要使用detach返回一个新的tensor,从当前的计算图中分离出来
plt.plot(x.numpy(),y_pred.detach().numpy(),'r-',label='predict')
plt.scatter(x.numpy(),y.numpy(),color='blue',marker='o',label='true')
plt.xlim(-1,1)
plt.ylim(2,6)
plt.legend()
plt.show()
print(w,b)
1
2
3
4
5
6
7
8
9