通透讲解！Pytorch 十大核心操作全总结！！!

之前我们在学习算法框架时，常会纠结是学习 TensorFlow 还是学习 Pytorch 呢？现在不必了，大模型已经把 Pytorch 带火了。

最新写了很多关于 Pytorch 的文章，主要针对刚刚接触 Pytorch 的同学，文章我给大家列出来了，喜欢可以从0开始学习：

• 小白学 PyTorch 系列：这一次，我准备了 20节 PyTorch 中文课程
• 小白学 PyTorch 系列：54个超强 pytorch 操作
• 小白学 PyTorch 系列：9个技巧让你的 PyTorch 模型训练飞快！
• 小白学 PyTorch 系列：PyTorch 进阶指南，10个必须知道的原则
• 小白学 PyTorch 系列：Pytorch，16个超强转换函数全总结！！
• 小白学 PyTorch 系列：手把手教你使用 PyTorch 搭建神经网络
• 小白学 PyTorch 系列：Keras 3.0发布：全面拥抱 PyTorch

今天的内容，准备了两天。总结了 PyTorch 最重要的十类操作，无论是初学者还是有基础的读者，都可以看看。尤其是准备实战或者面试的同学。老规矩：大家伙如果觉得近期文章还不错！欢迎大家点个赞~

当大家谈到 PyTorch 中最重要的操作时，以下是10个常用且重要的操作。

包括详细的介绍和示例代码。

技术交流&资料获取

独学而无优则孤陋而寡闻，技术要学会交流、分享，不建议闭门造车。

建立了 Pytorch 技术与面试交流群，本文详细资料、实战项目、面试真题，均可加交流群获取，群友已超过2000人，添加时最好的备注方式为：来源+兴趣方向，方便找到志同道合的朋友。

方式①、微信搜索公众号：Python学习与数据挖掘，后台回复：交流
方式②、添加微信号：dkl88194，备注：交流

张量创建和基本操作

张量类似于 NumPy 的数组，但具有额外的功能，如自动求导（automatic differentiation）和 GPU 加速。

下面是在 PyTorch 中创建张量和进行基本操作的详细介绍。

1. 张量的创建

从 Python 列表或 NumPy 数组创建张量：

import torch
import numpy as np

# 从列表创建张量
tensor_from_list = torch.tensor([1, 2, 3])

# 从 NumPy 数组创建张量
numpy_array = np.array([4, 5, 6])
tensor_from_numpy = torch.tensor(numpy_array)
1
2
3
4
5
6
7
8
9

使用特定值创建张量：

# 创建全零张量
zeros_tensor = torch.zeros((3, 4))

# 创建全一张量
ones_tensor = torch.ones((2, 2))

# 创建指定范围的张量
range_tensor = torch.arange(0, 10, 2)

# 创建均匀分布的张量
uniform_tensor = torch.rand((3, 3))

