基于LSTM模型的时间序列预测：代码详解与优化

import numpy as np
from keras.layers.core import Dense, Activation, Dropout
from keras.layers import LSTM
from keras.models import Sequential, load_model
from keras.callbacks import Callback
import keras.backend as KTF
import tensorflow as tf
import pandas as pd
import os
import keras.callbacks
import matplotlib.pyplot as plt

# 设定为自增长
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.compat.v1.Session(config=config)
KTF.tf.compat.v1.keras.backend.set_session(session)


def create_dataset(data, n_predictions, n_next):
    '''
    对数据进行处理
    '''
    dim = data.shape[1]
    train_X, train_Y = [], []
    for i in range(data.shape[0] - n_predictions - n_next - 1):
        a = data[i:(i + n_predictions), :]
        train_X.append(a)
        tempb = data[(i + n_predictions):(i + n_predictions + n_next), :]
        b = []
        for j in range(len(tempb)):
            for k in range(dim):
                b.append(tempb[j, k])
        train_Y.append(b)
    train_X = np.array(train_X, dtype='float64')
    train_Y = np.array(train_Y, dtype='float64')

    test_X, test_Y = [], []
    i = data.shape[0] - n_predictions - n_next - 1
    a = data[i:(i + n_predictions), :]
    test_X.append(a)
    tempb = data[(i + n_predictions):(i + n_predictions + n_next), :]
    b = []
    for j in range(len(tempb)):
        for k in range(dim):
            b.append(tempb[j, k])
    test_Y.append(b)
    test_X = np.array(test_X, dtype='float64')
    test_Y = np.array(test_Y, dtype='float64')

    return train_X, train_Y, test_X, test_Y


def NormalizeMult(data, set_range):
    '''
    返回归一化后的数据和最大最小值
    '''
    normalize = np.arange(2 * data.shape[1], dtype='float64')
    normalize = normalize.reshape(data.shape[1], 2)

    for i in range(0, data.shape[1]):
        if set_range == True:
            list = data[:, i]
            listlow, listhigh = np.percentile(list, [0, 100])
        else:
            if i == 0:
                listlow = -90
                listhigh = 90
            else:
                listlow = -180
                listhigh = 180

        normalize[i, 0] = listlow
        normalize[i, 1] = listhigh

        delta = listhigh - listlow
        if delta != 0:
            for j in range(0, data.shape[0]):
                data[j, i] = (data[j, i] - listlow) / delta

    return data, normalize


def trainModel(train_X, train_Y):
    '''
    trainX，trainY: 训练LSTM模型所需要的数据
    '''
    model = Sequential()
    model.add(LSTM(
        120,
        input_shape=(train_X.shape[1], train_X.shape[2]),
        return_sequences=True))
    model.add(Dropout(0.3))

    model.add(LSTM(
        120,
        return_sequences=False))
    model.add(Dropout(0.3))

    model.add(Dense(
        train_Y.shape[1]))
    model.add(Activation('relu'))

    model.compile(loss='mse', optimizer='adam', metrics=['acc'])
    model.fit(train_X, train_Y, epochs=100, batch_size=64, verbose=1)
    model.summary()

    return model


if __name__ == '__main__':
    train_num = 6
    per_num = 1
    # set_range = False
    set_range = True

    # 读入时间序列的文件数据
    data = pd.read_csv('11112_testData.csv', sep=',').iloc[0:, 1:5].values
    # data = pd.read_csv('11112_testData.csv', sep=',').values
    print(data)
    print('样本数：{0}，维度：{1}'.format(data.shape[0], data.shape[1]))
    print(data)

    # 画样本数据库
    plt.plot(data[:, 1], data[:, 0], c='r', label='result of recognition')
    plt.legend(loc='upper left')
    plt.grid()
    plt.show()

    # 归一化
    data, normalize = NormalizeMult(data, set_range)
    # print(normalize)

    # 生成训练数据
    train_X, train_Y, test_X, test_Y = create_dataset(data, train_num, per_num)
    print('x\n', train_X.shape)
    print('y\n', train_Y.shape)

    # 训练模型
    model = trainModel(train_X, train_Y)
    loss, acc = model.evaluate(train_X, train_Y, verbose=2)
    print('Loss : {}, Accuracy: {}'.format(loss, acc * 100))

    # 保存模型
    np.save('traj_model_trueNorm_LSTM.npy', normalize)
    model.save('./traj_model_120_LSTM.h5')

代码详解

1. 数据预处理

   • create_dataset(data, n_predictions, n_next) 函数用于生成训练数据和测试数据。它根据提供的参数n_predictions和n_next来划分数据。n_predictions表示使用多少个时间步长的数据预测下一个时间步长的数据，n_next表示预测多少个时间步长的数据。
   • NormalizeMult(data, set_range) 函数对数据进行归一化处理，将数据映射到[0, 1]之间。

2. 模型训练

   • trainModel(train_X, train_Y) 函数构建并训练LSTM模型。该模型包含两个LSTM层，两个Dropout层，一个Dense层和一个ReLU激活层。模型使用均方误差作为损失函数，Adam优化器进行优化。

3. 模型评估

   • 使用model.evaluate()函数对训练好的模型进行评估，并输出损失值和准确率。

4. 模型保存

   • 使用np.save()函数保存归一化参数，方便后续对新数据进行归一化处理。
   • 使用model.save()函数保存训练好的模型。

代码优化

1. 代码注释: 添加代码注释，方便理解代码逻辑。
2. 变量命名: 使用更具描述性的变量名称，提高代码可读性。
3. 格式化输出: 使用格式化字符串输出结果，提高可读性。
4. 数据可视化: 使用matplotlib库对原始数据进行可视化，方便直观地理解数据。

搜索引擎优化

1. 标题: 使用更具描述性的标题，例如“基于LSTM模型的时间序列预测：代码详解与优化”，并包含关键词“时间序列预测”，'LSTM'等。
2. 描述: 在代码中添加注释，解释代码的功能，并使用关键词“时间序列预测”，'LSTM'，'深度学习'等，方便搜索引擎理解代码内容。
3. 关键词: 在json格式的输出中添加关键词，例如“时间序列预测”，'LSTM'，'深度学习'，'Python'等。

通过对代码进行优化和搜索引擎优化，可以提高代码的可读性和可理解性，并方便搜索引擎收录代码，提高代码的搜索排名。