如何使用編碼器 - 解碼器LSTM來回顯隨機整數序列 · Machine Learning Mastery 博客文章翻譯

# 如何使用編碼器 - 解碼器LSTM來回顯隨機整數序列 > 原文： [https://machinelearningmastery.com/how-to-use-an-encoder-decoder-lstm-to-echo-sequences-of-random-integers/](https://machinelearningmastery.com/how-to-use-an-encoder-decoder-lstm-to-echo-sequences-of-random-integers/) 長短期記憶（LSTM）循環神經網絡的一個強大功能是它們可以記住長序列間隔的觀察結果。這可以通過設計簡單的序列回波問題來證明，其中輸入序列的整個輸入序列或部分連續塊作為輸出序列被回應。開發LSTM循環神經網絡以解決序列回波問題既是LSTM功能的良好證明，也可用于演示最先進的循環神經網絡架構。在這篇文章中，您將了解如何開發LSTM以使用Keras深度學習庫解決Python中的完整和部分序列回聲問題。完成本教程后，您將了解： * 如何生成隨機的整數序列，使用一個熱編碼表示它們，并將序列構建為具有輸入和輸出對的監督學習問題。 * 如何開發序列到序列LSTM以將整個輸入序列作為輸出進行回顯。 * 如何開發編碼器 - 解碼器LSTM以回顯長度與輸入序列不同的部分序列。讓我們開始吧。 ![How to use an Encoder-Decoder LSTM to Echo Sequences of Random Integers](img/2f2624d74546ef2b5dcc7b1ecf597328.jpg) 如何使用編碼器 - 解碼器LSTM來回放隨機整數序列照片來自 [hammy24601](https://www.flickr.com/photos/jdjtc/27740211344/) ，保留一些權利。 ## 概觀本教程分為3個部分;他們是： 1. 序列回波問題 2. 回聲整個序列（序列到序列模型） 3. 回聲部分序列（編碼器 - 解碼器模型） ### 環境本教程假定您已安裝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/) ## 序列回波問題回波序列問題涉及將LSTM暴露于一系列觀察中，一次一個，然后要求網絡回顯觀察到的部分或完整的連續觀察列表。這迫使網絡記住連續觀測的塊，并且是LSTM循環神經網絡學習能力的一個很好的證明。第一步是編寫一些代碼來生成隨機的整數序列，并為網絡編碼。這涉及3個步驟： 1. 生成隨機序列 2. 一個熱編碼隨機序列 3. 用于學習的幀編碼序列 ### 生成隨機序列我們可以使用 [randint（）函數](https://docs.python.org/3/library/random.html#random.randint)在Python中生成隨機整數，該函數接受兩個參數，指示從中繪制值的整數范圍。在本教程中，我們將問題定義為具有0到99之間的整數值以及100個唯一值。 ```py randint(0, 99) ``` 我們可以將它放在一個名為generate_sequence（）的函數中，該函數將生成所需長度的隨機整數序列，默認長度設置為25個元素。此功能如下所列。 ```py # generate a sequence of random numbers in [0, 99] def generate_sequence(length=25): return [randint(0, 99) for _ in range(length)] ``` ### 一個熱編碼隨機序列一旦我們生成了隨機整數序列，我們需要將它們轉換為適合訓練LSTM網絡的格式。一種選擇是將整數重新縮放到范圍[0,1]。這可行，并要求將問題表述為回歸。我有興趣預測正確的數字，而不是接近預期值的數字。這意味著我更傾向于將問題框架化為分類而不是回歸，其中預期輸出是一個類，并且有100個可能的類值。在這種情況下，我們可以使用整數值的一個熱編碼，其中每個值由100個元素的二進制向量表示，除了整數的索引（標記為1）之外，該二進制向量都是“0”值。下面的函數one_hot_encode（）定義了如何迭代整數序列并為每個整數創建二進制向量表示，并將結果作為二維數組返回。 ```py # one hot encode sequence def one_hot_encode(sequence, n_unique=100): encoding = list() for value in sequence: vector = [0 for _ in range(n_unique)] vector[value] = 1 encoding.append(vector) return array(encoding) ``` 我們還需要解碼編碼值，以便我們可以使用預測，在這種情況下，只需查看它們。可以通過使用 [argmax（）NumPy函數](https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmax.html)來反轉一個熱編碼，該函數返回具有最大值的向量中的值的索引。下面的函數名為one_hot_decode（），將對編碼序列進行解碼，并可用于稍后解碼來自我們網絡的預測。 ```py # decode a one hot encoded string def one_hot_decode(encoded_seq): return [argmax(vector) for vector in encoded_seq] ``` ### 用于學習的幀編碼序列一旦生成并編碼了序列，就必須將它們組織成適合學習的框架。這涉及將線性序列組織成輸入（X）和輸出（y）對。例如，序列[1,2,3,4,5]可以被構造為具有2個輸入（t和t-1）和1個輸出（t-1）的序列預測問題，如下所示： ```py X, y NaN, 1, NaN 1, 2, 1 2, 3, 2 3, 4, 3 4, 5, 4 5, NaN, 5 ``` 請注意，缺少數據標有NaN值。這些行可以用特殊字符填充并屏蔽。或者，更簡單地說，可以從數據集中移除這些行，代價是從要學習的序列中提供更少的示例。后一種方法將是本例中使用的方法。我們將使用 [Pandas shift（）函數](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.shift.html)來創建編碼序列的移位版本。使用 [dropna（）函數](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.dropna.html)刪除缺少數據的行。然后，我們可以從移位的數據幀中指定輸入和輸出數據。數據必須是3維的，以用于序列預測LSTM。輸入和輸出都需要維度[樣本，時間步長，特征]，其中樣本是行數，時間步長是從中學習預測的滯后觀察數，而特征是單獨值的數量（例如100一個熱門編碼）。下面的代碼定義了實現此功能的to_supervised（）函數。它需要兩個參數來指定用作輸入和輸出的編碼整數的數量。輸出整數的數量必須小于或等于輸入的數量，并從最早的觀察計算。例如，如果在序列[1,2,3,4,5]上為輸入和輸出指定了5和1，那么該函數將返回X中的單行[1,2,3,4,5]和[1]中的y一行。 ```py # convert encoded sequence to supervised learning def to_supervised(sequence, n_in, n_out): # create lag copies of the sequence df = DataFrame(sequence) df = concat([df.shift(n_in-i-1) for i in range(n_in)], axis=1) # drop rows with missing values df.dropna(inplace=True) # specify columns for input and output pairs values = df.values width = sequence.shape[1] X = values.reshape(len(values), n_in, width) y = values[:, 0:(n_out*width)].reshape(len(values), n_out, width) return X, y ``` 有關將序列轉換為監督學習問題的更多信息，請參閱帖子： * [時間序列預測作為監督學習](http://machinelearningmastery.com/time-series-forecasting-supervised-learning/) * [如何將時間序列轉換為Python中的監督學習問題](http://machinelearningmastery.com/convert-time-series-supervised-learning-problem-python/) ### 完整的例子我們可以將所有這些結合在一起。下面是完整的代碼清單，用于生成25個隨機整數的序列，并將每個整數編碼為二進制向量，將它們分成X，y對進行學習，然后打印解碼對以供查看。 ```py from random import randint from numpy import array from numpy import argmax from pandas import DataFrame from pandas import concat # generate a sequence of random numbers in [0, 99] def generate_sequence(length=25): return [randint(0, 99) for _ in range(length)] # one hot encode sequence def one_hot_encode(sequence, n_unique=100): encoding = list() for value in sequence: vector = [0 for _ in range(n_unique)] vector[value] = 1 encoding.append(vector) return array(encoding) # decode a one hot encoded string def one_hot_decode(encoded_seq): return [argmax(vector) for vector in encoded_seq] # convert encoded sequence to supervised learning def to_supervised(sequence, n_in, n_out): # create lag copies of the sequence df = DataFrame(sequence) df = concat([df.shift(n_in-i-1) for i in range(n_in)], axis=1) # drop rows with missing values df.dropna(inplace=True) # specify columns for input and output pairs values = df.values width = sequence.shape[1] X = values.reshape(len(values), n_in, width) y = values[:, 0:(n_out*width)].reshape(len(values), n_out, width) return X, y # generate random sequence sequence = generate_sequence() print(sequence) # one hot encode encoded = one_hot_encode(sequence) # convert to X,y pairs X,y = to_supervised(encoded, 5, 3) # decode all pairs for i in range(len(X)): print(one_hot_decode(X[i]), '=>', one_hot_decode(y[i])) ``` 運行示例可能會為您生成不同的特定數字。將序列分成5個數字的輸入序列，并輸出來自輸入序列的3個最老觀察結果的序列。 ```py [86, 81, 88, 1, 23, 78, 64, 7, 99, 23, 2, 36, 73, 26, 27, 33, 24, 51, 73, 64, 13, 13, 53, 40, 64] [86, 81, 88, 1, 23] => [86, 81, 88] [81, 88, 1, 23, 78] => [81, 88, 1] [88, 1, 23, 78, 64] => [88, 1, 23] [1, 23, 78, 64, 7] => [1, 23, 78] [23, 78, 64, 7, 99] => [23, 78, 64] [78, 64, 7, 99, 23] => [78, 64, 7] [64, 7, 99, 23, 2] => [64, 7, 99] [7, 99, 23, 2, 36] => [7, 99, 23] [99, 23, 2, 36, 73] => [99, 23, 2] [23, 2, 36, 73, 26] => [23, 2, 36] [2, 36, 73, 26, 27] => [2, 36, 73] [36, 73, 26, 27, 33] => [36, 73, 26] [73, 26, 27, 33, 24] => [73, 26, 27] [26, 27, 33, 24, 51] => [26, 27, 33] [27, 33, 24, 51, 73] => [27, 33, 24] [33, 24, 51, 73, 64] => [33, 24, 51] [24, 51, 73, 64, 13] => [24, 51, 73] [51, 73, 64, 13, 13] => [51, 73, 64] [73, 64, 13, 13, 53] => [73, 64, 13] [64, 13, 13, 53, 40] => [64, 13, 13] [13, 13, 53, 40, 64] => [13, 13, 53] ``` 現在我們知道如何準備和表示整數的隨機序列，我們可以看一下使用LSTM來學習它們。 ## 回聲全序列（_序列 - 序列模型_）在本節中，我們將開發一個LSTM，用于簡單地解決問題，即預測或再現整個輸入序列。也就是說，給定固定的輸入序列，例如5個隨機整數，輸出相同的序列。這可能聽起來不像問題的簡單框架，但這是因為解決它所需的網絡架構很簡單。我們將生成25個整數的隨機序列，并將它們構造為5個值的輸入 - 輸出對。我們將創建一個名為get_data（）的便捷函數，我們將使用它來創建編碼的X，y對隨機整數，使用上一節中準備的所有功能。此功能如下所列。 ```py # prepare data for the LSTM def get_data(n_in, n_out): # generate random sequence sequence = generate_sequence() # one hot encode encoded = one_hot_encode(sequence) # convert to X,y pairs X,y = to_supervised(encoded, n_in, n_out) return X,y ``` 將使用參數5和5調用此函數，以創建21個樣本，其中5個步驟的100個特征作為輸入，并且與輸出相同（21個而不是25個，因為刪除了由于序列移位而導致缺失值的某些行）。我們現在可以為此問題開發LSTM。我們將使用有狀態LSTM并在訓練結束時為每個生成的樣本顯式重置內部狀態。由于學習所需的上下文將作為時間步長提供，因此可能需要或可能不需要跨序列中的樣本維持網絡內的內部狀態;盡管如此，這個額外的狀態可能會有所幫助。讓我們首先將輸入數據的預期尺寸定義為100個特征的5個時間步長。因為我們使用有狀態LSTM，所以將使用batch_input_shape參數而不是input_shape指定。 LSTM隱藏層將使用20個內存單元，這應該足以學習這個問題。批量大小為7。批量大小必須是訓練樣本數量的因子（在這種情況下為21），并定義數量樣本，之后更新LSTM中的權重。這意味著對于訓練網絡的每個隨機序列，權重將更新3次。 ```py model = Sequential() model.add(LSTM(20, batch_input_shape=(7, 5, 100), return_sequences=True, stateful=True)) ``` 我們希望輸出層一次輸出一個整數，每個輸出觀察一個。我們將輸出層定義為完全連接的層（Dense），其中100個神經元用于一個熱編碼中的100個可能的整數值中的每一個。因為我們使用一個熱編碼并將問題框架化為多類分類，所以我們可以在Dense層中使用softmax激活函數。 ```py Dense(100, activation='softmax') ``` 我們需要將此輸出層包裝在TimeDistributed層中。這是為了確保我們可以使用輸出層為輸入序列中的每個項目預測一個整數。這是關鍵，因此我們正在實現真正的多對多模型（例如序列到序列），而不是多對一模型，其中基于內部狀態和值創建一次性向量輸出輸入序列中最后一次觀察的結果（例如，輸出層一次輸出5 * 100個值）。這要求先前的LSTM層通過設置return_sequences = True來返回序列（例如，輸入序列中的每個觀察的一個輸出而不是整個輸入序列的一個輸出）。 TimeDistributed層執行將來自LSTM層的序列的每個切片應用為包裝的Dense層的輸入的技巧，以便一次可以預測一個整數。 ```py model.add(TimeDistributed(Dense(100, activation='softmax'))) ``` 我們將使用適用于多類分類問題的日志丟失函數（categorical_crossentropy）和具有默認超參數的高效ADAM優化算法。除了報告每個時期的日志損失之外，我們還將報告分類準確性，以了解我們的模型是如何訓練的。 ```py model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) ``` 為了確保網絡不記住問題，并且網絡學習為所有可能的輸入序列推廣解決方案，我們將在每個訓練時期生成新的隨機序列。 LSTM隱藏層內的內部狀態將在每個時期結束時重置。我們將為500個訓練時期擬合模型。 ```py # train LSTM for epoch in range(500): # generate new random sequence X,y = get_data(5, 5) # fit model for one epoch on this sequence model.fit(X, y, epochs=1, batch_size=7, verbose=2, shuffle=False) model.reset_states() ``` 一旦擬合，我們將通過對一個新的整數隨機序列進行預測來評估模型，并將解碼的預期輸出序列與預測的序列進行比較。 ```py # evaluate LSTM X,y = get_data(5, 5) yhat = model.predict(X, batch_size=7, verbose=0) # decode all pairs for i in range(len(X)): print('Expected:', one_hot_decode(y[i]), 'Predicted', one_hot_decode(yhat[i])) ``` 綜合這些，下面提供了完整的代碼清單。 ```py from random import randint from numpy import array from numpy import argmax from pandas import DataFrame from pandas import concat from keras.models import Sequential from keras.layers import LSTM from keras.layers import Dense from keras.layers import TimeDistributed # generate a sequence of random numbers in [0, 99] def generate_sequence(length=25): return [randint(0, 99) for _ in range(length)] # one hot encode sequence def one_hot_encode(sequence, n_unique=100): encoding = list() for value in sequence: vector = [0 for _ in range(n_unique)] vector[value] = 1 encoding.append(vector) return array(encoding) # decode a one hot encoded string def one_hot_decode(encoded_seq): return [argmax(vector) for vector in encoded_seq] # convert encoded sequence to supervised learning def to_supervised(sequence, n_in, n_out): # create lag copies of the sequence df = DataFrame(sequence) df = concat([df.shift(n_in-i-1) for i in range(n_in)], axis=1) # drop rows with missing values df.dropna(inplace=True) # specify columns for input and output pairs values = df.values width = sequence.shape[1] X = values.reshape(len(values), n_in, width) y = values[:, 0:(n_out*width)].reshape(len(values), n_out, width) return X, y # prepare data for the LSTM def get_data(n_in, n_out): # generate random sequence sequence = generate_sequence() # one hot encode encoded = one_hot_encode(sequence) # convert to X,y pairs X,y = to_supervised(encoded, n_in, n_out) return X,y # define LSTM n_in = 5 n_out = 5 encoded_length = 100 batch_size = 7 model = Sequential() model.add(LSTM(20, batch_input_shape=(batch_size, n_in, encoded_length), return_sequences=True, stateful=True)) model.add(TimeDistributed(Dense(encoded_length, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) # train LSTM for epoch in range(500): # generate new random sequence X,y = get_data(n_in, n_out) # fit model for one epoch on this sequence model.fit(X, y, epochs=1, batch_size=batch_size, verbose=2, shuffle=False) model.reset_states() # evaluate LSTM X,y = get_data(n_in, n_out) yhat = model.predict(X, batch_size=batch_size, verbose=0) # decode all pairs for i in range(len(X)): print('Expected:', one_hot_decode(y[i]), 'Predicted', one_hot_decode(yhat[i])) ``` 運行該示例會在每個時期打印日志丟失和準確性。通過生成新的隨機序列并將預期序列與預測序列進行比較來結束運行。根據所選擇的配置，每次運行時，網絡幾乎都會收斂到100％的準確度。請注意，您可能會看到不同的最終序列和最終的日志丟失。 ```py ... Epoch 1/1 0s - loss: 1.7310 - acc: 1.0000 Epoch 1/1 0s - loss: 1.5712 - acc: 1.0000 Epoch 1/1 0s - loss: 1.7447 - acc: 1.0000 Epoch 1/1 0s - loss: 1.5704 - acc: 1.0000 Epoch 1/1 0s - loss: 1.6124 - acc: 1.0000 Expected: [98, 30, 98, 11, 49] Predicted [98, 30, 98, 11, 49] Expected: [30, 98, 11, 49, 1] Predicted [30, 98, 11, 49, 1] Expected: [98, 11, 49, 1, 77] Predicted [98, 11, 49, 1, 77] Expected: [11, 49, 1, 77, 80] Predicted [11, 49, 1, 77, 80] Expected: [49, 1, 77, 80, 23] Predicted [49, 1, 77, 80, 23] Expected: [1, 77, 80, 23, 32] Predicted [1, 77, 80, 23, 32] Expected: [77, 80, 23, 32, 27] Predicted [77, 80, 23, 32, 27] Expected: [80, 23, 32, 27, 66] Predicted [80, 23, 32, 27, 66] Expected: [23, 32, 27, 66, 96] Predicted [23, 32, 27, 66, 96] Expected: [32, 27, 66, 96, 76] Predicted [32, 27, 66, 96, 76] Expected: [27, 66, 96, 76, 10] Predicted [27, 66, 96, 76, 10] Expected: [66, 96, 76, 10, 39] Predicted [66, 96, 76, 10, 39] Expected: [96, 76, 10, 39, 44] Predicted [96, 76, 10, 39, 44] Expected: [76, 10, 39, 44, 57] Predicted [76, 10, 39, 44, 57] Expected: [10, 39, 44, 57, 11] Predicted [10, 39, 44, 57, 11] Expected: [39, 44, 57, 11, 48] Predicted [39, 44, 57, 11, 48] Expected: [44, 57, 11, 48, 39] Predicted [44, 57, 11, 48, 39] Expected: [57, 11, 48, 39, 28] Predicted [57, 11, 48, 39, 28] Expected: [11, 48, 39, 28, 15] Predicted [11, 48, 39, 28, 15] Expected: [48, 39, 28, 15, 49] Predicted [48, 39, 28, 15, 49] Expected: [39, 28, 15, 49, 76] Predicted [39, 28, 15, 49, 76] ``` ## 回聲部分序列（_編碼器 - 解碼器模型_）到目前為止，這么好，但是如果我們希望輸出序列的長度與輸入序列的長度不同呢？也就是說，我們希望從5個觀測值的輸入序列中回顯前2個觀測值： ```py [1, 2, 3, 4, 5] => [1, 2] ``` 這仍然是序列到序列預測問題，但需要更改網絡體系結構。一種方法是使輸出序列具有相同的長度，并使用填充將輸出序列填充到相同的長度。或者，我們可以使用更優雅的解決方案。我們可以實現允許可變長度輸出的編碼器 - 解碼器網絡，其中編碼器學習輸入序列的內部表示，并且解碼器讀取內部表示并學習如何創建相同或不同長度的輸出序列。對于網絡來說，這是一個更具挑戰性的問題，并且需要額外的容量（更多的內存單元）和更長的訓練（更多的時期）。網絡的輸入，第一個隱藏的LSTM層和TimeDistributed密集輸出層保持不變，除了我們將內存單元的數量從20增加到150.我們還將批量大小從7增加到21，以便重量更新是在隨機序列的所有樣本的末尾執行。經過一些實驗，發現這可以使這個網絡的學習更快。 ```py model.add(LSTM(150, batch_input_shape=(21, 5, 100), stateful=True)) ... model.add(TimeDistributed(Dense(100, activation='softmax'))) ``` 第一個隱藏層是編碼器。我們必須添加一個額外的隱藏LSTM層來充當解碼器。同樣，我們將在此層中使用150個內存單元，并且與前面的示例一樣，TimeDistributed層之前的層將返回序列而不是單個值。 ```py model.add(LSTM(150, return_sequences=True, stateful=True)) ``` 這兩層不能整齊地配合在一起。編碼器層將輸出2D陣列（21,150），并且解碼器期望3D陣列作為輸入（21，α，150）。我們通過在編碼器和解碼器之間添加RepeatVector（）層來解決這個問題，并確保編碼器的輸出重復適當的次數以匹配輸出序列的長度。在這種情況下，輸出序列中兩個時間步長為2次。 ```py model.add(RepeatVector(2)) ``` 因此，LSTM網絡定義為： ```py model = Sequential() model.add(LSTM(150, batch_input_shape=(21, 5, 100), stateful=True)) model.add(RepeatVector(2)) model.add(LSTM(150, return_sequences=True, stateful=True)) model.add(TimeDistributed(Dense(100, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) ``` 訓練時期的數量從500增加到5,000，以說明網絡的額外容量。示例的其余部分是相同的。將這些結合在一起，下面提供了完整的代碼清單。 ```py from random import randint from numpy import array from numpy import argmax from pandas import DataFrame from pandas import concat from keras.models import Sequential from keras.layers import LSTM from keras.layers import Dense from keras.layers import TimeDistributed from keras.layers import RepeatVector # generate a sequence of random numbers in [0, 99] def generate_sequence(length=25): return [randint(0, 99) for _ in range(length)] # one hot encode sequence def one_hot_encode(sequence, n_unique=100): encoding = list() for value in sequence: vector = [0 for _ in range(n_unique)] vector[value] = 1 encoding.append(vector) return array(encoding) # decode a one hot encoded string def one_hot_decode(encoded_seq): return [argmax(vector) for vector in encoded_seq] # convert encoded sequence to supervised learning def to_supervised(sequence, n_in, n_out): # create lag copies of the sequence df = DataFrame(sequence) df = concat([df.shift(n_in-i-1) for i in range(n_in)], axis=1) # drop rows with missing values df.dropna(inplace=True) # specify columns for input and output pairs values = df.values width = sequence.shape[1] X = values.reshape(len(values), n_in, width) y = values[:, 0:(n_out*width)].reshape(len(values), n_out, width) return X, y # prepare data for the LSTM def get_data(n_in, n_out): # generate random sequence sequence = generate_sequence() # one hot encode encoded = one_hot_encode(sequence) # convert to X,y pairs X,y = to_supervised(encoded, n_in, n_out) return X,y # define LSTM n_in = 5 n_out = 2 encoded_length = 100 batch_size = 21 model = Sequential() model.add(LSTM(150, batch_input_shape=(batch_size, n_in, encoded_length), stateful=True)) model.add(RepeatVector(n_out)) model.add(LSTM(150, return_sequences=True, stateful=True)) model.add(TimeDistributed(Dense(encoded_length, activation='softmax'))) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) # train LSTM for epoch in range(5000): # generate new random sequence X,y = get_data(n_in, n_out) # fit model for one epoch on this sequence model.fit(X, y, epochs=1, batch_size=batch_size, verbose=2, shuffle=False) model.reset_states() # evaluate LSTM X,y = get_data(n_in, n_out) yhat = model.predict(X, batch_size=batch_size, verbose=0) # decode all pairs for i in range(len(X)): print('Expected:', one_hot_decode(y[i]), 'Predicted', one_hot_decode(yhat[i])) ``` 運行該示例將顯示每個訓練時期隨機生成的序列的日志丟失和準確性。選擇的配置意味著模型將收斂到100％的分類準確度。生成最終隨機生成的序列，并比較預期序列與預測序列。運行示例時生成的特定序列可能不同。 ```py ... Epoch 1/1 0s - loss: 0.0248 - acc: 1.0000 Epoch 1/1 0s - loss: 0.0399 - acc: 1.0000 Epoch 1/1 0s - loss: 0.0285 - acc: 1.0000 Epoch 1/1 0s - loss: 0.0410 - acc: 0.9762 Epoch 1/1 0s - loss: 0.0236 - acc: 1.0000 Expected: [6, 52] Predicted [6, 52] Expected: [52, 96] Predicted [52, 96] Expected: [96, 45] Predicted [96, 45] Expected: [45, 69] Predicted [45, 69] Expected: [69, 52] Predicted [69, 52] Expected: [52, 96] Predicted [52, 96] Expected: [96, 11] Predicted [96, 96] Expected: [11, 96] Predicted [11, 96] Expected: [96, 54] Predicted [96, 54] Expected: [54, 27] Predicted [54, 27] Expected: [27, 48] Predicted [27, 48] Expected: [48, 9] Predicted [48, 9] Expected: [9, 32] Predicted [9, 32] Expected: [32, 62] Predicted [32, 62] Expected: [62, 41] Predicted [62, 41] Expected: [41, 54] Predicted [41, 54] Expected: [54, 20] Predicted [54, 20] Expected: [20, 80] Predicted [20, 80] Expected: [80, 63] Predicted [80, 63] Expected: [63, 69] Predicted [63, 69] Expected: [69, 36] Predicted [69, 36] ``` ## 擴展本節列出了您可能希望探索的教程的一些可能的擴展。 * **線性表示**。使用了問題的分類（一個熱編碼）框架，顯著增加了模擬該問題所需的權重數量（每個隨機整數100個）。使用線性表示（將整數縮放到0-1之間的值）進行探索，并將問題建模為回歸。了解這將如何影響系統技能，所需的網絡規模（內存單元）和訓練時間（時期）。 * **掩碼缺失值**。當序列數據被構造為監督學習問題時，刪除了具有缺失數據的行。使用屏蔽層或特殊值（例如-1）進行探索，以允許網絡忽略或學習忽略這些值。 * **Echo Longer Sequences** 。學會回應的部分子序列只有2個項目。使用編碼器 - 解碼器網絡探索回顯更長的序列。請注意，您可能需要更長時間（更多迭代）訓練更大的隱藏層（更多內存單元）。 * **忽略狀態**。注意僅在每個隨機整數序列的所有樣品的末尾清除狀態而不是在序列內洗滌樣品。這可能不是必需的。使用批量大小為1的無狀態LSTM探索和對比模型表現（在每個序列的每個樣本之后進行重量更新和狀態重置）。我希望幾乎沒有變化。 * **備用網絡拓撲**。注意使用TimeDistributed包裝器作為輸出層，以確保使用多對多網絡來模擬問題。通過一對一配置（作為功能的時間步長）或多對一（作為功能向量的輸出）探索序列回聲問題，并了解它如何影響所需的網絡大小（內存單元）和訓練時間（時代）。我希望它需要更大的網絡，并需要更長的時間。你有沒有探索過這些擴展？在下面的評論中分享您的發現。 ## 摘要在本教程中，您了解了如何開發LSTM循環神經網絡以從隨機生成的整數列表中回顯序列和部分序列。具體來說，你學到了： * 如何生成隨機的整數序列，使用一個熱編碼表示它們，并將問題構建為監督學習問題。 * 如何開發基于序列到序列的LSTM網絡以回顯整個輸入序列。 * 如何開發基于編碼器 - 解碼器的LSTM網絡，以回顯長度與輸入序列長度不同的部分輸入序列。你有任何問題嗎？在評論中發表您的問題，我會盡力回答。