# 時間序列預測的多層感知器網絡探索性配置 > 原文： [https://machinelearningmastery.com/exploratory-configuration-multilayer-perceptron-network-time-series-forecasting/](https://machinelearningmastery.com/exploratory-configuration-multilayer-perceptron-network-time-series-forecasting/) 當開始使用神經網絡的新預測建模項目時，可能會很困難。 有很多配置，并沒有明確的想法從哪里開始。 系統化很重要。您可以打破糟糕的假設并快速磨練有效的配置和可能需要進一步調查的區域。 在本教程中，您將了解如何使用多層感知器（MLP）神經網絡的探索性配置來為時間序列預測找到良好的首先模型。 完成本教程后，您將了解： * 如何設計一個強大的實驗測試工具來評估 MLP 模型的時間序列預測。 * 針對不同時期，神經元和滯后配置的系統實驗設計。 * 如何解釋結果并使用診斷來了解有關良好表現模型的更多信息。 讓我們開始吧。 * **2017 年 7 月更新**：更改了創建模型的功能，使其更具描述性。  用于時間序列預測的多層感知器網絡的探索性配置 照片由 [Lachlan Donald](https://www.flickr.com/photos/lox/33885582/) 拍攝，保留一些權利。 ## 教程概述 本教程分為 6 個部分。他們是： 1. 洗發水銷售數據集 2. 實驗測試線束 3. 不同的訓練時代 4. 改變隱藏層神經元 5. 具有滯后的變隱藏層神經元 6. 審查結果 ### 環境 本教程假定您已安裝 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），因為它會對大錯誤進行處罰，并產生與預測數據相同的分數，即每月洗發水銷售額。 ### 數據準備 在我們將 MLP 模型擬合到數據集之前，我們必須轉換數據。 在擬合模型和進行預測之前，對數據集執行以下三個數據變換。 1. **轉換時間序列數據，使其靜止**。具體而言，滯后= 1 差分以消除數據中的增加趨勢。 2. **將時間序列轉換為監督學習問題**。具體而言，將數據組織成輸入和輸出模式，其中前一時間步的觀察被用作預測當前時間步的觀察的輸入 3. **將觀察結果轉換為具有特定比例**。具體而言，將數據重新調整為-1 到 1 之間的值。 這些變換在預測時反轉，在計算和誤差分數之前將它們恢復到原始比例。 ### MLP 模型 我們將使用具有 1 個神經元隱藏層的基礎 MLP 模型，對隱藏神經元的整流線性激活函數，以及輸出神經元上的線性激活函數。 在可能的情況下使用批量大小為 4，并且截斷訓練數據以確保模式的數量可被 4 整除。在某些情況下，使用批量大小為 2。 通常，訓練數據集在每個批次或每個時期之后進行混洗，這有助于將訓練數據集擬合到分類和回歸問題上。所有實驗都關閉了改組，因為它似乎可以帶來更好的表現。需要更多的研究來確認時間序列預測的結果。 使用有效的 ADAM 優化算法和均方誤差損失函數來擬合模型。 ### 實驗運行 每個實驗場景將運行 30 次，并且測試集上的 RMSE 得分將從每次運行結束時記錄。 讓我們深入研究實驗。 ## 不同的訓練時代 在第一個實驗中，我們將研究改變隱藏層中具有一個隱藏層和一個神經元的簡單 MLP 的訓練時期的數量。 我們將使用批量大小為 4 并評估訓練時期 50,100,500,1000 和 2000。 完整的代碼清單如下。 此代碼清單將用作所有后續實驗的基礎，后續部分中僅提供對此代碼的更改。 ```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 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 MLP network to training data def fit_model(train, batch_size, nb_epoch, neurons): X, y = train[:, 0:-1], train[:, -1] model = Sequential() model.add(Dense(neurons, activation='relu', input_dim=X.shape[1])) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(X, y, epochs=nb_epoch, batch_size=batch_size, verbose=0, shuffle=False) return model # run a repeated experiment def experiment(repeats, series, epochs, lag, 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, lag) supervised_values = supervised.values[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(repeats): # fit the model batch_size = 4 train_trimmed = train_scaled[2:, :] model = fit_model(train_trimmed, batch_size, epochs, neurons) # forecast test dataset test_reshaped = test_scaled[:,0:-1] output = model.predict(test_reshaped, batch_size=batch_size) 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 # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # experiment repeats = 30 results = DataFrame() lag = 1 neurons = 1 # vary training epochs epochs = [50, 100, 500, 1000, 2000] for e in epochs: results[str(e)] = experiment(repeats, series, e, lag, neurons) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('boxplot_epochs.png') ``` 運行實驗在每次實驗運行結束時打印測試集 RMSE。 在所有運行結束時，提供了一個摘要統計表，每個統計信息對應一行，每列有一個配置。 總結統計表明，平均 1000 個訓練時期導致更好的表現，隨著訓練時期的增加，誤差總體下降趨勢。 ```py 50 100 500 1000 2000 count 30.000000 30.000000 30.000000 30.000000 30.000000 mean 129.660167 129.388944 111.444027 103.821703 107.500301 std 30.926344 28.499592 23.181317 22.138705 24.780781 min 94.598957 94.184903 89.506815 86.511801 86.452041 25% 105.198414 105.722736 90.679930 90.058655 86.457260 50% 129.705407 127.449491 93.508245 90.118331 90.074494 75% 141.420145 149.625816 136.157299 135.510850 135.741340 max 198.716220 198.704352 141.226816 139.994388 142.097747 ``` 還創建了每個配置的測試 RMSE 分數分布的盒子和須狀圖，并保存到文件中。 該圖強調了每個配置在測試 RMSE 分數（框）中顯示相同的一般分布，中位數（綠線）隨著訓練時期的增加而向下趨勢。 結果證實，配置的 MLP 訓練 1000 是這個問題的一個很好的起點。  用于洗發水銷售數據集的時間序列預測的變化訓練時期的盒子和晶須圖 網絡配置需要考慮的另一個角度是模型適應時的行為方式。 我們可以在每個訓練時期之后評估訓練和測試數據集上的模型，以了解配置是否過度擬合或不適合問題。 我們將在每組實驗的最佳結果上使用此診斷方法。將運行總共 10 次重復的配置，并且在線圖上繪制每個訓練迭代之后的訓練和測試 RMSE 得分。 在這種情況下，我們將在 MLP 適合 1000 個時期使用此診斷。 完整的診斷代碼清單如下。 與前面的代碼清單一樣，下面的代碼清單將用作本教程中所有診斷的基礎，并且后續部分中僅提供對此清單的更改。 ```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 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) df = df.drop(0) 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] # forecast dataset output = model.predict(X, 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)) return rmse # fit an MLP network to training data def fit(train, test, raw, scaler, batch_size, nb_epoch, neurons): X, y = train[:, 0:-1], train[:, -1] # prepare model model = Sequential() model.add(Dense(neurons, activation='relu', input_dim=X.shape[1])) 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) # 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 repeats = 10 n_batch = 4 n_epochs = 1000 n_neurons = 1 n_lag = 1 # 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(repeats): history = fit(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, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_epochs.png') # entry point run() ``` 運行診斷程序打印最終訓練并測試每次運行的 RMSE。更有趣的是創建的最終線圖。 線圖顯示了每個訓練時期之后的訓練 RMSE（藍色）和測試 RMSE（橙色）。 在這種情況下，診斷圖顯示在大約 400 個訓練時期之后訓練和測試 RMSE 幾乎沒有差異。訓練和測試表現均接近平坦線。 這種快速平衡表明模型正在達到容量，并且可以從滯后觀察或額外神經元方面的更多信息中受益。  訓練診斷線圖和洗發水銷售數據集 1000 個時期的測試表現 ## 改變隱藏層神經元 在本節中，我們將研究改變單個隱藏層中神經元的數量。 增加神經元的數量會增加網絡的學習能力，從而存在過度擬合訓練數據的風險。 我們將探索將神經元的數量從 1 增加到 5 并使網絡適合 1000 個時期。 下面列出了實驗腳本的不同之處。 ```py # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # experiment repeats = 30 results = DataFrame() lag = 1 epochs = 1000 # vary neurons neurons = [1, 2, 3, 4, 5] for n in neurons: results[str(n)] = experiment(repeats, series, epochs, lag, n) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('boxplot_neurons.png') ``` 運行實驗將打印每個配置的摘要統計信息。 從平均表現來看，它表明測試 RMSE 隨著單個隱藏層中神經元數量的增加而減少。 最好的結果似乎是 3 個神經元。 ```py 1 2 3 4 5 count 30.000000 30.000000 30.000000 30.000000 30.000000 mean 105.107026 102.836520 92.675912 94.889952 96.577617 std 23.130824 20.102353 10.266732 9.751318 6.421356 min 86.565630 84.199871 83.388967 84.385293 87.208454 25% 88.035396 89.386670 87.643954 89.154866 89.961809 50% 90.084895 91.488484 90.670565 91.204303 96.717739 75% 136.145248 104.416518 93.117926 100.228730 101.969331 max 143.428154 140.923087 136.883946 135.891663 106.797563 ``` 還創建了一個盒子和須狀圖，以總結和比較結果的分布。 該圖證實了 3 個神經元與其他配置相比表現良好的建議，并且還表明結果的擴散也較小。這可能表明配置更穩定。  用于洗發水銷售數據集的時間序列預測的變異隱藏神經元的盒子和晶須圖 同樣，我們可以通過回顧適用于 1000 個時期的 3 個神經元的所選配置的診斷來更深入地潛水。 診斷腳本的更改僅限于 _run（）_ 功能，如下所示。 ```py # run diagnostic experiments def run(): # config repeats = 10 n_batch = 4 n_epochs = 1000 n_neurons = 3 n_lag = 1 # 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(repeats): history = fit(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, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_neurons.png') ``` 運行診斷腳本為每個訓練時期提供了訓練和測試 RMSE 的線圖。 這種診斷方法表明模型技能可能已經過時，可能大約有 400 個時代。該圖還提出了過度擬合的可能情況，其中測試 RMSE 在過去 500 個訓練時期略有增加，但訓練 RMSE 沒有強烈增加。  訓練診斷線圖和 3 個隱藏神經元在洗發水銷售數據集上的測試表現 ## 具有滯后的變隱藏層神經元 在本節中，我們將考慮將滯后觀測值作為輸入增加，同時增加網絡容量。 增加的滯后觀察將自動縮放輸入神經元的數量。例如，作為輸入的 3 個滯后觀察將導致 3 個輸入神經元。 添加的輸入將需要網絡中的額外容量。因此，我們還將使用滯后觀察的數量作為輸入來縮放一個隱藏層中的神經元的數量。 我們將使用奇數個滯后觀察作為 1,3,5 和 7 的輸入，并分別使用相同數量的神經元。 輸入數量的改變影響在將時間序列數據轉換為監督學習問題期間的訓練模式的總數。因此，對于本節中的所有實驗，批量大小從 4 減少到 2。 在每次實驗運行中總共使用 1000 個訓練時期。 基礎實驗腳本的更改僅限于 _ 實驗（）_ 功能和實驗運行，如下所示。 ```py # run a repeated experiment def experiment(repeats, series, epochs, lag, 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, lag) supervised_values = supervised.values[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(repeats): # fit the model batch_size = 2 model = fit_model(train_scaled, batch_size, epochs, neurons) # forecast test dataset test_reshaped = test_scaled[:,0:-1] output = model.predict(test_reshaped, batch_size=batch_size) 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 # load dataset series = read_csv('shampoo-sales.csv', header=0, parse_dates=[0], index_col=0, squeeze=True, date_parser=parser) # experiment repeats = 30 results = DataFrame() epochs = 1000 # vary neurons neurons = [1, 3, 5, 7] for n in neurons: results[str(n)] = experiment(repeats, series, epochs, n, n) # summarize results print(results.describe()) # save boxplot results.boxplot() pyplot.savefig('boxplot_neurons_lag.png') ``` 運行實驗會使用每個配置的描述性統計信息匯總結果。 結果表明滯后輸入變量的所有增加隨隱藏神經元的增加而降低表現。 值得注意的是 1 個神經元和 1 個輸入配置，與上一節的結果相比，產生了類似的均值和標準差。 表現的降低可能與較小的批量大小有關，并且 1-神經元/ 1 滯后情況的結果不足以解釋這一點。 ```py 1 3 5 7 count 30.000000 30.000000 30.000000 30.000000 mean 105.465038 109.447044 158.894730 147.024776 std 20.827644 15.312300 43.177520 22.717514 min 89.909627 77.426294 88.515319 95.801699 25% 92.187690 102.233491 125.008917 132.335683 50% 92.587411 109.506480 166.438582 145.078842 75% 135.386125 118.635143 189.457325 166.329000 max 139.941789 144.700754 232.962778 186.185471 ``` 還創建了結果分布的盒子和須狀圖，允許比較配置。 有趣的是，與其他配置相比，使用 3 個神經元和 3 個輸入變量顯示更緊密的傳播。這類似于上一節中所見的 3 個神經元和 1 個輸入變量的觀察結果。  用于洗發水銷售數據集的時間序列預測的變化滯后特征和隱藏神經元的盒子和晶須圖 我們還可以使用診斷來梳理模型動態在擬合模型時可能發生的變化。 3-lag / 3-neurons 的結果很有意思，我們將進一步研究它們。 診斷腳本的更改僅限于 _run（）_ 功能。 ```py # run diagnostic experiments def run(): # config repeats = 10 n_batch = 2 n_epochs = 1000 n_neurons = 3 n_lag = 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(repeats): history = fit(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, history['train'].iloc[-1], history['test'].iloc[-1])) pyplot.savefig('diagnostic_neurons_lag.png') ``` 運行診斷腳本會創建一個線圖，顯示在每個訓練時期之后 10 次實驗運行的訓練和測試 RMSE。 結果表明在前 500 個時期內學習良好，并且可能在剩余的時期過度擬合，測試 RMSE 顯示出增加的趨勢，并且訓練 RMSE 顯示出下降趨勢。  訓練診斷線圖和 3 個隱藏神經元的測試表現和洗發水銷售數據集的滯后特征 ## 審查結果 我們在本教程中介紹了很多內容。讓我們來復習。 * **時代**。我們研究了模型技能如何隨著訓練時期的變化而變化，并發現 1000 可能是一個很好的起點。 * **神經元**。我們研究了隱藏層中神經元數量的變化，發現 3 個神經元可能是一個很好的配置。 * **滯后輸入**。我們考慮將滯后觀察的數量作為輸入變化，同時增加隱藏層中神經元的數量，并發現結果通常變得更糟，但是隱藏層中的 3 個神經元顯示出興趣。與其他實驗相比，差的結果可能與批量大小從 4 變為 2 有關。 結果表明，在隱藏層中使用 1 個滯后輸入，3 個神經元，并且適合作為首次切割模型配置的 1000 個時期。 這可以通過多種方式得到改善;下一節列出了一些想法。 ### 擴展 本節列出了您可能想要探索的擴展和后續實驗。 * **Shuffle vs No Shuffle** 。沒有使用洗牌，這是不正常的。在擬合時間序列預測模型時，開發一個實驗來比較改組與訓練集的無改組。 * **歸一化方法**。數據重新調整為-1 到 1，這是 tanh 激活函數的典型值，未在模型配置中使用。探索其他重新縮放，例如 0-1 規范化和標準化以及對模型表現的影響。 * **多層**。探索使用多個隱藏層來增加網絡容量，以了解更復雜的多步模式。 * **特色工程**。探索使用其他功能，例如錯誤時間序列，甚至每個觀察的日期時間元素。 另外，看看帖子： * [如何提高深度學習效能](http://machinelearningmastery.com/improve-deep-learning-performance/) 你嘗試過這些擴展嗎？ 在以下評論中發布您的結果。 ## 摘要 在本教程中，您了解了如何使用系統實驗來探索多層感知器在時間序列預測中的配置，并開發出第一個切割模型。 具體來說，你學到了： * 如何開發一個強大的測試工具來評估時間序列預測的 MLP 模型。 * 如何系統地評估訓練時期，隱藏層神經元和滯后輸入。 * 如何使用診斷來幫助解釋結果并建議后續實驗。 您對本教程有任何疑問嗎？ 在下面的評論中提出您的問題，我會盡力回答。