【用pytorch进行LSTM模型的学习】

LSTM模型

LSTM模型长下面这样，主要用在时间序列的预测，具有比RNN较好的性能。原因在于内部增加了很多门，用来控制前序信息的继续、遗忘、更新等，比RNN更好的表达了特征。

用pytorch，采用LSTM对seaborn数据集做预测

基本步骤

一般而言，进行深度学习的训练与应用包含大概如下步骤

=========工作流程=========
 - 数据读取与基本处理
    * 数据集读取
    * 数据的观察-画图
    * 特殊数据处理-空值、奇异值等
 - 数据集构建
    * 归一化
    * 训练集、验证集、测试集划分    
 - 模型建模
    * 基础模型架构
    * 损失函数
    * 优化器选择
 - 模型训练
    * 模型训练 与各种超参
    * 训练过程观察 
    * 训练中模型保存
    * 模型训练指标记录
 - 测试验证
    * 模型性能验证
    * 结果可视化
    * 测试性能指标记录

下面就流程中的几个重点进行说明

数据的观察

在拿到数据的时候，我们首先要对数据进行观察，观察的方法根据数据的类型略有不同，但是总体可以概括为

• 肉眼观察：打开数据文件夹或者文件进行查看，比如文件个数有多少个，数据的大小是多少。
• 数据展示观察：对于一些不好直接观察的，可以通过数据展示看一下，如打印dataframe结构的前几行，可以看到列名等信息，方便数据处理。
• 画图观察：对于一些时序信息，可以通过作图的方式，看看数据的分布情况，是否有异常点等等。

为什么要对数据进行观察？主要有以下几个原因

• 获取数据的基本信息，知道我们要处理的数据大概是怎样的。
• 对原始数据有个感觉，数据的情况可能会影响我们模型的选择。以及模型训练的策略。比如小样本数据，样本数的多少会影响下一步的决策，如是否数据增强，是否迁移等等。
• 观察到异常情况，如空值，奇异点，为下一步数据处理做准备。

特殊数据处理

机器学习处理的是数据的一般情况，即反映数据的一般规律和一般分布，对于奇异值或者特殊值，机器学习模型没有能力处理或者需要付出很大的代价才能处理。机器学习是帮助我们解决一般问题或者共性问题，对于一些特殊的问题，并不是这个学科的主要研究方向。当然，只有一个方向除外，即异常检测。
一般需要特殊处理的，有空值、错误值、奇异值。基本的处理方式有

• 删除，即删除特殊值
• 补全，补全空值
• 修正，更改错误值

数据归一化

在一般情况下，尤其是时序数据，需要进行归一化，即把数据压缩到0-1之间。目的是使得数据有相同的尺度。例如，在一个数据集中，包含样本的年龄信息，收入信息等，这两个信息的度量尺度是不同的，如果不做归一化，那么由于年龄与收入在数值上相差很大，那么年龄的特征不能在模型中发挥很好的作用。

模型的构建与选择

针对不同的任务选择不同的模型，有pytorch内置了很多基础模型，因此模型结构的构建变得简单容易，需要注意的是模型的输入参数要求以及维度匹配，这就需要我们学习pytorch内置模型的接口函数，做一个合格的调包侠

模型的保存

在训练过程中，模型是不断更新的，每一次迭代后模型的参数就会不同。在这个过程中有必要有条件地保存下当前模型，主要有如下几个用途

• 防止训练突然崩掉，重新训练浪费资源。在较长时间的训练过程中，由于种种原因，训练可能会崩溃，如突然掉电，机器故障灯，如果没有保存训练过程中的模型，则需要重新训练，那么浪费时间，浪费资源，尤其是接近训练完成的时候发生崩溃，人就更崩溃了。如果保存了模型，那么可以重新加载模型，断点续训练。
• 根据过程中保存下来的模型，我们可以查看模型演变过程，进行过程的考察。
• 测试验证用，保存模型，尤其是保存最后的或者最好的模型，在测试验证时，可以直接加载进行验证，不必再次训练

