logo
PyTorch常见用法
Published in：2024-01-16 | category： 兴趣 工具

PyTorch常见用法

1. 导入 PyTorch 库

1
2
3
4
5
6
import torch  
import torch.nn as nn  
import torch.optim as optim  
import torch.nn.functional as F  
from torch.utils.data import DataLoader, Dataset  
from torchvision import transforms

2. 检查 GPU 支持

1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

3. 创建自定义数据集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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, index):  
        x = self.data[index]  
        y = self.labels[index]  
  
        if self.transform:  
            x = self.transform(x)  
  
        return x, y

4. 使用数据增强

1
2
3
4
5
transform = transforms.Compose([  
    transforms.RandomHorizontalFlip(),  
    transforms.RandomRotation(10),  
    transforms.ToTensor(),  
])

5. 数据加载

1
2
train_dataset = CustomDataset(train_data, train_labels, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

6. 定义神经网络模型

1
2
3
4
5
6
7
8
9
10
11
12
13
class Net(nn.Module):  
    def __init__(self):  
        super(Net, self).__init__()  
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  
        self.fc1 = nn.Linear(32 * 28 * 28, 128)  
        self.fc2 = nn.Linear(128, 10)  
  
    def forward(self, x):  
        x = F.relu(self.conv1(x))  
        x = x.view(x.size(0), -1)  # Flatten the tensor  
        x = F.relu(self.fc1(x))  
        x = self.fc2(x)  
        return x

7. 实例化模型和优化器

1
2
model = Net().to(device)  
optimizer = optim.Adam(model.parameters(), lr=0.001)

8. 定义损失函数

1
criterion = nn.CrossEntropyLoss()

9. 训练模型

1
2
3
4
5
6
7
8
9
10
11
12
for epoch in range(num_epochs):  
    for batch_idx, (data, target) in enumerate(train_loader):  
        data, target = data.to(device), target.to(device)  
  
        optimizer.zero_grad()  # 清空梯度  
        output = model(data)  # 前向传播  
        loss = criterion(output, target)  # 计算损失  
        loss.backward()  # 反向传播  
        optimizer.step()  # 更新权重  
  
        if batch_idx % log_interval == 0:  
            print(f"Train Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} ({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}")

10. 评估模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
model.eval()  # 设置为评估模式  
test_loss = 0  
correct = 0  
with torch.no_grad():  # 禁用梯度计算  
    for data, target in test_loader:  
        data, target = data.to(device), target.to(device)  
        output = model(data)  
        test_loss += criterion(output, target).item() # 累加测试集的损失
pred = output.argmax(dim=1, keepdim=True) # 获取概率最高的预测结果
correct += pred.eq(target.view_as(pred)).sum().item()

test_loss /= len(test_loader.dataset)
test_accuracy = 100. * correct / len(test_loader.dataset)

print(f'Test set: Average loss: {test_loss:.4f}, Accuracy: {correct}/{len(test_loader.dataset)} ({test_accuracy:.0f}%)')

11. 保存和加载模型

1
2
3
4
5
6
7
# 保存模型  
torch.save(model.state_dict(), 'model.pth')  
  
# 加载模型  
model = Net()  
model.load_state_dict(torch.load('model.pth'))  
model.to(device)

12. 使用 GPU 加速

如果有 NVIDIA GPU，并且已经安装了 CUDA，那么 PyTorch 可以利用它来加速训练过程。

1
2
3
model = model.to(device)  
data = data.to(device)  
target = target.to(device)

13. 使用 TensorBoard 进行可视化

TensorBoard 是 TensorFlow 的一个可视化工具，但 PyTorch 用户也可以通过 torch.utils.tensorboard 使用它。

1
2
3
4
5
6
7
8
9
10
11
from torch.utils.tensorboard import SummaryWriter  
  
writer = SummaryWriter()  
  
for epoch in range(num_epochs):  
    # 进行训练和记录...  
    writer.add_scalar('Loss/train', loss.item(), epoch)  
    writer.add_scalar('Accuracy/train', accuracy, epoch)  
    # ...  
  
writer.close()

14. 调整学习率

1
2
3
4
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)  
for epoch in range(num_epochs):  
    scheduler.step()  # 更新学习率  
    # 进行训练...

15. 使用预训练模型

