PyTorch | 实现机器学习（线性回归）

一、使用 Numpy 实现机器学习
- 1.1 导入需要的库
- 1.2 生成输入数据 x 及目标数据 y
- 1.3 查看 x、y 数据分布情况
- 1.4 初始化权重参数
- 1.5 训练模型
- 1.6 可视化训练结果
二、使用 Tensor 及 Autograd 实现机器学习
- 2.1 导入需要的库
- 2.2 生成训练数据，并可视化数据分布情况
- 2.3 初始化权重参数
- 2.4 训练模型
- 2.5 可视化训练结果

一、使用 Numpy 实现机器学习

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

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

qquad 最后，采用梯度下降法，通过多次迭代，学习到 w 、 b w、b 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 生成输入数据 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.3 查看 x、y 数据分布情况

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

1.4 初始化权重参数

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

1.5 训练模型

定义损失函数，假设批量大小为 100 100 100： L o s s = 1 2 ∑ i = 1 100 ( w x i 2 + b − y i ) 2 displaystyle Loss=frac{1}{2}sum_{i=1}^{100}(wx_i^2+b-y_i)^2 Loss=21i=1∑100(wxi2+b−yi)2
对损失函数求导： ∂ L o s s ∂ w = ∑ i = 1 100 ( w x i 2 + b − y i ) x i 2 ∂ L o s s ∂ b = ∑ i = 1 100 ( w x i 2 + b − y i ) displaystylefrac{partial Loss}{partial w}=sum_{i=1}^{100}(wx_i^2+b-y_i)x_i^2\displaystylefrac{partial Loss}{partial b}=sum_{i=1}^{100}(wx_i^2+b-y_i) ∂w∂Loss=i=1∑100(wxi2+b−yi)xi2∂b∂Loss=i=1∑100(wxi2+b−yi)
利用梯度下降法学习参数，学习率为 l r lr lr。 w = w − l r ∗ ∂ L o s s ∂ w b = b − l r ∗ ∂ L o s s ∂ b w=w-lr*frac{partial Loss}{partial w}\b=b-lr*frac{partial Loss}{partial b} w=w−lr∗∂w∂Lossb=b−lr∗∂b∂Loss

用代码实现上面这些表达式：

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.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)

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

qquad 使用 P y T o r c h PyTorch PyTorch 的自动求导包 a u t o g r a d autograd autograd 便可利用自动反向传播来求梯度。

2.1 导入需要的库

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

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()

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)

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

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)

PyTorch | 实现机器学习（线性回归）

Python相关栏目本月热门文章