Pytorch中利用GPU訓練，CPU測試

要先利用GPU訓練，CPU測試，那么在模型訓練時候，是能保存模型的參數而不能保存整個模型，可見Pytorch模型保存機制便可以學會模型的保存、加載、測試

💥這里主要講一點重要的，即在pytorch 1.6的版本中訓練模型保存時，不能直接使用

torch.save(state_r, model_out_r_path)

否則，在CPU測試時，由於版本的不兼容會導致出錯，正確使用如下：

torch.save(state_g, model_out_g_path, _use_new_zipfile_serialization=False)

而后，在模型加載時候，要限定map_location = cpu的加載：

checkpoint_r = torch.load(opt.model_r,map_location='cpu')
model_rt.load_state_dict(checkpoint_r['model'])
model_rt.eval()
optimizer_rt.load_state_dict(checkpoint_r['optimizer'])
epochs_rt = checkpoint_r['epoch']

GPU下訓練的模型即可方便的在CPU環境中測試了

若模型已經訓練保存，但是有沒有使用_use_new_zipfile_serialization=False來進行約束，那么，可以在pytorch 1.6中直接加載模型，然后再次使用torch.save進行保存為非zip格式：

#在torch 1.6版本中重新加載一下網絡參數

model = MyModel().cuda() # 先預加載模型

model.load_state_dict(torch.load(pre_model))  #加載模型參數，pre_model為直接沒有設置_use_new_zipfile_serialization=False而模型的參數模型

#重新保存網絡參數
torch.save(model.state_dict(), pre_model,_use_new_zipfile_serialization=False)

另外，網絡模型的參數一般較大，在CPU中測試時，可能會導致內存爆滿而使得程序無法運行，此時，可以將模型的輸入進行修改。

以下，是我將input的圖像設置為512*512，導致了16G內存爆滿

之后，我將input image裁剪成128 * 128進行CPU測試，便可大功告成。

具體的CPU測試代碼如下，可供參考與理解：

from __future__ import print_function
import argparse
import torch
from PIL import Image
from torchvision.transforms import Compose, ToTensor, CenterCrop
import torchvision
from model import LapSRN_r, LapSRN_g
import torch.optim as optim
# Argument settingsss
parser = argparse.ArgumentParser(description='PyTorch LapSRN')
parser.add_argument('--input', type=str, required=False, default='/content/drive/My Drive/TestImg/val/44-512pix-speed7-ave1.tif', help='input image to use')
parser.add_argument('--model_r', type=str, default='LapSRN_r_epoch_10.pth', help='model file to use')
parser.add_argument('--model_g', type=str, default='LapSRN_g_epoch_10.pth', help='model file to use')
parser.add_argument('--outputHR2', type=str, default='./73_LapSRN_R_epochs100_HR2.tif', help='where to save the output image')
parser.add_argument('--outputHR4', type=str, default='./73_LapSRN_R_epochs100_HR4.tif', help='where to save the output image')
parser.add_argument('--cuda', action='store_true', help='use cuda')
opt = parser.parse_args()
print(opt)

model_rt = LapSRN_r()
model_gt = LapSRN_g()
optimizer_rt = optim.Adagrad(model_rt.parameters(), lr=1e-3, weight_decay=1e-5)
optimizer_gt = optim.Adagrad(model_gt.parameters(), lr=1e-3, weight_decay=1e-5)

checkpoint_r = torch.load(opt.model_r,map_location='cpu')
model_rt.load_state_dict(checkpoint_r['model'])
model_rt.eval()
optimizer_rt.load_state_dict(checkpoint_r['optimizer'])
epochs_rt = checkpoint_r['epoch']

checkpoint_g = torch.load(opt.model_g,map_location='cpu')
model_gt.load_state_dict(checkpoint_g['model'])
model_rt.eval()
optimizer_gt.load_state_dict(checkpoint_g['optimizer'])
epochs_gt = checkpoint_g['epoch']

transform = Compose(
    [
        ToTensor(),
    ])

img = Image.open(opt.input).convert('RGB')
r, g, _ = img.split()

r = transform(r)
r = r.unsqueeze(0)

g = transform(g)
g = g.unsqueeze(0)

HR_2_r, HR_4_r = model_rt(r)
HR_2_g, HR_4_g = model_gt(g)

black_2 = torch.zeros(1, 128 * 2, 128 * 2).unsqueeze(0)
HR_2 = torch.cat((HR_2_r.squeeze(0), HR_2_g.squeeze(0), black_2.squeeze(0))).unsqueeze(0)
black_4 = torch.zeros(1, 128 * 4, 128 * 4).unsqueeze(0)
HR_4 = torch.cat((HR_4_r.squeeze(0), HR_4_g.squeeze(0), black_4.squeeze(0))).unsqueeze(0)
torchvision.utils.save_image(HR_2, opt.outputHR2, padding=0) 
torchvision.utils.save_image(HR_4, opt.outputHR4, padding=0)
print("saved !")