PyTorch复现线性模型

【前言】

本专题为PyTorch专栏。从本专题开始，我将通过使用PyTorch编写基础神经网络，带领大家学习PyTorch。并顺便带领大家复习以下深度学习的知识。希望大家通过本专栏学习，更进一步了解人更智能这个领域。

材料来源：2.线性模型_哔哩哔哩_bilibili

PyTorch编写思路

对于大部分的神经网络模型，我们应该要有以下编写思路：

1.构建数据集

2.设计模型

3.构造损失函数和优化器

4.周期训练模型

5.测试模型

一、构建数据集

python 复制代码

import torch
#torch.Tensor()用来创建张量，即创建矩阵
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[2.0],[4.0],[6.0]])

这里为大家扩充一个知识点：

**【张量】**张量（Tensor）是 PyTorch 中最基本的数据结构，类似于 NumPy 中的数组，但张量可以利用 GPU 加速计算，这使得它非常适合用于深度学习任务。张量可以表示从标量（0 维张量）到向量（1 维张量）、矩阵（2 维张量）以及更高维度的数据。

二、设计模型

1.构造计算图

当你有了一个计算图之后，你将会加深对神经网络计算过程的理解，更加便于你构造神经网络模型

2.代码实现

python 复制代码

class LinearModel(torch.nn.Module):
    """
    定义了一个类，继承自PyTorch的torch.nn.Module模块.
    是 PyTorch 中所有神经网络模块的基类，所有自定义的模型都应该继承自这个类。
    """                                 
    
    def __init__(self):
        #是 PyTorch 中所有神经网络模块的基类，所有自定义的模型都应该继承自这个类。
        super(LinearModel,self).__init__()
        """
           调用了父类 torch.nn.Module 的初始化方法。这是必要的，
           因为 torch.nn.Module 的初始化方法会进行一些内部的初始化操作，确保模型能够正常工作。
        """
        self.linear=torch.nn.Linear(1,1)
        #创建了一个线性层
        #第一个参数为输入特征的数量。即输入张量的最后一个维度的大小。
        #第二个参数为输出特征的数量。即输出张量的最后一个维度的大小。

    #定义了一个前向传播
    def forward(self,x):
        y_pred=self.linear(x)
        return y_pred

#类实例化
model=LinearModel()

代码中的注释很详细，大家仔细看一下。

三、构造损失函数和优化器

python 复制代码

#方差损失函数
criterion=torch.nn.MSELoss(size_average=False)
#优化器optim.SGD()
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)

1.【方差损失函数】

顾名思义，这种损失函数计算的是预测值与真实值的平方差。计算公式如下：

后面我们会讲到其他损失函数，如下一节课我们将要讲到的"交叉熵损失函数"

2.【优化器SGD】

torch.optim.SGD 是 PyTorch 中实现随机梯度下降优化算法的类。

SGD是一种常用的优化算法，用于在训练过程中更新模型的参数，以最小化损失函数。

四、周期训练模型

我们定周期为100，并打印周期内的方差损失函数的损失值

python 复制代码

for epoch in range(100):
    #前向传播
    y_pred=model(x_data)#计算预测值Y hat
    loss=criterion(y_pred,y_data)#损失函数
    print(epoch,loss)
   
    optimizer.zero_grad()
    loss.backward()#后向传播
    optimizer.step()#参数更新

1.loss.backward() 的作用

在 PyTorch 中，loss.backward() 方法实现了反向传播算法。当调用 loss.backward() 时，它会：

计算梯度：自动计算损失函数关于所有模型参数的梯度。

累加梯度 ：将计算得到的梯度累加到每个参数的 .grad 属性中。

2.optimizer.zero_grad()：

在每次反向传播之前，需要清空之前的梯度。这是因为 PyTorch 的梯度是累加的，不清空会导致梯度错误地累加。

这一步确保每次计算的梯度是当前批次的梯度，而不是之前批次的梯度。

我知道很多人对上面这段话很不理解，没关系，接下来我对详细为大家解释：

为什么需要清空之前的梯度？

在 PyTorch 中，梯度是累加的 。这意味着当你对一个张量调用 .backward() 方法计算梯度时，计算得到的梯度会被累加到张量的 .grad 属性中，而不是替换它。

举个例子：
python 复制代码
import torch

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x * 2
y.backward(torch.tensor([1.0, 1.0, 1.0]))  # 计算梯度
print(x.grad)  # 输出: tensor([2., 2., 2.])

# 再次计算梯度，不调用 zero_grad()
y = x * 3
y.backward(torch.tensor([1.0, 1.0, 1.0]))
print(x.grad)  # 输出: tensor([5., 5., 5.])
在上面的例子中：

第一次调用 y.backward() 后，x.grad 的值是 [2., 2., 2.]。

