PyTrch深度学习简明实战12 - 模型保存与加载

作者: 薛东弗斯 | 来源:发表于2023-03-25 11:07 被阅读0次

PyTrch深度学习简明实战2 -逻辑回归
PyTrch深度学习简明实战1 - 线性回归
如何用Python和深度神经网络锁定即将流失的客户？
《深度学习 Caffe之经典模型详解与实战.pdf》PDF高清完
pytorch学习(十七)—模型的保存与加载
15-岭回归以及模型的保存与加载
PyTorch模型保存深入理解
第八章 Keras高层接口
Java调用TensorFlow库预测图片质量
深度学习小技巧（一）：如何保存和恢复TensorFlow训练的模

学习笔记14：模型保存 - pbc的成长之路 - 博客园 (cnblogs.com)
简单模型

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import torchvision
import os
import copy
from torchvision import transforms

base_dir = r'./data/4_weather'
train_dir = os.path.join(base_dir,'train')
test_dir = os.path.join(base_dir,'test')

transform = transforms.Compose([
                  transforms.Resize((96, 96)),
                  transforms.ToTensor(),
                  transforms.Normalize(mean=[0.5, 0.5, 0.5],
                                       std=[0.5, 0.5, 0.5])
])

train_ds = torchvision.datasets.ImageFolder(
               train_dir,
               transform=transform
)

test_ds = torchvision.datasets.ImageFolder(
               test_dir,
               transform=transform
)

BATCHSIZE = 16

train_dl = torch.utils.data.DataLoader(
                                       train_ds,
                                       batch_size=BATCHSIZE,
                                       shuffle=True
)

test_dl = torch.utils.data.DataLoader(
                                       test_ds,
                                       batch_size=BATCHSIZE,
)

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 3)
        self.conv3 = nn.Conv2d(32, 64, 3)
        self.fc1 = nn.Linear(64*10*10, 1024)
        self.fc2 = nn.Linear(1024, 256)
        self.fc3 = nn.Linear(256, 4)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 64 * 10 * 10)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
    
model = Net()
if torch.cuda.is_available():
    model.to('cuda')
    
optim = torch.optim.Adam(model.parameters(), lr=0.001)
loss_fn = nn.CrossEntropyLoss()

def fit(epoch, model, trainloader, testloader):
    correct = 0
    total = 0
    running_loss = 0
    model.train()
    for x, y in trainloader:
        if torch.cuda.is_available():
            x, y = x.to('cuda'), y.to('cuda')
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        optim.zero_grad()
        loss.backward()
        optim.step()
        with torch.no_grad():
            y_pred = torch.argmax(y_pred, dim=1)
            correct += (y_pred == y).sum().item()
            total += y.size(0)
            running_loss += loss.item()
    epoch_loss = running_loss / len(trainloader.dataset)
    epoch_acc = correct / total
        
        
    test_correct = 0
    test_total = 0
    test_running_loss = 0 
    
    model.eval()
    with torch.no_grad():
        for x, y in testloader:
            if torch.cuda.is_available():
                x, y = x.to('cuda'), y.to('cuda')
            y_pred = model(x)
            loss = loss_fn(y_pred, y)
            y_pred = torch.argmax(y_pred, dim=1)
            test_correct += (y_pred == y).sum().item()
            test_total += y.size(0)
            test_running_loss += loss.item()
    
    epoch_test_loss = test_running_loss / len(testloader.dataset)
    epoch_test_acc = test_correct / test_total
    
        
    print('epoch: ', epoch, 
          'loss： ', round(epoch_loss, 3),
          'accuracy:', round(epoch_acc, 3),
          'test_loss： ', round(epoch_test_loss, 3),
          'test_accuracy:', round(epoch_test_acc, 3)
             )
        
    return epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc

epochs = 10

train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc = fit(epoch,
                                                                 model,
                                                                 train_dl,
                                                                 test_dl)
    train_loss.append(epoch_loss)
    train_acc.append(epoch_acc)
    test_loss.append(epoch_test_loss)
    test_acc.append(epoch_test_acc)

epoch:  0 loss：  0.047 accuracy: 0.653 test_loss：  0.037 test_accuracy: 0.804
epoch:  1 loss：  0.028 accuracy: 0.839 test_loss：  0.038 test_accuracy: 0.844
epoch:  2 loss：  0.023 accuracy: 0.856 test_loss：  0.034 test_accuracy: 0.836
epoch:  3 loss：  0.022 accuracy: 0.871 test_loss：  0.034 test_accuracy: 0.796
epoch:  4 loss：  0.018 accuracy: 0.893 test_loss：  0.032 test_accuracy: 0.853
epoch:  5 loss：  0.018 accuracy: 0.9 test_loss：  0.033 test_accuracy: 0.862
epoch:  6 loss：  0.015 accuracy: 0.906 test_loss：  0.034 test_accuracy: 0.88
epoch:  7 loss：  0.012 accuracy: 0.926 test_loss：  0.038 test_accuracy: 0.849
epoch:  8 loss：  0.015 accuracy: 0.918 test_loss：  0.034 test_accuracy: 0.893
epoch:  9 loss：  0.008 accuracy: 0.946 test_loss：  0.043 test_accuracy: 0.867