# 创建正态分布的张量
normal_tensor = torch.randn((2, 2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用特定形状的张量：

# 创建未初始化的张量
uninitialized_tensor = torch.empty((2, 2))

# 创建与现有张量相同形状的张量
like_tensor = torch.ones_like(zeros_tensor)
1
2
3
4
5

2. 张量的基本操作

索引和切片：

# 获取张量中的特定元素
element = tensor_from_list[1]

# 切片操作
sliced_tensor = tensor_from_list[1:3]
1
2
3
4
5

张量的形状操作：

# 获取张量的形状
shape = tensor_from_list.shape

# 改变张量的形状
reshaped_tensor = tensor_from_list.view(1, 3)

# 转置张量
transposed_tensor = tensor_from_list.t()
1
2
3
4
5
6
7
8

数学运算：

# 加法
sum_tensor = tensor_from_list + tensor_from_numpy

# 乘法
product_tensor = torch.matmul(zeros_tensor, ones_tensor)

# 广播操作
broadcasted_tensor = tensor_from_list * 2
1
2
3
4
5
6
7
8

这些功能使得 PyTorch 成为深度学习领域的一流选择，因为它提供了方便、灵活且高效的工具来处理张量和构建神经网络模型。

自动求导

PyTorch中的自动求导（Autograd）允许用户自动计算张量的梯度，而无需手动编写反向传播算法。

Autograd的核心是计算图（computational graph），它记录了计算张量的操作，并在需要时能够生成梯度。

1. 张量的requires_grad属性

在创建张量时，可以通过设置requires_grad属性为True来指示PyTorch跟踪对该张量的操作，从而构建计算图。

import torch

# 创建一个需要梯度的张量
x = torch.tensor([1.0, 2.0], requires_grad=True)
1
2
3
4

2. 张量操作和计算图

一旦设置了requires_grad=True，PyTorch将自动追踪对该张量的所有操作，构建一个计算图。这个计算图记录了张量之间的关系和操作。

y = x + 2
z = y * y * 3
out = z.mean()

1
2
3
4

上述例子中，y、z 和 out 都是通过对 x 进行操作得到的新张量，这些操作构成了计算图。

3. 计算梯度

一旦有了计算图，可以调用 backward() 方法计算梯度。梯度计算完成后，可以通过张量的 grad 属性获取梯度值。

out.backward()  # 计算梯度

# 获取梯度
print(x.grad)
1
2
3
4

4. 阻止梯度追踪

在某些情况下，可能需要阻止PyTorch对某些操作的梯度追踪，可以使用 torch.no_grad() 上下文管理器或者在张量上使用 .detach() 方法。

with torch.no_grad():
    # 不追踪梯度的操作
    y = x + 2

# 或者
z = y.detach()
1
2
3
4
5
6

5. 使用with torch.autograd.set_grad_enabled(False):控制梯度计算

在某些情况下，可能需要在一段代码中关闭梯度计算，可以使用上下文管理器 torch.autograd.set_grad_enabled。

with torch.autograd.set_grad_enabled(False):
    # 在此处的操作不会被追踪，也不会计算梯度
    y = x + 2
1
2
3

6. 示例：使用自动求导进行优化

import torch.optim as optim

# 定义一个变量并设置需要梯度
x = torch.tensor([1.0, 2.0], requires_grad=True)

# 定义一个优化器（例如梯度下降）
optimizer = optim.SGD([x], lr=0.01)

# 在循环中执行优化步骤
for _ in range(100):
    y = x + 2
    loss = y[0] * y[1]  # 这里定义了一个简单的损失函数

    optimizer.zero_grad()  # 清零梯度
    loss.backward()  # 计算梯度
    optimizer.step()  # 更新参数

# 查看优化后的结果
print(x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这个例子演示了如何使用自动求导来执行优化步骤，通过反向传播计算梯度并使用优化器更新参数。

总体而言，PyTorch中的自动求导提供了一个方便的工具，使得深度学习的模型训练变得更加简单和高效。

神经网络层

在 PyTorch 中，nn.Module 是构建神经网络模型的基础类。nn.Module 提供了一个模块化和灵活的方式来组织复杂的神经网络结构。通过继承 nn.Module 类，可以创建自定义的神经网络层、模型或整个神经网络。

1. 创建一个简单的神经网络层

import torch
import torch.nn as nn

class SimpleLayer(nn.Module):
    def __init__(self, input_size, output_size):
        super(SimpleLayer, self).__init__()
        self.linear = nn.Linear(input_size, output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.linear(x)
        x = self.relu(x)
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13

上面的例子中，SimpleLayer 继承自 nn.Module，并定义了一个包含线性层（nn.Linear）和激活函数 ReLU 的简单神经网络层。forward 方法定义了前向传播的计算过程。

2. 构建更复杂的模型

可以通过将多个神经网络层组合在一起构建更复杂的模型。下面是一个简单的多层感知机 (MLP) 的例子：

class MLP(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(MLP, self).__init__()
        self.layer1 = SimpleLayer(input_size, hidden_size)
        self.layer2 = SimpleLayer(hidden_size, output_size)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        return x
1
2
3
4
5
6
7
8
9
10

3. 模块的嵌套和子模块

nn.Module 支持嵌套和包含其他 nn.Module 实例，这有助于构建更复杂的神经网络。子模块会自动跟踪其参数和梯度。

class ComplexModel(nn.Module):
    def __init__(self):
        super(ComplexModel, self).__init__()
        self.layer1 = SimpleLayer(10, 20)
        self.layer2 = MLP(20, 30, 5)

    def forward(self, x):
        x = self.layer1(x)
        x = self.layer2(x)
        return x
1
2
3
4
5
6
7
8
9
10

4. 访问模块的参数

通过 named_parameters() 或 parameters() 方法可以访问模块中的所有参数。

model = ComplexModel()
for name, param in model.named_parameters():
    print(f"{name}: {param.size()}")
1
2
3

5. 模型的保存和加载

可以使用 torch.save 保存模型的状态字典，并使用 torch.load 加载模型。

# 保存模型
torch.save(model.state_dict(), 'model.pth')

# 加载模型
loaded_model = ComplexModel()
loaded_model.load_state_dict(torch.load('model.pth'))
1
2
3
4
5
6

6. 模型的设备移动

可以使用 to 方法将模型移动到指定的设备，例如 GPU。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
1
2

7. 自定义层和操作

可以通过继承 nn.Module 类创建自定义的神经网络层和操作，例如自定义的激活函数、损失函数等。

这些功能使得 nn.Module 成为 PyTorch 中构建和组织神经网络的核心工具之一。通过模块化的设计，可以更灵活地搭建、训练和调整复杂的神经网络结构。

优化器

在 PyTorch 中，优化器（Optimizer）是用于更新神经网络模型参数的工具。优化器基于模型参数的梯度信息来调整参数，从而最小化或最大化某个损失函数。PyTorch 提供了多种优化器，包括随机梯度下降（SGD）、Adam、RMSprop 等。

1. SGD 优化器

随机梯度下降是最基本的优化算法之一。在 PyTorch 中，可以使用 torch.optim.SGD 类来创建 SGD 优化器。

import torch
import torch.optim as optim

# 定义模型和损失函数
model = ...
criterion = ...

# 定义 SGD 优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
1
2
3
4
5
6
7
8
9

2. Adam 优化器

Adam 是一种自适应学习率的优化算法，它在训练深度学习模型时表现良好。在 PyTorch 中，可以使用 torch.optim.Adam 类来创建 Adam 优化器。

# 定义 Adam 优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)
1
2

3. RMSprop 优化器

RMSprop（Root Mean Square Propagation）是另一种自适应学习率的优化算法。在 PyTorch 中，可以使用 torch.optim.RMSprop 类来创建 RMSprop 优化器。

# 定义 RMSprop 优化器
optimizer = optim.RMSprop(model.parameters(), lr=0.001)
1
2

4. 设置学习率

可以通过 lr 参数来设置优化器的学习率。

optimizer = optim.SGD(model.parameters(), lr=0.01)
1

5. 梯度清零

在每个训练步骤之前，通常需要清零梯度。可以使用 zero_grad() 方法来实现。

optimizer.zero_grad()
1

6. 梯度更新

使用优化器的 step() 方法来更新模型参数。

loss.backward()  # 计算梯度
optimizer.step()  # 更新参数
1
2

7. 动态调整学习率

PyTorch 提供了一些学习率调整策略，如学习率衰减、余弦退火等。可以使用 torch.optim.lr_scheduler 模块来实现。

from torch.optim import lr_scheduler

# 创建学习率衰减策略
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

# 在训练循环中使用
for epoch in range(num_epochs):
    # 训练模型
    ...

    # 更新学习率
    scheduler.step()
1
2
3
4
5
6
7
8
9
10
11
12

8. 自定义优化器

可以通过继承 torch.optim.Optimizer 类来创建自定义的优化器。

class CustomOptimizer(optim.Optimizer):
    def __init__(self, params, lr=0.01):
        defaults = dict(lr=lr)
        super(CustomOptimizer, self).__init__(params, defaults)

    def step(self, closure=None):
        # 自定义的优化步骤
        ...
1
2
3
4
5
6
7
8

优化器是深度学习训练过程中关键的组件之一，选择适当的优化器和学习率策略对于模型的性能至关重要。PyTorch 提供了丰富的优化器和学习率调整工具，使得用户能够根据具体问题选择合适的训练策略。

损失函数（Loss Function）

损失函数（Loss Function）用于度量模型输出与真实标签之间的差异，是训练神经网络时优化的目标。

PyTorch 提供了多种损失函数，适用于不同类型的任务，如分类、回归等。

1. 均方误差损失（Mean Squared Error, MSE）

均方误差是回归任务中常用的损失函数，计算模型输出与真实标签之间的平方差的平均值。

import torch.nn as nn

criterion = nn.MSELoss()
1
2
3

2. 交叉熵损失（Cross-Entropy Loss）

交叉熵损失是分类任务中常用的损失函数，适用于多类别分类问题。

criterion = nn.CrossEntropyLoss()
1

3. 二元交叉熵损失（Binary Cross-Entropy Loss）

二元交叉熵损失通常用于二分类问题，其中每个样本属于两个类别之一。

criterion = nn.BCELoss()
1

4. 二元交叉熵损失（带权重）

可以为每个类别设置不同的权重，以处理类别不平衡的问题。

weights = torch.tensor([weight_class_0, weight_class_1])
criterion = nn.BCEWithLogitsLoss(pos_weight=weights)
1
2

5. K-L 散度损失（Kullback-Leibler Divergence Loss）

适用于度量两个概率分布之间的差异，通常用于生成对抗网络（GANs）。

criterion = nn.KLDivLoss()
1

6. 三元组损失（Triplet Margin Loss）

在训练人脸识别等任务时，可以使用三元组损失来确保相同类别样本之间的距离小于不同类别样本之间的距离。

from torch.nn.functional import triplet_margin_loss

criterion = triplet_margin_loss
1
2
3

7. 自定义损失函数

可以通过继承 nn.Module 类创建自定义的损失函数，实现自定义的损失计算逻辑。

import torch

class CustomLoss(nn.Module):
    def __init__(self, weight):
        super(CustomLoss, self).__init__()
        self.weight = weight

    def forward(self, output, target):
        loss = torch.mean((output - target) ** 2)
        return self.weight * loss

1
2
3
4
5
6
7
8
9
10
11

8. 使用损失函数进行训练

在训练循环中，通过计算模型输出与真实标签的损失，并调用反向传播和优化器更新参数来训练模型。

output = model(inputs)
loss = criterion(output, labels)

optimizer.zero_grad()
loss.backward()
optimizer.step()
1
2
3
4
5
6

选择适当的损失函数取决于任务类型和数据特性。通常，可以根据任务的性质和输出的特点选择合适的损失函数。

数据加载与预处理

在 PyTorch 中，数据加载与预处理是深度学习中非常重要的一部分，它涉及到将原始数据加载到模型中并进行适当的预处理，以便用于训练和测试。PyTorch 提供了 torch.utils.data 模块来实现数据加载和预处理，同时可以使用 torchvision 提供的一些工具进行常见的图像处理。

1. 数据集的定义

在 PyTorch 中，通常通过创建一个自定义的数据集类来加载数据。自定义数据集需要继承自 torch.utils.data.Dataset，并实现 __len__ 和 __getitem__ 方法。

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, data, labels, transform=None):
        self.data = data
        self.labels = labels
        self.transform = transform

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        sample = {'data': self.data[idx], 'label': self.labels[idx]}

        if self.transform:
            sample = self.transform(sample)

        return sample
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 数据加载器

数据加载器是 PyTorch 中用于批量加载数据的工具。通过创建一个数据加载器，可以方便地在模型训练中迭代地获取批量数据。

from torch.utils.data import DataLoader

# 创建数据集
dataset = CustomDataset(data, labels, transform=...)

# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)
1
2
3
4
5
6
7

3. 预处理与转换

可以使用 torchvision.transforms 中的预处理函数对数据进行常见的预处理，例如缩放、裁剪、旋转等。

from torchvision import transforms

# 定义转换
transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.RandomCrop((224, 224)),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

# 将转换应用于数据集
dataset = CustomDataset(data, labels, transform=transform)
1
2
3
4
5
6
7
8
9
10
11
12
13

4. 使用预训练模型

如果使用了预训练的模型，可能需要采用与训练时相同的预处理方式。torchvision.transforms 中也提供了用于预训练模型的一些标准预处理方法。

from torchvision import transforms

# 使用 ImageNet 预训练模型的标准化参数
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
1
2
3
4
5
6
7
8
9

5. 数据加载与迭代

通过数据加载器，可以在训练循环中方便地迭代加载批量的数据。

for batch in dataloader:
    inputs, labels = batch['data'], batch['label']
    # 进行模型训练
1
2
3

6. 使用预训练模型

当使用预训练模型时，通常需要使用与预训练时相同的数据预处理方式。torchvision.transforms 中提供了一些用于预训练模型的标准预处理方法。

from torchvision import transforms

# 使用 ImageNet 预训练模型的标准化参数
preprocess = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
1
2
3
4
5
6
7
8
9

这些步骤提供了一个基本的数据加载与预处理的框架。根据实际问题和数据特点，可能需要进行更复杂的数据处理。

模型保存与加载

在 PyTorch 中，模型的保存与加载是训练深度学习模型中重要的一部分。模型的保存使得可以在训练过程中保存中间结果或在训练结束后保存最终模型，而模型的加载则允许在其他地方或其他时间使用已经训练好的模型。

1. 模型的保存

在 PyTorch 中，可以使用 torch.save 函数保存模型的状态字典（state_dict）或整个模型。状态字典包含了模型的参数和其他相关信息。

import torch
import torch.nn as nn

# 定义模型
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 1)

model = SimpleModel()

# 保存模型的状态字典
torch.save(model.state_dict(), 'model_state.pth')

# 保存整个模型（包括结构和参数）
torch.save(model, 'model.pth')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. 模型的加载

使用 torch.load 函数加载模型的状态字典或整个模型。

# 加载模型的状态字典
loaded_state_dict = torch.load('model_state.pth')
model.load_state_dict(loaded_state_dict)

# 加载整个模型
loaded_model = torch.load('model.pth')
1
2
3
4
5
6

3. 跨设备加载模型

如果在训练时使用了 GPU，而在加载时想切换到 CPU，可以使用 map_location 参数。

# 在 CPU 上加载 GPU 上保存的模型
loaded_model = torch.load('model.pth', map_location=torch.device('cpu'))
1
2

4. 保存与加载模型的结构和参数

在保存整个模型时，模型的结构和参数都会被保存。

# 保存整个模型（包括结构和参数）
torch.save(model, 'model.pth')

# 加载整个模型
loaded_model = torch.load('model.pth')
1
2
3
4
5

5. 保存与加载模型的结构

如果只想保存和加载模型的结构而不包含参数，可以使用 torch.save 时设置 save_model_obj=False。

# 保存模型结构
torch.save(model, 'model_structure.pth', save_model_obj=False)

# 加载模型结构
loaded_model_structure = torch.load('model_structure.pth')
1
2
3
4
5

6. 只保存和加载模型参数

如果只想保存和加载模型参数而不包含模型结构，可以使用 torch.save 时设置 save_model_obj=False。

# 保存模型参数
torch.save(model.state_dict(), 'model_parameters.pth')

# 加载模型参数
loaded_parameters = torch.load('model_parameters.pth')
model.load_state_dict(loaded_parameters)
1
2
3
4
5
6

以上是在 PyTorch 中保存与加载模型的基本方法。在实际应用中，还可以结合其他工具，如 torch.optim 优化器状态字典的保存与加载，以便在恢复训练时继续优化过程。

学习率调整

在深度学习中，学习率调整是优化算法的关键部分之一。PyTorch 提供了 torch.optim.lr_scheduler 模块来实现各种学习率调整策略。

1. StepLR 学习率调整

StepLR 是一种简单的学习率调整策略，每经过一定的步数，将学习率按照给定的因子进行衰减。

import torch.optim as optim
from torch.optim import lr_scheduler

# 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 定义学习率调整策略
scheduler = lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)

# 在训练循环中使用
for epoch in range(num_epochs):
    # 训练模型
    ...

    # 更新学习率
    scheduler.step()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. MultiStepLR 学习率调整

MultiStepLR 是在预定义的多个时间点降低学习率的策略。

scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[10, 20, 30], gamma=0.1)
1

3. ExponentialLR 学习率调整

ExponentialLR 对学习率进行指数衰减。

scheduler = lr_scheduler.ExponentialLR(optimizer, gamma=0.9)
1

4. CosineAnnealingLR 学习率调整

CosineAnnealingLR 使用余弦退火函数来调整学习率。

scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)
1

