怎么查看深度学习pytorch中的pt权值文件

最新推荐文章于 2024-07-29 23:14:40 发布

用编程减轻生活压力

最新推荐文章于 2024-07-29 23:14:40 发布

阅读量4.3k

点赞数 60

分类专栏： pytorch 文章标签： pytorch

本文链接：https://blog.csdn.net/weixin_50531046/article/details/135911407

版权

pytorch 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

checkpoint = torch.load(pt_filename)
print(checkpoint['state_dict'].keys())

torch.load(pt_filename）是将pt权值文件加载进pytorch，方便利用pytorch库进行查看和操作。

pt文件是一个字典文件，内部只有一个键，键名是'state_dict'，'state_dict'对应的键值是一个字典。

print(checkpoint['state_dict'].keys())是打印输出'state_dict'对应的这个字典中的全部键名。

.keys()是字典中所有键名的意思。
'state_dict'对应的这个字典中有很多键。

torch.load 用于加载 PyTorch 模型的权重文件（通常是以 .pt 或 .pth 为扩展名的文件），加载后得到一个字典。

这个字典的键 'state_dict' 对应着模型的状态字典，里面包含了模型的所有参数。

打印 checkpoint['state_dict'].keys() 会显示这个状态字典中的所有键，每个键对应模型的一个参数。

通常，这些键的命名与模型中定义的层和参数名称相对应。

这样的设计使得在加载模型权重后，可以方便地将这些权重应用到相应的模型结构上，或者查看加载的模型中都包含哪些参数。

通过 checkpoint['state_dict'].keys() 获取的结果是包含在模型状态字典中的所有键的集合。这些键的具体名称取决于您的模型的结构和参数命名。

如果您想具体查看这些键的内容，可以通过打印出每个键对应的值来实现。

逐个打印每个键和其对应的值，以便更详细地了解模型的状态字典中包含的内容。

for key, value in checkpoint['state_dict'].items():
print(f"{key}: {value}")

net.state_dict() 是 PyTorch 中用于获取神经网络模型的状态字典（state dictionary）的方法。这个方法返回一个字典，其中包含了模型的所有参数（权重和偏置项）及其对应的键。

通常，当你训练或保存模型时，会使用 state_dict 来保存或加载模型的参数。这个字典可以方便地被 PyTorch 的 torch.save() 和 torch.load() 函数使用。

import torch
import torch.nn as nn

# 定义一个简单的神经网络
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc = nn.Linear(10, 5)

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

# 创建模型实例
net = SimpleNet()

# 获取模型的状态字典
model_state_dict = net.state_dict()

# 保存模型的状态字典到文件
torch.save(model_state_dict, "model_weights.pth")

# 保存整个模型到文件
torch.save(net, "full_model.pth")

# 加载模型的状态字典
loaded_state_dict = torch.load("model_weights.pth")

# 加载整个模型
loaded_model = torch.load("full_model.pth")

torch.save(net, "full_model.pth") 将整个神经网络模型 net 保存到文件 "full_model.pth" 中，包括模型的结构和所有的参数。

而后，loaded_model = torch.load("full_model.pth") 用于从文件中加载保存的整个模型。

这样的操作对于以下情况可能会有用：

模型的迁移和部署: 可以在训练环境中保存训练好的模型，然后在另一个环境中加载模型，而无需重新训练。

模型的共享: 可以将经过训练的模型分享给其他人，他们可以通过加载模型来使用你已经训练好的参数和结构。

模型的断点续训: 可以定期保存模型，以防止训练过程中的意外中断。如果中断了，可以从最近的保存点继续训练，而不必重新开始。

net.load_state_dict(state_dict) 是 PyTorch 中用于加载模型参数的函数。它将一个预训练模型的状态字典（state_dict）加载到神经网络模型中。这通常用于恢复模型的训练状态或者加载预训练的权重。

net 是你的神经网络模型，而 state_dict 是包含模型参数的字典。通过这个操作，你可以将模型的参数从预训练模型或者保存的检查点中加载到你的模型中，从而实现参数的迁移或继续训练。

net.load_state_dict(state_dict)

net.state_dict() 返回的是一个字典，包含了神经网络模型的所有参数。这个字典的键是参数的名称，而值是对应参数的张量值。这个函数通常用于保存模型参数或者在训练中进行模型的断点保存。

而 checkpoint = torch.load(pt_filename) 是加载一个保存的模型状态字典。checkpoint 实际上是一个字典，其中至少包含了一个键为 'state_dict' 的子字典。checkpoint['state_dict'] 就是模型的状态字典，也包含了模型的所有参数。这个字典的结构与 net.state_dict() 返回的相同。

通常，你可以使用 net.load_state_dict(checkpoint['state_dict']) 将加载的状态字典中的参数加载到你的模型中，以便继续训练或者进行推断。

net.load_state_dict(checkpoint['state_dict'])

具体而言：

torch.save(model_state_dict, "model_weights.pth") 保存的是模型的权重参数部分，它是一个简化的状态字典，只包含模型的参数值。

checkpoint = torch.load(pt_filename) 中的 checkpoint 是通过 torch.save 函数保存的文件加载得到的完整字典。这个字典中有可能包含模型的其他信息，而 checkpoint['state_dict'] 才是包含完整模型权重参数的子字典。

如果你在保存模型时使用的是 torch.save(net.state_dict(), "model_weights.pth")，那么加载时应该使用 net.load_state_dict(torch.load("model_weights.pth"))，这样可以直接加载模型的权重参数。如果保存时使用的是完整模型对象（torch.save(net, "full_model.pth")），则加载时可以使用 torch.load("full_model.pth")，但需要注意加载后可能需要通过 loaded_model.state_dict() 获取权重参数。

torch.rand(X.shape) 生成与张量 X 相同形状的随机张量，其值在 [0, 1) 之间均匀分布。

torch.rand(X.shape) 是一个 PyTorch 操作，用于生成一个张量，其形状与输入张量 X 相同，其中的元素值是在区间 [0, 1) 内均匀分布的随机数。这个操作会生成一个与 X 具有相同形状的张量，其中的每个元素都是独立随机生成的。

如果 X 是一个形状为 (3, 4) 的张量，那么 torch.rand(X.shape) 将生成一个形状也为 (3, 4) 的张量，其中的元素值是在 [0, 1) 内的随机数。

均匀分布意味着在给定的范围内，每个数值出现的概率相同，不会强调某个数是某个数的倍数。在 [0, 1) 内的均匀分布，每个小区间的概率是相等的。

通过直方图来观察生成的随机数的分布情况。如果使用足够大的样本量，直方图应该大致呈现平均分布的特征，即每个小区间内的随机数数量大致相等。

在 torch.rand(X.shape) 中，生成的每个元素都是从 [0, 1) 区间内均匀分布中随机抽取的。这意味着在生成的随机数中，每个值都有相同的概率被选中。例如，如果 X 是形状为 (3, 4) 的张量，那么 torch.rand(X.shape) 将生成一个形状也为 (3, 4) 的张量，其中的每个元素都是从 [0, 1) 区间内均匀分布中随机抽取的值。

这种均匀分布的性质是在 [0, 1) 区间内的任何子区间上都有相同的概率密度。因此，你可以期望在大量生成的随机数中，它们在 [0, 1) 区间内的分布是均匀的，即每个小区间内的随机数数量大致相等。

torch.rand(X.shape) < keep_prob

这个张量中，每个元素的数值与keep_prob的数值比较，若元素的数值比keep_prob的数值小，则该元素数值取1，若元素的数值比keep_prob的数值大，则该元素数值取0。

X.float() 是将张量 X 的数据类型转换为 float 类型。这个操作会返回一个新的张量，其数据类型为 float。

在深度学习中，有时候需要将张量的数据类型转换为 float，特别是在进行数值计算时，确保数据的精度足够。默认情况下，PyTorch 的张量可能是整数类型（如 int 类型），但在进行神经网络的训练和其他数值计算过程中，通常会使用 float 类型。

A.to(B.device) 是将张量 A 移动到与张量 B 相同的设备上。这个操作会返回一个新的张量，其数据存储在与张量 B 相同的设备上。

在深度学习中，经常需要将不同设备上的张量进行操作，因此需要确保这些张量位于相同的设备上。通过使用 .to() 方法，可以方便地将一个张量移动到另一个设备上。

例如，假设有两个张量 A 和 B，其中 A 在 CPU 上，B 在 GPU 上，如果要在 GPU 上执行操作，可以使用以下代码：

A = A.to(B.device)
这会将张量 A 移动到与张量 B 相同的 GPU 设备上。如果 A 已经在目标设备上，这个操作不会产生额外的开销。

mask = (torch.rand(X.shape) < keep_prob).float().to(X.device)

这行代码创建了一个掩码 (mask)，用于在 dropout 操作中保留元素。让我们逐步解释这行代码：

torch.rand(X.shape): 生成一个形状与输入张量 X 相同的张量，其中的元素值是在 [0, 1) 区间内均匀分布的随机数。

(torch.rand(X.shape) < keep_prob): 将上述生成的随机数张量与 keep_prob 比较，得到一个布尔张量，其中元素值为 True 的概率为 keep_prob，表示该位置的元素需要被保留。

.float(): 将布尔张量转换为浮点数张量，将 True 转换为 1.0，False 转换为 0.0。

.to(X.device): 将上述浮点数张量移动到与输入张量 X 相同的设备上，确保与输入张量相同的存储位置。

因此，这个 mask 张量的作用是在 dropout 操作中，以概率 keep_prob 保留元素，同时将被保留的元素置为 1.0，被丢弃的元素置为 0.0。

def dropout(X, drop_prob):
    assert 0 <= drop_prob <= 1
    keep_prob = 1 - drop_prob
    # 这种情况下把全部元素都丢弃
    if keep_prob == 0:
        return torch.zeros_like(X)
    mask = (torch.rand(X.shape) < keep_prob).float().to(X.device)
    return mask * X / keep_prob

在 mask * X / keep_prob 中，除以 keep_prob 的目的是为了在训练时保持期望值不变。

在实施 dropout 操作时，我们将一部分元素置零，但为了保持期望值不变，我们需要对剩余的非零元素进行缩放。这就是为什么要除以 keep_prob。

具体来说，如果我们将一部分元素置零，那么这些被置零的元素的贡献就没有了，为了保持总体的期望值不变，我们需要对剩余的非零元素进行缩放。而这个缩放因子就是 1 / keep_prob。这样，被置零的元素在整个操作中的影响就被抵消了。

这种缩放保证了在测试阶段（不使用 dropout）时，模型的输出保持与训练阶段相同的期望值，从而使模型在不同阶段的行为一致。

net = net.cuda(0)

这行代码将神经网络模型 (net) 移动到 CUDA 设备上，设备的索引由数字 0 给出。在 PyTorch 中，.cuda() 用于将模型移动到 GPU 上，可以通过提供 GPU 设备的索引来指定使用哪块 GPU。

如果 0 是一个有效的 GPU 设备索引，模型将被移动到第一块 GPU 上。如果你的系统上有多个 GPU，可以根据需要选择不同的 GPU 设备索引。这对于使用多 GPU 进行训练或推理是很有用的。

在 PyTorch 中，.cuda() 方法的参数是一个设备索引，而不是多个设备索引。如果你想要将模型放在多个 GPU 上进行并行训练，可以使用 torch.nn.DataParallel。

from torch.nn import DataParallel

device_list = [0, 1]
net = net.cuda(device_list[0]) # 将模型移动到第一个 GPU 上
net = DataParallel(net, device_ids=device_list) # 使用 DataParallel 在多个 GPU 上并行训练

在这个示例中，首先将模型移到第一个 GPU 上，然后使用 DataParallel 将模型包装起来，指定 device_ids 参数为你希望使用的 GPU 设备索引列表。

optimizer.load_state_dict(checkpoint['optimizer']) 这行代码的目的是将优化器的状态从一个已保存的 checkpoint 中加载回来，以便从之前保存的状态继续训练模型。

在训练神经网络时，除了要保存模型的权重外，还需要保存优化器的状态。优化器的状态包括学习率、动量等信息，这些信息在训练的不同阶段可能发生变化。通过加载优化器的状态，可以从之前保存的训练状态继续优化模型，而不是从头开始。

在使用 torch.save() 保存 checkpoint 时，通常会保存模型的权重和优化器的状态。

# 保存 checkpoint
checkpoint = {
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
# 其他需要保存的信息
}
torch.save(checkpoint, 'checkpoint.pth')

然后在加载时使用：

# 加载 checkpoint
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# 恢复其他信息

这样就可以在训练中断或重新开始时加载之前保存的状态。