devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Keras 之 LSTM 有状态模型（stateful LSTM）和无状态模型（stateless LSTM）_electricityloaddiagrams20112014

作者：喵喵爱编程 | 2024-07-18 23:26:57

赞

踩

electricityloaddiagrams20112014

 目录

1. 区别

2. 例子

3. 疑问解答

4. 实战

    1. 实例1：官方的example——lstm_stateful.py

    2.  实例2：用Keras实现有状态LSTM——电量消费预测

    3.  实例3：用Keras实现有状态LSTM序列预测 

普通多层神经网络

stateless LSTM

单层Stateful LSTM

双层stacked Stateful LSTM

有状态的RNN，能在训练中维护跨批次的状态信息，即为当前批次的训练数据计算的状态值，可以用作下一批次训练数据的初始隐藏状态。因为Keras RNN默认是无状态的，这需要显示设置。stateful代表除了每个样本内的时间步内传递，而且每个样本之间会有信息(c,h)传递，而stateless指的只是样本内的信息传递。

参考目录：

1. 区别

  • stateful LSTM：

       能让模型学习到你输入的samples之间的时序特征，适合一些长序列的预测，哪个sample在前，哪个sample在后对模型是有影响的。

       优点：更小的网络，或更少的训练时间。

       缺点：需要使用反应数据周期性的批大小来训练网络，并在每个训练批后重置状态。

  • stateless LSTM：

        输入samples后，默认就会shuffle，可以说是每个sample独立，之间无前后关系，适合输入一些没有关系的样本。

2. 例子

  1. stateful LSTM：我想根据一篇1000句的文章预测第1001句，每一句是一个sample。我会选用stateful，因为这文章里的1000句是有前后关联的，是有时序的特征的，我不想丢弃这个特征。利用这个时序性能让第一句的特征传递到我们预测的第1001句。（batch_size = 10时）
  2. stateless LSTM：我想训练LSTM自动写诗句，我想训练1000首诗，每一首是一个sample，我会选用stateless LSTM，因为这1000首诗是独立的，不存在关联，哪怕打乱它们的顺序，对于模型训练来说也没区别。

当使用有状态 RNN 时，假定：

  1. 所有的批次都有相同数量的样本
  2. 如果 x1 和 x2 是连续批次的样本，则x2[i]是 x1[i] 的后续序列，对于每个i。

要在 RNN 中使用状态，需要:

  1. 通过将 batch_size 参数传递给模型的第一层来显式指定你正在使用的批大小。例如，对于 10 个时间步长的 32 样本的 batch，每个时间步长具有 16 个特征，batch_size = 32。
  2. 在 RNN 层中设置 stateful = True。
  3. 在调用 fit() 时指定 shuffle = False。

重置累积状态：

  1. 使用 model.reset_states()来重置模型中所有层的状态
  2. 使用layer.reset_states()来重置指定有状态 RNN 层的状态

     