1
2
3
import torchvision.models as models  
  
model = models.resnet18(pretrained=True)

16. 迁移学习

1
2
3
4
5
for param in model.parameters():  
    param.requires_grad = False  # 冻结模型参数  
  
# 替换最后的全连接层以适应新的类别数  
model.fc = nn.Linear(model.fc.in_features, num_classes)

PyTorch 高频用法 (1)

数学运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
torch.add, torch.sub, torch.mul, torch.div # 张量加法，减法，乘法，除法

torch.mul, torch.dot # 数乘、点积

torch.mm, torch.matmul # 矩阵乘法

torch.pow, torch.exp, torch.sqrt # 幂运算、e的指数、平方根

torch.sum, torch.mean, torch.std # 分别计算张量的和，均值以及标准差

torch.max, torch.min # 最大值，最小值

torch.cumsum, torch.cumprod # 分别计算张量的累积和和累积积

torch.clamp # 将输入张量的每个元素限制在[min, max]范围内

torch.einsum # 提供了一种计算多线性代数方程的方式

torch.bmm, torch.batch_matmul # 批量矩阵乘法

torch.scatter, torch.scatter_add # 将源张量的值沿指定轴散布到指定的索引处

torch.gather # 根据索引从输入张量中取值

torch.index_select # 根据给定的索引从输入张量中选择元素

torch.masked_select # 根据布尔掩码从输入张量中选择元素

torch.split, torch.chunk # 将张量分割成多个块

torch.sort, torch.topk # 排序以及返回给定维度上最大的k个元素

torch.view_as_real, torch.view_as_complex # 把复数张量视作实数张量、把实数张量视作复数张量

torch.eig, torch.svd, torch.qr # 特征分解，奇异值分解，QR分解

torch.inverse # 计算方阵的逆矩阵

tensor.t, tensor.transpose # 转置，前者只能用于二维张量，后者可以转置任意两个维度

张量操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
torch.tensor # 创建一个张量

torch.from_numpy, torch.as_tensor # 从 NumPy 数组创建张量

torch.zeros, torch.ones, torch.eye # 创建一个全零或全一的张量或二维单位矩阵

torch.zeros_like, torch.ones_like # 创建与给定张量形状和类型相同的全零或全一张量

torch.empty, torch.clone # 创建一个未初始化的张量，克隆一个张量

torch.rand, torch.randn, torch.normal # 创建一个填充了均匀分布、标准正态分布以及指定均值方差正态分布随机数的张量

torch.randint # 生成一个给定形状的整数张量，其元素从指定的区间[low, high)内随机采样

torch.full # 生成一个给定形状的张量，所有元素初始化为指定的值

torch.arange # 创建一个按指定范围和步长的一维张量

torch.linspace, torch.logspace # 创建包含在指定范围内均匀分布以及对数尺度分布的指定数量的点的一维张量

torch.randperm # 生成一个随机排列的张量

torch.cat # 将张量在指定维度上拼接

torch.stack # 在新的维度上堆叠张量序列

tensor.view, tensor.reshape # 重塑张量，但后者能自动处理不连续的张量

tensor.squeeze, tensor.unsqueeze # 去除或添加维度为1的维度

tensor.permute # 重新排列张量的维度

tensor.expand_as, tensor.repeat, torch.tile # 扩展和重复张量

torch.where # 一个条件选择操作，它接受三个参数：一个条件张量和两个张量（或标量）作为选项

torch.any, torch.all # 测试一个张量中是否至少有一个元素是非零，测试张量中的所有元素是否都是非零

torch.nonzero # 返回一个包含输入张量中所有非零元素索引的张量

torch.bernoulli, torch.multinomial, torch.normal, torch.poisson # 从伯努利分布、多项分布、正态分布、泊松分布中抽取样本

网络层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
torch.nn.Module # 所有神经网络模块的基类

torch.nn.Linear # 全连接层

torch.nn.Embedding # 用于创建词嵌入

torch.nn.Identity # 一个占位层，输出与输入相同

torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d # 一维卷积、二维卷积、三维卷积

torch.nn.ConvTranspose2d # 转置卷积层（有时也称为反卷积），用于从低分辨率特征图生成更高分辨率的特征图

