Model_Analysis

查看网络结构

# 1. 直接打印网络
print(model)
# 2. 打印网络及按名称查看子网络
for name, module in net.named_modules():
    print(name, module)
# 3. 按名称查看子网络
for name, module in net.named_children():
    print(name, module)
# 4. 使用第三方工具库
# 使用 pip install torchsummary
import torch
import torchvision.models as models
from torchsummary import summary

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
model = models.resnet18().to(device) 
summary(model, (3,256,256)) # 输入的为输入数据

# 查看参数
# 1. 查看所有参数
for param in net.parameters():
    print(param)
# 2. 按名称查看所有参数
for name,parameters in net.named_parameters():
    print(name,':',parameters.size())
# 2. 查看个别网络参数
print(net.fc.weight.item())
print(net.fc.bias.item())

查看网络回传

model=model_Adnet(channels=3).cuda() # 构建模型
input = torch.randn(32, 3, 96, 96).clamp(0.,1.0).cuda()
# print(model) # 可以查看网络
out =model(input) # 送入数据
criterion =torch.nn.MSELoss()
loss = criterion(out,input)  # 计算损失
loss.backward() # 回传
for name, parms in model.named_parameters():
    print('-->name:', name, '-->grad_requirs:', parms.requires_grad, '--weight', torch.mean(parms.data),
          ' -->grad_value:', torch.mean(parms.grad))
--------
-->name: convblock13.convblock.1.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(1.8441e-08, device='cuda:0')
-->name: convblock14.convblock.0.weight -->grad_requirs: True --weight tensor(7.3778e-05, device='cuda:0')  -->grad_value: tensor(7.6115e-08, device='cuda:0')
-->name: convblock14.convblock.1.weight -->grad_requirs: True --weight tensor(0.4762, device='cuda:0')  -->grad_value: tensor(3.9709e-06, device='cuda:0')
-->name: convblock14.convblock.1.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(3.0582e-06, device='cuda:0')
-->name: convblock16.weight -->grad_requirs: True --weight tensor(0.0006, device='cuda:0')  -->grad_value: tensor(3.1860e-05, device='cuda:0')
-->name: convblock17.weight -->grad_requirs: True --weight tensor(-0.0013, device='cuda:0')  -->grad_value: tensor(3.4109e-06, device='cuda:0')
-->name: convblock17.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(3.2572e-05, device='cuda:0')

关于路径问题

python的import问题

原理

在Python中，一个.py文件就称之为一个模块（Module），
包含.py文件的文件夹，且里面有一个__init_.py的文件夹称为包（Package），init.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，它的模块名就是包名。
在python脚本被执行，python导入其他包或模块时，python会根据sys.path列表里的路径寻找这些包或模块。如果没找到的话，程序就会报错。

>>> import sys
>>> print(sys.path)
['', 'C:\\Users\\SONG\\Anaconda3\\python37.zip', 'C:\\Users\\SONG\\Anaconda3\\DLLs', 'C:\\Users\\SONG\\Anaconda3\\lib', 'C:\\Users\\SO......']

程序中要导入包或模块就需要在这些路径中进行查找，分为三种情况：

当前执行脚本（主动执行，而不是被其他模块调用）所在路径。上面例子是在交互界面进行操作，没有执行脚本，所以为空字符串。
python内置的标准库路径，PYTHONPATH。
安装的第三方模块路径。

分析

以运行python module_0.py为前提，目录如下

package_0
├── module_0.py
├── module_1.py
├── package_1
│   ├── module_2.py
│   ├── module_3.py
│   └── package_2
│       ├── module_21.py
│       └── module_22.py
└── package_3
    └── module_4.py

python module_0.py，即/home/…/package_0会被添加到 sys.path 中，可以通过该路径找到其他模块的，比如下面这些语句是不会报错的。

# module_0.py
import module_1
from package_1 import module_2
from package_1.package_2 import module_21

而下面的语句会报错：ModuleNotFoundError: No module named 'module_3’