3. 疑问解答

  1. 将一个很长的序列（例如时间序列）分成小序列来构建我的输入矩阵。那LSTM网络会发现我这些小序列之间的关联依赖吗？
           不会，除非你使用 stateful LSTM 。大多数问题使用stateless LSTM即可解决，所以如果你想使用stateful LSTM，请确保自己是真的需要它。在stateless时，长期记忆网络并不意味着你的LSTM将记住之前batch的内容。

  2. 在Keras中stateless LSTM中的stateless指的是?
            注意，此文所说的stateful是指的在Keras中特有的，是batch之间的记忆cell状态传递。而非说的是LSTM论文模型中表示那些记忆门，遗忘门，c，h等等在同一sequence中不同timesteps时间步之间的状态传递。
            假定我们的输入X是一个三维矩阵，shape = （nb_samples, timesteps, input_dim），每一个row代表一个sample，每个sample都是一个sequence小序列。X[i]表示输入矩阵中第i个sample。步长啥的我们先不用管。
            当我们在默认状态stateless下，Keras会在训练每个sequence小序列（=sample）开始时，将LSTM网络中的记忆状态参数reset初始化（指的是c，h而并非权重w），即调用model.reset_states()。

  3. 为啥stateless LSTM每次训练都要初始化记忆参数?
            因为Keras在训练时会默认地shuffle samples，所以导致sequence之间的依赖性消失，sample和sample之间就没有时序关系，顺序被打乱，这时记忆参数在batch、小序列之间进行传递就没意义了，所以Keras要把记忆参数初始化。
  4. 那stateful LSTM到底怎么传递记忆参数？
           首先要明确一点，LSTM作为有记忆的网络，它的有记忆指的是在一个sequence中，记忆在不同的timesteps中传播。举个例子，就是你有一篇文章X，分解，然后把每个句子作为一个sample训练对象（sequence），X[i]就代表一句话，而一句话里的每个word各自代表一个timestep时间步，LSTM的有记忆即指的是在一句话里，X[i][0]第一个单词（时间步）的信息可以被记忆，传递到第5个单词（时间步）X[i][5]中。
           而我们突然觉得，这还远远不够，因为句子和句子之间没有任何的记忆啊，假设文章一共1000句话，我们想预测出第1001句是什么，不想丢弃前1000句里的一些时序性特征（stateless时这1000句训练时会被打乱，时序性特征丢失）。那么，stateful LSTM就可以做到。
           在stateful = True 时，我们要在fit中手动使得shuffle = False。随后，在X[i]（表示输入矩阵中第i个sample）这个小序列训练完之后，Keras会将将训练完的记忆参数传递给X[i+bs]（表示第i+bs个sample）,作为其初始的记忆参数。bs = batch_size。这样一来，我们的记忆参数就能顺利地在sample和sample之间传递，X[i+n*bs]也能知道X[i]的信息

4. 实战

    1. 实例1：官方的example——lstm_stateful.py

https://github.com/keras-team/keras/blob/master/examples/lstm_stateful.py

    2.  实例2：用Keras实现有状态LSTM——电量消费预测

代码如下：

