50个pytorch的超强操作！！

已于 2025-06-07 12:52:41 修改
阅读量1.5k 收藏 14
点赞数 47
CC 4.0 BY-SA版权
分类专栏： 数据科学 Transformer PyTorch 文章标签： pytorch 人工智能 深度学习 机器学习
于 2025-06-06 23:33:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_70350287/article/details/148480872

我是 我不是小upper，最近发现 PyTorch 在学术界热度持续飙升，工业界虽然还有不少 legacy 项目用着老框架，但越来越多人开始拥抱 PyTorch 啦。花了超多精力，整理出 68 个（实际挖掘了 10086+ 常用操作后精选）PyTorch 关键操作，不管是刚入门想快速上手，还是想查漏补缺的同学，都能从这篇内容里挖到宝！觉得有用的话，点赞收藏走一波。

下面咱们就从最基础的张量创建开始，一步步拆解 PyTorch 核心玩法！

1.基础张量操作：搭建 PyTorch 认知基石

1. 张量创建：数据向张量的蜕变

PyTorch 里，torch.tensor() 是把 Python 数据转化为张量的 “魔法入口”，能生成标量、向量、矩阵等不同维度张量：

import torch
# 标量（零维）：单个数值的极致简化
scalar = torch.tensor(42)  
# 一维向量：像一条数据“直线”
vector = torch.tensor([1, 2, 3])  
# 二维矩阵：行列交织的二维世界
matrix = torch.tensor([[1, 2], [3, 4]])  

它就像数据的 “塑形器”，把 Python 里的数字、列表，变成 PyTorch 能理解、能计算的张量结构，是一切操作的起点。

2. 形状变换：张量的 “变形术“

”torch.view() 能在不改变元素数量的前提下，重塑张量形状，让数据适配不同计算需求：

# 先生成 1-8 的一维序列
original = torch.arange(1, 9)  
# 一键变形成 2 行 4 列的二维张量
reshaped = original.view(2, 4)  

这就好比把一串糖葫芦（一维），重新摆成 2 行 4 列的糖画矩阵，元素还是那些，只是排列方式变了，方便后续和其他 “矩阵形态” 的数据运算。

3. 张量拼接：“数据的合体术“

torch.cat() 能沿着指定维度，把多个张量 “粘” 在一起，扩充数据规模：

# 两个待拼接的张量
t1 = torch.tensor([[1, 2], [3, 4]])  
t2 = torch.tensor([[5, 6]])  
# 沿行维度（dim=0）拼接，让 t2 “接在” t1 下方
concatenated = torch.cat((t1, t2), dim=0)  

想象成把两摞积木按同一方向堆叠，拼出更高的 “积木塔”，维度就是堆叠的方向指引。

4. 索引与切片：精准提取数据片段

# 构造 3×3 矩阵
matrix = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])  
# 捞第一行数据
first_row = matrix[0, :]  
# 捞第一列数据
first_col = matrix[:, 0]  
# 捞右下角 2×2 子矩阵（从第二行、第二列开始）
subset = matrix[1:, 1:]  

通过索引和切片，能从张量里 “挑出” 需要的部分，像在数据海洋里捞特定的 “鱼”：就像用渔网在矩阵池塘里，按行、列坐标精准捕捞，拿到想要的数据片段做分析。二、进阶张量处理：解锁高效计算姿势

5. 张量转置：矩阵的 “镜像翻转”

# 2 行 3 列的原始矩阵
matrix = torch.tensor([[1, 2, 3], [4, 5, 6]])  
# 转置后变成 3 行 2 列
transposed = torch.t(matrix)  

torch.t() 专门处理二维矩阵转置，行列互换，给矩阵来个 “镜像翻转”：类似把写满字的本子旋转 90 度，行列内容交换位置，方便后续和其他转置后的矩阵做运算。

6. 矩阵乘法：线性代数核心运算

# 两个 2×2 矩阵
m1 = torch.tensor([[1, 2], [3, 4]])  
m2 = torch.tensor([[5, 6], [7, 8]])  
# 矩阵相乘，得到新 2×2 矩阵
result = torch.mm(m1, m2)  

torch.mm() 实现矩阵相乘，严格遵循线性代数规则（前矩阵列数 = 后矩阵行数）：这是神经网络里权重更新、特征变换的基础运算，就像两个数据 “密码本” 相乘，生成新的 “加密结果”。

