跟着StatQuest学知识07-张量与PyTorch

news2025/3/26 16:41:20

一、张量tensor

张量重新命名一些数据概念，存储数据以及权重和偏置。

张量还允许与数据相关的数学计算能够相对快速的完成。

通常，张量及其进行的数学计算会通过成为图形处理单元（GPUs）的特殊芯片来加速。但还有张量处理单元（TPUs）专门处理张量，使得神经网络运行相当更快。

另外，张量通过自动微分处理反向传播。

二、PyTorch

以下部分参考【深度学习基础】用PyTorch从零开始搭建DNN深度神经网络

图中的这个神经网络的参数都是训练优化好的，下面我们简便起见，假设最后一个参数b_final没有优化过，初始化为0，我们尝试用Pytorch实现一下对这个参数的优化，将final_bias初始化为0，看看最终这个-16可否被优化出来的。首先引入一些相关的库：

import torch
import torch.nn as nn
import torch.nn.functional as F
 
import matplotlib.pyplot as plt
import seaborn as sns

其中torch就是PyTorch框架，matplotlib和seaborn都是用来绘图的库。然后我们定义对照着图中的各个参数，搭建神经网络如下：

class BasicNN_train(nn.Module):  # 继承父类nn.Module
    def __init__(self):
        super().__init__()  # 对父类的成员进行初始化

        self.w00 = nn.Parameter(torch.tensor(1.7), requires_grad=False)
        self.b00 = nn.Parameter(torch.tensor(-0.85), requires_grad=False)
        self.w01 = nn.Parameter(torch.tensor(-40.8), requires_grad=False)

        self.w10 = nn.Parameter(torch.tensor(12.6), requires_grad=False)
        self.b10 = nn.Parameter(torch.tensor(0.0), requires_grad=False)
        self.w11 = nn.Parameter(torch.tensor(2.7), requires_grad=False)

        self.final_bias = nn.Parameter(torch.tensor(0.0), requires_grad=True)
        # requires_grad=True 表示需要优化

    def forward(self, input):  # 前向传播
        input_to_top_relu = input * self.w00 + self.b00
        top_relu_output = F.relu(input_to_top_relu)
        scaled_top_relu_output = top_relu_output * self.w01

        input_to_bottom_relu = input * self.w10 + self.b10
        bottom_relu_output = F.relu(input_to_bottom_relu)
        scaled_bottom_relu_output = bottom_relu_output * self.w11

        input_to_final_relu = scaled_top_relu_output + scaled_bottom_relu_output + self.final_bias
        output = F.relu(input_to_final_relu)

        return output

然后我们实例化这个网路，设定epoch=100，即最多进行100次前向和反向传播，定义损失函数就是预测值和实际值的平方误差，当损失函数之和低于0.0001时，我们就停止训练（最多训练100轮次），代码如下：

if __name__ == '__main__':
    model = BasicNN_train()  # 实例化神经网络模型
    inputs = torch.tensor([0., 0.5, 1.])  # 输入张量
    labels = torch.tensor([0., 1., 0.])  # 输出张量
    # 定义一个优化器 optimizer，使用随机梯度下降（SGD）算法来更新模型的参数
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)  # 学习率为0.1
    print("优化前的final_bias是:" + str(model.final_bias.data) + '\n')
    # 开始训练，最多100轮次
    for epoch in range(100):
        total_loss = 0  # 累积当前 epoch 中所有样本的损失值
        for iteration in range(len(inputs)): # len(inputs) 表示数据集中样本的数量
            input_i = inputs[iteration]
            label_i = labels[iteration]

            output_i = model(input_i) # 前向传播
            loss = (output_i - label_i) ** 2

            loss.backward() # 反向传播
            # 通过反向传播，PyTorch 会自动计算每个参数的梯度，并存储在参数的 .grad 属性中
            total_loss += float(loss)# 将每个样本的loss加和

backward() 的功能:

        backward() 使用链式法则计算损失函数 loss 对模型参数的梯度。

        loss.backward() 是从 loss 开始，沿着计算图反向传播梯度，最终得到每个参数的梯度值。这些梯度值（数据）会被存储在模型参数的 .grad 属性中，用于后续的参数更新。

正向传播是怎么实现的？

        model(input_i) 会自动调用 model 中定义的 forward 方法。

        在 Python 中，当一个类的实例被“调用”时（例如 model(input_i)），Python 会尝试调用该实例的 __call__ 方法。

        PyTorch 的 nn.Module 类实现了 __call__ 方法。当你调用 model(input_i) 时，实际上是调用了 model.__call__(input_i)。

        if total_loss < 0.0001:
            print(f"当前是第{epoch}轮次，已经满足total_loss < 0.0001，结束程序。")
            break
        optimizer.step()  # 使用优化器（如 SGD）更新模型的权重和偏置，以最小化损失函数。
        optimizer.zero_grad()  # 清除模型参数的梯度。
        print(f"当前是第{epoch}轮次，此时的final_bias值为{model.final_bias.data},total_loss为{total_loss}")
        # 画图如下
        input_doses = torch.linspace(start=0, end=1, steps=11)
        output_values = model(input_doses)
        sns.set(style="whitegrid")
        sns.lineplot(x=input_doses,
                     y=output_values.detach(),
                     color='green',
                     linewidth=2.5)
        plt.ylabel('Effectiveness')
        plt.xlabel('Dose')
        plt.show()
    print(f"优化后的final_bias值为：{model.final_bias.data}")

最终的输出结果如下：