PyTorch 基础语法详解：张量操作、自动求导与模型定义全解析

下 栽 の 地 止 ：789it.top/1089/

PyTorch 是一个被广泛应用的深度学习框架。它具备灵活的张量操作功能，还拥有自动求导的机制以及模型定义的机制。以下是关于 PyTorch 的基础语法的详细解释，其中包含了张量操作方面的内容、自动求导方面的内容以及模型定义方面的内容。

1. 张量操作（Tensor Operations）

张量是 PyTorch 中最为基本的数据结构，它与 NumPy 数组有相似之处，不过能够在 GPU 上进行高效的计算。以下是 PyTorch 中张量的一些常见操作。

创建张量

pythonimport torch
# 创建一个未初始化的张量，形状为 (2, 3)
x = torch.empty(2, 3)
# 创建一个全为零的张量
y = torch.zeros(2, 3)
# 创建一个全为1的张量
z = torch.ones(2, 3)
# 从数据创建张量
data = [1, 2, 3, 4]
t = torch.tensor(data)
# 使用随机数生成张量
r = torch.rand(2, 3)
# 创建一个单位矩阵
创建一个单位矩阵，该矩阵是一个 3 行 3 列的方阵，对角线上的元素为 1，其余元素为 0，这个单位矩阵被赋值给变量 identity_matrix，它是通过 torch.eye(3) 函数得到的。
# 获取张量的形状
shape = r.shape

张量运算

python# 张量加法
a = torch.tensor([1, 2])
b = torch.tensor([3, 4])
c = a + b
# 张量减法
d = a - b
# 张量乘法（逐元素相乘）
e = a * b
# 矩阵乘法
f 等于 torch.matmul 函数作用于 a 进行 view 操作后得到的形状为(1, -1)的张量与 b 进行 view 操作后得到的形状为(-1, 1)的张量
# 张量的求和、均值等
sum_val = a.sum()        # 求和
求均值的操作是计算 a 的平均值，将其赋值给 mean_val

张量的索引和切片

python# 张量的索引
x = torch.rand(4, 4)
x[0, 0]  # 访问第 0 行，第 0 列元素
x[:, 1]  # 访问第 1 列的所有元素

张量转换

python# 转换形状
y 被修改形状为 (2, 8)，其操作是 x.view(2, 8)
# 转换为 NumPy 数组
numpy_array = x.numpy()
# 转换为 GPU 张量
if torch.cuda.is_available():
    x_cuda = x.cuda()

2. 自动求导（Autograd）

PyTorch 的一个核心是 autograd。它具备这样的功能，即能够让我们自动去计算张量的梯度。而这种自动计算梯度的能力，对于反向传播以及模型训练来说是非常方便的。

启用梯度计算

python# 创建一个张量并启用梯度计算
定义了一个张量 x，它是通过 torch.randn 函数生成的，维度为 3 行 3 列，并且设置了 requires_grad 为 True
# 计算张量的某些操作
y = x * 2
z = y.mean()
# 反向传播计算梯度
z.backward()
# 查看梯度
print(x.grad)

防止梯度计算

使用 `torch.no_grad()` 可以停止梯度计算。
with torch.no_grad():
    y = x * 2

创建计算图

pythona 是一个张量，其值为 [2.0]，并且需要计算梯度，即 requires_grad 为 True
b = a ** 2 + 3 * a
c = b.mean()
c.backward()
print(a.grad)  # 打印梯度

3. 模型定义（Model Definition）

PyTorch 能够提供一种灵活的方式去定义神经网络模型，一般是通过继承 torch.nn.Module 这个类来构建属于自己的模型。

定义一个简单的神经网络

pythonimport torch.nn as nn
import torch.optim as optim
class SimpleNN(nn.Module):
    def __init__(self):
调用父类 SimpleNN 的构造函数并传入 self 参数，进行初始化操作。
self 的 fc1 是一个线性层，它有 2 个输入，3 个输出。即 self.fc1 等于 nn.Linear(2, 3) ，用于实现第一层的功能，将输入的维度从 2 转换为 3 。
self.fc2 是一个线性层，它有 3 个输入，1 个输出。
    def forward(self, x):
x 等于 self.fc1(x)经过 torch.relu 函数处理后的结果  # ReLU 激活
        x = self.fc2(x)
        return x
# 创建模型实例
model = SimpleNN()
# 查看模型结构
print(model)

训练模型

在训练模型的过程中，我们要先定义损失函数，接着定义优化器，之后再运用反向传播去更新模型的参数。

python# 创建损失函数和优化器
均方误差损失函数为 criterion = nn.MSELoss()
使用随机梯度下降优化器，其参数为 model.parameters()，学习率为 0.01 。
# 输入数据
torch 中存在一个张量 inputs，它的值为[[1.0, 2.0], [3.0, 4.0]]
目标是一个张量，其值为[[1.0], [2.0]]。 这个张量包含两个子张量，分别为[1.0]和[2.0]。 每个子张量都只有一个元素，分别为 1.0 和 2.0。
# 训练步骤
for epoch in range(100):
    # 前向传播
    outputs = model(inputs)
criterion 作用于 outputs 和 targets 得到了 loss。
    
    # 反向传播
清空之前的梯度，这是通过 optimizer.zero_grad() 来实现的。
    loss.backward()        # 计算梯度
进行优化器的一步操作，从而更新模型的参数。
    
    if (epoch + 1) % 10 == 0:
打印出（f'Epoch [{epoch+1}/100]，损失：{loss.item():.4f}')

4. 其他常用功能迁移到 GPU

python# 将模型和张量迁移到 GPU
如果 torch.cuda 可用，那么 device 为 torch.device("cuda")；否则，device 为 torch.device("cpu")
model = model.to(device)
inputs = inputs.to(device)
targets = targets.to(device)

保存和加载模型

				         
				       # 保存模型
将模型的状态字典保存到“model.pth”文件中，使用 torch.save 函数来实现这一操作。
# 加载模型
model = SimpleNN()
模型加载状态字典，该状态字典是通过加载“model.pth”文件得到的。
model.eval()  # 设为评估模式

总结

PyTorch 具备极为丰富的功能，能助力我们高效地展开深度学习的研究与开发。我们能够借助张量操作、自动求导以及灵活的模型定义，去构建、训练以及优化神经网络。利用 torch.nn.Module 类来构建模型是很简洁的，并且自动求导系统简化了梯度计算，让反向传播变得更为方便。