7. 元素级乘法：逐元素的 “数值相乘”

# 两个同形状矩阵
t1 = torch.tensor([[1, 2], [3, 4]])  
t2 = torch.tensor([[5, 6], [7, 8]])  
# 对应位置元素相乘，结果还是 2×2 矩阵
result = torch.mul(t1, t2)  

torch.mul() 不管维度匹配规则（只要广播后能对应），直接逐元素相乘：像是两个相同尺寸的 “数字拼图”，每个位置的小块数值直接相乘，得到新的数值拼图，常用在逐元素的特征缩放场景。

8. 求和运算：张量的 “数值汇总”

# 2×2 矩阵
tensor = torch.tensor([[1, 2], [3, 4]])  
# 所有元素求和：1+2+3+4=10
sum_val = torch.sum(tensor)

torch.sum() 把张量里所有元素加起来，得到一个汇总值：好比把一筐数字全倒进 “加法漏斗”，最后流出总和，用于计算损失、统计全局特征等场景。

9. 平均值计算：数据的 “平均水平”

# 用浮点型数据创建张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])  
# 平均值：(1+2+3+4)/4 = 2.5
mean_val = torch.mean(tensor)  

torch.mean() 计算张量元素的平均值，注意输入得是浮点型（否则会报错）：就像给数据做 “平均化体检”，看看整体数值的中心位置，在损失计算、特征归一化里常用。三、数学与统计功能：挖掘张量背后的规律

10. 标准差：数据离散程度的 “度量尺”

# 浮点型张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])  
# 计算标准差，看数据偏离平均值多远
std_val = torch.std(tensor)  

torch.std() 算出张量元素的标准差，反映数据的离散、波动程度：数值越大，说明数据越 “参差不齐”；越小则越 “整齐划一”，帮我们了解数据分布特性。

11. 最大值查找：揪出 “数据尖子生”

# 2×2 矩阵
tensor = torch.tensor([[1, 2], [3, 4]])  
# 按行找最大值（dim=1），每行的最大值和对应列索引
max_val, max_idx = torch.max(tensor, dim=1)  

torch.max() 能找出张量里的最大值，还能拿到它的索引位置（指定维度时更灵活）：像是在数据班里选 “最高分”，还能知道谁考了最高分（索引），在分类任务找预测类别、筛选特征时常用。

12. 最小值查找：锁定 “数据后进生

# 2×2 矩阵
tensor = torch.tensor([[1, 2], [3, 4]])  
# 按行找最小值，拿到值和列索引
min_val, min_idx = torch.min(tensor, dim=1)  

”torch.min() 和 max 逻辑相反，找最小值及索引：在需要找数据下限、异常值场景中，能快速定位 “拖后腿” 的元素。

13. 绝对值：负数的 “转正术”

# 含负数的张量
tensor = torch.tensor([[-1, 2], [-3, 4]])  
# 绝对值处理后，负数变正
abs_tensor = torch.abs(tensor)  

torch.abs() 把张量里的负数转成正数，正数、零保持不变：不管数据原本是正是负，统一 “取正”，常用于处理带符号的误差、距离计算等场景。

14. 指数运算：数值的 “爆炸式增长”

# 浮点型张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])  
# 计算 e^1, e^2 等结果
exp_tensor = torch.exp(tensor)  

torch.exp() 对张量元素做自然指数运算（e^x），让数值按指数规律变化：数值越大，结果增长越 “迅猛”，在激活函数（如 Softmax 分母计算）、概率建模里经常用到。

15. 对数运算：数值的 “逆向缩放”

# 浮点型、正数张量
tensor = torch.tensor([[1.0, 2.0], [3.0, 4.0]])  
# 计算 ln(1), ln(2) 等结果
log_tensor = torch.log(tensor)  

torch.log() 计算自然对数（ln x），把大数值 “压缩” 变小，前提是元素得大于 0：常和指数运算配合，做数据的 “缩放 - 还原” 操作，也用于损失函数（如交叉熵）计算里。

张量数学操作（深度学习基础运算）

