小白学 PyTorch 系列：54个超强 pytorch 操作

最近观察到一个有趣的趋势，越来越多的人在学术界热衷于学习和应用PyTorch。在工业界，虽然仍有一些项目在延续使用之前的深度学习框架，但 PyTorch 的影响力也在逐渐渗透。

对于昨天为什么没发文，原因很心酸。把 PyTorch 的这篇文章梳理好的时候，已经太晚了，又赶上了跨年，太不容易了。

另外，细心的朋友会发现，我最近频繁在写 Pytorch 的文章，原因很简单：2024年是大模型应用落地的重要一年，大部分的大模型都是基于 Pytorch 去写的。我感觉这是作为普通人的我们，想在AI领域抓住最后一个风口，Pytorch 还是要认真去学。

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

今天把整体稍微修改了一下，整整54个PyTorch操作，这其中包含了许多实用的技巧。无论你是想学习，理清思路，还是亲自动手实践，这份总结都能给你带来不小的收获。

按照老规矩，如果你觉得这篇文章对你有所帮助，欢迎点个赞、收藏

基本张量操作

1. 创建张量

介绍： torch.tensor() 是 PyTorch 中用于创建张量的基本函数。

简单使用：

import torch

# 创建一个标量（零维张量）
scalar_tensor = torch.tensor(42)
print(scalar_tensor)

# 创建一个一维张量
vector_tensor = torch.tensor([1, 2, 3])
print(vector_tensor)

# 创建一个二维张量
matrix_tensor = torch.tensor([[1, 2], [3, 4]])
print(matrix_tensor)

2. 张量形状变换

介绍： torch.view() 用于改变张量的形状，但要确保元素数量不变。

简单使用：

import torch

# 创建一个一维张量
original_tensor = torch.arange(1, 9)  # 1, 2, 3, ..., 8
print("原始张量:", original_tensor)

# 将一维张量转换为二维张量
reshaped_tensor = original_tensor.view(2, 4)
print("形状变换后的张量:", reshaped_tensor)

3. 张量拼接

介绍： torch.cat() 用于沿指定维度拼接张量。

简单使用：

import torch

# 创建两个张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6]])

# 沿着行维度拼接张量
concatenated_tensor = torch.cat((tensor1, tensor2), dim=0)
print("拼接后的张量:", concatenated_tensor)

4. 张量索引与切片

介绍： 使用索引和切片可以获取张量的特定元素或子集。

简单使用：

import torch

# 创建一个二维张量
matrix_tensor = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 获取第一行
first_row = matrix_tensor[0, :]
print("第一行:", first_row)

# 获取第一列
first_column = matrix_tensor[:, 0]
print("第一列:", first_column)

# 切片获取子集
subset_tensor = matrix_tensor[1:, 1:]
print("子集张量:", subset_tensor)

重要的张量处理方式

5. 张量转置

介绍： torch.t() 用于计算矩阵的转置。

简单使用：

import torch

# 创建一个二维张量
matrix_tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])

# 计算转置
transposed_tensor = torch.t(matrix_tensor)
print("转置后的张量:", transposed_tensor)

6. 矩阵乘法

介绍： torch.mm() 用于计算两个矩阵的乘积。

简单使用：

import torch

# 创建两个矩阵
matrix1 = torch.tensor([[1, 2], [3, 4]])
matrix2 = torch.tensor([[5, 6], [7, 8]])

# 计算矩阵乘积
result_matrix = torch.mm(matrix1, matrix2)
print("矩阵乘积:", result_matrix)

7. 元素级乘法

介绍： torch.mul() 用于执行两个张量的元素级乘法。

简单使用：

import torch

# 创建两个张量
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[5, 6], [7, 8]])

# 元素级乘法
result_tensor = torch.mul(tensor1, tensor2)
print("元素级乘法结果:", result_tensor)

8. 求和

介绍： torch.sum() 用于计算张量元素的和。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]])

# 计算张量元素的和
sum_result = torch.sum(tensor)
print("张量元素的和:", sum_result)

9. 平均值

介绍： torch.mean() 用于计算张量元素的平均值。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 计算张量元素的平均值
mean_result = torch.mean(tensor)
print("张量元素的平均值:", mean_result)

张量：数学和统计功能

10. 标准差

介绍： torch.std() 用于计算张量元素的标准差。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 计算张量元素的标准差
std_result = torch.std(tensor)
print("张量元素的标准差:", std_result)

11. 最大值

介绍： torch.max() 用于找到张量中的最大值及其索引。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]])