torch.nn.BatchNorm1d, torch.nn.BatchNorm2d, torch.nn.BatchNorm3d # 对小批量的一维、二维、三维数据进行批标准化处理

torch.nn.GroupNorm, torch.nn.LayerNorm # 分组归一化和层归一化

torch.nn.SyncBatchNorm, torch.nn.LocalResponseNorm # 跨多个 GPU 设备同步的批量归一化，局部响应归一化

torch.nn.ReLU, torch.nn.Sigmoid, torch.nn.Tanh # 修正线性单元 ReLU 激活函数、Sigmoid 激活函数、双曲正切 Tanh 激活函数

torch.nn.MaxPool2d, torch.nn.AvgPool2d # 二维最大池化层、二维平均池化层

torch.nn.AdaptiveMaxPool2d, torch.nn.AdaptiveAvgPool2d # 二维自适应最大池化层、二维自适应平均池化层

torch.nn.Dropout, torch.nn.Dropout2d, torch.nn.Dropout3d # 在训练过程中随机使神经元失活，防止过拟合

torch.nn.Parameter # 一种特殊的张量，被视为模块的参数

torch.nn.ParameterList, torch.nn.ParameterDict # 包含参数的列表、字典，参数可以是 torch.nn.Parameter

torch.nn.Unfold, torch.nn.Fold # 用于实现卷积的滑动窗口和其逆操作

torch.nn.Sequential # 一个时序容器，模块将按照它们在构造函数中传递的顺序添加到容器中

torch.nn.ModuleList, torch.nn.ModuleDict # 包含子模块的列表、字典，类似普通列表和字典

torch.nn.RNN, torch.nn.LSTM, torch.nn.GRU # 循环神经网络，长短期记忆网络层和门控循环单元层

torch.nn.LSTMCell, torch.nn.GRUCell # LSTM单元和GRU单元

torch.nn.MultiheadAttention, torch.nn.Transformer # 多头注意力机制和 Transformer 模型

PyTorch 高频用法 (2)

数据加载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
torch.utils.data.Dataset # 用于创建自定义数据集的抽象类

torch.utils.data.TensorDataset # 当数据已经是 Tensor 时，可以直接使用 TensorDataset 将数据包装成 Dataset 对象

torch.utils.data.Subset # 从一个大的数据集中选择一个子集

torch.utils.data.DataLoader # 封装了数据集，并提供批量处理、打乱数据、多线程加载等功能

torch.utils.data.IterableDataset # 用于创建基于迭代器的数据集，适用于大规模数据集或流式数据

torch.utils.data.SequentialSampler # 按顺序依次抽取样本，不进行打乱

torch.utils.data.RandomSampler # 随机抽取样本，每个 epoch 数据的顺序都会被打乱

torch.utils.data.SubsetRandomSampler # 随机抽取数据集的一个子集，通常用于分割训练 / 验证集

torch.utils.data.WeightedRandomSampler # 根据每个样本的权重进行随机抽取，用于处理不均衡数据集

torch.utils.data.BatchSampler # 将sampler抽取的样本分组成批次

torch.utils.data.distributed.DistributedSampler # 采样器，用于分布式训练，确保每个进程得到不同部分的数据集

损失函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
torch.nn.MSELoss, torch.nn.BCELoss, torch.nn.NLLLoss # 均方误差损失，二元交叉熵损失，负对数似然损失

torch.nn.L1Loss, torch.nn.SmoothL1Loss # 绝对误差损失和平滑L1损失

torch.nn.CrossEntropyLoss # 交叉熵损失，结合了 LogSoftmax 和 NLLLoss

torch.nn.GaussianNLLLoss # 用于基于高斯分布的不确定性估计的回归任务

torch.nn.PoissonNLLLoss # 泊松负对数似然损失，用于回归任务，特别是当目标值是计数或事件率时

torch.nn.BCEWithLogitsLoss # 结合了 Sigmoid 层和 BCELoss 的损失函数

torch.nn.KLDivLoss # KL散度损失，用于计算预测概率分布和目标概率分布之间的 Kullback-Leibler 散度

torch.nn.CosineEmbeddingLoss # 计算余弦相似度的损失函数，用于学习嵌入表示

torch.nn.HingeEmbeddingLoss # 合页嵌入损失，用于学习基于距离的损失

torch.nn.MarginRankingLoss # 间隔排序损失，用于排序任务