# module_2.py
import module_3

原因：执行 python module_0.py 时，把路径（’/home/…/package_0’）添加到 sys.path 中，该路径下就不能在 module_2.py 中通过这种方式找到module_3，因为module_2.py 在路径/home/…/package_0/package_1下。

==修改办法：绝对路径：从当前执行脚本所在路径/…/需要的module==

# module_2.py
from package_1 import module_3
# module_21.py
from package_1.package_2 import module_21

==修改办法：相对路径==
- 单点表示引用的模块或包与当前模块在同一目录中（同一个包中）。
- 两点表示在当前模块所在位置的父目录中。

# module_2.py
from . import module_3
from .package_2 import module_21

# module_21.py
from .. import module_2

下面的语句会报错：ValueError: attempted relative import beyond top-level package

# module_2.py
from ..package_3 import module_4

原因：试图在顶级包（top-level package）之外进行相对导入。也就是说相对导入只适用于顶级包之内的模块。

如果将 module_0.py 当作执行模块，则和该模块同级的 package_1 和 package_3 就是顶级包（top-level package），

而 module_2 在package_1中，module_0、module_1和module_4都在 package_1之外，所以调用这三个模块时，就会报这个错误。

下面的语句会报错：ModuleNotFoundError: No module named ‘main.package_1’; ‘main’ is not a package

# module_0.py
from .package_1 import module_2

原因：用了相对导入的模块文件不能作为顶层执行文件，即不能 python module_0.py

==sys.path.append==

# module_2.py
sys.path.append(os.path.dirname(__file__))
import module_3
from package_2 import module_21

# module_2.py
sys.path.append(os.path.join(os.path.dirname(__file__), '../package_3'))
import module_4

sys.path.append()用法

sys.path使用
自动化测试中需要使用批处理命令运行测试脚本，
此时需要使用到sys.path.append来添加当前项目目录来支持脚本import模块，
但一般用绝对路径如：sys.path.append（‘c:\project\pro’）或者绝对路径也可以
但是这样的话如果我的脚本更换电脑或者路径那就不得不手动修改源码，我需要一种一劳永逸的方法。

sys.path.append(os.path.realpath(’…’))方法

this_dir = os.path.dirname(__file__) 
filename = os.path.realpath("{0}/relative/file.path".format(this_dir))

还有sys.path.insert指定需要去的目录。例如，需要上一级目录

import sys
sys.path.insert(0, '../')

加载和保存模型

torch.save：保存序列化的对象到磁盘，使用了Python的pickle进行序列化，模型、张量、所有对象的字典。
torch.load：使用了pickle的unpacking将pickled的对象反序列化到内存中。
torch.nn.Module.load_state_dict：使用反序列化的state_dict加载模型的参数字典。

state_dict 是一个Python字典，将每一层映射成它的参数张量。注意只有带有可学习参数的层（卷积层、全连接层等），以及注册的缓存（batchnorm的运行平均值）在state_dict 中才有记录。state_dict同样包含优化器对象，存储了优化器的状态，所使用到的超参数。

一个简单的例子

