# 如何使用 LSTM 網絡的 Dropout 進行時間序列預測 > 原文： [https://machinelearningmastery.com/use-dropout-lstm-networks-time-series-forecasting/](https://machinelearningmastery.com/use-dropout-lstm-networks-time-series-forecasting/) 長短期記憶（LSTM）模型是一種能夠學習觀察序列的循環神經網絡。 這可能使它們成為一個非常適合時間序列預測的網絡。 LSTM 的一個問題是他們可以輕松地過度訓練訓練數據，降低他們的預測技巧。 Dropout 是一種正規化方法，在訓練網絡時，LSTM 單元的輸入和重復連接在概率上被排除在激活和權重更新之外。這具有減少過度擬合和改善模型表現的效果。 在本教程中，您將了解如何在 LSTM 網絡和設計實驗中使用 dropout 來測試其對時間序列預測的有效性。 完成本教程后，您將了解： * 如何設計一個強大的測試工具來評估 LSTM 網絡的時間序列預測。 * 如何使用 LSTM 使用輸入權重丟失來設計，執行和解釋結果。 * 如何設計，執行和解釋使用 LSTM 重復丟失重量的結果。 讓我們開始吧。  如何使用 LSTM 網絡的 Dropout 進行時間序列預測 照片來自 Jonas Bengtsson，保留一些權利。 ## 教程概述 本教程分為 5 個部分。他們是： 1. 洗發水銷售數據集 2. 實驗測試線束 3. 輸入 dropout 4. 經常性 dropout 5. 審查結果 ### 環境 本教程假定您已安裝 Python SciPy 環境。您可以在此示例中使用 Python 2 或 3。 本教程假設您安裝了 TensorFlow 或 Theano 后端的 Keras v2.0 或更高版本。 本教程還假設您安裝了 scikit-learn，Pandas，NumPy 和 Matplotlib。 接下來，讓我們看看標準時間序列預測問題，我們可以將其用作此實驗的上下文。 如果您在設置 Python 環境時需要幫助，請參閱以下帖子： * [如何使用 Anaconda 設置用于機器學習和深度學習的 Python 環境](http://machinelearningmastery.com/setup-python-environment-machine-learning-deep-learning-anaconda/) ## 洗發水銷售數據集 該數據集描述了 3 年期間每月洗發水的銷售數量。 單位是銷售計數，有 36 個觀察。原始數據集歸功于 Makridakis，Wheelwright 和 Hyndman（1998）。 [您可以在此處下載并了解有關數據集的更多信息](https://datamarket.com/data/set/22r0/sales-of-shampoo-over-a-three-year-period)。 下面的示例加載并創建已加載數據集的圖。 ```py # load and plot dataset from pandas import read_csv from pandas import datetime from matplotlib import pyplot # load dataset def parser(x): return datetime.strptime('190'+x, '%Y-%m') series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # summarize first few rows print(series.head()) # line plot series.plot() pyplot.show() ``` 運行該示例將數據集作為 Pandas Series 加載并打印前 5 行。 ```py Month 1901-01-01 266.0 1901-02-01 145.9 1901-03-01 183.1 1901-04-01 119.3 1901-05-01 180.3 Name: Sales, dtype: float64 ``` 然后創建該系列的線圖，顯示明顯的增加趨勢。  洗發水銷售數據集的線圖 接下來，我們將看一下實驗中使用的模型配置和測試工具。 ## 實驗測試線束 本節介紹本教程中使用的測試工具。 ### 數據拆分 我們將 Shampoo Sales 數據集分為兩部分：訓練和測試集。 前兩年的數據將用于訓練數據集，剩余的一年數據將用于測試集。 將使用訓練數據集開發模型，并對測試數據集進行預測。 測試數據集的持久性預測（樸素預測）實現了每月洗發水銷售 136.761 的錯誤。這在測試集上提供了較低的可接受表現限制。 #### 模型評估 將使用滾動預測場景，也稱為前進模型驗證。 測試數據集的每個時間步驟將一次一個地走。將使用模型對時間步長進行預測，然后將獲取測試集的實際預期值，并使其可用于下一時間步的預測模型。 這模仿了一個真實世界的場景，每個月都會有新的洗發水銷售觀察結果，并用于下個月的預測。 這將通過訓練和測試數據集的結構進行模擬。 將收集關于測試數據集的所有預測，并計算錯誤分數以總結模型的技能。將使用均方根誤差（RMSE），因為它會對大錯誤進行處罰，并產生與預測數據相同的分數，即每月洗發水銷售額。 ### 數據準備 在我們將模型擬合到數據集之前，我們必須轉換數據。 在擬合模型和進行預測之前，對數據集執行以下三個數據變換。 1. **轉換時間序列數據，使其靜止**。具體而言，滯后= 1 差分以消除數據中的增加趨勢。 2. **將時間序列轉換為監督學習問題**。具體而言，將數據組織成輸入和輸出模式，其中前一時間步的觀察被用作預測當前時間步的觀察的輸入 3. **將觀察結果轉換為具有特定比例**。具體而言，將數據重新調整為-1 到 1 之間的值。 這些變換在預測時反轉，在計算和誤差分數之前將它們恢復到原始比例。 ### LSTM 模型 我們將使用基礎狀態 LSTM 模型，其中 1 個神經元適合 1000 個時期。 批量大小為 1 是必需的，因為我們將使用前向驗證并對最后 12 個月的測試數據進行一步預測。 批量大小為 1 意味著該模型將使用在線訓練（而不是批量訓練或小批量訓練）。因此，預計模型擬合將具有一些變化。 理想情況下，將使用更多的訓練時期（例如 1500），但這被截斷為 1000 以保持運行時間合理。 使用有效的 ADAM 優化算法和均方誤差損失函數來擬合模型。 ### 實驗運行 每個實驗場景將運行 30 次，并且測試集上的 RMSE 得分將從每次運行結束時記錄。 讓我們深入研究實驗。 ## 基線 LSTM 模型 讓我們從基線 LSTM 模型開始。 此問題的基線 LSTM 模型具有以下配置： * 滯后輸入：1 * 時代：1000 * LSTM 隱藏層中的單位：3 * 批量大小：4 * 重復：3 完整的代碼清單如下。 此代碼清單將用作所有后續實驗的基礎，只有后續部分中提供的此代碼清單的更改。 ```py from pandas import DataFrame from pandas import Series from pandas import concat from pandas import read_csv from pandas import datetime from sklearn.metrics import mean_squared_error from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from math import sqrt import matplotlib # be able to save images on server matplotlib.use('Agg') from matplotlib import pyplot import numpy # date-time parsing function for loading the dataset def parser(x): return datetime.strptime('190'+x, '%Y-%m') # frame a sequence as a supervised learning problem def timeseries_to_supervised(data, lag=1): df = DataFrame(data) columns = [df.shift(i) for i in range(1, lag+1)] columns.append(df) df = concat(columns, axis=1) return df # create a differenced series def difference(dataset, interval=1): diff = list() for i in range(interval, len(dataset)): value = dataset[i] - dataset[i - interval] diff.append(value) return Series(diff) # invert differenced value def inverse_difference(history, yhat, interval=1): return yhat + history[-interval] # scale train and test data to [-1, 1] def scale(train, test): # fit scaler scaler = MinMaxScaler(feature_range=(-1, 1)) scaler = scaler.fit(train) # transform train train = train.reshape(train.shape[0], train.shape[1]) train_scaled = scaler.transform(train) # transform test test = test.reshape(test.shape[0], test.shape[1]) test_scaled = scaler.transform(test) return scaler, train_scaled, test_scaled # inverse scaling for a forecasted value def invert_scale(scaler, X, yhat): new_row = [x for x in X] + [yhat] array = numpy.array(new_row) array = array.reshape(1, len(array)) inverted = scaler.inverse_transform(array) return inverted[0, -1] # fit an LSTM network to training data def fit_lstm(train, n_batch, nb_epoch, n_neurons): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) model = Sequential() model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=n_batch, verbose=0, shuffle=False) model.reset_states() return model # run a repeated experiment def experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons): # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # run experiment error_scores = list() for r in range(n_repeats): # fit the model train_trimmed = train_scaled[2:, :] lstm_model = fit_lstm(train_trimmed, n_batch, n_epochs, n_neurons) # forecast test dataset test_reshaped = test_scaled[:,0:-1] test_reshaped = test_reshaped.reshape(len(test_reshaped), 1, 1) output = lstm_model.predict(test_reshaped, batch_size=n_batch) predictions = list() for i in range(len(output)): yhat = output[i,0] X = test_scaled[i, 0:-1] # invert scaling yhat = invert_scale(scaler, X, yhat) # invert differencing yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i) # store forecast predictions.append(yhat) # report performance rmse = sqrt(mean_squared_error(raw_values[-12:], predictions)) print('%d) Test RMSE: %.3f' % (r+1, rmse)) error_scores.append(rmse) return error_scores # configure the experiment def run(): # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # configure the experiment n_lag = 1 n_repeats = 30 n_epochs = 1000 n_batch = 4 n_neurons = 3 # run the experiment results = DataFrame() results['results'] = experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('experiment_baseline.png') # entry point run() ``` 運行實驗將打印所有重復測試 RMSE 的摘要統計信息。 我們可以看到，平均而言，這種模型配置實現了約 92 個月洗發水銷售的測試 RMSE，標準偏差為 5。 ```py results count 30.000000 mean 92.842537 std 5.748456 min 81.205979 25% 89.514367 50% 92.030003 75% 96.926145 max 105.247117 ``` 還會根據測試 RMSE 結果的分布創建一個盒子和胡須圖并保存到文件中。 該圖清楚地描述了結果的傳播，突出了中間 50％的值（框）和中位數（綠線）。  洗發水銷售數據集中基線表現的盒子和晶須圖 網絡配置需要考慮的另一個角度是模型適應時的行為方式。 我們可以在每個訓練時期之后評估訓練和測試數據集上的模型，以了解配置是否過度擬合或不適合問題。 我們將在每組實驗的最佳結果上使用此診斷方法。將運行總共 10 次重復的配置，并且在線圖上繪制每個訓練迭代之后的訓練和測試 RMSE 得分。 在這種情況下，我們將在適用于 1000 個時期的 LSTM 上使用此診斷。 完整的診斷代碼清單如下。 與前面的代碼清單一樣，下面的代碼將用作本教程中所有診斷的基礎，并且后續部分中僅提供對此列表的更改。 ```py from pandas import DataFrame from pandas import Series from pandas import concat from pandas import read_csv from pandas import datetime from sklearn.metrics import mean_squared_error from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM from math import sqrt import matplotlib # be able to save images on server matplotlib.use('Agg') from matplotlib import pyplot import numpy # date-time parsing function for loading the dataset def parser(x): return datetime.strptime('190'+x, '%Y-%m') # frame a sequence as a supervised learning problem def timeseries_to_supervised(data, lag=1): df = DataFrame(data) columns = [df.shift(i) for i in range(1, lag+1)] columns.append(df) df = concat(columns, axis=1) return df # create a differenced series def difference(dataset, interval=1): diff = list() for i in range(interval, len(dataset)): value = dataset[i] - dataset[i - interval] diff.append(value) return Series(diff) # scale train and test data to [-1, 1] def scale(train, test): # fit scaler scaler = MinMaxScaler(feature_range=(-1, 1)) scaler = scaler.fit(train) # transform train train = train.reshape(train.shape[0], train.shape[1]) train_scaled = scaler.transform(train) # transform test test = test.reshape(test.shape[0], test.shape[1]) test_scaled = scaler.transform(test) return scaler, train_scaled, test_scaled # inverse scaling for a forecasted value def invert_scale(scaler, X, yhat): new_row = [x for x in X] + [yhat] array = numpy.array(new_row) array = array.reshape(1, len(array)) inverted = scaler.inverse_transform(array) return inverted[0, -1] # evaluate the model on a dataset, returns RMSE in transformed units def evaluate(model, raw_data, scaled_dataset, scaler, offset, batch_size): # separate X, y = scaled_dataset[:,0:-1], scaled_dataset[:,-1] # reshape reshaped = X.reshape(len(X), 1, 1) # forecast dataset output = model.predict(reshaped, batch_size=batch_size) # invert data transforms on forecast predictions = list() for i in range(len(output)): yhat = output[i,0] # invert scaling yhat = invert_scale(scaler, X[i], yhat) # invert differencing yhat = yhat + raw_data[i] # store forecast predictions.append(yhat) # report performance rmse = sqrt(mean_squared_error(raw_data[1:], predictions)) # reset model state model.reset_states() return rmse # fit an LSTM network to training data def fit_lstm(train, test, raw, scaler, batch_size, nb_epoch, neurons): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) # prepare model model = Sequential() model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') # fit model train_rmse, test_rmse = list(), list() for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False) model.reset_states() # evaluate model on train data raw_train = raw[-(len(train)+len(test)+1):-len(test)] train_rmse.append(evaluate(model, raw_train, train, scaler, 0, batch_size)) # evaluate model on test data raw_test = raw[-(len(test)+1):] test_rmse.append(evaluate(model, raw_test, test, scaler, 0, batch_size)) history = DataFrame() history['train'], history['test'] = train_rmse, test_rmse return history # run diagnostic experiments def run(): # config n_lag = 1 n_repeats = 10 n_epochs = 1000 n_batch = 4 n_neurons = 3 # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # fit and evaluate model train_trimmed = train_scaled[2:, :] # run diagnostic tests for i in range(n_repeats): history = fit_lstm(train_trimmed, test_scaled, raw_values, scaler, n_batch, n_epochs, n_neurons) pyplot.plot(history['train'], color='blue') pyplot.plot(history['test'], color='orange') print('%d) TrainRMSE=%f, TestRMSE=%f' % (i+1, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_baseline.png') # entry point run() ``` 運行診斷程序打印最終訓練并測試每次運行的 RMSE。更有趣的是創建的最終線圖。 線圖顯示了每個訓練時期之后的訓練 RMSE（藍色）和測試 RMSE（橙色）。 在這種情況下，診斷圖顯示訓練和測試 RMSE 穩定下降到大約 400-500 個時期，此后似乎可能發生一些過度擬合。這表現為訓練 RMSE 的持續下降和測試 RMSE 的增加。  洗發水銷售數據集基線模型的診斷線圖 ## 輸入 dropout Dropout 可以應用于 LSTM 節點內的輸入連接。 輸入的丟失意味著對于給定的概率，每個 LSTM 塊的輸入連接上的數據將從節點激活和權重更新中排除。 在 Keras 中，在創建 LSTM 層時使用 _dropout_ 參數指定。丟失值是 0（無丟失）和 1（無連接）之間的百分比。 在這個實驗中，我們將比較沒有 dropout 率和 20％，40％和 60％的輸入 dropout 率。 下面列出了更新的 _fit_lstm（）_，_ 實驗（）_ 和 _run（）_ 函數，用于將輸入丟失與 LSTM 一起使用。 ```py # fit an LSTM network to training data def fit_lstm(train, n_batch, nb_epoch, n_neurons, dropout): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) model = Sequential() model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True, dropout=dropout)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=n_batch, verbose=0, shuffle=False) model.reset_states() return model # run a repeated experiment def experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons, dropout): # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # run experiment error_scores = list() for r in range(n_repeats): # fit the model train_trimmed = train_scaled[2:, :] lstm_model = fit_lstm(train_trimmed, n_batch, n_epochs, n_neurons, dropout) # forecast test dataset test_reshaped = test_scaled[:,0:-1] test_reshaped = test_reshaped.reshape(len(test_reshaped), 1, 1) output = lstm_model.predict(test_reshaped, batch_size=n_batch) predictions = list() for i in range(len(output)): yhat = output[i,0] X = test_scaled[i, 0:-1] # invert scaling yhat = invert_scale(scaler, X, yhat) # invert differencing yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i) # store forecast predictions.append(yhat) # report performance rmse = sqrt(mean_squared_error(raw_values[-12:], predictions)) print('%d) Test RMSE: %.3f' % (r+1, rmse)) error_scores.append(rmse) return error_scores # configure the experiment def run(): # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # configure the experiment n_lag = 1 n_repeats = 30 n_epochs = 1000 n_batch = 4 n_neurons = 3 n_dropout = [0.0, 0.2, 0.4, 0.6] # run the experiment results = DataFrame() for dropout in n_dropout: results[str(dropout)] = experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons, dropout) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('experiment_dropout_input.png') ``` 運行此實驗會打印每個已評估配置的描述性統計信息。 結果表明，平均輸入 dropout 率為 40％會帶來更好的表現，但 dropout 率為 20％，40％和 60％的平均結果之間的差異非常小。所有人似乎都勝過 dropout。 ```py 0.0 0.2 0.4 0.6 count 30.000000 30.000000 30.000000 30.000000 mean 97.578280 89.448450 88.957421 89.810789 std 7.927639 5.807239 4.070037 3.467317 min 84.749785 81.315336 80.662878 84.300135 25% 92.520968 84.712064 85.885858 87.766818 50% 97.324110 88.109654 88.790068 89.585945 75% 101.258252 93.642621 91.515127 91.109452 max 123.578235 104.528209 96.687333 99.660331 ``` 還會創建一個框和胡須圖來比較每個配置的結果分布。 該圖顯示結果的擴散隨輸入 dropout 的增加而減少。該圖還表明輸入丟失率為 20％可能略低于中值測試 RMSE。 結果確實鼓勵對所選 LSTM 配置使用一些輸入丟失，可能設置為 40％。  洗發水銷售數據集中輸入 dropout 表現的盒子和晶須圖 我們可以查看 40％的輸入丟失如何影響模型的動態，同時適合訓練數據。 下面的代碼總結了 _fit_lstm（）_ 和 _run（）_ 函數與診斷腳本基線版本的更新。 ```py # fit an LSTM network to training data def fit_lstm(train, test, raw, scaler, batch_size, nb_epoch, neurons, dropout): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) # prepare model model = Sequential() model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True, dropout=dropout)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') # fit model train_rmse, test_rmse = list(), list() for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False) model.reset_states() # evaluate model on train data raw_train = raw[-(len(train)+len(test)+1):-len(test)] train_rmse.append(evaluate(model, raw_train, train, scaler, 0, batch_size)) # evaluate model on test data raw_test = raw[-(len(test)+1):] test_rmse.append(evaluate(model, raw_test, test, scaler, 0, batch_size)) history = DataFrame() history['train'], history['test'] = train_rmse, test_rmse return history # run diagnostic experiments def run(): # config n_lag = 1 n_repeats = 10 n_epochs = 1000 n_batch = 4 n_neurons = 3 dropout = 0.4 # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # fit and evaluate model train_trimmed = train_scaled[2:, :] # run diagnostic tests for i in range(n_repeats): history = fit_lstm(train_trimmed, test_scaled, raw_values, scaler, n_batch, n_epochs, n_neurons, dropout) pyplot.plot(history['train'], color='blue') pyplot.plot(history['test'], color='orange') print('%d) TrainRMSE=%f, TestRMSE=%f' % (i+1, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_dropout_input.png') ``` 運行更新的診斷會在每個訓練時期之后創建訓練圖并測試模型的 RMSE 表現以及輸入丟失。 結果顯示在訓練上明顯增加了凸起并測試了 RMSE 軌跡，這在測試 RMSE 分數上更為明顯。 我們還可以看到過度擬合的癥狀已經通過測試 RMSE 在整個 1000 個時期內持續下降來解決，這可能表明需要額外的訓練時期來利用這種行為。  洗發水銷售數據集中輸入 dropout 表現的診斷線圖 ## 經常性 dropout 丟失也可以應用于 LSTM 單元上的循環輸入信號。 在 Keras 中，這是通過在定義 LSTM 層時設置 _recurrent_dropout_ 參數來實現的。 在這個實驗中，我們將比較沒有 dropout 率與 20％，40％和 60％的復發 dropout 率。 下面列出了更新的 _fit_lstm（）_，_ 實驗（）_ 和 _run（）_ 函數，用于將輸入丟失與 LSTM 一起使用。 ```py # fit an LSTM network to training data def fit_lstm(train, n_batch, nb_epoch, n_neurons, dropout): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) model = Sequential() model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True, recurrent_dropout=dropout)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=n_batch, verbose=0, shuffle=False) model.reset_states() return model # run a repeated experiment def experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons, dropout): # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # run experiment error_scores = list() for r in range(n_repeats): # fit the model train_trimmed = train_scaled[2:, :] lstm_model = fit_lstm(train_trimmed, n_batch, n_epochs, n_neurons, dropout) # forecast test dataset test_reshaped = test_scaled[:,0:-1] test_reshaped = test_reshaped.reshape(len(test_reshaped), 1, 1) output = lstm_model.predict(test_reshaped, batch_size=n_batch) predictions = list() for i in range(len(output)): yhat = output[i,0] X = test_scaled[i, 0:-1] # invert scaling yhat = invert_scale(scaler, X, yhat) # invert differencing yhat = inverse_difference(raw_values, yhat, len(test_scaled)+1-i) # store forecast predictions.append(yhat) # report performance rmse = sqrt(mean_squared_error(raw_values[-12:], predictions)) print('%d) Test RMSE: %.3f' % (r+1, rmse)) error_scores.append(rmse) return error_scores # configure the experiment def run(): # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # configure the experiment n_lag = 1 n_repeats = 30 n_epochs = 1000 n_batch = 4 n_neurons = 3 n_dropout = [0.0, 0.2, 0.4, 0.6] # run the experiment results = DataFrame() for dropout in n_dropout: results[str(dropout)] = experiment(series, n_lag, n_repeats, n_epochs, n_batch, n_neurons, dropout) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('experiment_dropout_recurrent.png') ``` 運行此實驗會打印每個已評估配置的描述性統計信息。 平均結果表明，平均復發性 dropout 率為 20％或 40％是首選，但總體而言，結果并不比基線好多少。 ```py 0.0 0.2 0.4 0.6 count 30.000000 30.000000 30.000000 30.000000 mean 95.743719 93.658016 93.706112 97.354599 std 9.222134 7.318882 5.591550 5.626212 min 80.144342 83.668154 84.585629 87.215540 25% 88.336066 87.071944 89.859503 93.940016 50% 96.703481 92.522428 92.698024 97.119864 75% 101.902782 100.554822 96.252689 100.915336 max 113.400863 106.222955 104.347850 114.160922 ``` 還會創建一個框和胡須圖來比較每個配置的結果分布。 該圖顯示了更緊密的分布，反復 dropout 率為 40％，相比之下，20％和基線，可能使這種配置更可取。該圖還強調，當使用反復丟失時，分布中的最小（最佳）測試 RMSE 似乎已受到影響，從而提供更差的表現。  洗發水銷售數據集中反復 dropout 表現的盒子和晶須圖 我們可以查看 40％的經常性 dropout 率如何影響模型的動態，同時適合訓練數據。 下面的代碼總結了 _fit_lstm（）_ 和 _run（）_ 函數與診斷腳本基線版本的更新。 ```py # fit an LSTM network to training data def fit_lstm(train, test, raw, scaler, batch_size, nb_epoch, neurons, dropout): X, y = train[:, 0:-1], train[:, -1] X = X.reshape(X.shape[0], 1, X.shape[1]) # prepare model model = Sequential() model.add(LSTM(neurons, batch_input_shape=(batch_size, X.shape[1], X.shape[2]), stateful=True, recurrent_dropout=dropout)) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') # fit model train_rmse, test_rmse = list(), list() for i in range(nb_epoch): model.fit(X, y, epochs=1, batch_size=batch_size, verbose=0, shuffle=False) model.reset_states() # evaluate model on train data raw_train = raw[-(len(train)+len(test)+1):-len(test)] train_rmse.append(evaluate(model, raw_train, train, scaler, 0, batch_size)) # evaluate model on test data raw_test = raw[-(len(test)+1):] test_rmse.append(evaluate(model, raw_test, test, scaler, 0, batch_size)) history = DataFrame() history['train'], history['test'] = train_rmse, test_rmse return history # run diagnostic experiments def run(): # config n_lag = 1 n_repeats = 10 n_epochs = 1000 n_batch = 4 n_neurons = 3 dropout = 0.4 # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # transform data to be stationary raw_values = series.values diff_values = difference(raw_values, 1) # transform data to be supervised learning supervised = timeseries_to_supervised(diff_values, n_lag) supervised_values = supervised.values[n_lag:,:] # split data into train and test-sets train, test = supervised_values[0:-12], supervised_values[-12:] # transform the scale of the data scaler, train_scaled, test_scaled = scale(train, test) # fit and evaluate model train_trimmed = train_scaled[2:, :] # run diagnostic tests for i in range(n_repeats): history = fit_lstm(train_trimmed, test_scaled, raw_values, scaler, n_batch, n_epochs, n_neurons, dropout) pyplot.plot(history['train'], color='blue') pyplot.plot(history['test'], color='orange') print('%d) TrainRMSE=%f, TestRMSE=%f' % (i+1, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_dropout_recurrent.png') ``` 運行更新的診斷會在每個訓練時期之后創建訓練圖并測試模型的 RMSE 表現以及輸入丟失。 該圖顯示了測試 RMSE 跡線上增加的凸起，對訓練 RMSE 跡線幾乎沒有影響。該圖還表明，在大約 500 個時期之后，如果不是測試 RMSE 的增加趨勢，則該平臺也是如此。 至少在這個 LSTM 配置和這個問題上，可能反復發生的丟失可能不會增加太多價值。  洗發水銷售數據集中經常性 dropout 表現的診斷線圖 ## 擴展 本節列出了在完成本教程后您可能希望考慮進一步實驗的一些想法。 * **輸入層丟失**。可能值得探討在輸入層上使用壓差以及它如何影響 LSTM 的表現和過度擬合。 * **組合輸入和循環**。可能值得探索輸入和重復丟失的組合，以查看是否可以提供任何額外的好處。 * **其他正則化方法**。使用 LSTM 網絡探索其他正則化方法可能是值得的，例如各種輸入，循環和偏置權重正則化函數。 ## 進一步閱讀 有關在 Keras 中使用 MLP 模型退出的更多信息，請參閱帖子： * [具有 Keras 的深度學習模型中的丟失正則化](http://machinelearningmastery.com/dropout-regularization-deep-learning-models-keras/) 以下是一些關于 LSTM 網絡 dropout 的論文，您可能會發現這些論文對于進一步閱讀非常有用。 * [循環神經網絡正則化](https://arxiv.org/abs/1409.2329) * [dropout 在循環神經網絡中的理論基礎應用](https://arxiv.org/abs/1512.05287) * [Dropout 改進了手寫識別的循環神經網絡](https://arxiv.org/abs/1312.4569) ## 摘要 在本教程中，您了解了如何將 dropout 與 LSTM 一起用于時間序列預測。 具體來說，你學到了： * 如何設計一個強大的測試工具來評估 LSTM 網絡的時間序列預測。 * 如何在 LSTM 上配置輸入權重丟失以進行時間序列預測。 * 如何在 LSTM 上配置循環重量丟失以進行時間序列預測。 您對使用 LSTM 網絡的丟失有任何疑問嗎？ 在下面的評論中提出您的問題，我會盡力回答。