数据集：UCI机器学习库下载 ElectricityLoadDiagrams20112014

  1. from __future__ import division, print_function
  2. from keras.layers.core import Dense
  3. from keras.layers.recurrent import LSTM
  4. from keras.models import Sequential
  5. from sklearn.preprocessing import MinMaxScaler
  6. import numpy as np
  7. import math
  8. import os
  9.  
  10. DATA_DIR = "../data"
  11.  
  12. data = np.load(os.path.join(DATA_DIR, "LD_250.npy"))
  13.  
  14. STATELESS = False
  15.  
  16. NUM_TIMESTEPS = 20
  17. HIDDEN_SIZE = 10
  18. BATCH_SIZE = 96   # 24 hours (15 min intervals)
  19. NUM_EPOCHS = 5
  20.  
  21. # 归一化：range (0, 1)
  22. data = data.reshape(-1, 1)
  23. scaler = MinMaxScaler(feature_range=(0, 1), copy=False)
  24. data = scaler.fit_transform(data)
  25.  
  26. # 把输入张量调整为LSTM需要的三维向量，即（样例，时间步，特征）
  27. X = np.zeros((data.shape[0], NUM_TIMESTEPS))
  28. Y = np.zeros((data.shape[0], 1))
  29. for i in range(len(data) - NUM_TIMESTEPS - 1):
  30.     X[i] = data[i:i + NUM_TIMESTEPS].T
  31.     Y[i] = data[i + NUM_TIMESTEPS + 1]
  32.  
  33. # 将X变形为三维 (samples, timesteps, features)
  34. X = np.expand_dims(X, axis=2)   
  35. # 在第axis=2维加上一维数据，即（data.shape[0],，NUM_TIMESTEPS，1），最后一维代表1个特征
  36.  
  37. # 划分数据集
  38. sp = int(0.7 * len(data))
  39. Xtrain, Xtest, Ytrain, Ytest = X[0:sp], X[sp:], Y[0:sp], Y[sp:]
  40. print(Xtrain.shape, Xtest.shape, Ytrain.shape, Ytest.shape)
  41.  
  42. # 无状态
  43. if STATELESS:
  44.     # stateless
  45.     model = Sequential()
  46.     model.add(LSTM(HIDDEN_SIZE, input_shape=(NUM_TIMESTEPS, 1), 
  47.                    return_sequences=False))
  48.     model.add(Dense(1))
  49.  
  50. # 有状态
  51. else:
  52.     # stateful
  53.     model = Sequential()
  54.     model.add(LSTM(HIDDEN_SIZE, stateful=True,
  55.                    batch_input_shape=(BATCH_SIZE, NUM_TIMESTEPS, 1), 
  56.                    return_sequences=False))
  57.     model.add(Dense(1))
  58.  
  59. model.compile(loss="mean_squared_error", optimizer="adam",
  60.               metrics=["mean_squared_error"])
  61.  
  62. # 无状态
  63. if STATELESS:
  64.     # stateless
  65.     model.fit(Xtrain, Ytrain, epochs=NUM_EPOCHS, batch_size=BATCH_SIZE,
  66.               validation_data=(Xtest, Ytest),
  67.               shuffle=False)
  68.  
  69. # 有状态
  70. else:
  71.     # 将训练和测试数据设为BATCH_SIZE的倍数
  72.     train_size = (Xtrain.shape[0] // BATCH_SIZE) * BATCH_SIZE
  73.     test_size = (Xtest.shape[0] // BATCH_SIZE) * BATCH_SIZE
  74.     Xtrain, Ytrain = Xtrain[0:train_size], Ytrain[0:train_size]
  75.     Xtest, Ytest = Xtest[0:test_size], Ytest[0:test_size]
  76.     print(Xtrain.shape, Xtest.shape, Ytrain.shape, Ytest.shape)
  77.     for i in range(NUM_EPOCHS):
  78.         print("Epoch {:d}/{:d}".format(i+1, NUM_EPOCHS))
  79.         model.fit(Xtrain, Ytrain, batch_size=BATCH_SIZE, epochs=1,
  80.                   validation_data=(Xtest, Ytest),
  81.                   shuffle=False)
  82.         model.reset_states()
  83.  
  84. score, _ = model.evaluate(Xtest, Ytest, batch_size=BATCH_SIZE)
  85. rmse = math.sqrt(score)
  86. print("\nMSE: {:.3f}, RMSE: {:.3f}".format(score, rmse))
  87.  
  88. pre = model.predict(Xtest, batch_size=BATCH_SIZE)
  89.  
  90. plt.figure(figsize=(12,5))
  91. # plt.subplot(211)
  92. plt.plot(pre[:1000],'r',label='predctions')
  93. # plt.subplot(212)
  94. plt.plot(Ytest[:1000],label='origin')
  95. plt.legend()
  96. plt.show()

结果： 

 3.  实例3：用Keras实现有状态LSTM序列预测

本实战代码地址：GitHub
       https://github.com/youyuge34/Cosine_Stateful_Lstm/blob/master/Stateful_Lstm_Keras.ipynb

  • 普通多层神经网络

  1. import numpy as np
  2.  
  3. from __future__ import print_function
  4. from standard_plots import *
  5.  
  6. from keras.models import Sequential
  7. from keras.layers import Dense, LSTM, Dropout
  8. import matplotlib.pyplot as plt
  9.  
  10. # 创建数据集
  11. dataset = np.cos(np.arange(1000)*(20*np.pi/1000))
  12. plt_plot(y = dataset, title = 'cos')
  13.  
  14. # 转换数据为LSTM输入格式： dataset matrix
  15. def create_dataset(dataset, look_back=1):
  16.     dataX, dataY = [], []
  17.     for i in range(len(dataset)-look_back):
  18.         dataX.append(dataset[i:(i+look_back)])
  19.         dataY.append(dataset[i + look_back])
  20.     return np.array(dataX), np.array(dataY)
  21.  
  22.  
  23. look_back =40
  24. dataset = np.cos(np.arange(1000)*(20*np.pi/1000))
  25.  
  26. # 归一化，y值域为(0,1)
  27. dataset = (dataset+1) / 2.
  28.  
  29. # split into train and test sets
  30. train_size = int(len(dataset) * 0.8)
  31. test_size = len(dataset) - train_size
  32. train, test = dataset[:train_size], dataset[train_size:]
  33.  
  34. trainX, trainY = create_dataset(train, look_back)
  35. print(trainX.shape)
  36. print(trainY.shape)
  37.  
  38. trainX = np.squeeze(trainX)
  39. testX = np.squeeze(testX)
  40. model4 = Sequential()
  41. model4.add(Dense(units=32,input_dim=look_back,activation="relu"))
  42. model4.add(Dropout(0.3))
  43. for i in range(2):
  44.     model4.add(Dense(units=32,activation="relu"))
  45.     model4.add(Dropout(0.3))
  46. model4.add(Dense(1))
  47. model4.compile(loss='mse', optimizer='adagrad')
  48. model4.fit(trainX, trainY, epochs=400, batch_size=32, verbose=0)
  49.  
  50. x = np.hstack((trainX[-1][1:],(trainY[-1])))
  51. preds = []
  52. pred_num = 500
  53. for i in np.arange(pred_num):
  54.     pred = model4.predict(x.reshape((1,-1)),batch_size = batch_size)
  55.     preds.append(pred.squeeze())
  56.     x = np.append(x[1:],pred)
  57.  
  58. # print(preds[:20])
  59. # print(np.array(preds).shape)
  60. plt.figure(figsize=(12,5))
  61. plt.plot(np.arange(pred_num),np.array(preds),'r',label='predctions')
  62. cos_y = (np.cos(np.arange(pred_num)*(20*np.pi/1000))+1)/ 2.
  63. plt.plot(np.arange(pred_num),cos_y,label='origin')
  64. plt.legend()
  65. plt.show()
预测结果：

 

  • stateless LSTM

  1. # 20长度的滑动窗口进行预测
  2. look_back = 20
  3.  
  4. #归一化，y值域为(0,1)
  5. dataset = (dataset+1) / 2.
  6.  
  7. # split into train and test sets
  8. train_size = int(len(dataset) * 0.8)
  9. test_size = len(dataset) - train_size
  10. train, test = dataset[:train_size], dataset[train_size:]
  11.  
  12. trainX, trainY = create_dataset(train, look_back)
  13. testX, testY = create_dataset(test, look_back)
  14.  
  15. trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
  16. testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))
  17. '''
  18.     trainX.shape =  (780, 20, 1)
  19.     testX.shape =  (180, 20, 1)
  20.     trainY.shape =  (780,)
  21.     testY.shape =  (180,)
  22. '''
  23.  
  24. batch_size = 1
  25.  
  26. # 建立模型
  27. # 无状态LSTM
  28. model = Sequential()
  29. model.add(LSTM(32, input_shape=(20, 1)))
  30. model.add(Dropout(0.2))
  31. model.add(Dense(1))
  32.  
  33. model.compile(loss = 'mse', optimizer = 'adam')
  34. model.fit(trainX,trainY,batch_size = batch_size,epochs=30, verbose=2)
  35.  
  36. # 预测
  37. x = np.vstack((trainX[-1][1:],(trainY[-1])))  # 获取trainX的最后一个窗口数据，来预测未来数据
  38. preds = []
  39. pred_num = 500
  40. for i in np.arange(pred_num):
  41.     pred = model.predict(x.reshape((1,-1,1)),batch_size = batch_size)
  42.     preds.append(pred.squeeze())
  43.     x = np.vstack((x[1:],pred))
  44.     
  45. # print(preds[:20])
  46. # print(np.array(preds).shape)
  47. plt.figure(figsize=(12,5))
  48. plt.plot(np.arange(pred_num),np.array(preds),'r',label='predctions')
  49. cos_y = (np.cos(np.arange(pred_num)*(20*np.pi/1000))+1)/ 2.
  50. plt.plot(np.arange(pred_num),cos_y,label='origin')
  51. plt.legend()
  52. plt.show()