torch.nn.TripletMarginLoss # 三元组间隔损失，用于度量学习，目标是使相似的样本距离近，不相似的样本距离远

torch.nn.CTCLoss # 连续时间分类损失，用于序列到序列的学习任务，如语音识别

torch.nn.MultiLabelSoftMarginLoss, torch.nn.MultiLabelMarginLoss # 多标签分类问题的损失

torch.nn.SoftMarginLoss, torch.nn.MultiMarginLoss # 用于二分类和多分类的合页损失版本

梯度管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
tensor.grad # 获取张量的梯度

tensor.retain_grad # 保留梯度

torch.no_grad, tensor.detach # 禁用张量的梯度

tensor.requires_grad_ # 设置张量的 requires_grad 属性，以确定是否需要计算梯度

tensor.backward # 在张量上执行反向传播，计算梯度

torch.autograd # 提供自动微分的功能，用于计算梯度

torch.autograd.grad # 计算和返回给定张量的梯度

torch.autograd.gradcheck # 用于检查自定义autograd运算的梯度正确性

torch.autograd.Variable # 包装了张量并记录了梯度计算历史的变量

torch.autograd.backward # 给定张量和梯度，计算并回传梯度

torch.autograd.Function # 通过定义 forward 和 backward 方法来创建自定义的梯度计算功能

torch.autograd.functional # 计算更复杂的梯度操作，如高阶导数和雅可比矩阵

optimizer.zero_grad, tensor.grad.zero_ # 梯度清零

torch.nn.utils.clip_grad_norm_, torch.nn.utils.clip_grad_value_ # 对梯度进行裁剪，对梯度的每个值进行裁剪

torch.set_grad_enabled(False), torch.set_grad_enabled(True) # 禁用或启用梯度计算

性能优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
torch.jit # 提供 Just-In-Time 编译功能，将 PyTorch 代码转换为更高效的 TorchScript 代码

torch.jit.trace # 通过运行函数来跟踪模型，捕获其结构

torch.jit.script # 将 Python 函数转换为 TorchScript 代码

torch.jit.fork, torch.jit.wait # 用于并行执行任务和同步等待结果，有助于优化执行性能

torch.onnx # 导出 PyTorch 模型到 ONNX（Open Neural Network Exchange）格式

torch.backends.cudnn.benchmark # 让cuDNN自动寻找最适合当前配置的高效算法，对于固定输入大小可提高运行性能

torch.backends.cudnn.deterministic # 当设置为True时，可以确保得到确定性的计算结果，但可能会影响性能

torch.backends.cudnn.enabled # 指示cuDNN是否可用

torch.nn.utils.fusion # 将多个线性层或卷积层融合成一个层，以提高效率

torch.nn.utils.prune # 提供模型修剪技术，可以移除不重要的参数

prune.random_unstructured(module, name='weight', amount=0.3) # 随机无结构剪枝

prune.l1_unstructured(module, name='weight', amount=0.3) # L1范数无结构剪枝，剪去权重矩阵中绝对值最小的部分

prune.ln_structured(module, name='weight', amount=0.5, n=2, dim=0) # LN范数结构剪枝，根据权重矩阵的LN范数

prune.random_structured(module, name='weight', amount=0.3, dim=0) # 随机结构剪枝

prune.global_unstructured(parameters_to_prune, pruning_method, amount) # 全局无结构剪枝

prune.BasePruningMethod # 继承该类并实现 compute_mask 方法，决定哪些权重会被剪枝

prune.remove(module, 'weight') # 使剪枝永久生效

torch.nn.utils.convert_parameters # 在向量形式和参数形式之间转换模型参数

torch.quantization # 用于模型量化的工具，减少模型大小和提高推理速度

torch.utils.checkpoint # 通过 checkpointing 技术来减少运行时内存消耗

torch.cuda.amp # 提供自动混合精度训练的功能，可以减少内存使用并提高训练速度

torch.autograd.profiler # 上下文管理器，用于分析 CPU 和 CUDA 性能

PyTorch 高频用法 (3)

优化器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
torch.optim.SGD # 随机梯度下降优化器

torch.optim.ASGD # 平均随机梯度下降，ASGD 是 SGD 的一个变种，它在优化过程中维护一个参数的运行平均值

