【前言】
本专题为PyTorch专栏。从本专题开始，我将通过使用PyTorch编写基础神经网络，带领大家学习PyTorch。并顺便带领大家复习以下深度学习的知识。希望大家通过本专栏学习，更进一步了解人更智能这个领域。
材料来源：2.线性模型_哔哩哔哩_bilibili
PyTorch编写思路
对于大部分的神经网络模型，我们应该要有以下编写思路：
1.构建数据集
2.设计模型
3.构造损失函数和优化器
4.周期训练模型
5.测试模型
一、构建数据集
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.代码实现
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()代码中的注释很详细，大家仔细看一下。
三、构造损失函数和优化器
#方差损失函数
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，并打印周期内的方差损失函数的损失值
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属性中，而不是替换它。举个例子：
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.]。这种累加行为在某些情况下是有用的，但在大多数训练循环中，我们希望每次计算的梯度是当前批次的梯度，而不是之前批次的梯度。
运行结果如下：
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...我们可以直观的看到，随着训练次数越来越多，损失值在不断的减少，这也就意味着模型的效果越来越好。这也就是梯度下降过程。
五、测试模型
#输出权重和偏置
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 标量。
测试结果如下：
W= 0.7572911977767944
b= -0.33243346214294434
y_pred tensor([[2.6967]])我们可以看到预测值已经很接近正确答案了。