# 找到张量中的最大值及其索引
max_value, max_index = torch.max(tensor, dim=1)
print("最大值:", max_value)
print("最大值索引:", max_index)

12. 最小值

介绍： torch.min() 用于找到张量中的最小值及其索引。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]])

# 找到张量中的最小值及其索引
min_value, min_index = torch.min(tensor, dim=1)
print("最小值:", min_value)
print("最小值索引:", min_index)

13. 绝对值

介绍： torch.abs() 用于计算张量元素的绝对值。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[-1, 2], [-3, 4]])

# 计算张量元素的绝对值
abs_result = torch.abs(tensor)
print("张量元素的绝对值:", abs_result)

14. 指数运算

介绍： torch.exp() 用于计算张量元素的指数。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 计算张量元素的指数
exp_result = torch.exp(tensor)
print("张量元素的指数:", exp_result)

15. 对数运算

介绍： torch.log() 用于计算张量元素的自然对数。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

# 计算张量元素的自然对数
log_result = torch.log(tensor)
print("张量元素的自然对数:", log_result)

张量：深度学习方面的操作

16. 向下取整

介绍： torch.floor() 用于将张量元素向下取整，得到不超过每个元素的最大整数。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])

# 向下取整
floor_result = torch.floor(tensor)
print("向下取整结果:", floor_result)

17. 向上取整

介绍： torch.ceil() 用于将张量元素向上取整，得到不小于每个元素的最小整数。

简单使用：

import torch

# 创建一个张量
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])

# 向上取整
ceil_result = torch.ceil(tensor)
print("向上取整结果:", ceil_result)

18. 梯度清零

介绍： 在训练深度学习模型时，使用 optimizer.zero_grad() 将梯度清零是一个常见的步骤，以防止梯度累积。

简单使用：

import torch
import torch.optim as optim