torch.optim.Adam # 自适应矩估计，结合了 AdaGrad 和 RMSProp 优化器的特点，通常对超参数的选择不是特别敏感

torch.optim.AdamW # 对 Adam 的改进版本，加入了权重衰减，通常在某些任务中会取得更好的泛化性能

torch.optim.Adamax # Adam 的一个变种，它使用无穷范数来计算梯度的规模，有时在某些任务上比 Adam 更稳定

torch.optim.SparseAdam # 专为稀疏张量设计的 Adam 算法的变种

torch.optim.Adagrad # 自适应梯度算法，调整每个参数的学习率

torch.optim.Adadelta # Adagrad 的一个扩展，试图减少其激进的、单调递减的学习率

torch.optim.RMSprop # 以均方根传播为基础的自适应学习率方法，通常用于非凸优化

torch.optim.Rprop # 弹性反向传播，Rprop只使用梯度的符号来更新参数，每个参数都有各自的更新步长

torch.optim.LBFGS # 利用拟牛顿方法的一种算法，适用于小规模数据集

torch.optim.Optimizer # 通过继承该类并实现所需的优化逻辑来创建自定义的优化器

学习率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
torch.optim.lr_scheduler.StepLR # 每隔一定的 epoch 数，学习率乘以一个固定的因子 gamma

torch.optim.lr_scheduler.MultiStepLR # 在一系列预定义的 epoch 数处，学习率乘以一个固定的因子

torch.optim.lr_scheduler.LinearLR # 以线性的方式调整学习率，从一个初始学习率线性衰减到一个结束学习率

torch.optim.lr_scheduler.ExponentialLR # 学习率以指数方式衰减，每个epoch乘以一个固定的因子

torch.optim.lr_scheduler.CosineAnnealingLR # 使用余弦退火的方式调整学习率，在每个周期内先降低再升高

torch.optim.lr_scheduler.LambdaLR # 自定义学习率，接收 epoch 索引作为输入，并返回一个乘以基础学习率的因子

torch.optim.lr_scheduler.ReduceLROnPlateau # 当模型的性能不再提升时，减少学习率，例如当验证集的损失不再下降时

torch.optim.lr_scheduler.CyclicLR # 循环地调整学习率，在一个范围内循环增加和减少

torch.optim.lr_scheduler.OneCycleLR# 用于训练周期性调整学习率，通常在训练开始时快速增加到最大学习率，然后逐渐减少

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts # 使用余弦退火调整学习率，并在每次重启时重新设置学习率

torch.optim.lr_scheduler.TriangularLR # 循环学习率策略，其中学习率在给定的最小值和最大值之间循环变化

torch.optim.lr_scheduler.Triangular2LR # TriangularLR 的一个变种，其中每个循环的学习率最大值减半

functional函数

torch.nn.functional 模块包含了一系列用于构建神经网络的函数，它们与在 torch.nn 中的类似，但 torch.nn.functional 中的函数通常是无状态的，意味着它们不包含可训练的参数。这些函数通常用于执行某些操作，比如激活函数、损失函数和各种层的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import torch.nn.functional as F

F.interpolate # 对数据进行上采样或下采样，支持多种插值模式，如最近邻、线性、双线性、三线性等

F.pad # 对张量进行填充，有 constant，reflect，circular 以及 replicate 等模式

F.relu, F.sigmoid, F.tanh, F.softmax # ReLU，Sigmoid，Tanh 以及 Softmax 激活函数

F.mse_loss, F.cross_entropy, F.nll_loss, F.l1_loss # 均方误差，交叉熵损失，NLL损失，L1损失

F.multilabel_soft_margin_loss, F.triplet_margin_loss, F.margin_ranking_loss, F.cosine_embedding_loss # 同上

F.conv1d, F.conv2d, F.conv3d, F.conv_transpose2d # 一维，二维，三维与转置卷积

F.unfold, F.fold # 多通道2D卷积与转置卷积 

F.max_pool2d, F.avg_pool2d, F.adaptive_max_pool2d, F.adaptive_avg_pool2d # 最大，平均池化及自适应形式

F.pyramid_pooling # 金字塔池化

F.batch_norm, F.layer_norm, F.group_norm # 批量归一化，层归一化及组归一化

F.local_response_norm # 局部响应归一化  

