时间序列预测——双向LSTM(Bi-LSTM)

置顶 已于 2022-03-19 14:19:13 修改
阅读量2.2w 收藏 373
点赞数 35
分类专栏： 人工智能 文章标签： 神经网络 人工智能 python lstm 深度学习
于 2021-04-12 16:07:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a321123b/article/details/115626329
版权
本文详细介绍了如何运用双向LSTM进行时间序列预测，涵盖了数据预处理、Bi-LSTM模型构建、训练、预测及误差评估的全部步骤。通过实例展示了数据的导入、清洗、转换以及动态学习率和早停策略的设置。
摘要由CSDN通过智能技术生成

  本文展示了使用双向LSTM(Bi-LSTM)进行时间序列预测的全过程，包含详细的注释。整个过程主要包括：数据导入、数据清洗、结构转化、建立Bi-LSTM模型、训练模型（包括动态调整学习率和earlystopping的设置）、预测、结果展示、误差评估等完整的时间序列预测流程。
  本文使用的数据集在本人上传的资源中，链接为mock_kaggle.csv

代码如下：

import pandas as pd
import numpy as np
import math
import keras
from matplotlib import pyplot as plt
from matplotlib.pylab import mpl
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from keras import backend as K
from keras.layers import LeakyReLU
from sklearn.metrics import mean_squared_error # 均方误差
from keras.callbacks import LearningRateScheduler
from keras.callbacks import EarlyStopping
from tensorflow.keras import Input, Model,Sequential
from keras.layers import Bidirectional#, Concatenate

mpl.rcParams['font.sans-serif'] = ['SimHei']   #显示中文
mpl.rcParams['axes.unicode_minus']=False       #显示负号

取数据

data=pd.read_csv('mock_kaggle.csv',encoding ='gbk',parse_dates=['datetime'])
Date=pd.to_datetime(data.datetime)
data['date'] = Date.map(lambda x: x.strftime('%Y-%m-%d'))
datanew=data.set_index(Date)
series = pd.Series(datanew['股票'].values, index=datanew['date'])

series

date
2014-01-01    4972
2014-01-02    4902
2014-01-03    4843
2014-01-04    4750
2014-01-05    4654
              ... 
2016-07-27    3179
2016-07-28    3071
2016-07-29    4095
2016-07-30    3825
2016-07-31    3642
Length: 937, dtype: int64

滞后扩充数据

dataframe1 = pd.DataFrame()
num_hour = 16
for i in range(num_hour,0,-1):
    dataframe1['t-'+str(i)] = series.shift(i)
dataframe1['t'] = series.values
dataframe3=dataframe1.dropna()
dataframe3.index=range(len(dataframe3))

dataframe3
t-16t-15t-14t-13t-12t-11t-10t-9t-8t-7t-6t-5t-4t-3t-2t-1t
04972.04902.04843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464
14902.04843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265
24843.04750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161
34750.04654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161.04091
44654.04509.04329.04104.04459.05043.05239.05118.04984.04904.04822.04728.04464.04265.04161.04091.03964
......................................................
9161939.01967.01670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179
9171967.01670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071
9181670.01532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095
9191532.01343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095.03825
9201343.01022.0813.01420.01359.01075.01015.0917.01550.01420.01358.02893.03179.03071.04095.03825.03642

921 rows × 17 columns

二折划分数据并标准化

pd.DataFrame(np.random.shuffle(dataframe3.values))  #shuffle
pot=len(dataframe3)-12
train=dataframe3[:pot]
test=dataframe3[pot:]
scaler = MinMaxScaler(feature_range=(0, 1)).fit(train)
#scaler = preprocessing.StandardScaler().fit(train)
train_norm=pd.DataFrame(scaler.fit_transform(train))
test_norm=pd.DataFrame(scaler.transform(test))

test_norm.shape,train_norm.shape

((12, 17), (909, 17))

X_train=train_norm.iloc[:,:-1]
X_test=test_norm.iloc[:,:-1]
Y_train=train_norm.iloc[:,-1:]
Y_test=test_norm.iloc[:,-1:]

