深度学习pytorch常用操作以及流程
在微信公众号上看到这篇文章,担心以后想找的时候迷路,所以记录到了自己的博客上,侵扰致歉,随时联系可删除。
1.基本张量操作
1. 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)
1.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)
1.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)
1.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)
2.重要的张量处理方式
2.1 张量转置
介绍: torch.t()
用于计算矩阵的转置。
简单使用:
import torch
# 创建一个二维张量
matrix_tensor = torch.tensor([[1, 2, 3], [4, 5, 6]])
# 计算转置
transposed_tensor = torch.t(matrix_tensor)
print("转置后的张量:", transposed_tensor)
2.2 矩阵乘法
介绍: 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)
2.3 元素级乘法
介绍: 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)
2.4 求和
介绍: torch.sum()
用于计算张量元素的和。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1, 2], [3, 4]])
# 计算张量元素的和
sum_result = torch.sum(tensor)
print("张量元素的和:", sum_result)
2.5 平均值
介绍: torch.mean()
用于计算张量元素的平均值。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
# 计算张量元素的平均值
mean_result = torch.mean(tensor)
print("张量元素的平均值:", mean_result)
3.张量:数学和统计功能
3.1 标准差
介绍: torch.std()
用于计算张量元素的标准差。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
# 计算张量元素的标准差
std_result = torch.std(tensor)
print("张量元素的标准差:", std_result)
3.2 最大值
介绍: 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)
3.3 最小值
介绍: 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)
3.4 绝对值
介绍: torch.abs()
用于计算张量元素的绝对值。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[-1, 2], [-3, 4]])
# 计算张量元素的绝对值
abs_result = torch.abs(tensor)
print("张量元素的绝对值:", abs_result)
3.5 指数运算
介绍: torch.exp()
用于计算张量元素的指数。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
# 计算张量元素的指数
exp_result = torch.exp(tensor)
print("张量元素的指数:", exp_result)
3.6 对数运算
介绍: torch.log()
用于计算张量元素的自然对数。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
# 计算张量元素的自然对数
log_result = torch.log(tensor)
print("张量元素的自然对数:", log_result)
4.张量:深度学习方面的操作
4.1 向下取整
介绍: torch.floor()
用于将张量元素向下取整,得到不超过每个元素的最大整数。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])
# 向下取整
floor_result = torch.floor(tensor)
print("向下取整结果:", floor_result)
4.2 向上取整
介绍: torch.ceil()
用于将张量元素向上取整,得到不小于每个元素的最小整数。
简单使用:
import torch
# 创建一个张量
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])
# 向上取整
ceil_result = torch.ceil(tensor)
print("向上取整结果:", ceil_result)
4.3 梯度清零
介绍: 在训练深度学习模型时,使用 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()
4.4 梯度裁剪
介绍: 用于防止梯度爆炸的技术,通过对模型的梯度进行裁剪。
简单使用:
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()
4.5 数据加载与处理
介绍: 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)
5.训练和优化的核心概念
5.1 模型定义与搭建
介绍: 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)
5.2 损失函数
介绍: 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())
5.3 优化器
介绍: 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()
5.4 学习率调度
介绍: 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()
5.5 模型保存与加载
介绍: 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'))
5.6 GPU 加速
介绍: PyTorch 允许在GPU上运行张量和模型,以加速深度学习任务。
简单使用:
import torch
# 检查是否有可用的GPU
if torch.cuda.is_available():
# 将模型和张量移动到GPU
model = model.cuda()
tensor = tensor.cuda()
5.7 分布式训练
介绍: 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))
5.8 数据并行与模型并行
介绍: 数据并行是将数据分布在多个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)
6.pytorch 高级框架和工具
6.1 图像处理与加载
介绍: 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)
6.2 图像加载
介绍: 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)
7.自定义操作
7.1 自定义损失函数
介绍: 你可以通过继承 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)
7.2 自定义初始化方法
介绍: 你可以自定义模型参数的初始化方法。
简单使用:
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)
7.3 自定义学习率调度器
介绍: 你可以通过继承 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)
7.4 可视化工具
介绍: 使用可视化工具可以更好地理解模型的训练过程。
简单使用:
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
7.5 自定义数据加载器
介绍: 继承 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)
7.6 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)
7.7 混合精度训练
介绍: 使用混合精度训练可以加速模型训练,减少显存占用。
简单使用:
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()
7.8 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)
7.9 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
7.10 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)
7.11 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)
7.12 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}')
参考文章
【创作不易,望点赞收藏,若有疑问,请留言,谢谢】