保存模型

state_dict就是一个简单的Python字典，它将模型中的可训练参数（比如weights和biases，batchnorm的running_mean、torch.optim参数等）通过将模型每层与层的参数张量之间一一映射，实现保存、更新、变化和再存储。

PATH = './my_net.pth'
torch.save(model.state_dict(), PATH)

恢复模型

new_model = Net()
new_model.load_state_dict(torch.load(PATH))

new_model.to(device)

Net(
  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))
  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
  (fc1): Linear(in_features=6400, out_features=1024, bias=True)
  (fc2): Linear(in_features=1024, out_features=256, bias=True)
  (fc3): Linear(in_features=256, out_features=4, bias=True)
)

test_correct = 0
test_total = 0
new_model.eval()
with torch.no_grad():
    for x, y in test_dl:
        if torch.cuda.is_available():
            x, y = x.to('cuda'), y.to('cuda')
        y_pred = new_model(x)
        y_pred = torch.argmax(y_pred, dim=1)
        test_correct += (y_pred == y).sum().item()
        test_total += y.size(0)
    
epoch_test_acc = test_correct / test_total
print(epoch_test_acc)

训练函数保存最优参数

model = Net()
if torch.cuda.is_available():
    model.to('cuda')
    
optim = torch.optim.Adam(model.parameters(), lr=0.001)

best_model_wts = copy.deepcopy(model.state_dict())
best_acc = 0.0

train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    epoch_loss, epoch_acc, epoch_test_loss, epoch_test_acc = fit(epoch,
                                                                 model,
                                                                 train_dl,
                                                                 test_dl)
    train_loss.append(epoch_loss)
    train_acc.append(epoch_acc)
    test_loss.append(epoch_test_loss)
    test_acc.append(epoch_test_acc)
    
    
    if epoch_test_acc > best_acc:
        best_acc = epoch_acc
        best_model_wts = copy.deepcopy(model.state_dict())        

model.load_state_dict(best_model_wts)
model.eval()

完整模型的保存和加载

PATH = './my_whole_model.pth'
torch.save(model, PATH)
new_model2 = torch.load(PATH)
new_model2.eval()
#Net(
#  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))
#  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))
#  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))
#  (fc1): Linear(in_features=6400, out_features=1024, bias=True)
#  (fc2): Linear(in_features=1024, out_features=256, bias=True)
#  (fc3): Linear(in_features=256, out_features=4, bias=True)
#)

跨设备的模型保存和加载

GPU保存，CPU加载

PATH = './my_gpu_model_wts'
torch.save(model.state_dict(), PATH)
device = torch.device('cpu')
model = Net()
model.load_state_dict(torch.load(PATH, map_location=device))

保存在GPU 上，在 GPU 上加载

PATH = './my_gpu_model2_wts'
torch.save(model.state_dict(), PATH)
device = torch.device("cuda")
model = Net()
model.load_state_dict(torch.load(PATH))
model.to(device)

保存 CPU 上，在 GPU 上加载

PATH = 'my_cpu_wts.pth'
torch.save(model.state_dict(), PATH)
device = torch.device("cuda")
model = Net()
model.load_state_dict(torch.load(PATH, map_location="cuda:0"))  # Choose whatever GPU device number you want
model.to(device)

PyTrch深度学习简明实战2 -逻辑回归
PyTrch深度学习简明实战1 - 线性回归
清华大学出版社-图书详情-《PyTorch深度学习简明实战》 (tsinghua.edu.cn)[http://w...
如何用Python和深度神经网络锁定即将流失的客户？
Python深度学习简明实战教程来了。别犹豫了，赶紧从零开始，搭建你自己的第一个深度学习模型吧！想不想了解如何用...
《深度学习 Caffe之经典模型详解与实战.pdf》PDF高清完
《深度学习 Caffe之经典模型详解与实战.pdf》PDF高清完整版-免费下载《深度学习 Caffe之经典模型详...
pytorch学习(十七)—模型的保存与加载
前言在深度学习中，模型的保存和加载很重要，当我们辛辛苦苦训练好的一个网络模型，自然需要将训练好的模型保存为文件。...
15-岭回归以及模型的保存与加载
岭回归模型的保存与加载 api：sklearn.externals.joblib保存：joblib.dump加载...
PyTorch模型保存深入理解
前面写过一篇PyTorch保存模型的文章：Pytorch模型保存与加载，并在加载的模型基础上继续训练，简单介绍了...
第八章 Keras高层接口
8.3 模型保存与加载在 Keras 中，有三种常用的模型保存与加载方法 8.3.1 张量方式网络的状态主要体...
Java调用TensorFlow库预测图片质量
概述本文参考官方的java使用TensorFlow库的例子，将深度学习模型保存成pb文件，在java环境中加载模...
深度学习小技巧（一）：如何保存和恢复TensorFlow训练的模
摘要：深度学习小技巧掌握：作者通过一个简单的例子详细介绍了如何将训练过程中的深度学习模型保存，然后如何加载。有了这...