利用torch自动求导机制理解反向传播

weixin_42924890

已于 2024-03-08 10:12:59 修改

阅读量1.1k

点赞数 34

文章标签： python pytorch

于 2024-02-22 14:21:45 首次发布

本文链接：https://blog.csdn.net/weixin_42924890/article/details/136232487

版权

BP算法

反向传播算法，又称BP算法，它将输出层的误差反向逐层传播，通过计算偏导数来更新网络参数使得误差函数最小化。

前言

本文通过torch的自动求导机制验证反向传播的过程，并通过梯度下降法进行验证。

在可视化的过程中，突然发现在利用pytorch进行模型训练的时候batch size对损失值的影响，有人说在显存够大的情况尽可能的让batch size大一点，也许从损失值的可视化中可以看到原因。

2024.3.8更新
对于batch size的相关问题参考神经网络的训练过程这篇文章也许可以解释本文loss图像的变化。解释总结如下：
1）batch size变大更新次数少，但是每一次迭代考虑的样本更多了。每次迭代考虑的样本大了以后，梯度优化的波动变小，下降更平滑。
2）batch size很小梯度会产生频繁震荡，不容易收敛。正常情况下，适当增大batch size，应该是更容易收敛。
3）如果batch size太大，不同batch的梯度方向变化太小，容易陷入局部极小值，自然收敛就慢。

目标函数为
$\begin{aligned} & \hat{y} = X\cdot w +b \\ & \\ & loss = \dfrac{1}{n} \sum_{i=1}^{n} (y^{(i)}-\hat{y}^{(i)})^{2} \\ \\ & X_{n \times m} 样本集，w_{m\times 1}待求权重，b_{1 \times 1}待求偏置 \end{aligned}$

设置权重和偏置

w_0 = np.array([1.0, 2.0, 3.0])
b_0 = np.array([2])

利用torch的反向求导机制和梯度下降法来反向求解这两个参数。

torch实现

import torch
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(123)
x_data_ = np.random.rand(100, 3)
x_data = torch.from_numpy(x_data_)

w_0 = np.array([1.0, 2.0, 3.0])
b_0 = np.array([2.0])
y_data_ = x_data_.dot(w_0) + b_0
y_data = torch.from_numpy(y_data_)

# 创建tensor节点，需要更新的权重
w = torch.ones(3).double()
b = torch.zeros(1).double()
# 需要计算梯度
w.requires_grad = True
b.requires_grad = True
epochs = 10
learn_rate = 0.01
# 记录每一个样本的损失值便于可视化
loss_list = []
for epoch in range(epochs):
    # 梯度更新的次数为 epochs*x_data.shape[0]次
    l_sum = 0.0
    for i in range(x_data.shape[0]):
        # 损失函数计算
        y_hat = torch.matmul(x_data[i], w) + b
        l = (y_hat - y_data[i]) ** 2
        # 反向传播计算grad值
        l.backward()
        loss_list.append(l.detach().numpy())
        # 借助pytorch计算的梯度来更新模型参数w和b
        w.data = w.data - learn_rate * w.grad.data
        b.data = b.data - learn_rate * b.grad.data
        # 将当前梯度清零，避免梯度累加
        w.grad.data.zero_()
        b.grad.data.zero_()
print(f"截距: {b}")
print(f"系数: {w}")

plt.plot(range(epochs * x_data.shape[0]), loss_list)
plt.show()

损失函数结果图，损失值大概在400次的迭代基本收敛到0附近。这里仅仅是单个样本的损失值根据梯度去更新权重系数。
在这里插入图片描述

梯度下降法实现

梯度下降法还不是很熟的可以参考这里批量梯度下降法原理

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(123)
x_data = np.random.rand(100, 3)
w_0 = np.array([1.0, 2.0, 3.0])
b_0 = np.array([2])
y_data = x_data.dot(w_0) + b_0
y_data = y_data.flatten()


# 定义目标函数
def J(theta, X_b, y):
    try:
        y_hat = X_b.dot(theta)
        return np.sum((y - y_hat) ** 2) / len(y)
    except:
        return float('inf')


# 计算梯度
def dJ(theta, X_b, y):
    y_hat = X_b.dot(theta)
    return X_b.T.dot(y_hat - y) * 2. / len(y)


def gradient_descent(X_b, y, initial_theta, eta=0.01, n_iters=1e5, epsilon=1e-18):
    theta = initial_theta
    cur_iter = 0
    loss_list = []
    while cur_iter < n_iters:
        gradient = dJ(theta, X_b, y)
        last_theta = theta
        theta = theta - eta * gradient
        loss_list.append(J(theta, X_b, y))

        if abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon:
            break

        cur_iter += 1

    return theta, loss_list


# 在x_data的第一列加上全1列形成增广矩阵，将截距放在权重的第一个位置
X_b = np.hstack([np.ones((len(x_data), 1)), x_data])
# initial_theta[0]是截距
initial_theta = np.ones(X_b.shape[1])
eta = 0.01
n_iters = 1000
theta, loss_list = gradient_descent(X_b, y_data, initial_theta, eta, n_iters=n_iters)

print(f"截距: {theta[0]}")
print(f"系数: {theta[1:]}")

plt.plot(range(n_iters), loss_list)
plt.show()

损失函数结果图，损失函数的图像比较平滑，gradient_descent函数中while的每一次循环都是所有样本的损失值根据梯度更新权重系数。
在这里插入图片描述

从损失函数的可视化可以看出两种算法的有不一样的地方。这里最大的区别是torch在反向传播的时候是每一个样本计算一个损失，然后根据损失的梯度进行参数更新。

numpy的梯度下降法是根据所有样本计算一个损失，然后根据这个损失计算梯度进行参数更新。

反映在图上就是torch的损失值比较坎坷，梯度下降发就是比较平滑。

这里torch中损失的计算和梯度的更新可以看成是batch _size=1。修改代码将batch _size设置成10及和样本数一致，看一下损失值的图像。

import torch
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(123)
x_data_ = np.random.rand(100, 3)
x_data = torch.from_numpy(x_data_)

w_0 = np.array([1.0, 2.0, 3.0])
b_0 = np.array([2.0])
y_data_ = x_data_.dot(w_0) + b_0
y_data = torch.from_numpy(y_data_)

# 创建tensor节点，需要更新的权重
w = torch.ones(3).double()
b = torch.zeros(1).double()
# 需要计算梯度
w.requires_grad = True
b.requires_grad = True

# 样本训练次数
epochs = 100
# 按批次进行损失计算和更新
batch_size = 10
learn_rate = 0.01
loss_list = []

for epoch in range(epochs):
    # 梯度更新的次数为 epochs*x_data.shape[0]次
    for i in range(int(len(x_data) / batch_size)):
        start = i * batch_size
        end = (i + 1) * batch_size
        # 损失函数计算
        y_hat = torch.matmul(x_data[start:end], w) + b
        l = torch.sum((y_hat - y_data[start:end]) ** 2) / batch_size
        # 反向传播计算grad值
        l.backward()
        loss_list.append(l.detach().numpy())
        # 借助pytorch计算的梯度来更新模型参数w和b
        w.data = w.data - learn_rate * w.grad.data
        b.data = b.data - learn_rate * b.grad.data
        # 将当前梯度清零，避免梯度的累加
        w.grad.data.zero_()
        b.grad.data.zero_()
print(f"截距: {b}")
print(f"系数: {w}")

plt.plot(range(epochs * int(len(x_data) / batch_size)), loss_list)
plt.show()