Pytorch框架——自动微分和反向传播

一、自动微分概念

自动微分（Automatic Differentiation，AD）是一种利用计算机程序自动计算函数导数的技术，它是机器学习和优化算法中的核心工具（如神经网络的梯度下降），通过反向传播计算并更新梯度。

计算梯度的目的是更新权重w和b，，其中value是梯度值，学习率需要提前指定，求导计算梯度，前面我们学过了手动求导，这次使用自动微分的方法，来简化我们的工作量。

注意：

1. w和b一定是可自动微分的张量，类型是浮点型，超参数requries_grad=Ture表示允许自动微分。

2. detach()：自动微分的张量不能转换成numpy数组, 通过 张量.detach().numpy() 剥离成不自动微分后可以转换。detach()返回一个与当前张量共享数据的新张量，该张量是不开启自动微分的，不参与梯度计算。

    clone()：返回一个与当前张量数据相同的新张量，默认开启自动微分，但新张量拥有独立的存储。

3. 默认梯度是累加的,所以多轮中每个轮次需要在自动微分之前进行清零！！！

4. 查看张量底层数据地址时推荐使用 张量名.data_ptr() 

import torch

# TODO 单轮
#定义权重，并开启自动微分
w = torch.tensor([10,20],requires_grad=Ture,dtype=torch.float)
#定义损失函数（loss,cost,criterion...）
loss = 2 * w**2
#自动微分求梯度，自动更新梯度
loss.sun().backward()
#手动更新权重
w.data = w.data - 0.01*w.grad


# TODO 多轮
#定义权重，并开启自动微分
w = torch.tensor([10,20],requires_grad=Ture,dtype=torch.float)
#定义遍历轮次
epochs = 500
for epoch in range(epochs):
    loss = 2 * w**2
    # 默认梯度是累加的，所以每轮需要在自动微分之前进行清零
    if w.grad is not None:
        w.grad.zero_()
    loss.sum().backward()
    # 格式化输出
    print(f"当前轮次:{epoch + 1} 当前权重: {w.data},固定学习率:{0.01} 更新后梯度: {w.grad},下一个权重: {w.data - 0.01 * w.grad}")
    #手动更新权重
    w.data = w.data - 0.01*w.grad

推导w和b的方法：

import torch
x = torch.ones(2, 5)
y = torch.zeros(2, 3)
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)

# 1.首先获取损失函数
loss_fn = torch.nn.MSELoss()
# 2.然后,计算预测值-> z=wx+b 注意: 这里面的wx是矩阵乘法，需要遵循 (n,m)*(m,p)=(n,p)
z = x.matmul(w) + b
# 3.接着,根据损失函数计算损失值
loss = loss_fn(z, y)
# 4.最后,反向传播推导更新梯度
loss.sum().backward()

# 5.打印结果
print(f'w.grad: {w.grad}')
print(f'b.grad: {b.grad}')

二、 反向传播及案例

正向传播：从输入到输出，目的是预测结果和损失值；

反向传播：从输出到输入，更新参数做出优化。

案例：使用pytorch构建一个回归模型

步骤：

1.获取数据集，提前封装数据为张量

2.模型训练预测以及计算损失值

3.绘制损失曲线以及预测和真实值的拟合线

from sklearn.datasets import make_regression
import torch
from torch.utils.data import DataLoader, TensorDataset
from torch.nn import Linear, MSELoss
from torch.optim import SGD
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False


# 1.获取数据集，提前封装成张量
def get_data():
    X,y,coef = make_regressionn(n_samples=100,n_features=1,n_targets=1,noise=10,random_state=1,coef=Ture,bias=14.5)
    X = torch.tensor(X,dtype=torch.float32)
    y = torch.tensor(y,dtype=torch.float32)
    return X,y,coef

# 2.模型训练预测及损失值计算
def get_model_and_loss_list(x, y, epochs):
    # 2.1 处理数据封装为数据加载器，为了分批次训练，避免内存溢出
    dataloader = DataLoader(TensorDataset(x,y),batch_size = 5,shuffle=Ture)
    # 2.2 创建模型对象，为了模型预测
    model = Linear(in_features=1,out_features=1)
    # 2.3 创建损失函数对象，为了计算损失值
    loss_fn = MSELoss()
    # 2.4 创建SGD优化器对象，为了更新模型参数
    optimizer = SGD(model.parameters(),lr=0.03)
    # 2.5 模型训练预测和计算损失
    # 2.5.1 定义一个空列表，用于保存每轮损失值，再定义累加损失和批次，用于计算每轮的损失值
    loss_list,total_loss,batch_cnt = [],0.0,0
    # for循环，外循环轮次，内循环批次
    for epoch in range(epochs):
        for batch_x,batch_y in dataloader:
            # [重点] 正向传播
            # 计算预测值
            y_predict = model(batch_x)
            # 计算损失值，MSE计算要求形状必须一致，否则自动广播会出现无效计算
            loss = loss_fn(y_predict,batch_y.reshape(-1,1))
            # 累加损失和批次
            total_loss += loss.item()
            batch_cnt += 1
            # [重点] 反向传播
            # 梯度清零
            optimizer.zero_grad()
            # 梯度计算
            loss.backward()
            # 参数更新 step()底层是w1 = w0-lr*梯度
            optimizer.step()
        # TODO 内层循环结束,即一轮结束,可以计算每轮损失值,并保存到列表中
        epoch_loss = total_loss / batch_cnt
        loss_list.append(epoch_loss)
        print(f"第{epoch + 1}轮,损失值为:{epoch_loss:.2f}")
    # TODO 外层循环结束,即所有轮次结束,可以返回模型和损失值列表
    # 打印模型参数字典
    print(f"模型参数:{model.state_dict()}")
    # print(f"模型权重:{model.weight}, 偏置:{model.bias}")
    # 返回结果
    return model, loss_list

# 3.绘制损失曲线及预测和真实值拟合线
def plot_show(epochs, model, loss_list, x, y, coef):
    # todo 1.绘制每轮损失曲线
    plt.plot(range(epochs), loss_list)
    plt.xlabel('训练的轮数')
    plt.ylabel('该轮的平均损失')
    plt.title('损失变化曲线图')
    plt.grid()
    plt.show()
    #  todo 2.绘制预测和真实值拟合线
    plt.scatter(x, y)
    # 使用x的最小值,最大值生成1000个x值等差张量
    X = torch.linspace(x.min(), x.max(), 1000)
    # 细节:  numpy * 张量 -> 不可以     张量 * numpy -> 可以, 要么把v放到前面位置要么把coef转为张量
    y_pred = torch.tensor([v * model.weight + model.bias for v in X])
    y_true = torch.tensor([v * coef + 14.5 for v in X])
    plt.plot(X, y_pred, label='训练', color='red')
    plt.plot(X, y_true, label='真实', color='green')
    plt.legend()
    plt.grid()
    plt.show()


if __name__ =='__main__':
    
    # 1.获取数据集,提前封装数据为张量
    x, y, coef = get_data()
    # 2.模型训练预测以及计算损失值
    epochs = 4000
    model, loss_list = get_model_and_loss_list(x, y, epochs)
    # 3.绘制损失曲线以及预测和真实值拟合线
    plot_show(epochs, model, loss_list, x, y, coef)