# 创建一个模型和优化器
model = torch.nn.Linear(3, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 前向传播、反向传播、梯度清零
input_data = torch.randn(10, 3)
output = model(input_data)
loss = torch.nn.functional.mse_loss(output, torch.randn(10, 1))
loss.backward()
optimizer.zero_grad()

19. 梯度裁剪

介绍： 用于防止梯度爆炸的技术，通过对模型的梯度进行裁剪。

简单使用：

import torch
import torch.nn as nn
import torch.optim as optim

# 创建一个模型和优化器
model = nn.Linear(3, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 前向传播、反向传播
input_data = torch.randn(10, 3)
output = model(input_data)
loss = torch.nn.functional.mse_loss(output, torch.randn(10, 1))
loss.backward()

# 梯度裁剪
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()

20. 数据加载与处理

介绍： torch.utils.data 模块提供了用于加载和处理数据的工具，包括 DataLoader 和 Dataset 等类。

简单使用：

import torch
from torch.utils.data import DataLoader, Dataset

# 自定义数据集类
class CustomDataset(Dataset):
    def __init__(self, data):
        self.data = data

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

    def __getitem__(self, index):
        return self.data[index]

# 创建自定义数据集实例
my_dataset = CustomDataset([1, 2, 3, 4, 5])

# 创建数据加载器
data_loader = DataLoader(my_dataset, batch_size=2, shuffle=True)

# 迭代数据加载器
for batch in data_loader:
    print("Batch:", batch)

训练和优化的核心概念

21. 模型定义与搭建

介绍： torch.nn.Module 是 PyTorch 中用于定义和搭建模型的基类。通过继承该类，可以创建自定义的深度学习模型。

简单使用：

import torch
import torch.nn as nn

# 自定义模型类
class SimpleModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(input_size, output_size)

    def forward(self, x):
        return self.linear(x)

# 创建模型实例
model = SimpleModel(input_size=10, output_size=5)

# 查看模型结构
print(model)

22. 损失函数

介绍： torch.nn.functional 模块提供了多种损失函数，例如均方误差损失（mse_loss）、交叉熵损失（cross_entropy）等。

简单使用：

import torch
import torch.nn.functional as F

# 创建模型输出和目标标签
output = torch.randn(3, 5)
target = torch.randint(5, (3,), dtype=torch.long)

# 计算交叉熵损失
loss = F.cross_entropy(output, target)
print("交叉熵损失:", loss.item())

23. 优化器

介绍： torch.optim 模块提供了多种优化器，例如随机梯度下降（SGD）、Adam 等。

简单使用：

import torch
import torch.optim as optim

# 创建模型和优化器
model = SimpleModel(input_size=10, output_size=5)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 在训练循环中使用优化器
for epoch in range(10):
    # ... 其他训练步骤 ...
    
    # 梯度清零
    optimizer.zero_grad()
    
    # 计算损失
    loss = compute_loss()
    
    # 反向传播
    loss.backward()
    
    # 参数更新
    optimizer.step()

24. 学习率调度

介绍： torch.optim.lr_scheduler 模块提供了多种学习率调度器，例如学习率衰减等。

简单使用：

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

# 创建模型、优化器和学习率调度器
model = SimpleModel(input_size=10, output_size=5)
optimizer = optim.SGD(model.parameters(), lr=0.01)
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)

# 在训练循环中使用学习率调度器
for epoch in range(20):
    # ... 其他训练步骤 ...
    
    # 梯度清零
    optimizer.zero_grad()
    
    # 计算损失
    loss = compute_loss()
    
    # 反向传播
    loss.backward()
    
    # 参数更新
    optimizer.step()
    
    # 更新学习率
    scheduler.step()

25. 模型保存与加载

介绍： torch.save() 和 torch.load() 用于模型的保存和加载。

简单使用：

import torch

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

# 加载模型
loaded_model = SimpleModel(input_size=10, output_size=5)
loaded_model.load_state_dict(torch.load('model.pth'))

26. GPU 加速

介绍： PyTorch 允许在GPU上运行张量和模型，以加速深度学习任务。

简单使用：

import torch

# 检查是否有可用的GPU
if torch.cuda.is_available():
    # 将模型和张量移动到GPU
    model = model.cuda()
    tensor = tensor.cuda()

27. 分布式训练

介绍： PyTorch 支持分布式训练，使得可以在多个GPU或多台机器上进行模型训练。

简单使用：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.multiprocessing as mp
import torch.distributed as dist

# 初始化分布式训练环境
mp.spawn(train, nprocs=4, args=(model, criterion, optimizer, train_loader))

28. 数据并行与模型并行

介绍： 数据并行是将数据分布在多个GPU上进行处理，而模型并行是将模型的不同部分分布在多个GPU上。

简单使用：

import torch
import torch.nn as nn

# 数据并行
model = nn.DataParallel(model)

# 模型并行
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.part1 = nn.Linear(10, 5)
        self.part2 = nn.Linear(5, 1)

# 将模型的不同部分放在不同的GPU上
model_part1 = MyModel().part1.cuda(0)
model_part2 = MyModel().part2.cuda(1)

29. 迁移学习

介绍： 迁移学习是使用在一个任务上训练好的模型来初始化另一个相关任务的模型。

简单使用：

import torch
import torchvision.models as models
import torch.nn as nn

# 加载预训练模型
pretrained_model = models.resnet18(pretrained=True)

# 修改并用于新任务
pretrained_model.fc = nn.Linear(pretrained_model.fc.in_features, num_classes)

30. 微调预训练模型

介绍： 微调是在预训练模型的基础上继续训练，以适应特定任务的技术。

简单使用：

import torch
import torchvision.models as models
import torch.nn as nn
import torch.optim as optim

# 加载预训练模型
pretrained_model = models.resnet18(pretrained=True)

# 修改并用于新任务
pretrained_model.fc = nn.Linear(pretrained_model.fc.in_features, num_classes)

# 定义损失和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(pretrained_model.parameters(), lr=0.001, momentum=0.9)

# 微调
for epoch in range(num_epochs):
    # ... 其他训练步骤 ...

pytorch 高级框架和工具

31. 图像处理与加载

介绍： torchvision.transforms 模块提供了许多用于图像处理和加载的转换操作，例如裁剪、旋转、缩放等。

简单使用：

import torch
from torchvision import transforms
from PIL import Image

# 定义图像转换
transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.RandomCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
])

# 加载图像并应用转换
image = Image.open('example.jpg')
transformed_image = transform(image)

32. 图像加载

介绍： torchvision.datasets.ImageFolder 允许从文件夹中加载图像数据集。

简单使用：

import torch
from torchvision import datasets, transforms

# 定义图像转换
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

# 加载图像数据集
dataset = datasets.ImageFolder(root='path/to/data', transform=transform)

33. PyTorch Lightning 框架

介绍： PyTorch Lightning 是一个轻量级的 PyTorch 框架，简化了训练循环和模型组织。

简单使用：

import torch
from torch import nn
from torch.utils.data import DataLoader
from pytorch_lightning import LightningModule, Trainer