16. 向下取整（torch.floor()）

  • 功能：对张量中每个元素执行向下取整运算，返回不大于该元素的最大整数。
  • 场景：处理模型输出的连续值（如回归任务预测值）时，若需离散化取整（如按整数量级统计），可通过此操作转换。
  • 代码逻辑：
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])  
floor_result = torch.floor(tensor)  # 输出 tensor([[1., 2.], [3., 4.]])

17. 向上取整（torch.ceil()）

  • 功能：对张量元素执行向上取整，返回不小于该元素的最小整数。
  • 场景：与向下取整互补，用于需要严格向上近似的场景（如资源分配类任务，计算最小需求数量）。
  • 代码逻辑：
tensor = torch.tensor([[1.2, 2.8], [3.5, 4.1]])  
ceil_result = torch.ceil(tensor)  # 输出 tensor([[2., 3.], [4., 5.]])

训练流程核心操作（梯度与优化）

18. 梯度清零（optimizer.zero_grad()）

  • 原理：PyTorch 中，反向传播会累积梯度（grad 属性）。若不清零，新计算的梯度会与历史梯度叠加，导致参数更新错误。
  • 必要性：每次训练迭代（前向→反向→更新）前，需主动清零梯度，确保参数更新仅基于当前 batch 数据。
  • 代码逻辑：
optimizer = optim.SGD(model.parameters(), lr=0.01)  
# 前向、反向传播后，更新参数前执行  
optimizer.zero_grad()

19. 梯度裁剪（torch.nn.utils.clip_grad_norm_）

  • 作用：限制梯度的范数（norm），防止梯度爆炸（梯度值过大导致参数更新幅度过猛、模型不稳定）。
  • 实现：通过 max_norm 设定梯度范数上限，超过则按比例缩放梯度。
  • 代码逻辑：
# 反向传播后、参数更新前执行  
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)  
optimizer.step()

数据加载与处理（训练数据准备）

20. 数据加载器（DataLoader & Dataset）

  • 设计逻辑：
    • Dataset：自定义数据集类，需实现 __len__（数据集大小）和 __getitem__（按索引取数据），封装数据读取与预处理。
    • DataLoader：基于 Dataset 生成可迭代的批量数据，支持 batch_size（批量大小）、shuffle（打乱数据）等配置，提升训练效率。
  • 代码逻辑：
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)

模型构建与训练（核心流程）

21. 模型定义（nn.Module 继承）

  • 规范：所有 PyTorch 模型需继承 nn.Module，通过 __init__ 定义层结构，forward 实现前向传播逻辑。
  • 作用：框架自动识别可训练参数，支持 to(device)（设备迁移）、parameters()（优化器参数传入）等功能。
  • 代码逻辑：
class SimpleModel(nn.Module):  
    def __init__(self, input_size, output_size):  
        super().__init__()  
        self.linear = nn.Linear(input_size, output_size)  
    def forward(self, x): return self.linear(x)  

model = SimpleModel(10, 5)

22. 损失函数（nn.functional 或 nn.Module）

  • 分类：
    • 函数式 API（nn.functional）：如 F.cross_entropy，需手动传入预测与标签。
    • 模块式 API（nn.Module 子类）：如 nn.CrossEntropyLoss，需实例化后调用。
  • 代码逻辑（函数式示例）：
output = torch.randn(3, 5)  # 模型输出（3 个样本，5 分类）  
target = torch.randint(5, (3,), dtype=torch.long)  # 真实标签  
loss = F.cross_entropy(output, target)

23. 优化器（torch.optim）

  • 功能：实现梯度下降算法（如 SGD、Adam），根据反向传播得到的梯度更新模型参数。
  • 流程：初始化时传入模型参数与学习率（lr），训练中通过 step() 执行参数更新。
  • 代码逻辑：
optimizer = optim.SGD(model.parameters(), lr=0.01)  
# 训练循环中：  
optimizer.zero_grad()  # 清零梯度  
loss.backward()        # 反向传播  
optimizer.step()       # 更新参数

24. 学习率调度（lr_scheduler）

  • 作用：动态调整学习率（如训练后期衰减学习率，稳定收敛）。
  • 示例（StepLR）：每 step_size 个 epoch，学习率乘以 gamma（衰减系数）。
  • 代码逻辑：
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)  
# 训练循环中，参数更新后执行  
scheduler.step()