5. LambdaLR 学习率调整

LambdaLR 允许使用任意的学习率调整函数。

scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda epoch: 0.95 ** epoch)
1

6. ReduceLROnPlateau 学习率调整

ReduceLROnPlateau 在验证集上监测指标，当指标不再提升时降低学习率。

scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.1, patience=5, verbose=True)
1

7. 使用学习率调整器

在训练循环中使用学习率调整器。

for epoch in range(num_epochs):
    # 训练模型
    ...

    # 更新学习率
    scheduler.step(validation_loss)  # 如果使用 ReduceLROnPlateau
1
2
3
4
5
6

8. 学习率调整的参数

在学习率调整中，有一些参数是常用的：

• optimizer: 优化器，可以通过 optim.SGD、optim.Adam 等创建。

• step_size（对于 StepLR 和 MultiStepLR）: 学习率衰减的步数。

• gamma: 学习率衰减的因子。

• milestones（对于 MultiStepLR）: 多步学习率衰减的时间点。

• T_max（对于 CosineAnnealingLR）: 一个周期的迭代次数。

• lr_lambda（对于 LambdaLR）: 自定义学习率衰减函数。

• mode（对于 ReduceLROnPlateau）: 监测指标的模式，可以是 'min'、'max' 或 'auto'。