# 定义模型
class TheModelClass(nn.Module):
    def __init__(self):
        super(TheModelClass, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 初始化模型
model = TheModelClass()

# 初始化优化器
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 打印模型的 state_dict
print("Model's state_dict:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

# 打印优化器的 state_dict
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:
conv1.weight     torch.Size([6, 3, 5, 5])
conv1.bias   torch.Size([6])
conv2.weight     torch.Size([16, 6, 5, 5])
conv2.bias   torch.Size([16])
fc1.weight   torch.Size([120, 400])
fc1.bias     torch.Size([120])
fc2.weight   torch.Size([84, 120])
fc2.bias     torch.Size([84])
fc3.weight   torch.Size([10, 84])
fc3.bias     torch.Size([10])

Optimizer's state_dict:
state    {}
param_groups     [{'lr': 0.001, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'params': [4675713712, 4675713784, 4675714000, 4675714072, 4675714216, 4675714288, 4675714432, 4675714504, 4675714648, 4675714720]}]

保存/加载 state_dict（推荐）

保存：torch.save(model.state_dict(), PATH) 加载：

model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.eval() # 评估模型时需要加上

要注意这个细节，如果使用nn.DataParallel在一台电脑上使用了多个GPU，那么加载模型的时候也必须先进行nn.DataParallel。

保存模型的推理过程的时候，只需要保存模型训练好的参数，使用torch.save()保存state_dict，能够方便模型的加载。因此推荐使用这种方式进行模型保存。

记住一定要使用model.eval()来固定dropout和归一化层，否则每次推理会生成不同的结果。

注意，load_state_dict()需要传入字典对象，因此需要先反序列化state_dict再传入load_state_dict()

保存/加载整个模型

保存：torch.save(model, PATH)

加载：

# 模型类必须在别的地方定义
model = torch.load(PATH)
model.eval()

这种保存/加载模型的过程使用了最直观的语法，所用代码量少。这使用Python的pickle保存所有模块。这种方法的缺点是，保存模型的时候，序列化的数据被绑定到了特定的类和确切的目录。这是因为pickle不保存模型类本身，而是保存这个类的路径，并且在加载的时候会使用。因此，当在其他项目里使用或者重构的时候，加载模型的时候会出错。

一般来说，PyTorch的模型以.pt或者.pth文件格式保存。

一定要记住在评估模式的时候调用model.eval()来固定dropout和批次归一化。否则会产生不一致的推理结果。

保存加载用于推理的常规Checkpoint/或继续训练

在保存用于推理或者继续训练的常规检查点的时候，除了模型的state_dict之外，还必须保存其他参数。保存优化器的state_dict也非常重要，因为它包含了模型在训练时候优化器的缓存和参数。除此之外，还可以保存停止训练时epoch数，最新的模型损失，额外的torch.nn.Embedding层等。

要保存多个组件，则将它们放到一个字典中，然后使用torch.save()序列化这个字典。一般来说，使用.tar文件格式来保存这些检查点。加载各个组件，首先初始化模型和优化器，然后使用torch.load()加载保存的字典，然后可以直接查询字典中的值来获取保存的组件。

# 保存
torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': loss,
            ...
            }, PATH)

# 加载：
model = TheModelClass(*args, **kwargs)
optimizer = TheOptimizerClass(*args, **kwargs)

checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']

model.eval()
# - 或者 -
model.train()同样，评估模型的时候一定不要忘了调用`model.eval()`。

保存多个模型到一个文件

保存：

torch.save({
            'modelA_state_dict': modelA.state_dict(),
            'modelB_state_dict': modelB.state_dict(),
            'optimizerA_state_dict': optimizerA.state_dict(),
            'optimizerB_state_dict': optimizerB.state_dict(),
            ...
            }, PATH)

加载：

modelA = TheModelAClass(*args, **kwargs)
modelB = TheModelBClass(*args, **kwargs)
optimizerA = TheOptimizerAClass(*args, **kwargs)
optimizerB = TheOptimizerBClass(*args, **kwargs)

checkpoint = torch.load(PATH)
modelA.load_state_dict(checkpoint['modelA_state_dict'])
modelB.load_state_dict(checkpoint['modelB_state_dict'])
optimizerA.load_state_dict(checkpoint['optimizerA_state_dict'])
optimizerB.load_state_dict(checkpoint['optimizerB_state_dict'])

modelA.eval()
modelB.eval()
# - 或者 -
modelA.train()
modelB.train()

保存的模型包含多个torch.nn.Modules时，比如GAN，一个序列-序列模型，或者组合模型，使用与保存常规检查点的方式来保存模型。也就是说，保存每个模型的state_dict和对应的优化器到一个字典中。我们可以保存任何能帮助我们继续训练的东西到这个字典中。

使用其他模型来预热当前模型

# 保存：
torch.save(modelA.state_dict(), PATH)