# 自定义 Lightning 模型类
class SimpleLightningModel(LightningModule):
    def __init__(self, input_size, output_size):
        super(SimpleLightningModel, self).__init__()
        self.linear = nn.Linear(input_size, output_size)

    def forward(self, x):
        return self.linear(x)

# 创建 Lightning 模型实例
lightning_model = SimpleLightningModel(input_size=10, output_size=5)

# 创建数据加载器
train_loader = DataLoader(dataset, batch_size=32, shuffle=True)

# 创建 PyTorch Lightning 训练器
trainer = Trainer(max_epochs=5, gpus=1)  # 可以指定 GPU 数量
trainer.fit(lightning_model, train_loader)

34. PyTorch Ignite 框架

介绍： PyTorch Ignite 是一个用于训练和评估深度学习模型的高级库。

简单使用：

import torch
from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator
from ignite.metrics import Accuracy

# 自定义 PyTorch 模型类
class SimpleModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(input_size, output_size)

    def forward(self, x):
        return self.linear(x)

# 创建 PyTorch 模型实例
model = SimpleModel(input_size=10, output_size=5)

# 创建 Ignite 引擎
trainer = create_supervised_trainer(model, optimizer, loss_fn)
evaluator = create_supervised_evaluator(model, metrics={'accuracy': Accuracy()})

# 训练和评估
@trainer.on(Events.EPOCH_COMPLETED)
def log_results(engine):
    evaluator.run(val_loader)
    metrics = evaluator.state.metrics
    print(f"Epoch {engine.state.epoch}: Accuracy - {metrics['accuracy']}")

trainer.run(train_loader, max_epochs=5)

35. PyTorch Hub 的使用

介绍： PyTorch Hub 提供了在预训练模型和标准实现之间共享的中心化存储库。

简单使用：

import torch

# 加载预训练模型
model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet18', pretrained=True)

自定义操作

36. 自定义损失函数

介绍： 你可以通过继承 torch.nn.Module 类来创建自定义的损失函数。

简单使用：

import torch
import torch.nn as nn

# 自定义损失函数类
class CustomLoss(nn.Module):
    def __init__(self, weight):
        super(CustomLoss, self).__init__()
        self.weight = weight

    def forward(self, predictions, targets):
        loss = torch.mean((predictions - targets) ** 2)
        weighted_loss = self.weight * loss
        return weighted_loss

# 使用自定义损失函数
loss_function = CustomLoss(weight=0.5)

37. 自定义初始化方法

介绍： 你可以自定义模型参数的初始化方法。

简单使用：

import torch.nn.init as init

# 自定义初始化方法
def custom_init(m):
    if isinstance(m, nn.Linear):
        init.constant_(m.weight, val=0.1)
        init.constant_(m.bias, val=0)

# 在模型中应用初始化方法
model.apply(custom_init)

38. 自定义学习率调度器

介绍： 你可以通过继承 torch.optim.lr_scheduler._LRScheduler 类来创建自定义学习率调度器。

简单使用：

import torch.optim as optim

# 自定义学习率调度器类
class CustomLRScheduler(optim.lr_scheduler._LRScheduler):
    def __init__(self, optimizer):
        super(CustomLRScheduler, self).__init__(optimizer)

    def get_lr(self):
        # 自定义学习率调度逻辑
        pass

# 使用自定义学习率调度器
optimizer = optim.SGD(model.parameters(), lr=0.01)
lr_scheduler = CustomLRScheduler(optimizer)

39. 可视化工具

介绍： 使用可视化工具可以更好地理解模型的训练过程。

简单使用：

from torch.utils.tensorboard import SummaryWriter

# 创建 TensorBoard 写入器
writer = SummaryWriter()

# 写入标量值
writer.add_scalar('Loss', loss, global_step=epoch)

# 写入模型结构
writer.add_graph(model, input_data)

# 在命令行中运行 TensorBoard
# tensorboard --logdir=runs

40. 自定义数据加载器

介绍： 继承 torch.utils.data.Dataset 类可以自定义数据加载器。

简单使用：

from torch.utils.data import Dataset

# 自定义数据加载器类
class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

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

    def __getitem__(self, index):
        return self.data[index], self.labels[index]

# 使用自定义数据加载器
custom_dataset = CustomDataset(data, labels)

进一步提升pytorch的功能和性能

41. 使用 PyTorch JIT 编译

介绍： PyTorch JIT（Just-In-Time）编译器允许将 PyTorch 模型转换为脚本，以提高性能。

简单使用：

import torch