选择适当的学习率调整策略对于模型的性能非常关键。在实践中，通常需要进行一些实验以确定最佳的学习率调整策略和参数。

模型评估

模型评估是在训练之后对模型性能进行定量评估的过程。评估模型涉及到使用验证集或测试集上的数据进行推理，并计算模型在这些数据上的性能指标，如准确率、精确度、召回率等。

1. 设置模型为评估模式

在进行模型评估之前，需要将模型切换到评估模式，即使用 eval() 方法。这会关闭 Dropout 等训练时使用的一些特定行为。

model.eval()
1

2. 使用验证集或测试集进行推理

通过遍历验证集或测试集，使用模型进行推理。

model.eval()

with torch.no_grad():
    for inputs, labels in dataloader:
        outputs = model(inputs)
        # 进行后续处理..
1
2
3
4
5
6

3. 计算性能指标

根据任务类型和需求，选择合适的性能指标进行计算。以下是一些常见的性能指标：

• 准确率（Accuracy）：

  correct = (predicted == labels).sum().item()
  total = labels.size(0)
  accuracy = correct / total
  1
  2
  3

• 精确度（Precision）：

  from sklearn.metrics import precision_score
  precision = precision_score(labels, predicted, average='weighted')
  1
  2

• 召回率（Recall）：

  from sklearn.metrics import recall_score
  recall = recall_score(labels, predicted, average='weighted')
  1
  2