转换为3维数据 [samples, timesteps, features]

source_x_train=X_train
source_x_test=X_test
X_train=X_train.values.reshape([X_train.shape[0],2,8]) #从(909, 16)-->(909, 2，8)
X_test=X_test.values.reshape([X_test.shape[0],2,8])  #从(12, 16)-->(12, 2,8)
Y_train=Y_train.values
Y_test=Y_test.values

X_train.shape,Y_train.shape

((909, 2, 8), (909, 1))

X_test.shape,Y_test.shape

((12, 2, 8), (12, 1))

动态调整学习率与提前终止函数

def scheduler(epoch):
    # 每隔50个epoch，学习率减小为原来的1/10
    if epoch % 50 == 0 and epoch != 0:
        lr = K.get_value(bilstm.optimizer.lr)
        if lr>1e-5:
            K.set_value(bilstm.optimizer.lr, lr * 0.1)
            print("lr changed to {}".format(lr * 0.1))
    return K.get_value(bilstm.optimizer.lr)

reduce_lr = LearningRateScheduler(scheduler)
early_stopping = EarlyStopping(monitor='loss', 
                               patience=20, 
                               min_delta=1e-5,
                               mode='auto',
                               restore_best_weights=False,#是否从具有监测数量的最佳值的时期恢复模型权重
                               verbose=2)

构造Bi-LSTM模型

# 特征数
input_size = X_train.shape[2]
# 时间步长：用多少个时间步的数据来预测下一个时刻的值
time_steps = X_train.shape[1]
# 隐藏层block的个数
cell_size = 128
batch_size=24

bilstm = keras.Sequential()
bilstm.add(Bidirectional(keras.layers.LSTM(
        units = cell_size, # 输出维度
        batch_input_shape=(batch_size, time_steps, input_size),# 输入维度
        stateful=False, #保持状态
        ), merge_mode='concat'))
bilstm.add(keras.layers.Dense(64))
bilstm.add(keras.layers.LeakyReLU(alpha=0.3))
bilstm.add(keras.layers.Dense(32))
bilstm.add(keras.layers.LeakyReLU(alpha=0.3))
bilstm.add(keras.layers.Dense(16))
bilstm.add(keras.layers.LeakyReLU(alpha=0.3))
# 输出层
bilstm.add(keras.layers.Dense(1))
bilstm.add(keras.layers.LeakyReLU(alpha=0.3))
# 定义优化器
nadam = keras.optimizers.Nadam(lr=1e-3)
bilstm.compile(optimizer=nadam, loss='mse', metrics=['accuracy'])

训练

history=bilstm.fit(X_train,Y_train, epochs=80,batch_size=32,callbacks=[reduce_lr])

