Python hmodel.state\u dict（）： #保存： torch.save（旧模型.state\u dict（），路径） #负载： 新模型=模型类（*args，**kwargs） 新的模式加载状态指令（火炬加载路径）

如果出于任何原因（或更喜欢更简单的语法）无法保存，则可以使用

torch.save（）

保存整个模型（实际上是对定义模型的文件及其状态的引用）：

但是，由于这是对定义模型类的文件位置的引用，因此，除非这些文件也被移植到相同的目录结构中，否则此代码是不可移植的

保存到云- 如果您希望您的模型是可移植的，您可以轻松地使用

torch.hub

导入它。如果将适当定义的

hubconf.py

文件添加到github repo中，则可以从PyTorch中轻松调用该文件，使用户可以加载带有/不带权重的模型：

hubconf.py

（）

dependencies=['torch']
从my_模块导入mymodel作为_mymodel
def mymodel（预训练=假，**kwargs）：
返回_mymodel（预训练=预训练，**kwargs）

加载模式：

new\u model=torch.hub.load（'repo\u owner/repo\u name'，'mymodel'）
new_model_pretrained=torch.hub.load（'repo_owner/repo_name'，'mymodel'，pretrained=True）

我认为这是因为torch.save（）还保存了所有中间变量，如用于反向传播的中间输出。但您只需要保存模型参数，如权重/偏差等。有时前者可能比后者大得多。我测试了

torch.save（model，f）

和

torch.save（model.state_dict（），f）

。保存的文件大小相同。现在我很困惑。另外，我发现使用pickle保存model.state_dict（）非常慢。我认为最好的方法是使用

torch.save（model.state_dict（），f）

，因为您处理模型的创建，而torch处理模型权重的加载，从而消除了可能的问题。参考资料：PyTorch似乎在他们的文章中更明确地阐述了这一点-这里有很多好的信息没有在答案中列出，包括一次保存多个模型和热启动模型。使用

pickle

？@CharlieParker torch.save是基于pickle的。下面是上面链接的教程：“[torch.save]将使用Python的pickle模块保存整个模块。这种方法的缺点是，序列化数据绑定到特定类以及保存模型时使用的确切目录结构。原因是pickle不保存模型类本身。相反，它保存到包含cl的文件的路径ass，在加载期间使用。因此，在其他项目中使用或重构后，您的代码可能会以各种方式中断。”根据@smth模型，默认情况下，重新加载以训练模型。因此，如果加载它是为了推理，而不是恢复训练，则需要在加载后手动调用_model.eval（）。无法解决在不需要访问模型类的情况下是否有任何保存选项？使用这种方法，如何跟踪在负载情况下需要传递的*arg和**kwarg？实际上，我只需要保存一个

nn.Sequential

模型。你知道怎么做吗？我没有模型类定义。这3种情况是否有建议的文件结尾？还是总是.pth？在这种情况下#3

torch.load

只返回一个OrderedDict。你是如何得到模型来进行预测的？嗨，我可以知道如何做上面提到的“案例2：保存模型以便稍后恢复训练”吗？我设法将检查点加载到模型，然后我无法运行或恢复到训练模型，如“model.to（device）model=train_model_epoch（model，criteria，optimizer，sched，epochs）”Hi，对于用于推理的案例一，在官方pytorch文档中说，必须保存优化器状态，以便进行推理或完成训练。“保存常规检查点（用于推断或恢复训练）时，必须保存的不仅仅是模型的状态记录。保存优化器的状态记录也很重要，因为它包含随着模型训练而更新的缓冲区和参数。”在案例#3中，模型类应该在某个地方定义。虽然它不是一个简单的解决方案，但问题的本质已经被深入分析了！Upvote.it引发：AttributeError:“dict”对象没有属性“eval”

torch.save(the_model.state_dict(), PATH)

the_model = TheModelClass(*args, **kwargs)
the_model.load_state_dict(torch.load(PATH))

torch.save(the_model, PATH)

the_model = torch.load(PATH)

torch.save(model.state_dict(), filepath)

#Later to restore:
model.load_state_dict(torch.load(filepath))
model.eval()

state = {
    'epoch': epoch,
    'state_dict': model.state_dict(),
    'optimizer': optimizer.state_dict(),
    ...
}
torch.save(state, filepath)

model.load_state_dict(state['state_dict'])
optimizer.load_state_dict(state['optimizer'])

torch.save(model, filepath)

# Then later:
model = torch.load(filepath)

import torch
import torch.optim as optim

model = torch.nn.Linear(5, 2)

# Initialize optimizer
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

print("Model's state_dict:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

print("Model weight:")    
print(model.weight)

print("Model bias:")    
print(model.bias)

print("---")
print("Optimizer's state_dict:")
for var_name in optimizer.state_dict():
    print(var_name, "\t", optimizer.state_dict()[var_name])

Model's state_dict:
weight   torch.Size([2, 5])
bias     torch.Size([2])
Model weight:
Parameter containing:
tensor([[ 0.1328,  0.1360,  0.1553, -0.1838, -0.0316],
        [ 0.0479,  0.1760,  0.1712,  0.2244,  0.1408]], requires_grad=True)
Model bias:
Parameter containing:
tensor([ 0.4112, -0.0733], requires_grad=True)
---
Optimizer's state_dict:
state    {}
param_groups     [{'lr': 0.001, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'params': [140695321443856, 140695321443928]}]

model = torch.nn.Sequential(
          torch.nn.Linear(D_in, H),
          torch.nn.Conv2d(A, B, C)
          torch.nn.Linear(H, D_out),
        )

torch.save(model.state_dict(), filepath)

path = "username/directory/lstmmodelgpu.pth"
torch.save(trainer, path)

model.load_state_dict(torch.load(PATH))
model.eval()

state = {
        'epoch': epoch,
        'state_dict': model.state_dict(),
        'optimizer': optimizer.state_dict(),
}
savepath='checkpoint.t7'
torch.save(state,savepath)

checkpoint = torch.load('checkpoint.t7')
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
epoch = checkpoint['epoch']

state = {
        'epoch': epoch,
        'state_dict': model.module.state_dict(),
        'optimizer': optimizer.state_dict(),
}
savepath='checkpoint.t7'
torch.save(state,savepath)

checkpoint = torch.load('checkpoint.t7')
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
epoch = checkpoint['epoch']

#Don't call DataParallel before loading the model otherwise you will get an error

model = nn.DataParallel(model) #ignore the line if you want to load on Single GPU

# Save:
torch.save(old_model, PATH)

# Load:
new_model = torch.load(PATH)