# 定义一个简单的模型
class SimpleModel(torch.nn.Module):
    def forward(self, x):
        return x * 2

# 创建模型实例
model = SimpleModel()

# 使用 JIT 编译模型
jit_model = torch.jit.script(model)

# 使用 JIT 模型进行推理
input_data = torch.tensor([1.0, 2.0, 3.0])
output = jit_model(input_data)
print(output)

42. PyTorch 转 ONNX

介绍： 将 PyTorch 模型转换为 ONNX（Open Neural Network Exchange）格式，以在其他框架或硬件上部署模型。

简单使用：

import torch
import torchvision.models as models

# 加载预训练模型
model = models.resnet18(pretrained=True)

# 将 PyTorch 模型转为 ONNX 格式
dummy_input = torch.randn(1, 3, 224, 224)
onnx_path = "resnet18.onnx"
torch.onnx.export(model, dummy_input, onnx_path, verbose=True)

43. PyTorch Mobile

介绍： PyTorch Mobile 允许在移动设备上运行 PyTorch 模型，支持 Android 和 iOS。

简单使用：

import torch
import torch_mobile

# 加载 PyTorch 模型
model = torch.load("model.pth")

# 将模型转为 PyTorch Mobile 格式
torch_mobile_model = torch_mobile.from_torch(model)

# 保存 PyTorch Mobile 模型
torch_mobile_model.save("model_mobile.ptl")

44. PyTorch Lightning Bolts

介绍： PyTorch Lightning Bolts 是 PyTorch Lightning 的扩展库，提供了各种模块和组件，以加速深度学习任务的开发。

简单使用：

import pl_bolts

# 使用 PyTorch Lightning Bolts 中的模块
from pl_bolts.models.autoencoders import BasicAE
model = BasicAE()

45. 混合精度训练

介绍： 使用混合精度训练可以加速模型训练，减少显存占用。

简单使用：

import torch
from torch.cuda.amp import autocast, GradScaler

# 创建模型和优化器
model = ...
optimizer = ...

# 创建混合精度训练的梯度缩放器
scaler = GradScaler()

# 在训练循环中使用混合精度训练
for epoch in range(num_epochs):
    for input_data, target in train_loader:
        optimizer.zero_grad()
        
        # 使用 autocast 将前向传播、损失计算和反向传播放在混合精度环境中
        with autocast():
            output = model(input_data)
            loss = loss_fn(output, target)
        
        # 反向传播和梯度更新
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()

46. PyTorch 模型剪枝

介绍： PyTorch 提供了用于剪枝（模型参数减少）的工具，以减小模型的大小。

简单使用：

import torch
import torch.nn.utils.prune as prune

# 创建模型
model = ...

# 定义剪枝配置
prune_config = prune.l1_unstructured(amount=0.2)

# 对模型进行剪枝
prune.global_unstructured(model, pruning_method=prune_config, name="weight")

47. PyTorch Profiler

介绍： PyTorch Profiler 允许开发人员分析模型的性能和内存使用情况。

简单使用：

import torch
from torch.profiler import profile, record_function, ProfilerActivity

# 创建模型
model = ...

# 使用 Profiler 分析模型性能
with profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA], record_shapes=True) as prof:
    with record_function("model_inference"):
        output = model(input_data)

# 打印分析结果
print(prof.key_averages().table(sort_by="self_cuda_time_total"))

48. PyTorch Lightning 提供的 Callbacks

介绍： PyTorch Lightning 提供了许多内置的 Callbacks，用于在训练过程中执行额外的操作。

简单使用：

import pytorch_lightning as pl

# 创建 Lightning 模型类
class MyModel(pl.LightningModule):
    def training_step(self, batch, batch_idx):
        # 训练步骤代码...

    def validation_step(self, batch, batch_idx):
        # 验证步骤代码...

# 使用 EarlyStoppingCallback
early_stopping_callback = pl.callbacks.EarlyStopping(monitor='val_loss', patience=3)

49. 模型解释性工具

介绍： captum 是一个 PyTorch 的模型解释性库，用于分析模型的预测结果。

简单使用：

import torch
from captum.attr import IntegratedGradients

# 创建模

型和输入数据
model = ...
input_data = ...

# 创建 Integrated Gradients 解释器
ig = IntegratedGradients(model)

# 计算输入数据的解释性值
attributions, delta = ig.attribute(input_data, target=1, return_convergence_delta=True)

50. PyTorch 中的异步数据加载

