cos大壮 2025-06-07 10:58 浙江
最近发现越来越多的人在学习和使用pytorch，尤其是在学术界。工业界的话，可能有很多遗留下来的项目，还在沿
最近发现越来越多的人在学习和使用pytorch，尤其是在学术界。
工业界的话，可能有很多遗留下来的项目，还在沿用一些之前的深度学习框架。
一天之内，居然总结了68个pytorch的操作，大家可以看一看、捋一捋，也可以跟着是操作一下。
找了10086个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 中的异步数据加载
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}')