输出结果：

  • 单层Stateful LSTM

  1. # 有状态 LSTM network
  2. batch_size = 1
  3. model2 = Sequential()
  4. model2.add(LSTM(32, batch_input_shape=(batch_size, look_back, 1), stateful=True))
  5. model2.add(Dropout(0.2))
  6. model2.add(Dense(1))
  7. model2.compile(loss='mse', optimizer='adam')
  8. for i in range(30):
  9.     model2.fit(trainX, trainY, epochs=1, batch_size=batch_size,  shuffle=False)
  10.     model2.reset_states()
  11.  
  12. x = np.vstack((trainX[-1][1:],(trainY[-1])))
  13. preds = []
  14. pred_num = 500
  15. for i in np.arange(pred_num):
  16.     pred = model2.predict(x.reshape((1,-1,1)),batch_size = batch_size)
  17.     preds.append(pred.squeeze())
  18.     x = np.vstack((x[1:],pred))
  19.  
  20. # print(preds[:20])
  21. # print(np.array(preds).shape)
  22. plt.figure(figsize=(12,5))
  23. plt.plot(np.arange(pred_num),np.array(preds),'r',label='predctions')
  24. cos_y = (np.cos(np.arange(pred_num)*(20*np.pi/1000))+1)/ 2.
  25. plt.plot(np.arange(pred_num),cos_y,label='origin')
  26. plt.legend()
  27. plt.show()