# 加载：
modelB = TheModelBClass(*args, **kwargs)
modelB.load_state_dict(torch.load(PATH), strict=False)

在迁移学习或者训练新的复杂模型时，加载部分模型是很常见的。利用经过训练的参数，即使只有少数参数可用，也将有助于预热训练过程，并且使模型更快收敛。

在加载部分模型参数进行预训练的时候，很可能会碰到键不匹配的情况（模型权重都是按键值对的形式保存并加载回来的）。因此，无论是缺少键还是多出键的情况，都可以通过在load_state_dict()函数中设定strict参数为False来忽略不匹配的键。

如果想将某一层的参数加载到其他层，但是有些键不匹配，那么修改state_dict中参数的key可以解决这个问题。

跨设备保存与加载模型

GPU上保存，CPU上加载

# 保存
torch.save(model.state_dict(), PATH)

# 加载
device = torch.device('cpu')
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH, map_location=device))

当在CPU上加载一个GPU上训练的模型时，在torch.load()中指定map_location=torch.device('cpu')，此时，map_location动态地将tensors的底层存储重新映射到CPU设备上。

上述代码只有在模型是在一块GPU上训练时才有效，如果模型在多个GPU上训练，那么在CPU上加载时，会得到类似如下错误：

KeyError: ‘unexpected key “module.conv1.weight” in state_dict’

原因是在使用多GPU训练并保存模型时，模型的参数名都带上了module前缀，因此可以在加载模型时，把key中的这个前缀去掉：

# 原始通过DataParallel保存的文件
state_dict = torch.load('myfile.pth.tar')
# 创建一个不包含`module.`的新OrderedDict
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
    name = k[7:] # 去掉 `module.`
    new_state_dict[name] = v
# 加载参数
model.load_state_dict(new_state_dict)

GPU上保存，GPU上加载

# 保存：
torch.save(model.state_dict(), PATH)

# 加载：
device = torch.device("cuda")
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.to(device)
# 往模型中输入数据的时候不要忘记在任意tensor上调用input = input.to(device)

在把GPU上训练的模型加载到GPU上时，只需要使用model.to(torch.devie('cuda'))将初始化的模型转换为CUDA优化模型。同时确保在模型所有的输入上使用.to(torch.device('cuda'))。注意，调用my_tensor.to(device)会返回一份在GPU上的my_tensor的拷贝。不会覆盖原本的my_tensor，因此要记得手动将tensor重写：my_tensor = my_tensor.to(torch.device('cuda'))。

CPU上保存，GPU上加载

# 保存：
torch.save(model.state_dict(), PATH)

# 加载：
device = torch.device("cuda")
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH, map_location="cuda:0"))  # 选择希望使用的GPU
model.to(device)

保存torch.nn.DataParallel模型

保存：

torch.save(model.module.state_dict(), PATH)

bias偏置

我们在进行写代码的时候，有时候会发现有的m = nn.Conv2d(16, 33, 3, stride=2,bias=False) ,bias是False，而默认的是True。为啥呢？是因为一般为False的时候，nn.Conv2d()后面通常接nn.BatchNorm2d(output)。

是因为BN里面有一个关键操作 $\widehat{x}=\frac{x-\mathrm{E}[x]}{\sqrt{\operatorname{Var}[x]+\epsilon}}$,其中x1=x0*w0+b0，而E[x1]=E[x0]*[w0]+b0，所以对于分子而言，加没加偏置，没有影响；而对于下面分母而言，因为Var是方差操作，所以也没有影响（为什么没影响，回头问问你的数学老师就知道了）。

所以，卷积之后，如果要接BN操作，最好是不设置偏置，因为不起作用，而且占显卡内存

解决Ubuntu系统找不到进程，但是GPU显存占满问题

Ubuntu系统有时候会出现GPU显存显示占满，但是使用top命令和nvidia-smi命令都查找不到进程。

fuser -v /dev/nvidia*

通过上条命令查找进程，然后使用