25. 模型保存与加载（torch.save & load_state_dict）

  • 保存：torch.save(model.state_dict(), 'model.pth') 仅保存模型参数（轻量化，需重新实例化模型）。
  • 加载：先创建模型实例，再通过 load_state_dict 恢复参数。
  • 代码逻辑：
# 保存  
torch.save(model.state_dict(), 'model.pth')  

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

五、高级训练策略

26. GPU 加速（cuda() 或 to(device)）

  • 实现：检查 torch.cuda.is_available() 后，通过 model.cuda()、tensor.cuda() 或 model.to(device)（device='cuda'）将模型和张量迁移到 GPU。
  • 作用：利用 GPU 并行计算能力，加速模型训练与推理。
  • 代码逻辑：
if torch.cuda.is_available():  
    model = model.cuda()  
    tensor = tensor.cuda()

27. 分布式训练（torch.distributed）

  • 原理：通过多进程（mp.spawn）或多机通信，将训练任务分配到多个 GPU / 机器，提升训练效率。
  • 核心：dist.init_process_group 初始化通信环境，DistributedSampler 划分数据集。
  • 代码逻辑（简化示例）：
def train(rank, model, criterion, optimizer, train_loader):  
    dist.init_process_group(backend='nccl', rank=rank, world_size=4)  
    # 训练逻辑...  

mp.spawn(train, nprocs=4, args=(model, criterion, optimizer, train_loader))

28. 数据并行与模型并行

  • 数据并行（nn.DataParallel）：
    • 原理：单进程多 GPU，将数据拆分到不同 GPU 计算，结果汇总。
    • 代码：model = nn.DataParallel(model)，自动处理多 GPU 分发。
  • 模型并行：
    • 原理：将模型不同层分配到不同 GPU（如 part1.cuda(0)、part2.cuda(1)），手动控制计算流。
    • 代码：
class MyModel(nn.Module):  
    def __init__(self):  
        self.part1 = nn.Linear(10, 5).cuda(0)  
        self.part2 = nn.Linear(5, 1).cuda(1)  
    def forward(self, x):  
        x = self.part1(x.cuda(0))  
        return self.part2(x.cuda(1))

29. 迁移学习（预训练模型复用）

  • 流程：加载预训练模型（如 models.resnet18(pretrained=True)），修改输出层（适配新任务类别数）。
  • 代码逻辑：
pretrained_model = models.resnet18(pretrained=True)  
# 替换全连接层  
pretrained_model.fc = nn.Linear(pretrained_model.fc.in_features, num_classes)

30. 微调预训练模型

  • 策略：加载预训练参数后，继续训练（通常设置较小学习率，避免破坏已有特征）。
  • 代码逻辑：
optimizer = optim.SGD(pretrained_model.parameters(), lr=0.001, momentum=0.9)  
for epoch in range(num_epochs):  
    # 前向、反向传播及参数更新（同常规训练）

pytorch 高级框架和工具

31. 图像处理与加载

介绍：在 PyTorch 中，torchvision.transforms 模块提供了丰富的图像处理功能，可用于图像的预处理和数据增强，常见的操作包括裁剪、旋转、缩放等。

详细解释：

  • torchvision.transforms 提供了多种图像转换操作，可用于图像的预处理和数据增强。

  • transforms.Compose 方法可以将多个转换操作组合在一起，形成一个转换流程。

  • transforms.Resize 用于将图像调整到指定大小。

  • transforms.RandomCrop 用于随机裁剪图像。

  • transforms.RandomHorizontalFlip 用于随机水平翻转图像。

  • transforms.ToTensor 用于将图像转换为 PyTorch 张量，并归一化像素值到 [0, 1] 范围。

代码示例：

import torch
from torchvision import transforms
from PIL import Image

# 定义图像转换流程
transform = transforms.Compose([
    transforms.Resize((256, 256)),        # 将图像调整为 256x256
    transforms.RandomCrop(224),           # 随机裁剪为 224x224
    transforms.RandomHorizontalFlip(),    # 随机水平翻转
    transforms.ToTensor(),                # 转换为张量并归一化
])

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

32. 图像加载

介绍：torchvision.datasets.ImageFolder 是一个用于从文件夹中加载图像数据集的工具。