Epoch 1/80
909/909 [==============================] - 3s 3ms/step - loss: 0.0200 - accuracy: 0.0187
Epoch 2/80
909/909 [==============================] - 1s 594us/step - loss: 0.0071 - accuracy: 0.0187
Epoch 3/80
909/909 [==============================] - 1s 611us/step - loss: 0.0057 - accuracy: 0.0187
Epoch 4/80
909/909 [==============================] - 1s 781us/step - loss: 0.0038 - accuracy: 0.0187
Epoch 5/80
909/909 [==============================] - 1s 719us/step - loss: 0.0037 - accuracy: 0.0187
Epoch 6/80
909/909 [==============================] - 1s 741us/step - loss: 0.0035 - accuracy: 0.0187
Epoch 7/80
909/909 [==============================] - 1s 576us/step - loss: 0.0040 - accuracy: 0.0187
Epoch 8/80
909/909 [==============================] - 1s 686us/step - loss: 0.0033 - accuracy: 0.01870s - loss: 0.0033 - accuracy: 0.01
Epoch 9/80
909/909 [==============================] - 1s 727us/step - loss: 0.0032 - accuracy: 0.0187
Epoch 10/80
909/909 [==============================] - 1s 652us/step - loss: 0.0030 - accuracy: 0.0187
Epoch 11/80
909/909 [==============================] - 1s 610us/step - loss: 0.0033 - accuracy: 0.0187
Epoch 12/80
909/909 [==============================] - 1s 573us/step - loss: 0.0031 - accuracy: 0.0187
Epoch 13/80
909/909 [==============================] - 1s 666us/step - loss: 0.0029 - accuracy: 0.0187
Epoch 14/80
909/909 [==============================] - 1s 552us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 15/80
909/909 [==============================] - 1s 718us/step - loss: 0.0030 - accuracy: 0.0187
Epoch 16/80
909/909 [==============================] - 1s 601us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 17/80
909/909 [==============================] - 0s 541us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 18/80
909/909 [==============================] - 1s 657us/step - loss: 0.0027 - accuracy: 0.0187
Epoch 19/80
909/909 [==============================] - 1s 680us/step - loss: 0.0027 - accuracy: 0.0187
Epoch 20/80
909/909 [==============================] - 1s 703us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 21/80
909/909 [==============================] - 1s 602us/step - loss: 0.0030 - accuracy: 0.0187
Epoch 22/80
909/909 [==============================] - 1s 622us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 23/80
909/909 [==============================] - 1s 700us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 24/80
909/909 [==============================] - 1s 613us/step - loss: 0.0025 - accuracy: 0.0187
Epoch 25/80
909/909 [==============================] - 1s 569us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 26/80
909/909 [==============================] - 0s 525us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 27/80
909/909 [==============================] - 0s 487us/step - loss: 0.0028 - accuracy: 0.0187
Epoch 28/80
909/909 [==============================] - 0s 493us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 29/80
909/909 [==============================] - 0s 494us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 30/80
909/909 [==============================] - 0s 490us/step - loss: 0.0027 - accuracy: 0.0187
Epoch 31/80
909/909 [==============================] - 0s 519us/step - loss: 0.0026 - accuracy: 0.01870s - loss: 0.0026 - accuracy: 0.
Epoch 32/80
909/909 [==============================] - 0s 494us/step - loss: 0.0027 - accuracy: 0.0187
Epoch 33/80
909/909 [==============================] - 0s 493us/step - loss: 0.0025 - accuracy: 0.0187
Epoch 34/80
909/909 [==============================] - 0s 500us/step - loss: 0.0025 - accuracy: 0.0187
Epoch 35/80
909/909 [==============================] - 0s 505us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 36/80
909/909 [==============================] - 1s 595us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 37/80
909/909 [==============================] - 1s 578us/step - loss: 0.0027 - accuracy: 0.01870s - loss: 0.0025 - accuracy: 
Epoch 38/80
909/909 [==============================] - 0s 518us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 39/80
909/909 [==============================] - 0s 525us/step - loss: 0.0024 - accuracy: 0.0187
Epoch 40/80
909/909 [==============================] - 0s 501us/step - loss: 0.0024 - accuracy: 0.0187
Epoch 41/80
909/909 [==============================] - 0s 500us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 42/80
909/909 [==============================] - 0s 529us/step - loss: 0.0023 - accuracy: 0.0187
Epoch 43/80
909/909 [==============================] - 1s 616us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 44/80
909/909 [==============================] - 1s 596us/step - loss: 0.0027 - accuracy: 0.0187
Epoch 45/80
909/909 [==============================] - 1s 582us/step - loss: 0.0024 - accuracy: 0.0187: 0s - loss: 0.0012 - accu
Epoch 46/80
909/909 [==============================] - 0s 508us/step - loss: 0.0025 - accuracy: 0.0187
Epoch 47/80
909/909 [==============================] - 1s 574us/step - loss: 0.0025 - accuracy: 0.0187
Epoch 48/80
909/909 [==============================] - 1s 724us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 49/80
909/909 [==============================] - 1s 696us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 50/80
909/909 [==============================] - 1s 667us/step - loss: 0.0026 - accuracy: 0.0187
Epoch 51/80
lr changed to 0.00010000000474974513
909/909 [==============================] - 1s 653us/step - loss: 0.0023 - accuracy: 0.0187
Epoch 52/80
909/909 [==============================] - 1s 703us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 53/80
909/909 [==============================] - 1s 616us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 54/80
909/909 [==============================] - 1s 650us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 55/80
909/909 [==============================] - 1s 648us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 56/80
909/909 [==============================] - 1s 661us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 57/80
909/909 [==============================] - 1s 718us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 58/80
909/909 [==============================] - 1s 687us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 59/80
909/909 [==============================] - 1s 628us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 60/80
909/909 [==============================] - 1s 725us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 61/80
909/909 [==============================] - 1s 697us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 62/80
909/909 [==============================] - 1s 768us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 63/80
909/909 [==============================] - 1s 834us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 64/80
909/909 [==============================] - 1s 755us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 65/80
909/909 [==============================] - 1s 666us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 66/80
909/909 [==============================] - 1s 561us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 67/80
909/909 [==============================] - 1s 565us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 68/80
909/909 [==============================] - 1s 565us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 69/80
909/909 [==============================] - 1s 558us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 70/80
909/909 [==============================] - 0s 542us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 71/80
909/909 [==============================] - 0s 545us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 72/80
909/909 [==============================] - 1s 612us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 73/80
909/909 [==============================] - 1s 647us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 74/80
909/909 [==============================] - 1s 765us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 75/80
909/909 [==============================] - 1s 664us/step - loss: 0.0022 - accuracy: 0.01870s - loss: 0.0024 - accuracy: 0.
Epoch 76/80
909/909 [==============================] - 1s 817us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 77/80
909/909 [==============================] - 1s 693us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 78/80
909/909 [==============================] - 1s 726us/step - loss: 0.0022 - accuracy: 0.0187TA: 0s - loss: 0.0018 - ac
Epoch 79/80
909/909 [==============================] - 1s 681us/step - loss: 0.0022 - accuracy: 0.0187
Epoch 80/80
909/909 [==============================] - 1s 562us/step - loss: 0.0022 - accuracy: 0.0187