• F1 分数（F1 Score）：

  from sklearn.metrics import f1_score
  f1 = f1_score(labels, predicted, average='weighted')
  1
  2

4. 混淆矩阵（Confusion Matrix）

混淆矩阵是一个很有用的工具，可以展示模型在每个类别上的性能。

from sklearn.metrics import confusion_matrix
conf_matrix = confusion_matrix(labels, predicted)
1
2

5. 模型性能可视化

通过绘制 ROC 曲线、学习曲线等图表，可以更直观地了解模型的性能。

import matplotlib.pyplot as plt

# 绘制 ROC 曲线等
1
2
3

6. 完整的评估过程示例

model.eval()

total_correct = 0
total_samples = 0

with torch.no_grad():
    for inputs, labels in dataloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        
        total_correct += (predicted == labels).sum().item()
        total_samples += labels.size(0)

accuracy = total_correct / total_samples
print(f'Accuracy: {accuracy}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7. 注意事项

• 在评估过程中，确保使用 torch.no_grad() 来关闭梯度计算，以减少内存使用和加速推理过程。

• 对于分类问题，使用 Softmax 函数获得类别概率，并选择概率最大的类别作为预测结果。

• 对于不同的任务（分类、回归、目标检测等），选择合适的性能指标进行评估。

以上是在 PyTorch 中进行模型评估的基本步骤。具体的评估过程会根据任务的性质和需求而有所不同。

GPU加速

在 PyTorch 中，利用 GPU 加速是训练深度学习模型的关键步骤之一。PyTorch 提供了简单而灵活的方式，使用户能够方便地将模型和数据移动到 GPU 上进行加速。

1. 检查 GPU 是否可用

在使用 GPU 加速之前，首先需要检查系统上是否有可用的 GPU 设备。

import torch

# 检查 GPU 是否可用
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Using device:', device)
1
2
3
4
5

2. 将模型移动到 GPU

使用 .to() 方法将模型移动到 GPU 上。

model = MyModel()  # 自定义模型
model.to(device)
1
2

3. 将张量移动到 GPU

同样地，使用 .to() 方法将张量移动到 GPU 上。

inputs, labels = data  # 假设 data 是从数据加载器中获取的一批数据
inputs, labels = inputs.to(device), labels.to(device)
1
2

4. 在 GPU 上执行前向传播和反向传播

使用 GPU 上的模型进行前向传播和反向传播。

outputs = model(inputs)
loss = criterion(outputs, labels)

optimizer.zero_grad()
loss.backward()
optimizer.step()
1
2
3
4
5
6

5. 多 GPU 加速

PyTorch 支持多 GPU 加速，可以使用 torch.nn.DataParallel 封装模型，使其能够并行在多个 GPU 上执行。

model = MyModel()
model = nn.DataParallel(model)
model.to(device)
1
2
3

6. 在 GPU 上保存和加载模型

保存和加载模型时，可以选择将模型参数保存到或加载自 GPU。

# 保存模型到 GPU
torch.save(model.state_dict(), 'model.pth')

# 加载模型到 GPU
model.load_state_dict(torch.load('model.pth'))
model.to(device)
1
2
3
4
5
6

7. GPU 上的数据并行

在使用多 GPU 进行数据并行训练时，可以使用 torch.nn.parallel.DistributedDataParallel。

model = MyModel()
model = nn.parallel.DistributedDataParallel(model)
model.to(device)
1
2
3

8. 注意事项

• 确保你的 PyTorch 版本支持 CUDA，并安装了与你的 GPU 驱动版本相匹配的 CUDA 版本。

• 模型和数据移动到 GPU 时，确保 GPU 上有足够的显存可用。

• 使用 torch.cuda.empty_cache() 可以释放一部分被 PyTorch 占用的 GPU 内存。

GPU 加速能够显著提高深度学习模型的训练速度，特别是对于复杂的模型和大规模的数据集。在实践中，GPU 的使用通常是深度学习项目中的标配。