详细解释：

  • torchvision.datasets.ImageFolder 可以从指定文件夹中加载图像数据集。

  • 文件夹结构通常为：文件夹名对应类别，每个类别文件夹包含该类别的图像。

  • 通过指定 transform 参数，可以在加载图像时应用预定义的转换操作。

代码示例：

import torch
from torchvision import datasets, transforms

# 定义图像转换
transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 调整图像大小为 224x224
    transforms.ToTensor(),          # 转换为张量
])

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

33. PyTorch Lightning 框架

介绍：PyTorch Lightning 是一个轻量级框架，旨在简化 PyTorch 模型的训练过程和组织结构。

详细解释：

  • PyTorch Lightning 通过封装训练循环和模型组织，减少了重复代码，提高了训练效率。

  • LightningModule 是 PyTorch Lightning 中的核心类，用于定义模型结构、优化器和训练步骤。

  • Trainer 类负责管理模型的训练过程，包括训练循环、日志记录和 GPU 管理等。

代码示例：

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_model = SimpleLightningModel(input_size=10, output_size=5)

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

# 创建训练器并启动训练
trainer = Trainer(max_epochs=5, gpus=1)  # 指定训练周期和 GPU 数量
trainer.fit(lightning_model, train_loader)

34. PyTorch Ignite 框架

介绍：PyTorch Ignite 是一个高级库，提供了丰富的工具用于训练和评估深度学习模型。

详细解释：

  • PyTorch Ignite 提供了 create_supervised_trainer 和 create_supervised_evaluator 函数，用于快速创建训练和评估引擎。

  • Events 和 Metrics 是 Ignite 中的重要组件，用于定义训练和评估过程中的事件处理和性能指标计算。

代码示例：

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

# 定义模型
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)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
loss_fn = torch.nn.MSELoss()

# 创建训练和评估引擎
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 是一个集中化的存储库，方便用户共享和使用预训练模型。

详细解释：

  • PyTorch Hub 提供了大量预训练模型，用户可以通过简单的 API 调用加载和使用这些模型。

  • torch.hub.load 函数用于从 Hub 中加载指定的预训练模型。

代码示例：

import torch

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

36. 自定义损失函数

介绍：在 PyTorch 中，用户可以通过继承 torch.nn.Module 类来创建自定义损失函数。

详细解释：

  • 自定义损失函数需要定义 __init__ 和 forward 方法。

  • __init__ 方法用于初始化损失函数的参数。

  • forward 方法定义了损失的计算逻辑。

代码示例：

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. 自定义初始化方法

介绍：在 PyTorch 中，用户可以自定义模型参数的初始化方法。

详细解释：

  • 用户可以通过定义函数来实现自定义的初始化逻辑。

  • 使用 model.apply 方法可以将自定义初始化方法应用到模型的所有层。

代码示例：

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. 自定义学习率调度器

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

详细解释：

  • 自定义学习率调度器需要定义 __init__ 和 get_lr 方法。

  • get_lr 方法用于实现学习率调度的逻辑。

代码示例：

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. 可视化工具

介绍：TensorBoard 是一个常用的可视化工具，可以帮助用户更好地理解模型的训练过程。

详细解释：

  • torch.utils.tensorboard.SummaryWriter 用于创建 TensorBoard 日志文件。

  • add_scalar 方法用于记录标量值，如损失和准确率。

  • add_graph 方法用于记录模型结构。

  • 通过命令行启动 TensorBoard，可以查看训练过程中的各种指标变化。

代码示例：

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. 自定义数据加载器

介绍：在 PyTorch 中，用户可以通过继承 torch.utils.data.Dataset 类来创建自定义数据加载器。

详细解释：

  • 自定义数据加载器需要实现 __init__、__len__ 和 __getitem__ 方法。

  • __init__ 方法用于初始化数据和标签。

  • __len__ 方法返回数据集的大小。

  • __getitem__ 方法用于获取指定索引处的数据和标签。

代码示例：

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 模型转换为脚本，以提高性能。

详细解释：

  • PyTorch JIT 编译器能够将模型转换为脚本，从而提升模型的运行速度。

  • JIT 编译器在模型运行时进行编译，优化模型的执行流程。

  • 转换后的模型可以更高效地在各种环境中运行，包括生产环境。