输出结果：

  • 双层stacked Stateful LSTM

  1. look_back =40
  2. dataset = np.cos(np.arange(1000)*(20*np.pi/1000))
  3. #归一化，y值域为(0,1)
  4. dataset = (dataset+1) / 2.
  5.  
  6. # split into train and test sets
  7. train_size = int(len(dataset) * 0.8)
  8. test_size = len(dataset) - train_size
  9. train, test = dataset[:train_size], dataset[train_size:]
  10.  
  11. trainX, trainY = create_dataset(train, look_back)
  12. testX, testY = create_dataset(test, look_back)
  13.  
  14. trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))
  15. testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))
  16.  
  17. # 建立模型：有状态
  18. batch_size = 1
  19. model3 = Sequential()
  20. model3.add(LSTM(32, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))
  21. model3.add(Dropout(0.3))
  22. model3.add(LSTM(32, batch_input_shape=(batch_size, look_back, 1), stateful=True))
  23. model3.add(Dropout(0.3))
  24. model3.add(Dense(1))
  25. model3.compile(loss='mean_squared_error', optimizer='adam')
  26. for i in range(100):
  27.     model3.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)
  28.     model3.reset_states()
  29.  
  30. # 预测
  31. x = np.vstack((trainX[-1][1:],(trainY[-1])))
  32. preds = []
  33. pred_num = 500
  34. for i in np.arange(pred_num):
  35.     pred = model3.predict(x.reshape((1,-1,1)),batch_size = batch_size)
  36.     preds.append(pred.squeeze())
  37.     x = np.vstack((x[1:],pred))
  38.  
  39. # print(preds[:20])
  40. # print(np.array(preds).shape)
  41. plt.figure(figsize=(12,5))
  42. plt.plot(np.arange(pred_num),np.array(preds),'r',label='predctions')
  43. cos_y = (np.cos(np.arange(pred_num)*(20*np.pi/1000))+1)/ 2.
  44. plt.plot(np.arange(pred_num),cos_y,label='origin')
  45. plt.legend()
  46. plt.show()

输出结果：

因此，有状态模型生成的结果略优于无状态模型。

警告： 永远不要在不熟悉stateful LSTM的情况下使用它

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/848267
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号