sudo kill -9 PID

将进程kill掉。

python程序命令行输出记录到log文件

$ python xxx.py args1 >> data/log.txt
 第一条命令的含义是：将xxx.py这个python文件中print()原本输出到console的内容重定向到"data/log.txt"文件中。（“>>”是追加，“>”是直接写入，即会发生覆盖）；
$ python xxx.py args1 | tee -a data/log.txt
第二条命令使用了tee命令，在保证xxx.py文件运行时将print内容输出到控制台的同时，还把这些内容保存在"data/log.txt"文件中。

问题：因为在python中，重定向和输出到控制台的内容会先被存在缓冲区中暂存，当它遇到换行符“\n”，或者缓存区的数据积累到一定的量的时候，就会将内容写到重定向的文件或者控制台中。

所以有的时候会发生比较蛋疼的情况，那就是可能要间隔很久，你才会看到你的"data/log.txt"中有内容；或者控制台才有内容显示。

解决

python的print()函数有个参数叫"flush"，将它设为True，程序运行到该条输出内容时就会将缓存区的内容写出一次。即

print("abcdefghijklmnopqrst", flush=True)

命令行运行py文件的时候，加上一个命令行参数"-u"。即

python -u xxx.py args1 | tee -a data/log.txt

PreviousDeploy_Issue NextModel_concept

Last updated 2 years ago

Model_Analysis

查看网络结构

# 1. 直接打印网络
print(model)
# 2. 打印网络及按名称查看子网络
for name, module in net.named_modules():
    print(name, module)
# 3. 按名称查看子网络
for name, module in net.named_children():
    print(name, module)
# 4. 使用第三方工具库
# 使用 pip install torchsummary
import torch
import torchvision.models as models
from torchsummary import summary

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
model = models.resnet18().to(device) 
summary(model, (3,256,256)) # 输入的为输入数据

# 查看参数
# 1. 查看所有参数
for param in net.parameters():
    print(param)
# 2. 按名称查看所有参数
for name,parameters in net.named_parameters():
    print(name,':',parameters.size())
# 2. 查看个别网络参数
print(net.fc.weight.item())
print(net.fc.bias.item())

查看网络回传

model=model_Adnet(channels=3).cuda() # 构建模型
input = torch.randn(32, 3, 96, 96).clamp(0.,1.0).cuda()
# print(model) # 可以查看网络
out =model(input) # 送入数据
criterion =torch.nn.MSELoss()
loss = criterion(out,input)  # 计算损失
loss.backward() # 回传
for name, parms in model.named_parameters():
    print('-->name:', name, '-->grad_requirs:', parms.requires_grad, '--weight', torch.mean(parms.data),
          ' -->grad_value:', torch.mean(parms.grad))
--------
-->name: convblock13.convblock.1.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(1.8441e-08, device='cuda:0')
-->name: convblock14.convblock.0.weight -->grad_requirs: True --weight tensor(7.3778e-05, device='cuda:0')  -->grad_value: tensor(7.6115e-08, device='cuda:0')
-->name: convblock14.convblock.1.weight -->grad_requirs: True --weight tensor(0.4762, device='cuda:0')  -->grad_value: tensor(3.9709e-06, device='cuda:0')
-->name: convblock14.convblock.1.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(3.0582e-06, device='cuda:0')
-->name: convblock16.weight -->grad_requirs: True --weight tensor(0.0006, device='cuda:0')  -->grad_value: tensor(3.1860e-05, device='cuda:0')
-->name: convblock17.weight -->grad_requirs: True --weight tensor(-0.0013, device='cuda:0')  -->grad_value: tensor(3.4109e-06, device='cuda:0')
-->name: convblock17.bias -->grad_requirs: True --weight tensor(0., device='cuda:0')  -->grad_value: tensor(3.2572e-05, device='cuda:0')

关于路径问题

python的import问题

原理

