一 简介

LSTM网络，即长短期记忆网络，是循环神经网络（RNN）的一种高级形式，擅长捕捉数据中的长期依赖关系。

二 实现

（1）数据集：

百度网盘链接：https://pan.baidu.com/s/1oHPLWcs3XnFqJnJfKcLStQ

提取码：clyz

（2）环境：pytorch、sklearn、pandas、matplotlib、numpy

（3）导入包：

import pandas as pd
from matplotlib import pyplot as plt # 结果可视化
from torch import nn
import time
import matplotlib.pyplot as plt
import numpy as np
from typing import Tuple
from sklearn.preprocessing import MinMaxScaler
import torch

（4）设置显示中文：

plt.rcParams['font.sans-serif'] = 'SimHei'
plt.rcParams['axes.unicode_minus'] = False

（5）定义网络：

class LSTM_Regression(nn.Module):
    """
        使用LSTM进行回归
        参数：
        - input_size: 输入维度
        - hidden_size: 隐藏层维度
        - output_size: 输出维度
        - num_layers: cell的层数
        - dropout: 遗忘率
        - learning_rate: 学习率
        - batch_size: 批大小
    """
 
    def __init__(self, input_size, hidden_size, output_size=1, num_layers=2, dropout=0.2, learning_rate=0.001, batch_size=32):
        super().__init__()
 
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers)  # LSTM层
        self.fc = nn.Linear(hidden_size, output_size)  # 全连接层
 
    def forward(self, _x):
        x, _ = self.lstm(_x)  # 输入数据和隐藏层输出
        s, b, h = x.shape  # 输入数据的形状
        x = x.view(s * b, h)  # 展开输入数据
        x = self.fc(x)  # 全连接层
        x = x.view(s, b, -1)  # 还原输入数据的形状
        return x

（6）定义数据集：

def create_dataset(data, days_for_train=5) -> Tuple[np.array, np.array]:
    """
        根据给定的序列data，生成数据集
        数据集分为输入和输出，每一个输入的长度为days_for_train，每一个输出的长度为1。
        也就是说用days_for_train天的数据，对应下一天的数据。
        若给定序列的长度为d，将输出长度为(d-days_for_train+1)个输入/输出对
    """
    dataset_x, dataset_y = [], []
    for i in range(len(data) - days_for_train):
        _x = data[i:(i + days_for_train)]
        dataset_x.append(_x)
        dataset_y.append(data[i + days_for_train])
    return (np.array(dataset_x), np.array(dataset_y))

（7）读取并查看数据：

 # 读取数据
    data = pd.read_csv('D:/myfile/myWorkSpace/参与的项目/备品备件-07.05/0708预处理/0718_datas/02/电力负荷.csv')

    # 转换为时间格式
    data['出库日期'] = pd.to_datetime(data['出库日期'])
    # print(data.head())
    df = data.rename(columns={'出库日期': 'ds', '数量和': 'y'})
    plt.plot(df['y'])
    plt.show()

（8）MinMaxScaler数据归一化

    # 创建一个MinMaxScaler实例
    scaler = MinMaxScaler()
    # 使用fit_transform方法来拟合数据并进行转换
    df_normalized = scaler.fit_transform(df['y'].values.reshape(-1, 1))

    plt.plot(df_normalized)
    plt.show()

（9）获取并打印数据集：

dataset_x, dataset_y = create_dataset(df_normalized, DAYS_FOR_TRAIN)
print(dataset_x.shape, dataset_y.shape)

（10）数据集准备：

        train_size = int(len(dataset_x) * 0.8)
    
        train_x = dataset_x[:train_size]
        train_y = dataset_y[:train_size]

        # 将数据改变形状，RNN 读入的数据维度是 (seq_size, batch_size, feature_size)
        train_x = train_x.reshape(-1, 1, DAYS_FOR_TRAIN)
        train_y = train_y.reshape(-1, 1, 1)

        # 转为pytorch的tensor对象
        train_x = torch.from_numpy(train_x).to(torch.float32) 
        train_y = torch.from_numpy(train_y).to(torch.float32) 

（11）使用模型：