代码示例：

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）格式，以便在其他框架或硬件上部署模型。

详细解释：

  • ONNX 是一种开放的神经网络交换格式，允许模型在不同框架之间互操作。

  • 将 PyTorch 模型转换为 ONNX 格式后，可以在其他支持 ONNX 的框架或硬件上运行。

  • 转换过程需要提供一个虚拟输入，用于确定模型的输入形状。

代码示例：

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 平台。

详细解释：

  • PyTorch Mobile 提供了将模型转换为适合移动设备运行的格式的工具。

  • 转换后的模型可以在移动设备上高效运行，适用于各种移动应用场景。

  • 这使得在移动设备上进行模型推理变得更加便捷。

代码示例：

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 的扩展库，提供了各种模块和组件，以加速深度学习任务的开发。

详细解释：

  • PyTorch Lightning Bolts 提供了许多预定义的模块和组件，涵盖了多种常见的深度学习任务。

  • 这些模块和组件可以快速集成到 PyTorch Lightning 项目中，减少开发时间和工作量。

  • 开发者可以利用这些工具快速构建和训练模型。

代码示例：

import pl_bolts

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

45. 混合精度训练

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

详细解释：

  • 混合精度训练结合了 FP16（16 位浮点数）和 FP32（32 位浮点数）两种精度格式。

  • FP16 精度可以加速计算并减少显存占用，但可能会导致梯度消失或溢出问题。

  • 梯度缩放器用于解决 FP16 精度下的梯度消失问题，确保训练过程的稳定。

代码示例：

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 提供了用于剪枝（模型参数减少）的工具，以减小模型的大小。

详细解释：

  • 剪枝是一种模型压缩技术，通过移除模型中不重要的参数来减小模型的大小。

  • 剪枝可以提高模型的推理速度，并降低存储和内存需求。

  • PyTorch 提供了多种剪枝方法，包括基于 L1 范数的剪枝等。

代码示例：

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 允许开发人员分析模型的性能和内存使用情况。

详细解释：

  • 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，用于在训练过程中执行额外的操作。

详细解释：

  • Callbacks 是 PyTorch Lightning 中用于在训练过程的不同阶段执行自定义代码的机制。

  • 它们可以在训练开始前、每个批次处理前、训练结束时等特定时间点执行。

  • 常见的 Callbacks 包括 EarlyStopping（提前停止训练）等。

代码示例：

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 的模型解释性库，用于分析模型的预测结果。

详细解释：

  • Captum 提供了多种解释性方法，帮助开发者理解模型的预测依据。

  • 它可以计算输入特征对模型输出的影响，揭示模型的决策过程。

  • 开发者可以根据解释性结果优化模型，提高模型的可解释性和透明度。

代码示例：

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 参数实现异步数据加载，加速数据加载过程。

详细解释：

  • 异步数据加载可以在 GPU 进行计算的同时，利用多个 CPU 核心提前加载下一批数据。

  • 这种方式可以减少 GPU 空闲等待数据的时间，提高整体训练效率。

  • 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 上。

详细解释：

  • 分布式训练允许多个 GPU 或多台机器协同训练一个模型，加速训练过程。

  • 每个 GPU 负责计算模型的一部分，然后通过通信机制同步梯度和参数。

  • 模型并行适用于超大型模型，将模型的不同部分分配到不同的 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 模块提供了自动微分的功能，可以方便地计算梯度。

详细解释：

  • 自动微分是深度学习框架中的核心技术之一，用于自动计算梯度。

  • 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 中的计算图是动态的，允许根据实际执行情况动态构建计算图。

详细解释：

  • 动态计算图在运行时构建，可以根据输入数据和条件语句动态调整计算流程。

  • 这使得 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 提供了保存和加载模型的工具，可以保存整个模型或仅保存模型的参数。

详细解释：

  • 保存和加载模型是深度学习项目中的重要步骤，便于模型的持久化和部署。

  • 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'))

55. 模型评估

介绍：在训练完成后，对模型进行评估，以确定其性能。

详细解释：

  • 模型评估是训练过程中的关键步骤，用于衡量模型在测试数据上的性能。

  • 评估指标通常包括准确率、损失值等，具体指标取决于任务类型。

  • 在评估过程中，模型处于评估模式，不进行梯度计算。