在Python中，一个.py文件就称之为一个模块（Module），
包含.py文件的文件夹，且里面有一个__init_.py的文件夹称为包（Package），init.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，它的模块名就是包名。
在python脚本被执行，python导入其他包或模块时，python会根据sys.path列表里的路径寻找这些包或模块。如果没找到的话，程序就会报错。

>>> import sys
>>> print(sys.path)
['', 'C:\\Users\\SONG\\Anaconda3\\python37.zip', 'C:\\Users\\SONG\\Anaconda3\\DLLs', 'C:\\Users\\SONG\\Anaconda3\\lib', 'C:\\Users\\SO......']

程序中要导入包或模块就需要在这些路径中进行查找，分为三种情况：

当前执行脚本（主动执行，而不是被其他模块调用）所在路径。上面例子是在交互界面进行操作，没有执行脚本，所以为空字符串。
python内置的标准库路径，PYTHONPATH。
安装的第三方模块路径。

分析

以运行python module_0.py为前提，目录如下

package_0
├── module_0.py
├── module_1.py
├── package_1
│   ├── module_2.py
│   ├── module_3.py
│   └── package_2
│       ├── module_21.py
│       └── module_22.py
└── package_3
    └── module_4.py

python module_0.py，即/home/…/package_0会被添加到 sys.path 中，可以通过该路径找到其他模块的，比如下面这些语句是不会报错的。

# module_0.py
import module_1
from package_1 import module_2
from package_1.package_2 import module_21

而下面的语句会报错：ModuleNotFoundError: No module named 'module_3’

# module_2.py
import module_3

==修改办法：绝对路径：从当前执行脚本所在路径/…/需要的module==

# module_2.py
from package_1 import module_3
# module_21.py
from package_1.package_2 import module_21

==修改办法：相对路径==
- 单点表示引用的模块或包与当前模块在同一目录中（同一个包中）。
- 两点表示在当前模块所在位置的父目录中。

# module_2.py
from . import module_3
from .package_2 import module_21

# module_21.py
from .. import module_2

下面的语句会报错：ValueError: attempted relative import beyond top-level package

# module_2.py
from ..package_3 import module_4

原因：试图在顶级包（top-level package）之外进行相对导入。也就是说相对导入只适用于顶级包之内的模块。

如果将 module_0.py 当作执行模块，则和该模块同级的 package_1 和 package_3 就是顶级包（top-level package），

而 module_2 在package_1中，module_0、module_1和module_4都在 package_1之外，所以调用这三个模块时，就会报这个错误。

下面的语句会报错：ModuleNotFoundError: No module named ‘main.package_1’; ‘main’ is not a package

# module_0.py
from .package_1 import module_2

原因：用了相对导入的模块文件不能作为顶层执行文件，即不能 python module_0.py

==sys.path.append==

# module_2.py
sys.path.append(os.path.dirname(__file__))
import module_3
from package_2 import module_21

# module_2.py
sys.path.append(os.path.join(os.path.dirname(__file__), '../package_3'))
import module_4

本文转自，如有侵权，请联系删除。

sys.path.append()用法

sys.path使用
自动化测试中需要使用批处理命令运行测试脚本，
此时需要使用到sys.path.append来添加当前项目目录来支持脚本import模块，
但一般用绝对路径如：sys.path.append（‘c:\project\pro’）或者绝对路径也可以
但是这样的话如果我的脚本更换电脑或者路径那就不得不手动修改源码，我需要一种一劳永逸的方法。

sys.path.append(os.path.realpath(’…’))方法

this_dir = os.path.dirname(__file__) 
filename = os.path.realpath("{0}/relative/file.path".format(this_dir))

还有sys.path.insert指定需要去的目录。例如，需要上一级目录

import sys
sys.path.insert(0, '../')

本文转自，如有侵权，请联系删除。

加载和保存模型

torch.save：保存序列化的对象到磁盘，使用了Python的pickle进行序列化，模型、张量、所有对象的字典。
torch.load：使用了pickle的unpacking将pickled的对象反序列化到内存中。
torch.nn.Module.load_state_dict：使用反序列化的state_dict加载模型的参数字典。

