一、张量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}")最终的输出结果如下：
一共34轮训练后，就实现了总损失小于0.001的要求，也看到最终的优化结果final_bia大概是-16，与之前我们的结论一致。 损失函数变化曲线如下:
最终迭代到第34轮次后，实现了最终的效果：
