基于PyTorch的深度学习4——使用numpy实现机器学习vs使用Tensor及Antograd实现机器学习

时间：2025-03-10 14:19:41

首先，给出一个数组x，然后基于表达式y=3x2+2，加上一些噪音数据到达另一组数据y。然后，构建一个机器学习模型，学习表达式y=wx2+b的两个参数w、b。利用数组x，y的数据为训练数据。最后，采用梯度梯度下降法，通过多次迭代，学习到w、b的值。以下为具体步骤：

1)导入需要的库。

import numpy as np
%matplotlib inline
from matplotlib import pyplot as plt

2)生成输入数据x及目标数据y

设置随机数种子，方便多种方法进行比较

np.random.seed(100)

x=np.linspace(-1,1,100).reshape(100,1)#我们把原本一维的、有100个元素的数组转换成了一个具有100行# 和1列的二维数组，也就是一个列向量。

y=3*np.power(x,2)+2+0.2*np.random.rand(x.size).reshape(100,1)
#创建了一个新的变量 y，它表示的是基于 x 计算出的一个二次多项式 y=3x^2+2，再加上一些小的随机噪声，这些噪声的大小在 [0, 0.2) 范围内随机变化。

3)初始化权重参数

w1=np.random.rand(1,1)
b1=np.random.rand(1,1)

4) 训练模型

定义损失函数，假设批量大小为100，对损失函数求导，利用梯度下降法学习参数（学习率为lr）

import numpy as np

# 假设 x, y 已经定义好
# 初始化参数
w1 = np.random.randn()  # 随机初始化权重
b1 = np.random.randn()  # 随机初始化偏置
lr = 0.001  # 学习率

for i in range(800):  # 迭代800次
    # 前向传播
    y_pred = np.power(x, 2) * w1 + b1
    
    # 定义损失函数
    loss = 0.5 * np.sum((y_pred - y) ** 2)
    
    # 计算梯度
    grad_w = np.sum((y_pred - y) * np.power(x, 2))
    grad_b = np.sum(y_pred - y)
    
    # 使用梯度下降法更新参数
    w1 -= lr * grad_w
    b1 -= lr * grad_b

这个过程实际上是在寻找使得预测值 y_pred 尽可能接近真实值 y 的最佳参数组合 (w1, b1)。通过不断调整这些参数，我们可以逐渐减小损失函数的值，从而提高模型的准确性。

________________________________________________________________________

本节我们将使用PyTorch的一个自动求导的包——antograd，利用这个包及对应的Tensor，便可利用自动反向传播来求梯度，无须手工计算梯度。以下是具体实现代码。

1)导入需要的库。

import torch as t
%matplotlib inline
from matplotlib import pyplot as plt

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

t.manual_seed(100)
dtype=t.float

#生成x坐标数据，x为tensor，需要把x的形状转换为100x1
x=t.unsqueeze(torch.linspace(-1,1,100),dim=1)

#生成y坐标数据，y为tensor，形状为100x1，另外加上一些噪声
y=3*.x.pow(2)+2+0.2*torch.rand(x.size())

3) 初始化权重参数

# 参数w，b为需要学习，所以requires_grad=True
w=t.randn(1,1,dtype=dtype,requires_grad=True)
b=t.zeros(1,1,dtype=dtype,requires_grad=True)

4)训练模型

import torch as t

# 假设 x, y, w, b 已经定义好，并且 w 和 b 需要是 requires_grad=True 的张量
lr = 0.001  # 学习率

for ii in range(800):
    # 前向传播，并定义损失函数 loss
    y_pred = x.pow(2).mm(w) + b
    loss = 0.5 * (y_pred - y).pow(2).sum()

    # 自动计算梯度，梯度保存在 grad 属性中
    loss.backward()

    # 手动更新参数，需要用 torch.no_grad()，使上下文环境中切断自动求导的计算
    with t.no_grad():
        w -= lr * w.grad
        b -= lr * b.grad

        # 梯度清零
        w.grad.zero_()
        b.grad.zero_()
  • 使用 torch.no_grad() 上下文管理器来临时禁用自动求导，以便在不需要跟踪这些操作的情况下更新权重和偏置。这是因为我们只希望向前传递时记录操作用于自动求导，而在更新权重时则不需要。
  • w -= lr * w.grad 和 b -= lr * b.grad：按照梯度下降的方式更新权重和偏置。
  • w.grad.zero_() 和 b.grad.zero_()：在每次更新之后，需要手动将梯度清零，否则梯度会累积，导致错误的更新步骤。

相关文章