一个简单的例子

# 定义模型
class TheModelClass(nn.Module):
    def __init__(self):
        super(TheModelClass, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 初始化模型
model = TheModelClass()

# 初始化优化器
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# 打印模型的 state_dict
print("Model's state_dict:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

# 打印优化器的 state_dict
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:
conv1.weight     torch.Size([6, 3, 5, 5])
conv1.bias   torch.Size([6])
conv2.weight     torch.Size([16, 6, 5, 5])
conv2.bias   torch.Size([16])
fc1.weight   torch.Size([120, 400])
fc1.bias     torch.Size([120])
fc2.weight   torch.Size([84, 120])
fc2.bias     torch.Size([84])
fc3.weight   torch.Size([10, 84])
fc3.bias     torch.Size([10])

Optimizer's state_dict:
state    {}
param_groups     [{'lr': 0.001, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'params': [4675713712, 4675713784, 4675714000, 4675714072, 4675714216, 4675714288, 4675714432, 4675714504, 4675714648, 4675714720]}]

保存/加载 state_dict（推荐）

保存：torch.save(model.state_dict(), PATH) 加载：

model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.eval() # 评估模型时需要加上

要注意这个细节，如果使用nn.DataParallel在一台电脑上使用了多个GPU，那么加载模型的时候也必须先进行nn.DataParallel。

记住一定要使用model.eval()来固定dropout和归一化层，否则每次推理会生成不同的结果。

注意，load_state_dict()需要传入字典对象，因此需要先反序列化state_dict再传入load_state_dict()

保存/加载整个模型

保存：torch.save(model, PATH)

加载：

# 模型类必须在别的地方定义
model = torch.load(PATH)
model.eval()

一般来说，PyTorch的模型以.pt或者.pth文件格式保存。

一定要记住在评估模式的时候调用model.eval()来固定dropout和批次归一化。否则会产生不一致的推理结果。

保存加载用于推理的常规Checkpoint/或继续训练

# 保存
torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': loss,
            ...
            }, PATH)

# 加载：
model = TheModelClass(*args, **kwargs)
optimizer = TheOptimizerClass(*args, **kwargs)

checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']

model.eval()
# - 或者 -
model.train()同样，评估模型的时候一定不要忘了调用`model.eval()`。

保存多个模型到一个文件

保存：

torch.save({
            'modelA_state_dict': modelA.state_dict(),
            'modelB_state_dict': modelB.state_dict(),
            'optimizerA_state_dict': optimizerA.state_dict(),
            'optimizerB_state_dict': optimizerB.state_dict(),
            ...
            }, PATH)

加载：

modelA = TheModelAClass(*args, **kwargs)
modelB = TheModelBClass(*args, **kwargs)
optimizerA = TheOptimizerAClass(*args, **kwargs)
optimizerB = TheOptimizerBClass(*args, **kwargs)

checkpoint = torch.load(PATH)
modelA.load_state_dict(checkpoint['modelA_state_dict'])
modelB.load_state_dict(checkpoint['modelB_state_dict'])
optimizerA.load_state_dict(checkpoint['optimizerA_state_dict'])
optimizerB.load_state_dict(checkpoint['optimizerB_state_dict'])

modelA.eval()
modelB.eval()
# - 或者 -
modelA.train()
modelB.train()

使用其他模型来预热当前模型

# 保存：
torch.save(modelA.state_dict(), PATH)

# 加载：
modelB = TheModelBClass(*args, **kwargs)
modelB.load_state_dict(torch.load(PATH), strict=False)

如果想将某一层的参数加载到其他层，但是有些键不匹配，那么修改state_dict中参数的key可以解决这个问题。

跨设备保存与加载模型

GPU上保存，CPU上加载

# 保存
torch.save(model.state_dict(), PATH)

# 加载
device = torch.device('cpu')
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH, map_location=device))