那么模型该如何保存呢？ 模型保存的格式：pytorch中最常见的模型保存使用 .pt 或者是 .pth 作为模型文件扩展名。

pytorch模型保存的两种方式：

• 一种是保存整个模型，

torch.save(model, "my_model.pth") # 保存整个模型` 

• 另一种是只保存模型的参数，该方法速度快，占用空间少

torch.save(model.state_dict(), "my_model.pth") # 只保存模型的参数

相应的，加载也有两种方式

• 加载整个模型

new_model = torch.load(PATH) 

• 先构架模型架构，然后加载参数

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

飞机航班流量预测示例

完整代码如下

# -*- coding: utf-8 -*-
# @Time    : 2023/03/10 10:23
# @Author  : HelloWorld！
# @FileName: seq.py
# @Software: PyCharm
# @Operating System: Windows 10
# @Python.version: 3.8

import torch
import torch.nn as nn
import argparse
import seaborn as sns
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import math


# 数据读取与基本处理
class LoadData:
    def __init__(self,data_path ):
        self.ori_data = pd.read_csv(data_path)
    def data_observe(self):
        self.ori_data.head()
        self.draw_data(self.ori_data)
    def draw_data(self, data):
        print(data.head())
        fig_size = plt.rcParams["figure.figsize"]
        fig_size[0] = 15
        fig_size[1] = 5
        plt.rcParams["figure.figsize"] = fig_size
        plt.title('Month vs Passenger')
        plt.ylabel('Total Passengers')
        plt.xlabel('Months')
        plt.grid(True)
        plt.autoscale(axis='x', tight=True)
        plt.plot(data['passengers'])
        plt.show()
    #数据预处理，归一化
    def data_process(self):
        flight_data = self.ori_data.drop(['year'], axis=1)  # 删除不需要的列
        flight_data = flight_data.drop(['month'], axis=1)  # 删删除不需要的列

        flight_data = flight_data.dropna()  # 滤除缺失数据
        dataset = flight_data.values  # 获得csv的值
        dataset = dataset.astype('float32')
        dataset=self.data_normalization(dataset)
        return dataset

    def data_normalization(self,x):
        '''
        数据归一化（0,1）
        :param x:
        :return:
        '''
        max_value = np.max(x)
        min_value = np.min(x)
        scale = max_value - min_value
        y = (x - min_value) / scale
        return y

#构建数据集，训练集、测试集
class CreateDataSet:
    def __init__(self, dataset,look_back=2):
        dataset = np.asarray(dataset)
        data_inputs, data_target = [], []
        for i in range(len(dataset) - look_back):
            a = dataset[i:(i + look_back)]
            data_inputs.append(a)
            data_target.append(dataset[i + look_back])
        self.data_inputs = np.array(data_inputs).reshape((-1, look_back))
        self.data_target = np.array(data_target).reshape((-1, 1))

    def split_train_test_data(self, rate=0.7):
        # 划分训练集和测试集，70% 作为训练集
        train_size = math.ceil(len(self.data_inputs) * rate)  #math.ceil()向上取整
        train_inputs = self.data_inputs[:train_size]
        train_target = self.data_target[:train_size]
        test_inputs = self.data_inputs[train_size:]
        test_target = self.data_target[train_size:]
        return train_inputs, train_target, test_inputs, test_target
# 构建模型
class LSTMModel(nn.Module):
    ''' 定义LSTM模型，由于pytorch已经集成LSTM，直接用即可'''
    def __init__(self, input_size, hidden_size=4, num_layers=2, output_dim=1):
        '''

        :param input_size:  输入数据的特征维数，通常就是embedding_dim(词向量的维度)
        :param hidden_size: LSTM中隐层的维度
        :param num_layers: 循环神经网络的层数
        :param output_dim:
        '''
        super(LSTMModel,self).__init__()
        self.lstm_layer=nn.LSTM(input_size=input_size,hidden_size=hidden_size,num_layers=num_layers)
        self.linear_layer=nn.Linear(hidden_size,output_dim)
    def forward(self,x):
        x,_=self.lstm_layer(x)
        s, b, h = x.shape
        x = x.view(s * b, h)  # 转换成线性层的输入格式
        x=self.linear_layer(x)
        x= x.view(s, b, -1)
        return x
