Pytorch进行分类任务总结

作为Pytorch初学者，利用MNIST数据集作为基本数据集，使用Pytorch进行搭建模型训练，本文档目的在记录Pytorch进行深度学习系统搭建流程，使用时能随时查阅。


文章目录

  • Pytorch进行分类任务总结
  • 1. 数据获取
  • 2.模型定义
  • 3.损失函数和优化器设置
  • 4.模型训练，验证
  • 5.acc和loss可视化
  • 6.保存模型
  • 7.模型和参数查看
  • 8.参考


1. 数据获取

导入必要的库

import numpy as np
import torch
from torchvision.datasets import mnist # 导入 pytorch 内置的 mnist 数据

from torch import nn
from torch.autograd import Variable
def data_tf(x):
    x = np.array(x, dtype='float32') / 255
    x = (x - 0.5) / 0.5 # 标准化处理
    x = x.reshape((-1,)) # 拉平
    x = torch.from_numpy(x)
    return x

train_set = mnist.MNIST('data/mnist', train=True, transform=data_tf, download=False) # 载入数据集，申明定义的数据变换
test_set = mnist.MNIST('data/mnist', train=False, transform=data_tf, download=False)

可以先将MNIST数据集下载到本地，直接导入数据即可，本文建立的是全连接网络，因此输入图像数据需要实用reshape拉成一个一维向量。

数据量太大时，使用数据迭代器，每次生成一个批次的数据。

from torch.utils.data import DataLoader
# 使用 pytorch 自带的 DataLoader 定义一个数据迭代器
train_data = DataLoader(train_set, batch_size=64, shuffle=True)
test_data = DataLoader(test_set, batch_size=128, shuffle=False)

获取一个批次的数据命令：

data, data_label = next(iter(train_data))

2.模型定义

Pytorch 中支持两种方式构建模型：Sequential和Module

使用Sequential建立模型

# 使用 Sequential 定义 4 层神经网络
net = nn.Sequential(
    nn.Linear(784, 400),
    nn.ReLU(),
    nn.Linear(400, 200),
    nn.ReLU(),
    nn.Linear(200, 100),
    nn.ReLU(),
    nn.Linear(100, 10)
)
#查看网络结构
print(net)

3.损失函数和优化器设置

定义损失函数：

Pytorch中提供了一些常用的损失函数

criterion = nn.CrossEntropyLoss()

定义优化器：

optimizer = torch.optim.SGD(net.parameters(), 1e-1) # 使用随机梯度下降，学习率 0.1

4.模型训练，验证

开始模型训练

# 开始训练
losses = [] #记录训练误差，用于作图分析
acces = []
eval_losses = []
eval_acces = []

for e in range(20):
    train_loss = 0
    train_acc = 0
    net.train()
    for im, label in train_data:
        im = Variable(im)
        label = Variable(label)
        # 前向传播
        out = net(im)
        loss = criterion(out, label)
        # 反向传播
        ## 梯度清零
        optimizer.zero_grad()
        ## 梯度反向传播
        loss.backward()
        ## 参数更新
        optimizer.step()
        # 记录误差
        train_loss += float(loss)
        # 计算分类的准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum()
        acc = int(num_correct) / im.shape[0]
        train_acc += acc
        
    losses.append(train_loss / len(train_data))
    acces.append(train_acc / len(train_data))
    
    # 在测试集上检验效果
    eval_loss = 0
    eval_acc = 0
    net.eval（) # 将模型改为预测模式
    for im, label in test_data:
        im = Variable(im)
        label = Variable(label)
        out = net(im)
        loss = criterion(out, label)
        # 记录误差
        eval_loss += float(loss)
        # 记录准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum()
        acc = int(num_correct) / im.shape[0]
        eval_acc += acc
        
    eval_losses.append(eval_loss / len(test_data))
    eval_acces.append(eval_acc / len(test_data))
    print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'
          .format(e, train_loss / len(train_data), train_acc / len(train_data), 
                     eval_loss / len(test_data), eval_acc / len(test_data)))

5.acc和loss可视化

上述模型训练完成后，可将保持的loss和accy通过作图直观的显示出来，如下是单独显示，也可以放在一张图上显示；

import matplotlib.pyplot as plt
%matplotlib inline
plt.title('train loss')
plt.plot(np.arange(len(losses)), losses)
plt.plot(np.arange(len(acces)), acces)
plt.title('train acc')

6.保存模型

Pytorch 保存模型提供两种方式：一，将模型和参数都保存在一起，二，只将参数保存下来。

  1. 将模型和参数保存在一起
# 将参数和模型保存在一起
torch.save(net, 'save_net.pth')

加载刚刚保存的模型和参数：

# 读取保存的模型
seq_net1 = torch.load('save_net.pth')
  1. 保存模型参数
# 保存模型参数
torch.save(net.state_dict(), 'save_net_params.pth')

加载模型参数，注意：加载模型参数之前需要重新定义一次模型：

net2.load_state_dict(torch.load('save_net_params.pth')) #net2为新定义的模型

7.模型和参数查看

查看模型的每一层：

#方法一
print(net)
#方法二
for layer in net:
    print(layer)

查看模型的参数：

#查看第1层的weight
net[0].weight
#查看第1层的bias
net[0].bias

8.参考

  1. https://pytorch-cn.readthedocs.io/zh/latest/#pytorch
  2. https://github.com/L1aoXingyu/pytorch-beginner

如有问题，请指正，谢谢！