上述代码只有在模型是在一块GPU上训练时才有效，如果模型在多个GPU上训练，那么在CPU上加载时，会得到类似如下错误：

KeyError: ‘unexpected key “module.conv1.weight” in state_dict’

原因是在使用多GPU训练并保存模型时，模型的参数名都带上了module前缀，因此可以在加载模型时，把key中的这个前缀去掉：

# 原始通过DataParallel保存的文件
state_dict = torch.load('myfile.pth.tar')
# 创建一个不包含`module.`的新OrderedDict
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in state_dict.items():
    name = k[7:] # 去掉 `module.`
    new_state_dict[name] = v
# 加载参数
model.load_state_dict(new_state_dict)

GPU上保存，GPU上加载

# 保存：
torch.save(model.state_dict(), PATH)

# 加载：
device = torch.device("cuda")
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.to(device)
# 往模型中输入数据的时候不要忘记在任意tensor上调用input = input.to(device)

CPU上保存，GPU上加载

# 保存：
torch.save(model.state_dict(), PATH)

# 加载：
device = torch.device("cuda")
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH, map_location="cuda:0"))  # 选择希望使用的GPU
model.to(device)

保存torch.nn.DataParallel模型

保存：

torch.save(model.module.state_dict(), PATH)

本文转自，如有侵权，请联系删除。

bias偏置

所以，卷积之后，如果要接BN操作，最好是不设置偏置，因为不起作用，而且占显卡内存

解决Ubuntu系统找不到进程，但是GPU显存占满问题

Ubuntu系统有时候会出现GPU显存显示占满，但是使用top命令和nvidia-smi命令都查找不到进程。

fuser -v /dev/nvidia*

通过上条命令查找进程，然后使用

sudo kill -9 PID

将进程kill掉。

本文转自，如有侵权，请联系删除。

python程序命令行输出记录到log文件

$ python xxx.py args1 >> data/log.txt
 第一条命令的含义是：将xxx.py这个python文件中print()原本输出到console的内容重定向到"data/log.txt"文件中。（“>>”是追加，“>”是直接写入，即会发生覆盖）；
$ python xxx.py args1 | tee -a data/log.txt
第二条命令使用了tee命令，在保证xxx.py文件运行时将print内容输出到控制台的同时，还把这些内容保存在"data/log.txt"文件中。

所以有的时候会发生比较蛋疼的情况，那就是可能要间隔很久，你才会看到你的"data/log.txt"中有内容；或者控制台才有内容显示。

解决

python的print()函数有个参数叫"flush"，将它设为True，程序运行到该条输出内容时就会将缓存区的内容写出一次。即

print("abcdefghijklmnopqrst", flush=True)

命令行运行py文件的时候，加上一个命令行参数"-u"。即

python -u xxx.py args1 | tee -a data/log.txt

本文转自，如有侵权，请联系删除。

PreviousDeploy_Issue NextModel_concept

Last updated 2 years ago

查看网络结构

查看网络回传

关于路径问题

python的import问题

sys.path.append()用法

加载和保存模型

保存/加载 state_dict（推荐）

保存/加载整个模型

保存加载 用于推理的常规Checkpoint/或继续训练

保存多个模型到一个文件

使用其他模型来预热当前模型

跨设备保存与加载模型

bias偏置

解决Ubuntu系统找不到进程，但是GPU显存占满问题

python程序命令行输出记录到log文件

查看网络结构

查看网络回传

关于路径问题

python的import问题

sys.path.append()用法

加载和保存模型

保存/加载 state_dict（推荐）

保存/加载整个模型

保存加载 用于推理的常规Checkpoint/或继续训练

保存多个模型到一个文件

使用其他模型来预热当前模型

跨设备保存与加载模型

bias偏置

解决Ubuntu系统找不到进程，但是GPU显存占满问题

python程序命令行输出记录到log文件

保存加载用于推理的常规Checkpoint/或继续训练

保存加载用于推理的常规Checkpoint/或继续训练