#模型训练
class Trainer:
    def __init__(self,args):
        self.num_epoch =args.num_epoch
        self. look_back=args.look_back
        self.batch_size=args.batch_size
        self.save_modelpath=args.save_modelpath #保存模型的位置
        load_data = LoadData(args.filepath)  # 加载数据
        self.dataset = load_data.data_process()  # 数据预处理
        dataset = CreateDataSet(self.dataset , look_back=args.look_back)  # 数据集开始构建

        self.train_inputs,  self.train_target,  self.test_inputs,  self.test_target = dataset.split_train_test_data()  # 拆分数据集为训练集、测试集
        self.data_inputs = dataset.data_inputs
        #改变下输入形状
        self.train_inputs = self.train_inputs.reshape(-1, self.batch_size, self.look_back)
        self.train_target = self.train_target.reshape(-1, self.batch_size, 1)
        self.test_inputs = self.test_inputs.reshape(-1, self.batch_size, self.look_back)
        self.data_inputs = self.data_inputs.reshape(-1, self.batch_size, self.look_back)

        self.model=self.build_model()
        self.loss =nn.MSELoss()
        self.optimizer=torch.optim.Adam(self.model.parameters(), lr=1e-2)
    def build_model(self):
        model=LSTMModel(input_size=self.look_back)
        return  model

#训练过程
    def train(self):
        #把数据转成torch形式的
        inputs= torch.from_numpy(self.train_inputs)
        target=torch.from_numpy(self.train_target)
        self.model.train() #训练模式
        #开始训练
        for epoch in range(self.num_epoch):
            #前向传播
            out=self.model(inputs)
            #计算损失
            loss=self.loss(out,target)
            #反向传播
            self.optimizer.zero_grad()  #梯度清零
            loss.backward()  #反向传播
            self.optimizer.step() #更新权重参数
            if epoch % 100 == 0:  # 每 100 次输出结果
                print('Epoch: {}, Loss: {:.5f}'.format(epoch, loss.item()))
                torch.save(self.model,self.save_modelpath+'/model'+str(epoch)+'.pth')
        torch.save(self.model, self.save_modelpath + '/model_last' +  '.pth')
        self.test()
    def test(self,load_model=False):

        if not load_model:
            self.model.eval()  # 转换成测试模式
            inputs = torch.from_numpy(self.data_inputs)
            # inputs = torch.from_numpy(self.test_inputs)
            output = self.model(inputs)  # 测试集的预测结果
        else:
            model=torch.load(self.save_modelpath+ '/model_last' +  '.pth')
            inputs = torch.from_numpy(self.data_inputs)
            # inputs = torch.from_numpy(self.test_inputs)
            output =model(inputs)  # 测试集的预测结果
        # 改变输出的格式
        output = output.view(-1).data.numpy() #把tensor摊平
        # 画出实际结果和预测的结果
        plt.plot(output, 'r', label='prediction')
        plt.plot(self.dataset, 'g', label='real')
        # plt.plot(self.dataset[1:], 'b', label='real')
        plt.legend(loc='best')
        plt.show()

if __name__ == '__main__':
    filepath ='seaborn-data-master/flights.csv'
    save_modelpath='model-path'
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--num_epoch',type=int, default=1000, help='训练的轮数' )
    parser.add_argument('--filepath',type=str, default=filepath, help='数据文件')
    parser.add_argument('--look_back', type=int, default=2, help='根据前几个数据预测')
    parser.add_argument('--batch_size', type=int, default=2, help='batch size')
    parser.add_argument('--save_modelpath',type=str, default=save_modelpath, help='训练中模型要保存的位置')

    args=parser.parse_args()

    train=Trainer(args)
    train.train()
    train.test(load_model=True)

结果如下