model = LSTM_Regression(DAYS_FOR_TRAIN, 60, output_size=1, num_layers=2, dropout=0.2, learning_rate=0.001, batch_size=32) 

（12）开始训练：

        train_loss = []
        loss_function = nn.MSELoss()
        optimizer = torch.optim.Adam(model.parameters(), lr=1e-2, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)

        for i in range(200):
            out = model(train_x)
            loss = loss_function(out, train_y)
            loss.backward()
            optimizer.step()
            optimizer.zero_grad()
            train_loss.append(loss.item())

（13）绘制损失曲线：

        # loss曲线
        plt.figure()
        plt.plot(train_loss, 'b', label='loss')
        plt.title("Train_Loss_Curve")
        plt.ylabel('train_loss')
        plt.xlabel('epoch_num')
        plt.legend()
        plt.show()

（14）模型评估：

        model = model.eval()  # 转换成评估模式
        # 注意这里用的是全集 模型的输出长度会比原数据少DAYS_FOR_TRAIN 需要填充使长度相等
        dataset_x = dataset_x.reshape(-1, 1, DAYS_FOR_TRAIN)  
        dataset_x = torch.from_numpy(dataset_x).to(torch.float32)  # 转为pytorch的tensor对象
    
        pred_test = model(dataset_x)  # 全量训练集
        pred_test = pred_test.view(-1).data.numpy()
        pred_test = np.concatenate((np.zeros(DAYS_FOR_TRAIN), pred_test))  # 填充0 使长度相同

（15）逆变换预测结果：

# 逆变换预测结果
preds = scaler.inverse_transform(pred_test.reshape(-1, 1))
reals = scaler.inverse_transform(df_normalized.reshape(-1, 1))

（16）绘图（预测值-实际值）：

（17）计算准确率：

       # 计算准确率
        errors = abs(preds - reals)

        errors_01 = [e < t * 0.01 for e, t in zip(errors, reals)]
        errors_03 = [e < t * 0.03 for e, t in zip(errors, reals)]
        errors_05 = [e < t * 0.05 for e, t in zip(errors, reals)]
        errors_10 = [e < t * 0.10 for e, t in zip(errors, reals)]
        errors_15 = [e < t * 0.15 for e, t in zip(errors, reals)]

        count_01 = np.mean(errors_01)
        count_03 = np.mean(errors_03)
        count_05 = np.mean(errors_05)
        count_10 = np.mean(errors_10)
        count_15 = np.mean(errors_15)

        print("误差 1%: ", count_01)
        print("误差 3%: ", count_03)
        print("误差 5%: ", count_05)
        print("误差 10%: ", count_10)
        print("误差 15%: ", count_15)

三 小结

模型没有进行任何处理，直接预测的结果较好，如果想进一步提高模型的精度，需要进行参数调整：

• 隐藏状态维度（hidden size/dimension）：定义LSTMLSTM记忆细胞的容量。较大的隐藏尺寸可以捕获更复杂的信息，但也会增加计算成本和过拟合的风险。
• 层数（num_layers）：LSTM层的数量。增加层数可以学习更深层次的特征表示，但也可能带来梯度消失/爆炸问题，并增加训练时间和计算资源需求。
• 学习率（learning rate）：这是优化器在梯度下降过程中更新权重的步长。选择合适的学习率很关键，过高可能导致训练不稳定，过低则收敛速度慢。常见的初始学习率范围为10e-2至10e?4，并可能在训练过程中动态调整。
• 批量大小（batch size）：每次迭代时处理的数据样本数量。较大的批量可以加速计算，但可能会导致泛化能力降低和内存需求增加。较小的批量提供了更好的泛化能力，但训练速度较慢。
• 激活函数：虽然不是直接的超参数，但选择不同的激活函数（如tanh、ReLU或softsign）会影响模型的训练动态和性能。
• 优化器（optimizer）：如Adam、RMSprop、SGD等，不同的优化器有不同的更新规则，影响学习效率和最终性能。
• dropout比例：在训练过程中随机“丢弃”一部分神经元以减少过拟合，常见的dropout比例为0.2至0.5。
• 序列长度（sequence length）：对于时间序列数据，决定输入序列的长度，可能影响模型理解和捕捉长期依赖的能力。