介绍： PyTorch 允许使用 torch.utils.data.DataLoader 的 num_workers 参数实现异步数据加载，加速数据加载过程。

简单使用：

import torch
from torch.utils.data import DataLoader

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)

其他

51. PyTorch 中的分布式训练与模型并行

介绍： PyTorch 支持分布式训练，可以在多个 GPU 或多台机器上进行模型训练。此外，PyTorch 也支持模型并行，允许将模型的不同部分分布在多个 GPU 上。

简单使用：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel

# 初始化分布式训练环境
dist.init_process_group(backend='nccl', init_method='tcp://localhost:23456', rank=0, world_size=1)

# 创建模型并将其移到 GPU
model = nn.Sequential(nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 1))
model = model.to('cuda')

# 使用 DistributedDataParallel 包装模型
model = DistributedDataParallel(model)

# 定义优化器和损失函数
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.MSELoss()

# 在训练循环中使用 DistributedDataParallel
for epoch in range(num_epochs):
    for input_data, target in train_loader:
        input_data, target = input_data.to('cuda'), target.to('cuda')
        output = model(input_data)
        loss = criterion(output, target)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# 在命令行中使用多 GPU 训练：
# python -m torch.distributed.launch --nproc_per_node=NUM_GPUS your_training_script.py

52. PyTorch 中的自动微分（Autograd）

介绍： PyTorch 中的 Autograd 模块提供了自动微分的功能，可以方便地计算梯度。

简单使用：

import torch

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

# 定义一个计算图
y = x.pow(2).sum()

# 反向传播，计算梯度
y.backward()

# 获取梯度
print(x.grad)

53. PyTorch 中的动态计算图

介绍： PyTorch 中的计算图是动态的，允许根据实际执行情况动态构建计算图。

简单使用：

import torch

# 创建动态计算图
def dynamic_computation(x):
    if x.sum() > 0:
        return x * 2
    else:
        return x * 3

# 构建计算图
x = torch.tensor([1.0, -1.0], requires_grad=True)
result = dynamic_computation(x)

# 反向传播，计算梯度
result.sum().backward()

# 获取梯度
print(x.grad)

54. PyTorch 中的模型保存与加载

介绍： PyTorch 提供了保存和加载模型的工具，可以保存整个模型或仅保存模型的参数。

简单使用：

import torch

# 定义一个简单的模型
class SimpleModel(torch.nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = torch.nn.Linear(10, 5)

    def forward(self, x):
        return self.fc(x)

# 创建模型实例
model = SimpleModel()

# 保存整个模型
torch.save(model, 'whole_model.pth')

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

# 加载整个模型
loaded_model = torch.load('whole_model.pth')

# 加载模型参数到新的模型实例
new_model = SimpleModel()
new_model.load_state_dict(torch.load('model_params.pth'))

import torch
import torch.nn as nn

# 创建模型和损失函数
model = ...
criterion = ...

# 创建数据加载器
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# 模型评估
model.eval()
total_loss = 0.0
correct_predictions = 0

with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        total_loss += loss.item()
        
        _, predicted_class = torch.max(outputs, 1)
        correct_predictions += (predicted_class == labels).sum().item()

average_loss = total_loss / len(test_loader.dataset)
accuracy = correct_predictions / len(test_loader.dataset)

print(f'Average Loss: {average_loss}, Accuracy: {accuracy}')

最后

给大家准备了**《机器学习学习面试册》PDF版本****，**亮色和暗色！

16大块的内容，124个问题的总结！

领取方式，微信私信即可！（备注“面试题”）

---

---

另外，我们最近发布了**《100个超强机器学习算法模型》****！！**

很多初学者是有这么一个痛点，就是需要完整的案例在你的学习路上助推一把！ 现在已经有1200人加入了进来！

详情点击这里：100个超强算法模型！！

喜欢本文的朋友可以收藏、点赞、转发起来！

关注本号，带来更多干货实例，提升工作学习效率！

推荐阅读机器学习全路线！回归类算法总结！svm算法详细总结！详解 5 种距离算法！详解过拟合和欠拟合！正则化算法完整总结！人工神经网络完整总结！27个，强大的Python库！一万字的统计学知识大梳理！机器学习各个算法的优缺点！9 大核心机器学习算法解释！最终篇：统计学知识大梳理！来啦！最强Python分析工具！7大方面，30个最强数据集！！通透！10种损失函数大梳理！！sklearn处理监督学习算法案例汇总！sklearn处理无监督学习算法案例汇总！6大部分，20 个机器学习算法全面汇总！！