F.dropout, F.dropout2d, F.dropout3d # 一维，二维与三维Dropout

F.upsample_nearest, F.upsample_bilinear # 最近邻，双线性上采样

F.bilinear # 双线性变换

F.flatten # 展平张量，从 start_dim 维度开始  

F.affine_grid, F.grid_sample # 仿射变换

F.gumbel_softmax # Gumbel Softmax，用于从分类分布中采样

分布式训练

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
torch.distributed # 包含了分布式训练的各种工具和方法

torch.distributed.launch # 用于启动分布式训练的实用程序

torch.distributed.reduce, torch.distributed.all_reduce # 在所有进程中对张量进行归约操作

torch.distributed.barrier # 同步分布式处理中的所有进程

torch.distributed.broadcast # 从一个进程广播张量到所有其他进程

torch.nn.DataParallel # 用于在多个GPU上并行运行模块

torch.nn.parallel.DistributedDataParallel # 分布式训练中的并行数据处理

torch.multiprocessing # 与Python multiprocessing模块类似的包，但它支持张量共享在进程之间

CUDA管理

1
2
3
4
5
6
7
8
9
10
11
torch.device # 指定使用CPU或者GPU等设备

tensor.to # 将张量移动到指定的设备上

torch.cuda.memory_allocated, torch.cuda.max_memory_allocated # 获取当前CUDA设备显存量和历史最大分配显存大小

torch.cuda.memory_cached # 获取当前CUDA设备上缓存的显存量

torch.cuda.empty_cache # 释放当前CUDA设备上未使用的缓存内存

torch.cuda.memory_summary # 打印CUDA设备的内存使用情况

模型管理

1
2
3
4
5
6
7
8
9
torch.save # 保存模型或张量到文件

torch.load # 从文件加载模型或张量

torch.nn.Module.state_dict # 获取模型的状态字典，包含了模型的参数和缓存

torch.nn.Module.load_state_dict # 加载状态字典到模型中

torch.hub # 提供了一个预训练模型的仓库，可以用来下载和加载经过预训练的模型和模型组件

调试和检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
torch.version # 获取当前PyTorch的版本信息

torch.cuda.get_device_name # 获取当前CUDA设备的名称

torch.set_printoptions # 设置打印张量时的选项

torch.is_tensor # 检查对象是否为 PyTorch 张量

torch.is_floating_point # 检查张量是否为浮点数据类型

torch.cuda.is_available # 检查CUDA是否可用

module.register_forward_hook(forward_hook) # 钩子函数，监控变量

module.register_backward_hook(backward_hook) # 钩子函数，监控梯度

torch.autograd.set_detect_anomaly # 开启异常检测，可以帮助调试模型中的梯度问题

torch.numel # 返回张量中元素的总数

torch.random.seed # 设置随机种子以确保实验的可复现性

torch.manual_seed # 设定生成随机数的种子，以确保结果可重现

其他函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
torchviz # 一个小型库，用于可视化PyTorch执行图（计算图）。

torch.utils.tensorboard # 记录训练过程中的参数和指标，方便在TensorBoard中进行可视化分析。

torch.utils.cpp_extension # 用于创建和加载自定义C++扩展。

torch.from_dlpack # 从DLpack导入张量。

tensor.to_dlpack # 将PyTorch张量导出为DLpack。

torch.set_num_threads # 设置用于并行计算的 OpenMP 线程数。

torch.set_flush_denormal # 当设置为True时，将会把非正规的浮点数刷新到零，这有助于防止某些操作中的性能下降。

torch.nn.utils.rnn.pack_padded_sequence # 用于打包RNN的填充序列

torch.nn.utils.rnn.pad_packed_sequence # 将打包的序列解压回填充序列

torch.nn.utils.weight_norm, torch.nn.utils.remove_weight_norm # 应用、移除权重归一化

torch.nn.utils.spectral_norm, torch.nn.utils.remove_spectral_norm # 应用、移除谱归一化

torch.distributions # 提供一系列概率分布和相关操作，可用于概率编程和贝叶斯推断

torch.distributions.Categorical # 用于创建具有离散分布的随机变量，常见于强化学习中的策略梯度算法
Prev:
Git常见命令

    • Copyright © 2024 Picrew | Powered by Hexo