第二次调用 y.backward() 时，没有清空之前的梯度，因此新的梯度 [3., 3., 3.] 会累加到之前的梯度 [2., 2., 2.] 上，最终结果是 [5., 5., 5.]。

这种累加行为在某些情况下是有用的，但在大多数训练循环中，我们希望每次计算的梯度是当前批次的梯度，而不是之前批次的梯度。

运行结果如下：

python 复制代码

0 tensor(16.7119, grad_fn=<MseLossBackward0>)
1 tensor(7.4562, grad_fn=<MseLossBackward0>)
2 tensor(3.3357, grad_fn=<MseLossBackward0>)
3 tensor(1.5010, grad_fn=<MseLossBackward0>)
4 tensor(0.6841, grad_fn=<MseLossBackward0>)
5 tensor(0.3202, grad_fn=<MseLossBackward0>)
6 tensor(0.1580, grad_fn=<MseLossBackward0>)
7 tensor(0.0855, grad_fn=<MseLossBackward0>)
8 tensor(0.0531, grad_fn=<MseLossBackward0>)
9 tensor(0.0384, grad_fn=<MseLossBackward0>)
10 tensor(0.0316, grad_fn=<MseLossBackward0>)
11 tensor(0.0284, grad_fn=<MseLossBackward0>)
12 tensor(0.0268, grad_fn=<MseLossBackward0>)
13 tensor(0.0259, grad_fn=<MseLossBackward0>)
14 tensor(0.0253, grad_fn=<MseLossBackward0>)
15 tensor(0.0248, grad_fn=<MseLossBackward0>)
16 tensor(0.0244, grad_fn=<MseLossBackward0>)
17 tensor(0.0240, grad_fn=<MseLossBackward0>)
18 tensor(0.0237, grad_fn=<MseLossBackward0>)
19 tensor(0.0233, grad_fn=<MseLossBackward0>)
20 tensor(0.0230, grad_fn=<MseLossBackward0>)
21 tensor(0.0226, grad_fn=<MseLossBackward0>)
22 tensor(0.0223, grad_fn=<MseLossBackward0>)
23 tensor(0.0220, grad_fn=<MseLossBackward0>)
24 tensor(0.0217, grad_fn=<MseLossBackward0>)
...
96 tensor(0.0076, grad_fn=<MseLossBackward0>)
97 tensor(0.0075, grad_fn=<MseLossBackward0>)
98 tensor(0.0074, grad_fn=<MseLossBackward0>)
99 tensor(0.0073, grad_fn=<MseLossBackward0>)
Output is truncated. View as a scrollable element or open in a text editor. Adjust cell output settings...

我们可以直观的看到，随着训练次数越来越多，损失值在不断的减少，这也就意味着模型的效果越来越好。这也就是梯度下降过程。

五、测试模型

python 复制代码

#输出权重和偏置
print('W=',model.linear.weight.item())
print('b=',model.linear.bias.item())

#测试模型
x_test=torch.Tensor([[4.0]])
y_test=model(x_test)
print('y_pred',y_test.data)

1.model.linear.weight.item()

model.linear.weight 是模型中线性层的权重参数。

.item() 方法将张量转换为 Python 标量。这里假设权重是一个一维张量，且只有一个元素（因为是单输入单输出的线性模型）。

2.model.linear.bias.item()

model.linear.bias 是模型中线性层的偏置参数。

.item() 方法同样将张量转换为 Python 标量。

测试结果如下：

python 复制代码

W= 0.7572911977767944
b= -0.33243346214294434
y_pred tensor([[2.6967]])

我们可以看到预测值已经很接近正确答案了。

PyTorch复现线性模型

【前言】

PyTorch编写思路

1.构建数据集

2.设计模型

3.构造损失函数和优化器

4.周期训练模型

5.测试模型

一、构建数据集

二、设计模型

1.构造计算图

2.代码实现

三、构造损失函数和优化器

1.【方差损失函数】

2.【优化器SGD】

四、周期训练模型

`1.loss.backward()` 的作用

`2.optimizer.zero_grad()`：

为什么需要清空之前的梯度？

五、测试模型

`1.model.linear.weight.item()`

2.`model.linear.bias.item()`

PyTorch复现线性模型

【前言】

PyTorch编写思路

1.构建数据集

2.设计模型

3.构造损失函数和优化器

4.周期训练模型

5.测试模型

一、构建数据集

二、设计模型

1.构造计算图

2.代码实现

三、构造损失函数和优化器

1.【方差损失函数】

2.【优化器SGD】

四、周期训练模型

1.loss.backward() 的作用

2.optimizer.zero_grad()：

为什么需要清空之前的梯度？

五、测试模型

1.model.linear.weight.item()

2.model.linear.bias.item()

`1.loss.backward()` 的作用

`2.optimizer.zero_grad()`：

`1.model.linear.weight.item()`

2.`model.linear.bias.item()`