使用Tensorflow 2.0 / Keras中的堆叠LSTM序列对自动编码器进行排序的多变量多步时间序

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

使用Tensorflow 2.0 / Keras中的堆叠LSTM序列对自动编码器进行排序的多变量多步时间序列预测
在序列到序列学习中，训练了RNN模型以将输入序列映射到输出序列。输入和输出不必具有相同的长度。seq2seq模型包含两个RNN，例如LSTM。它们可以被视为编码器和解码器。编码器部分将给定的输入序列转换为固定长度的向量，该向量用作输入序列的摘要。
该固定长度向量称为上下文向量。上下文向量作为解码器的输入，最终的编码器状态作为初始的解码器状态，以预测输出序列。序列到序列学习用于语言翻译，语音识别，时间序列
预测等。
我们将使用序列进行序列学习以进行时间序列预测。我们可以使用这种架构轻松地进行多步预测。我们将在体系结构中添加两层，即重复矢量层和时间分布密集层。
重复向量层用于重复从编码器获得的上下文向量，并将其作为输入传递给解码器。我们将重复执行n步（n是您要预测的将来的步骤数）。从解码器接收的关于每个时间步长的输出被混合。密集分布的时间将在每个时间步上应用完全连接的密集层，并为每个时间步分离输出。密集分布的时间是一个包装器，可以将一层应用于输入的每个时间片。
我们将在序列的编码器部分和解码器部分上堆叠其他层，以建立序列模型。通过堆叠LSTM，可以通过捕获不同级别的信息来提高模型理解隐藏层中时间序列数据的更复杂表示的能力。
时间序列LSTM图
码
所使用的数据是 个人家庭用电量。您 可以从此链接下载数据集。
导入库
将熊猫作为pd导入
将numpy导入为np
从sklearn.preprocessing导入MinMaxScaler
导入matplotlib.pyplot作为plt
将tensorflow作为tf导入
导入操作系统
现在将数据集加载到熊猫数据框中。
df = pd.read_csv（r'household_power_consumption.txt'，sep =';'，标头= 0，low_memory = False，infer_datetime_format = True，parse_dates = {'datetime'：[0
df.head（）
时间序列LSTM数据
归零值
df = df.replace（'？'，np.nan）
df.isnull（）。sum（）
行数
现在，我们将创建一个函数，该函数将通过将缺失值替换为前一天的值来插补缺失值。
def fill_missing（值）：
     one_day = 60 * 24
    对于范围（df.shape [0]）中的行：
        对于范围（df.shape [1]）中的col：
            如果np.isnan（values
[col]）：
                价值观
=值[row-one_day，col]
df = df.astype（'float32'）
fill_missing（df.values）
df.isnull（）。sum（）
从几分钟到几天的数据下采样
记录了超过20万个观测值。让我们通过从几分钟到几天的频率下采样来简化数据。
daily_df = df.resample（'D'）。sum（）
daily_df.head（）
约会时间
火车-测试拆分
下采样后，实例数为1442。我们将数据集分为实例数和实例数的75％和25％的训练数据和测试数据。（0.75 * 1442 = 1081）
train_df，test_df = daily_df [1：1081]，daily_df [1081：]
缩放值
数据框中的所有列都具有不同的比例。现在，我们将值缩放为-1到1，以更快地训练模型。
火车= train_df
定标器= {}
为我在train_df.columns中：
    定标器= MinMaxScaler（feature_range =（-1
    s_s = scaler.fit_transform（train [i] .values.reshape（-1
    s_s = np.reshape（s_s，len（s_s））
    定标器['scaler _'+ i] =定标器
    火车[i] = s_s
测试= test_df
为我在train_df.columns中：
    定标器=定标器['scaler _'+ i]
    s_s = scaler.transform（test [i] .values.reshape（-1
    s_s = np.reshape（s_s，len（s_s））
    定标器['scaler _'+ i] =定标器
    测试[i] = s_s
将系列转换为样本
现在，我们将创建一个函数，该函数将使用滑动窗口方法将我们的序列转换为输入的过去观测值样本和输出未来的观测值样本，以使用监督学习算法。
def split_series（系列，n_past，n_future）：
  ＃
  ＃n_past ==>没有以前的观察
  ＃
  ＃n_future ==>将来的观察数
  ＃
  X，y = list（），list（）
  对于window_start范围（len（系列））：
    past_end = window_start + n_past
    future_end = past_end + n_future
    如果future_end> len（series）：
      打破
    ＃切片窗口的过去和将来的部分
    过去，未来=系列[window_start：past_end，：]，系列[past_end：future_end，：]
    X.append（过去）
    y.append（未来）
  返回np.array（X），np.array（y）
对于这种情况，我们假设给定过去10天的观测值，我们需要预测接下来的5天的观测值。
n_past = 10
n_future = 5
n_features = 7
现在，使用split_series函数将训练数据和测试数据转换为样本。
X_train，y_train = split_series（train.values，n_past，n_future）
X_train = X_train.reshape（（X_train.shape [0]，X_train.shape [1]，n_features））
y_train = y_train.reshape（（y_train.shape [0]，y_train.shape [1]，n_features））
X_test，y_test = split_series（test.values，n_past，n_future）
X_test = X_test.reshape（（X_test.shape [0]，X_test.shape [1]，n_features））
y_test = y_test.reshape（（y_test.shape [0]，y_test.shape [1]，n_features））
模型架构
现在，我们将在下面提到的架构中创建两个模型。
E1D1 ==>具有一个编码器层和一个解码器层的序列到序列模型。
＃E1D1
＃n_features ==>数据中每个时间步均没有特征。
＃
encoder_inputs = tf.keras.layers.Input（shape =（n_past，n_features））
encoder_l1 = tf.keras.layers.LSTM（100，return_state = True）
encoder_outputs1 = encoder_l1（encoder_inputs）
encoder_states1 = encoder_outputs1 [1：]
＃
coder_inputs = tf.keras.layers.RepeatVector（n_future）（encoder_outputs1 [0]）
＃
coder_l1 = tf.keras.layers.LSTM（100，return_sequences = True）（解码器输入，初始状态=编码器状态1）
coder_outputs1 = tf.keras.layers.TimeDistributed（tf.keras.layers.Dense（n_features））（decoder_l1）
＃
model_e1d1 = tf.keras.models.Model（encoder_inputs，decoder_outputs1）
＃
model_e1d1.summary（）
E2D2 ==>序列到序列模型，具有两个编码器层和两个解码器层。
＃E2D2
＃n_features ==>数据中每个时间步均没有特征。
＃
encoder_inputs = tf.keras.layers.Input（shape =（n_past，n_features））
encoder_l1 = tf.keras.layers.LSTM（100，return_sequences = True，return_state = True）
encoder_outputs1 = encoder_l1（encoder_inputs）
encoder_states1 = encoder_outputs1 [1：]
encoder_l2 = tf.keras.layers.LSTM（100，return_state = True）
encoder_outputs2 = encoder_l2（encoder_outputs1 [0]）
encoder_states2 = encoder_outputs2 [1：]
＃
coder_inputs = tf.keras.layers.RepeatVector（n_future）（encoder_outputs2 [0]）
＃
coder_l1 = tf.keras.layers.LSTM（100，return_sequences = True）（解码器输入，初始状态=编码器状态1）
coder_l2 = tf.keras.layers.LSTM（100，return_sequences = True）（decoder_l1，initial_state = encoder_states2）
coder_outputs2 = tf.keras.layers.TimeDistributed（tf.keras.layers.Dense（n_features））（decoder_l2）
＃
model_e2d2 = tf.keras.models.Model（encoder_inputs，decoder_outputs2）
＃
model_e2d2.summary（）
模型输出
训练模型
我已经使用Adam优化器和Huber损失作为损失函数。让我们编译并运行模型。
reduce_lr = tf.keras.callbacks.LearningRateScheduler（lambda x：1e-3 * 0.90 ** x）
model_e1d1.compile（optimizer = tf.keras.optimizers.Adam（），loss = tf.keras.losses.Huber（））
history_e1d1 = model_e1d1.fit（X_train，y_train，epochs = 25，validation_data =（X_test，y_test），batch_size = 32，verbose = 0，callbacks = [reduce_lr]）
model_e2d2.compile（optimizer = tf.keras.optimizers.Adam（），loss = tf.keras.losses.Huber（））
history_e2d2 = model_e2d2.fit（X_train，y_train，epochs = 25，validation_data =（X_test，y_test），batch_size = 32，verbose = 0，回调= [reduce_lr]）
时间序列LSTM-e1d1损失
时间序列LSTM-e2d2模型损失
对测试样品的预测
pred_e1d1 = model_e1d1.predict（X_test）
pred_e2d2 = model_e2d2.predict（X_test）
预测值的反比例
现在，我们将预测转换为原始比例。
对于索引，i枚举（train_df.columns）：
    定标器=定标器['scaler _'+ i]
    pred1_e1d1 [：，：，index] = scaler.inverse_transform（pred1_e1d1 [：，：，index]）
    pred_e1d1 [：，：，index] = scaler.inverse_transform（pred_e1d1 [：，：，index]）
    pred1_e2d2 [：，：，index] = scaler.inverse_transform（pred1_e2d2 [：，：，index]）
    pred_e2d2 [：，：，index] = scaler.inverse_transform（pred_e2d2 [：，：，index]）
    y_train [：，：，index] = scaler.inverse_transform（y_train [：，：，index]）
    y_test [：，：，index] = scaler.inverse_transform（y_test [：，：，index]）
检查错误
现在我们将计算所有观测值的平均绝对误差。
从sklearn.metrics导入mean_absolute_error
对于索引，i枚举（train_df.columns）：
  打印（i）
  对于范围（1
    print（“ Day”，j，“：”）
    print（“ MAE-E1D1：”，mean_absolute_error（y_test [：，j-1，index]，pred1_e1d1 [：，j-1，index]），end =“，”）
    print（“ MAE-E2D2：”，mean_absolute_error（y_test [：，j-1，index]，pred1_e2d2 [：，j-1，index]））
  打印（）
  打印（）
错误功能
检查错误
次计量3
从上面的输出中，我们可以观察到，在某些情况下，E2D2模型的性能优于E1D1模型，并且误差较小。训练具有不同数量的堆叠层的不同模型并创建集成模型的效果也很好。
题库

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Tensor flow ten STM 编码器