history.history.keys() #查看history中存储了哪些参数
plt.plot(history.epoch,history.history.get('loss')) #画出随着epoch增大loss的变化图

在这里插入图片描述

预测

predict = bilstm.predict(X_test)
real_predict=scaler.inverse_transform(np.concatenate((source_x_test,predict),axis=1))
real_y=scaler.inverse_transform(np.concatenate((source_x_test,Y_test),axis=1))
real_predict=real_predict[:,-1]
real_y=real_y[:,-1]

误差评估

plt.figure(figsize=(15,6))
bwith = 0.75 #边框宽度设置为0.75
ax = plt.gca()#获取边框
ax.spines['bottom'].set_linewidth(bwith)
ax.spines['left'].set_linewidth(bwith)
ax.spines['top'].set_linewidth(bwith)
ax.spines['right'].set_linewidth(bwith)
plt.plot(real_predict,label='real_predict')
plt.plot(real_y,label='real_y')
plt.plot(real_y*(1+0.15),label='15%上限',linestyle='--',color='green')
plt.plot(real_y*(1-0.15),label='15%下限',linestyle='--',color='green')
plt.fill_between(range(0,12),real_y*(1+0.15),real_y*(1-0.15),color='gray',alpha=0.2)
plt.legend()
plt.show()

在这里插入图片描述

round(mean_squared_error(Y_test,predict),4)

0.0012

from sklearn.metrics import r2_score
round(r2_score(real_y,real_predict),4)

0.5152

per_real_loss=(real_y-real_predict)/real_y
avg_per_real_loss=sum(abs(per_real_loss))/len(per_real_loss)
print(avg_per_real_loss)

0.12909395542298405

#计算指定置信水平下的预测准确率
#level为小数
def comput_acc(real,predict,level):
    num_error=0
    for i in range(len(real)):
        if abs(real[i]-predict[i])/real[i]>level:
            num_error+=1
    return 1-num_error/len(real)

comput_acc(real_y,real_predict,0.2),comput_acc(real_y,real_predict,0.15),comput_acc(real_y,real_predict,0.1)