代码示例：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

# 创建模型和损失函数
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}')

大模型应用—超强的AI 视频生成模型！完全免费开源，生成质量极高！
12-23 1万+
此开源的视频生成模型：包含 PyTorch 模型定义、预训练权重和推理/采样代码。
PyTorch 的基本使用
YKenan的博客
05-23 1989
PyTorch 的基本使用1. 环境搭建2. 基础数据2.1 Tensors 的含义2.2 Tensors 和 Numpy 中的数组的关系2.3 Tensors 带有随机和常量值以及其属性2.3 Tensors 操作 1. 环境搭建 安装 python: Windows https://blog.youkuaiyun.com/YKenan/article/details/88135978 Centos https://blog.youkuaiyun.com/YKenan/article/details/97121698
Pytorch的使用
热门推荐
ungoing的博客
03-30 1万+
Pytorch的使用 一、环境配置 视频教程：https://www.bilibili.com/video/BV1hE411t7RN?from=search&seid=1911856662818066104&spm_id_from=333.337.0.0 1. 创建pytorch所需环境 先创建一个pytorch命名的新的Python环境，Python版本为3.6 conda create -n pytorch python=3.6 进入pytorch环境 conda acti
PyTorch可以用来做什么？
最新发布
cda2024的博客
06-12 1032
首先，让我们回顾一下PyTorch的历史和发展背景。PyTorch是由Facebook人工智能研究团队于2016年推出的一个开源深度学习框架。与传统的静态图框架（如TensorFlow 1.x）不同，PyTorch采用动态计算图，这使得模型构建更加灵活、直观，调试也更为简便。此外，PyTorch拥有强大的社区支持和丰富的生态系统，涵盖了从自然语言处理到计算机视觉等多个领域。因此，无论你是初学者还是经验丰富的开发者，PyTorch都能满足你的需求。
pytorch框架的使用
fkyyly的专栏
02-20 600
介绍 相比TensorFlow的静态图开发，Pytorch的动态图特性使得开发起来更加人性化，选择Pytorch的理由可以参考：https://www.jianshu.com/p/c1d9cdb52548，这里也顺便介绍一下TensorFlow静态图和Pytorch动态图开发的区别： 总的来说，在TensorFlow里你只能通过定义数据、网络等，然后直接训练、预测啥的，中间过程到底发生了什么对我们来说都是未知的，只能等待训练完毕后查看结果如何，想要debug都debug不了，于是在学了一段时间以后还是一
pytorch使用
jovieHung的博客
08-19 347
PyTorch学习笔记 1. PyTorch入门 1.1 Tensor t.Tensor(4, 5) # 此处构建 4*5 的矩阵，分配了空间，未初始化 x = t.rand(4, 5) # 使用[0,1]均匀分布随机初始化二维数组 a.shape # 查看 a 的形状，此处为 a 的属性 a.size() # 获取 a 的形状 一个Tensor有很多的属性 Tensor作为矩阵是可以相加的，torch提供了多种写法 x + y # 不改变x和y t.add(x,y) # 不改变x和y t.ad
pytorch使用教程
qq_45087786的博客
09-15 452
#查看形状 torch.size() #改变形状 torch.view() #和numpy互相转化 x.numpy() torch.from_numpy() 训练流程： #使用gpu训练，把数据和网络传入gpu即可 device=torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') model.to(device) inputs.to(device) out.to(device) #定义优化器和损失函数 optimizer=torc
Ascend Extension for PyTorch是个what？
xyz3120的专栏
11-08 1382
Ascend Extension for PyTorch 插件是基于昇腾的深度学习适配框架，使昇腾NPU可以支持PyTorch框架，为PyTorch框架的使用者提供昇腾AI处理器的超强算力。项目源码地址请参见LINK。昇腾为基于昇腾处理器和软件的行业应用及服务提供全栈AI计算基础设施。您可以通过访问昇腾社区，了解关于昇腾的更多信息。
深度学习框架PyTorch入门与实践：第一章 PyTorch简介
u011436316的博客
09-13 8046
本章为PyTorch简介。主要内容包括：PyTorch的诞生过程，常见主流深度学习框架的优劣，PyTorch相比这些框架的优势等。
有趣的深度学习2——利用pytorch对数据集进行预处理
weixin_46747850的博客
10-11 3055
我们在使用自定义的时候，主要需要写一下Dataset和Dataloader俩个类；Dataset类Dataset类是Pytorch中图像数据集中最为重要的一个类，也是Pytorch中所有数据集加载类中应该继承的父类。我们在使用自定义的数据集的时候，其中父类中的两个私有成员函数必须被重载，其中__len__应该返回数据集的大小，而__getitem__应该编写支持数据集索引的函数，例如通过dataset[i]可以得到数据集中的第i+1个数据。首先继承上面的dataset类。
算法金 | 超强！深度学习 Top 10 算法！
算法金「全网同名」的博客
05-29 1290
深度神经网络（DNN）是深度学习的基石，其设计灵感来源于人脑的结构和功能。从20世纪80年代开始，DNN就一直是人工智能研究的核心。随着计算能力的提升和大数据的可用性，DNN在21世纪初期迎来了爆发式的增长，成为了许多复杂问题求解的强大工具。
Python-介绍PyTorch的简单示例
08-09
介绍 PyTorch的简单示例
Pytorch用法说明
weixin_44857576的博客
03-26 2396
Pytorch基本学习
【深度强化学习】深度学习：Pytorch的使用
B417科研笔记
06-22 4843
文章目录前言第三章 深度学习：Pytorch的使用Pytorch库基础Tensor 张量标量张量张量的操作张量 与 梯度Pytorch 的神经网络包：torch.nn自定义网络层损失函数与优化器损失函数优化器通过Tensorboard监控网络训练 前言 重读《Deep Reinforcemnet Learning Hands-on》， 常读常新， 极其深入浅出的一本深度强化学习教程。 本文的唯一贡献是对其进行了翻译和提炼， 加一点自己的理解组织成一篇中文笔记。 原英文书下载地址: 传送门 原代码地址： 传送
PyTorch基本用法(五)——分类
SnailTyan
09-19 2881
PyTorch基本用法(五)——分类
PyTorch可以用来干嘛?
Keep_Calm_的博客
07-24 2725
PyTorch 是一个广泛使用的开源机器学习库，由 Facebook AI Research（FAIR）开发。它主要用于计算机视觉和自然语言处理等深度学习领域，但也可以应用于许多其他类型的机器学习任务。PyTorch 提供了丰富的功能和灵活的设计，使得构建和训练神经网络变得相对简单。以下是 PyTorch 的一些主要用途
Pytorch的使用-简洁明了（一）
m0_46561911的博客
03-23 2072
3.torch.IntTensor、torch.FloatTensor、torch.DoubleTensor创建指定类型的张量。2.torch.random.init_seed和torch.manaual_seed随机种子设置。3.torch.full和torch.full_like创建全为指定值张量。2.torch.zeros和torch.zeros_like创建全0张量。1.torch.tensor 根据指定数据创建张量。1.torch.ones和torch.ones_like 创建全1张量。
深度学习框架：PyTorch使用教程 ！！
不要给自己设限，尝试更多可能（思所向 皆可往）
05-01 4465
PyTorch是由Facebook的人工智能研究团队开发的一款开源深度学习框架。与TensorFlow的静态图相比，PyTorch采用动态图机制（即运行时定义计算图），便于调试和开发复杂模型。内置强大的自动求导（Autograd）模块，可以自动计算梯度，极大简化了反向传播算法的实现。提供了张量（Tensor）运算、神经网络层（nn模块）、优化器（optim模块）等丰富的工具和函数，方便快速搭建各种模型。支持CUDA，可以方便地将数据和模型转移到GPU上加速运算。
简单有趣的 NLP 教程：手把手教你用 PyTorch 辨别自然语言（附代码）
周红伟讲AI
06-21 789
 简单有趣的 NLP 教程：手把手教你用 PyTorch 辨别自然语言（附代码） 本文作者：AI研习社 2017-06-20 15:41 雷锋网(公众号：雷锋网)按：本文作者甄冉冉，原载于作者个人博客，雷锋网已获授权。 最近在学pyTorch的实际应用例子。这次说个简单的例子：给定一句话，判断是什么语言。这个例子是比如给定一句话： Give it to me
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我不是小upper

叮咚~池化层浓缩了你的真诚情感

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值