(0.8333333333333334, 0.6666666666666667, 0.5833333333333333)
行者无疆_ty
关注
专栏目录
深度学习：LSTM的拓展（双向LSTM和GRU等）
皮皮blog
11-13 2万+
这里三条黑线就是所谓的 peephole，传统的 LSTM 中遗忘门、输入门和输出门只用了 h(t-1) 和 xt 来控制门缝的大小，peephole 的意思是说不但要考虑 h(t-1) 和 xt，也要考虑 Ct-1 和 Ct，其中遗忘门和输入门考虑了 Ct-1，而输出门考虑了 Ct。RNN和LSTM都只能依据之前时刻的时序信息来预测下一时刻的输出，但在有些问题中，当前时刻的输出不仅和之前的状态有关，还可能和未来的状态有关系。而LSTM具有较多的参数，比较适合具有大量样本的情况，可能会获得较优的模型。
双向 LSTM（Bidirectional LSTM）与普通 LSTM 公式过程
weixin_44790306的博客
08-31 3352
双向 LSTM 结构中有两个 LSTM 层，一个从前向后处理序列，另一个从后向前处理序列。在处理序列时，每个时间步的输入会被分别传递给两个 LSTM 层，然后它们的输出会被合并。双向 LSTM（Bidirectional LSTM）与普通 LSTM 有类似的公式过程，但有一些细微的差别。LSTM 是一种循环神经网络（RNN），用于处理序列数据。通过双向 LSTM，我们可以获得更全面的序列信息，有助于提高模型在序列任务中的性能。是前向 LSTM 在第。个时间步的向量表示，个时间步的细胞状态，
使用LSTM模型进行时序数据预测
qq_42035021的博客
08-13 2792
准确理解样本的含义对于接下来的工作非常重要！样本就是一组数据，它包括两部分内容：特征数据和标签数据。标签数据很简单，就是你的预测目标，而特征数据则是用来计算标签数据的数据。举个例子：假设我想要用当前时刻的温度和气压去预测风速，那么温度和气压组成的数据就是特征数据，风速则是标签数据，特征数据和标签数据又组成一个样本。如果我有100个时刻的温度、气压、风速数据，那么就能形成100个样本，这便是样本集。如果只有单站点数据，那么样本数量把往往和时间长度有关；
Bi-LSTM学习
一枚小白的博客
03-30 2万+
什么是LSTM与Bi-LSTM LSTM的全称是Long Short-Term Memory，它是RNN（Recurrent Neural Network）的一种。LSTM由于其设计的特点，非常适合用于对时序数据的建模，如文本数据。BiLSTM是Bi-directional Long Short-Term Memory的缩写，是由前向LSTM与后向LSTM组合而成。两者在自然语言处理任务中都常被用...
tensorflow 双向lstm
luoganttcc的博客
10-25 2367
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Thu Oct 25 13:41:35 2018 @author: lg """ import numpy as np import pandas as pd import tensorflow as tf import tensorflow.contrib.rnn as...
Bi-LSTM（双向长短期记忆网络）
Hilda121的博客
06-06 605
Bi-LSTM（双向长短期记忆网络）是一种高级的递归神经网络（RNN），能够同时考虑输入序列的前后文信息，从而更全面地理解文本的语义。为了形象地解释Bi-LSTM模型，可以用一个日常生活中的例子来帮助理解。
双向 LSTM
极客X养成计划
08-11 3583
本文结构：为什么用双向 LSTM什么是双向 LSTM例子为什么用双向 LSTM？单向的 RNN，是根据前面的信息推出后面的，但有时候只看前面的词是不够的，例如，我今天不舒服，我打算__一天。只根据‘不舒服‘，可能推出我打算‘去医院‘，‘睡觉‘，‘请假‘等等，但如果加上后面的‘一天‘，能选择的范围就变小了，‘去医院‘这种就不能选了，而‘请假‘‘休息‘之类的被选择概率就会更大。什么是双向 LSTM？双
（五）通俗易懂理解——双向LSTM
热门推荐
qq_36696494的博客
04-04 6万+
中文翻译作者博客：https://www.cnblogs.com/wangduo/p/6773601.html?utm_source=itdadao&utm_medium=referral 英文原文作者网址：http://colah.github.io/posts/2015-08-Understanding-LSTMs/ 参考相关网址：https://www.imooc.com/art...
双向LSTM
sinat_22510827的博客
05-15 2万+
双向LSTM是传统LSTM的扩展，可以提高序列分类问题的模型性能。在输入序列的所有时间步长可用的问题中，双向LSTM在输入序列上训练两个而不是一个LSTM。输入序列中的第一个是原样的，第二个是输入序列的反转副本。这可以为网络提供额外的上下文，并导致更快，甚至更充分的学习问题。在本教程中，您将发现如何使用Keras深度学习库在Python中开发用于序列分类的双向LSTM。完成本教程后，您将知道：如何...
bi-lstm
anqi3776的博客
01-04 469
bi-lstm attention over attention的问题 ，优化的点 首先将文档D和问题Q转化为one-hot向量，然后将one-hot向量输入embedding层，这里的文档嵌入层和问题嵌入层的权值矩阵共享，通过共享词嵌入，文档和问题都可以参与嵌入的学习过程，然后使用双向GRU分别对文档和问题进行编码，文档和问题的编码都拼接正向和反向GRU的隐藏层输出，这时编码得到的文档和问题词向量都包含了上下文信息。计算过程如图所示： 文档的Contextual Embedding表示为h_doc，维度为
时间序列预测—双向LSTM(Bi-LSTM)
专注基础架构领域
11-17 794
本文展示了使用双向LSTM(Bi-LSTM)进行时间序列预测的全过程，包含详细的注释。整个过程主要包括：数据导入、数据清洗、结构转化、建立Bi-LSTM模型、训练模型（包括动态调整学习率和earlystopping的设置）、预测、结果展示、误差评估等完整的时间序列预测流程。本文使用的数据集在本人上传的资源中，链接为。
GTO-CNN-BiLSTM进行多变量多步时间序列预测的详细MATLAB项目实例（包含详细的完整的程序和数据）
最新发布
10-03
本文详述了利用结合GTO优化算法、卷积神经网络（CNN）和双向长短期记忆（BiLSTM）的混合模型——GTO-CNN-BiLSTM，在MATLAB环境下完成多变量时间序列预测的完整流程。内容包括了从数据生成与准备、模型搭建及参数配置...
专199-VMD-TCN-BiLSTM-MATT变分模态分解卷积双向长短期网络多头注意力多变量时序预测
05-10
根据提供的标题、描述以及部分上下文内容，我们可以深入探讨一种复合型深度学习模型——VMD-TCN-BiLSTM-MATT（变分模态分解卷积双向长短期记忆网络多头注意力机制）用于多变量时序预测的技术细节及其应用场景。...
深度学习多变量时间序列预测：Bi-LSTM算法构建时间序列多变量模型预测交通流量+代码实战
data+scenario+science+insight
06-29 2337
深度学习多变量时间序列预测：Bi-LSTM算法构建时间序列多变量模型预测交通流量+代码实战 人类并不是每时每刻都从一片空白的大脑开始他们的思考。在你阅读这篇文章时候，你都是基于自己已经拥有的对先前所见词的理解来推断当前词的真实含义。我们不会将所有的东西都全部丢弃，然后用空白的大脑进行思考。我们的思想拥有持久性。 传统的神经网络并不能做到这点，看起来也像是一种巨大的弊端。例如，假设你希望对电影中的每个时间点的时间类型进行分类。传统的神经网络应该很难来处理这个问题——使用电影中先前的事件推断后续的事.
时间序列预测 | Matlab基于EMD-BILSTM/BILSTM经验模态分解和双向长短期记忆网络的时间序列预测，含BILSTM、EMD-BILSTM模型
前程算法屋的博客
08-14 105
时间序列预测 | Matlab基于EMD-BILSTM/BILSTM经验模态分解和双向长短期记忆网络的时间序列预测，含LSTM、EMD-BILSTM模型
Keras深度学习实战（33）——基于LSTM的序列预测模型
盼小辉丶的博客
11-02 5904
长短时记忆网络 (LSTM) 可以返回最后一个时间戳的结果，即输出为一维数据，而多对多神经网络架构输出为多个维度，其中每个维度对应一个输出，而非多个类别的 softmax 激活函数值。例如，在股价预测中，我们可以使用多对多神经网络架构预测未来 5 天的股价，而不仅是下一个交易日的股价。在这类情况下，我们构建神经网络模型的方式有所不同。本文基于 LSTM 研究各类不同模型的序列预测问题，包括一对一架构以及多对多架构，并且通过实战验证了不同架构的输出结果。
利用双向LSTM进行数据的预测
Peter清风
11-30 1万+
双向LSTM 我们为什么要用双向LSTM？ 双向卷积神经网络的隐藏层要保存两个值， A 参与正向计算， A’ 参与反向计算。最终的输出值 y 取决于 A 和 A’: 即正向计算时，隐藏层的 s_t 与 s_t－1 有关；反向计算时，隐藏层的 s_t 与 s_t＋1 有关 现在们利用tensorflow提供双向LSTM函数来进行手写识别的分类案例，时间序列数据数据的预测也可以通过修改数据集来实现...
Bi-LSTM详解
真滴不可理喻的博客
01-23 9117
Bi-LSTM详解，双向LSTM，用LSTM做情感分析
时间序列预测——LSTM模型（附代码实现）
09-12
时间序列预测是一种常见的问题，可以使用LSTM（长短期记忆）模型来解决。LSTM是一种循环神经网络（RNN），能够有效地捕捉时间序列中的长期依赖关系。 下面是一个使用Python和Keras库实现LSTM模型进行时间序列预测的示例代码： ```python import numpy as np import pandas as pd from keras.models import Sequential from keras.layers import LSTM, Dense # 读取时间序列数据 data = pd.read_csv('data.csv') # 替换为实际的数据文件路径 # 数据预处理 # 将数据拆分为训练集和测试集 train_data = data.iloc[:800] # 使用前800个数据作为训练集 test_data = data.iloc[800:] # 使用后面的数据作为测试集 # 构建特征和标签 def create_dataset(dataset, look_back): X, Y = [], [] for i in range(len(dataset) - look_back): X.append(dataset[i:i + look_back]) Y.append(dataset[i + look_back]) return np.array(X), np.array(Y) look_back = 10 # 定义用于预测的时间步长 train_X, train_Y = create_dataset(train_data, look_back) test_X, test_Y = create_dataset(test_data, look_back) # 构建LSTM模型 model = Sequential() model.add(LSTM(units=50, activation='relu', input_shape=(look_back, 1))) model.add(Dense(units=1)) model.compile(optimizer='adam', loss='mean_squared_error') # 训练模型 model.fit(train_X, train_Y, epochs=100, batch_size=32) # 预测 train_predict = model.predict(train_X) test_predict = model.predict(test_X) # 可视化结果 import matplotlib.pyplot as plt # 绘制训练集和测试集的实际值 plt.plot(np.arange(len(train_data)), train_data, 'b', label='actual') plt.plot(np.arange(len(train_data), len(train_data) + len(test_data)), test_data, 'g', label='actual') # 绘制训练集和测试集的预测值 plt.plot(np.arange(look_back, len(train_predict) + look_back), train_predict, 'r', label='predicted') plt.plot(np.arange(len(train_predict) + look_back, len(train_predict) + look_back + len(test_predict)), test_predict, 'y', label='predicted') plt.legend() plt.show() ``` 在上面的代码中，首先读取时间序列数据，然后将数据拆分为训练集和测试集。接下来，通过定义一个`create_dataset`函数将时间序列数据转换为特征和标签，其中特征是前`look_back`个时间步长的数据，标签是下一个时间步长的数据。然后，使用Keras库构建一个简单的LSTM模型，并编译模型。 训练模型时，使用训练集的特征和标签进行训练。训练完成后，使用训练集和测试集的特征进行预测，并将结果可视化。 请注意，上述代码仅为示例，实际使用时可能需要根据具体情况进行适当调整。
评论 27
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值