五、TensorFlow 和 Keras 中的神經網絡和 MLP · ApacheCN 深度學習譯文集

# 五、TensorFlow 和 Keras 中的神經網絡和 MLP 神經網絡是一種受大腦結構和功能啟發的建模技術。正如大腦包含數百萬個被稱為神經元的微小互連單元一樣，今天的神經網絡由數百萬個分層排列的微小互連計算單元組成。由于神經網絡的計算單元僅存在于數字世界中，與大腦的物理神經元相反，它們也被稱為人工神經元。類似地，神經網絡（NN）也稱為人工神經網絡（ANN）。在本章中，我們將進一步擴展以下主題： * 感知機（人工神經元） * 前饋神經網絡 * 用于圖像分類的**多層感知機**（**MLP**） * 基于 TensorFlow 的用于 MNIST 圖像分類的 MLP * 基于 Keras 的用于 MNIST 分類的 MLP * 基于 TFLearn 的用于 MNIST 分類的 MLP * 用于時間序列回歸的 MLP # 感知機讓我們了解神經網絡的最基本構建塊，**感知機**，也稱為**人工神經元**。感知機的概念起源于 Frank Rosenblatt 于 1962 年的作品。您可能希望閱讀以下工作來探索神經網絡的起源： Frank Rosenblatt，神經動力學原理：感知器和腦機制理論，斯巴達書籍，1962 年在最簡化的視圖中，感知機被建模在生物神經元之后，使得它接收一個或多個輸入并將它們組合以產生輸出。如下圖所示，感知機采用三個輸入并將它們相加以生成輸出`y`： ![](https://img.kancloud.cn/f8/1a/f81af23bce4d4dc56aeff4eeb1968a3a_365x161.png) 這種感知機太簡單了，不具備任何實際用途。因此，通過添加權重，偏差和激活函數的概念來增強它。將權重添加到每個輸入以獲得加權和。如果加權和`Σw[i]x[i]`小于閾值，則輸出為 0，否則輸出為 1： ![](https://img.kancloud.cn/c5/24/c52421a6a1e8318796bceca2413ca1c4_2780x490.png) 閾值稱為**偏差**。讓我們將偏差移到等式的左邊，用`b`表示它，`Σw·x`代表`w`和`x`的向量點積。感知機的等式現在變為如下： ![](https://img.kancloud.cn/aa/fd/aafd4d4d8b52447ebce8537ea128e34c_2400x490.png) 感知機現在看起來像下圖： ![](https://img.kancloud.cn/bf/fa/bffa343c7729fa5fd5b160c6e2097077_365x219.png)?Simple perceptron with weights and bias 到目前為止，神經元是一個線性函數。為了使這個神經元產生非線性決策邊界，通過稱為**激活**或傳遞函數的非線性函數運行求和輸出。有許多流行的激活函數可用： * `ReLU`：**整流線性單元**，將值平滑到范圍`(0, x)`， ![](https://img.kancloud.cn/9d/97/9d976642b2cb96318bf7d20fc5348d96_1790x210.png) * `sigmoid`：**Sigmoid** 將值平滑到`(0, 1)`， ![](https://img.kancloud.cn/c8/51/c851a645213824754d6fd575d483f923_2640x430.png) * `tanh`：**雙曲正切**將值平滑到`(-1, 1)`， ![](https://img.kancloud.cn/3e/f4/3ef4c5dd51dd136bae593ee49b839170_1640x450.png) 使用激活函數，感知機的等式變為： ![](https://img.kancloud.cn/fc/40/fc40249380706583b0d8ff8202b2e2ff_1290x210.png) 其中`φ(·)`是激活函數。神經元看起來像下圖： ![](https://img.kancloud.cn/ad/53/ad53fd791e0f5df10fb7520b0aa2d296_453x219.png) # 多層感知機當我們將人工神經元連接在一起時，基于明確定義的結構，我們將其稱為神經網絡。這是一個神經元最簡單的神經網絡： ![](https://img.kancloud.cn/ab/b3/abb375d3a6530e489d728b5fe1358f25_430x235.png)Neural network with one neuron 我們連接神經元，使得一層的輸出成為下一層的輸入，直到最后一層的輸出成為最終輸出。這種神經網絡被稱為**前饋神經網絡（FFNN）**。由于這些 FFNN 由連接在一起的神經元層組成，因此它們被稱為**多層感知機（MLP）**或**深度神經網絡（DNN）**。作為示例，下圖中描繪的 MLP 具有三個特征作為輸入：兩個隱藏層，每個神經元包含五個神經元，一個輸出 y。神經元完全連接到下一層的神經元。這些層也稱為致密層或仿射層，并且這種模型也稱為順序模型。 ![](https://img.kancloud.cn/28/ed/28ed28db54f03be1e3ea69abcbdfb0b6_466x308.png) 讓我們重溫一下我們之前探索過的一些示例數據集，并在 TensorFlow 中構建簡單的神經網絡（MLP 或 DNN）。您可以按照 Jupyter 筆記本`ch-05_MLP`中的代碼進行操作。 # 用于圖像分類的 MLP 讓我們使用不同的庫（例如 TensorFlow，Keras 和 TFLearn）構建用于圖像分類的 MLP 網絡。我們將在本節中使用示例的 MNIST 數據集。 MNIST 數據集包含從 0 到 9 的手寫數字的`28x28`像素圖像，以及它們的標簽，訓練集為 60K，測試集為 10K。 MNIST 數據集是使用最廣泛的數據集，包括 TensorFlow 示例和教程。 [MNIST 數據集和相關文檔可從此鏈接獲得](http://yann.lecun.com/exdb/mnist/)。讓我們從純 TensorFlow 方法開始。 # TensorFlow 中的用于 MNIST 分類的 MLP 首先，加載 MNIST 數據集，并使用以下代碼定義訓練和測試特征以及目標： ```py from tensorflow.examples.tutorials.mnist import input_data mnist_home = os.path.join(datasetslib.datasets_root, 'mnist') mnist = input_data.read_data_sets(mnist_home, one_hot=True) X_train = mnist.train.images X_test = mnist.test.images Y_train = mnist.train.labels Y_test = mnist.test.labels num_outputs = 10 # 0-9 digits num_inputs = 784 # total pixels ``` 我們創建了三個輔助函數，它們將幫助我們創建一個只有一個隱藏層的簡單 MLP，然后是一個更大的 MLP，每層有多個層和多個神經元。 `mlp()`函數使用以下邏輯構建網絡層： 1. `mlp()`函數需要五個輸入： * `x`是輸入特征張量 * `num_inputs`是輸入特征的數量 * `num_outputs`是輸出目標的數量 * `num_layers`是所需隱藏層數 * `num_neurons`是包含每層神經元數量的列表 2. 將權重和偏差列表設置為空： ```py w=[] b=[] ``` 1. 為隱藏層的數量運行循環以創建權重和偏移張量并將它們附加到各自的列表： * 張量分別名為`w_<layer_num>`和`b_<layer_num>`。命名張量有助于調試和查找代碼問題。 * 使用`tf.random_normal()`以正態分布初始化張量。 * 權重張量的第一個維度是來自前一層的輸入數量。對于第一個隱藏層，第一個維度是`num_inputs`。權重張量的第二維是當前層中的神經元的數量。 * 偏差都是一維張量，其中維度等于當前層中的神經元數量。 ```py for i in range(num_layers): # weights w.append(tf.Variable(tf.random_normal( [num_inputs if i == 0 else num_neurons[i - 1], num_neurons[i]]), name="w_{0:04d}".format(i) )) # biases b.append(tf.Variable(tf.random_normal( [num_neurons[i]]), name="b_{0:04d}".format(i) )) ``` 1. 為最后一個隱藏層創建權重和偏差。在這種情況下，權重張量的維度等于最后隱藏層中的神經元數量和輸出目標的數量。偏差是一個張量，具有輸出特征數量大小的單一維度： ```py w.append(tf.Variable(tf.random_normal( [num_neurons[num_layers - 1] if num_layers > 0 else num_inputs, num_outputs]), name="w_out")) b.append(tf.Variable(tf.random_normal([num_outputs]), name="b_out")) ``` 1. 現在開始定義層。首先，將`x`視為第一個最明顯的輸入層： ```py # x is input layer layer = x ``` 1. 在循環中添加隱藏的層。每個隱藏層表示，通過激活函數`tf.nn.relu()`使線性函數`tf.matmul(layer, w[i]) + b[i]`非線性化： ```py # add hidden layers for i in range(num_layers): layer = tf.nn.relu(tf.matmul(layer, w[i]) + b[i]) ``` 1. 添加輸出層。輸出層和隱藏層之間的一個區別是輸出層中沒有激活函數： ```py layer = tf.matmul(layer, w[num_layers]) + b[num_layers] ``` 1. 返回包含 MLP 網絡的`layer`對象： ```py return layer ``` 整個 MLP 函數的完整代碼如下： ```py def mlp(x, num_inputs, num_outputs, num_layers, num_neurons): w = [] b = [] for i in range(num_layers): # weights w.append(tf.Variable(tf.random_normal( [num_inputs if i == 0 else num_neurons[i - 1], num_neurons[i]]), name="w_{0:04d}".format(i) )) # biases b.append(tf.Variable(tf.random_normal( [num_neurons[i]]), name="b_{0:04d}".format(i) )) w.append(tf.Variable(tf.random_normal( [num_neurons[num_layers - 1] if num_layers > 0 else num_inputs, num_outputs]), name="w_out")) b.append(tf.Variable(tf.random_normal([num_outputs]), name="b_out")) # x is input layer layer = x # add hidden layers for i in range(num_layers): layer = tf.nn.relu(tf.matmul(layer, w[i]) + b[i]) # add output layer layer = tf.matmul(layer, w[num_layers]) + b[num_layers] return layer ``` 輔助函數`mnist_batch_func()`為 MNIST 數據集包裝 TensorFlow 的批量函數，以提供下一批圖像： ```py def mnist_batch_func(batch_size=100): X_batch, Y_batch = mnist.train.next_batch(batch_size) return [X_batch, Y_batch] ``` 此函數不言自明。 TensorFlow 為 MNIST 數據集提供此函數；但是，對于其他數據集，我們可能必須編寫自己的批量函數。輔助函數`tensorflow_classification()`訓練并評估模型。 1. `tensorflow_classification()`函數有幾個輸入： * * `n_epochs`是要運行的訓練循環的數量 * `n_batches`是應該運行每個循環中的訓練的隨機抽樣批次的數量 * `batch_size`是每批中的樣本數 * `batch_func`是`batch_size`并返回`X`和`Y`樣本批次的函數 * `model`是具有神經元的實際神經網絡或層 * `optimizer`是使用 TensorFlow 定義的優化函數 * `loss`是優化器優化參數的成本函數損失 * `accuracy_function`是計算準確率分數的函數 * `X_test`和`Y_test`是測試的數據集 1. 啟動 TensorFlow 會話以運行訓練循環： ```py with tf.Session() as tfs: tf.global_variables_initializer().run() ``` 1. 運行`n_epoch`循環來訓練： ```py for epoch in range(n_epochs): ``` 1. 在每個循環中，取樣本集的`n_batches`數量并訓練模型，計算每批的損失，計算每個周期的平均損失： ```py epoch_loss = 0.0 for batch in range(n_batches): X_batch, Y_batch = batch_func(batch_size) feed_dict = {x: X_batch, y: Y_batch} _, batch_loss = tfs.run([optimizer, loss], feed_dict) epoch_loss += batch_loss average_loss = epoch_loss / n_batches print("epoch: {0:04d} loss = {1:0.6f}".format( epoch, average_loss)) ``` 1. 完成所有周期循環后，計算并打印用`accuracy_function`計算的精度分數： ```py feed_dict = {x: X_test, y: Y_test} accuracy_score = tfs.run(accuracy_function, feed_dict=feed_dict) print("accuracy={0:.8f}".format(accuracy_score)) ``` `tensorflow_classification()`函數的完整代碼如下： ```py def tensorflow_classification(n_epochs, n_batches, batch_size, batch_func, model, optimizer, loss, accuracy_function, X_test, Y_test): with tf.Session() as tfs: tfs.run(tf.global_variables_initializer()) for epoch in range(n_epochs): epoch_loss = 0.0 for batch in range(n_batches): X_batch, Y_batch = batch_func(batch_size) feed_dict = {x: X_batch, y: Y_batch} _, batch_loss = tfs.run([optimizer, loss], feed_dict) epoch_loss += batch_loss average_loss = epoch_loss / n_batches print("epoch: {0:04d} loss = {1:0.6f}".format( epoch, average_loss)) feed_dict = {x: X_test, y: Y_test} accuracy_score = tfs.run(accuracy_function, feed_dict=feed_dict) print("accuracy={0:.8f}".format(accuracy_score)) ``` 現在讓我們定義輸入和輸出占位符，`x`和`y`以及其他超參數： ```py # input images x = tf.placeholder(dtype=tf.float32, name="x", shape=[None, num_inputs]) # target output y = tf.placeholder(dtype=tf.float32, name="y", shape=[None, num_outputs]) num_layers = 0 num_neurons = [] learning_rate = 0.01 n_epochs = 50 batch_size = 100 n_batches = int(mnist.train.num_examples/batch_size) ``` 參數如下所述： * `num_layers`是隱藏層數。我們首先練習沒有隱藏層，只有輸入和輸出層。 * `num_neurons`是空列表，因為沒有隱藏層。 * `learning_rate`是 0.01，隨機選擇的小數。 * `num_epochs`代表 50 次迭代，以學習將輸入連接到輸出的唯一神經元的參數。 * `batch_size`保持在 100，這也是一個選擇問題。較大的批量大小不一定提供更高的好處。您可能需要探索不同的批量大小，以找到神經網絡的最佳批量大小。 * `n_batches`：批次數大致計算為示例數除以批次中的樣本數。現在讓我們將所有內容放在一起，使用到目前為止定義的變量定義網絡，`loss`函數，`optimizer`函數和`accuracy`函數。 ```py model = mlp(x=x, num_inputs=num_inputs, num_outputs=num_outputs, num_layers=num_layers, num_neurons=num_neurons) loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=y)) optimizer = tf.train.GradientDescentOptimizer( learning_rate=learning_rate).minimize(loss) predictions_check = tf.equal(tf.argmax(model, 1), tf.argmax(y, 1)) accuracy_function = tf.reduce_mean(tf.cast(predictions_check, tf.float32)) ``` 在這段代碼中，我們使用一個新的 tensorflow 函數來定義損失函數： ```py tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=y) ``` 當使用`softmax_cross_entropy_with_logits()`函數時，請確保輸出未縮放且尚未通過`softmax`激活函數。此函數在內部使用`softmax`來縮放輸出。該函數計算模型之間的 softmax 熵（估計值`y`）和`y`的實際值。當輸出屬于一個類而不是一個類時，使用熵函數。在我們的示例中，圖像只能屬于其中一個數字。有關此熵函數的更多信息，[請參閱此鏈接](https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits)。一旦定義了所有內容，運行`tensorflow_classification`函數來訓練和評估模型： ```py tensorflow_classification(n_epochs=n_epochs, n_batches=n_batches, batch_size=batch_size, batch_func=mnist_batch_func, model = model, optimizer = optimizer, loss = loss, accuracy_function = accuracy_function, X_test = mnist.test.images, Y_test = mnist.test.labels ) ``` 我們從運行分類得到以下輸出： ```py epoch: 0000 loss = 8.364567 epoch: 0001 loss = 4.347608 epoch: 0002 loss = 3.085622 epoch: 0003 loss = 2.468341 epoch: 0004 loss = 2.099220 epoch: 0005 loss = 1.853206 --- Epoch 06 to 45 output removed for brevity --- epoch: 0046 loss = 0.684285 epoch: 0047 loss = 0.678972 epoch: 0048 loss = 0.673685 epoch: 0049 loss = 0.668717 accuracy=0.85720009 ``` 我們看到單個神經元網絡在 50 次迭代中緩慢地將損失從 8.3 降低到 0.66，最終得到幾乎 85% 的準確率。對于這個具體的例子，這是非常糟糕的準確率，因為這只是使用 TensorFlow 進行分類使用 MLP 的演示。我們使用更多層和神經元運行相同的代碼，并獲得以下準確率： | 層數 | 每個隱藏層中的神經元數量 | 準確率 | | --- | --- | --- | | 0 | 0 | 0.857 | | 1 | 8 | 0.616 | | 2 | 256 | 0.936 | 因此，通過在每層添加兩行和 256 個神經元，我們將精度提高到 0.936。我們鼓勵您嘗試使用不同變量值的代碼來觀察它如何影響損失和準確率。 # Keras 中的用于 MNIST 分類的 MLP 現在讓我們與 Keras 建立相同的 MLP 網絡，Keras 是 TensorFlow 的高級庫。我們保留所有參數與本章中用于 TensorFlow 示例的參數相同，例如，隱藏層的激活函數保留為 ReLU 函數。 1. 從 Keras 導入所需的模塊： ```py import keras from keras.models import Sequential from keras.layers import Dense from keras.optimizers import SGD ``` 1. 定義超參數（我們假設數據集已經加載到`X_train`，`Y_train`，`X_test`和`Y_test`變量）： ```py num_layers = 2 num_neurons = [] for i in range(num_layers): num_neurons.append(256) learning_rate = 0.01 n_epochs = 50 batch_size = 100 ``` 1. 創建順序模型： ```py model = Sequential() ``` 1. 添加第一個隱藏層。只有在第一個隱藏層中，我們必須指定輸入張量的形狀： ```py model.add(Dense(units=num_neurons[0], activation='relu', input_shape=(num_inputs,))) ``` 1. 添加第二層： ```py model.add(Dense(units=num_neurons[1], activation='relu')) ``` 1. 使用 softmax 激活函數添加輸出層： ```py model.add(Dense(units=num_outputs, activation='softmax')) ``` 1. 打印模型詳細信息： ```py model.summary() ``` 我們得到以下輸出： ```py _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) (None, 256) 200960 _________________________________________________________________ dense_2 (Dense) (None, 256) 65792 _________________________________________________________________ dense_3 (Dense) (None, 10) 2570 ================================================================= Total params: 269,322 Trainable params: 269,322 Non-trainable params: 0 _________________________________________________________________ ``` 1. 使用 SGD 優化器編譯模型： ```py model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=learning_rate), metrics=['accuracy']) ``` 1. 訓練模型： ```py model.fit(X_train, Y_train, batch_size=batch_size, epochs=n_epochs) ``` 在訓練模型時，我們可以觀察每次訓練迭代的損失和準確率： ```py Epoch 1/50 55000/55000 [========================] - 4s - loss: 1.1055 - acc: 0.7413 Epoch 2/50 55000/55000 [========================] - 3s - loss: 0.4396 - acc: 0.8833 Epoch 3/50 55000/55000 [========================] - 3s - loss: 0.3523 - acc: 0.9010 Epoch 4/50 55000/55000 [========================] - 3s - loss: 0.3129 - acc: 0.9112 Epoch 5/50 55000/55000 [========================] - 3s - loss: 0.2871 - acc: 0.9181 --- Epoch 6 to 45 output removed for brevity --- Epoch 46/50 55000/55000 [========================] - 4s - loss: 0.0689 - acc: 0.9814 Epoch 47/50 55000/55000 [========================] - 4s - loss: 0.0672 - acc: 0.9819 Epoch 48/50 55000/55000 [========================] - 4s - loss: 0.0658 - acc: 0.9822 Epoch 49/50 55000/55000 [========================] - 4s - loss: 0.0643 - acc: 0.9829 Epoch 50/50 55000/55000 [========================] - 4s - loss: 0.0627 - acc: 0.9829 ``` 1. 評估模型并打印損失和準確率： ```py score = model.evaluate(X_test, Y_test) print('\n Test loss:', score[0]) print('Test accuracy:', score[1]) ``` 我們得到以下輸出： ```py Test loss: 0.089410082236 Test accuracy: 0.9727 ``` 筆記本`ch-05_MLP`中提供了使用 Keras 進行 MNIST 分類的 MLP 的完整代碼。 # TFLearn 中的用于 MNIST 分類的 MLP 現在讓我們看看如何使用 TFLearn 實現相同的 MLP，TFLearn 是 TensorFlow 的另一個高級庫： 1. 導入 TFLearn 庫： ```py import tflearn ``` 1. 定義超參數（我們假設數據集已經加載到`X_train`，`Y_train`，`X_test`和`Y_test`變量）： ```py num_layers = 2 num_neurons = [] for i in range(num_layers): num_neurons.append(256) learning_rate = 0.01 n_epochs = 50 batch_size = 100 ``` 1. 構建輸入層，兩個隱藏層和輸出層（與 TensorFlow 和 Keras 部分中的示例相同） ```py # Build deep neural network input_layer = tflearn.input_data(shape=[None, num_inputs]) dense1 = tflearn.fully_connected(input_layer, num_neurons[0], activation='relu') dense2 = tflearn.fully_connected(dense1, num_neurons[1], activation='relu') softmax = tflearn.fully_connected(dense2, num_outputs, activation='softmax') ``` 1. 使用最后一步中構建的 DNN（在變量`softmax`中）定義優化器函數，神經網絡和 MLP 模型（在 TFLearn 中稱為 DNN）： ```py optimizer = tflearn.SGD(learning_rate=learning_rate) net = tflearn.regression(softmax, optimizer=optimizer, metric=tflearn.metrics.Accuracy(), loss='categorical_crossentropy') model = tflearn.DNN(net) ``` 1. 訓練模型： ```py model.fit(X_train, Y_train, n_epoch=n_epochs, batch_size=batch_size, show_metric=True, run_id="dense_model") ``` 訓練結束后，我們得到以下輸出： ```py Training Step: 27499 | total loss: 0.11236 | time: 5.853s | SGD | epoch: 050 | loss: 0.11236 - acc: 0.9687 -- iter: 54900/55000 Training Step: 27500 | total loss: 0.11836 | time: 5.863s | SGD | epoch: 050 | loss: 0.11836 - acc: 0.9658 -- iter: 55000/55000 -- ``` 1. 評估模型并打印準確率分數： ```py score = model.evaluate(X_test, Y_test) print('Test accuracy:', score[0]) ``` 我們得到以下輸出： ```py Test accuracy: 0.9637 ``` 與使用 TFLearn 相比，我們獲得了相當的精確度。在筆記本`ch-05_MLP`中提供了使用 TFLearn 進行 MNIST 分類的 MLP 的完整代碼。 # TensorFlow，Keras 和 TFLearn 中的 MLP 總結在前面的部分中，我們學習了如何使用 TensorFLow 及其高級庫構建簡單的 MLP 架構。純 TensorFlow 的準確率約為 0.93-0.94，Keras 的準確率為 0.96-0.98，TFLearn 的準確率為 0.96-0.97。盡管我們的代碼的所有示例都使用下面的 TensorFlow，但相同架構和參數的準確率差異可歸因于這樣的事實：盡管我們初始化了一些重要的超參數，但高級庫和 TensorFlow 卻抽象了許多其他超級 - 我們沒有從默認值修改的參數。我們觀察到，與 Keras 和 TFLearn 相比，TensorFlow 中的代碼非常詳細和冗長。高級庫使我們更容易構建和訓練神經網絡模型。 # 用于時間序列回歸的 MLP 我們已經看到了圖像數據分類的例子；現在讓我們看一下時間序列數據的回歸。我們將建立并使用 MLP 作為一個較小的單變量時間序列數據集，稱為國際航空公司乘客數據集。該數據集包含多年來的乘客總數。該數據集可從此鏈接獲得： * <https://www.kaggle.com/andreazzini/international-airline-passengers/data> * <https://datamarket.com/data/set/22u3/international-airline-passengers-monthly-totals-in-thousands-jan-49-dec-60> 讓我們從準備數據集開始。 1. 首先，使用以下代碼加載數據集： ```py filename = os.path.join(datasetslib.datasets_root, 'ts-data', 'international-airline-passengers-cleaned.csv') dataframe = pd.read_csv(filename,usecols=[1],header=0) dataset = dataframe.values dataset = dataset.astype('float32') ``` 1. 利用`datasetslib`的效用函數，我們將數據集分成測試和訓練集。對于時間序列數據集，我們有一個單獨的函數，不會改變觀察結果，因為對于時間序列回歸，我們需要維持觀察的順序。我們使用 67% 的數據進行訓練，33% 的數據用于測試。您可能希望嘗試使用不同比例的示例。 ```py train,test=dsu.train_test_split(dataset,train_size=0.67) ``` 1. 對于時間序列回歸，我們轉換數據集以構建監督數據集。在此示例中，我們使用兩個時間步長的滯后。我們將`n_x`設置為 2，`mvts_to_xy()`函數返回輸入和輸出（`X`和`Y`）訓練和測試集，使得`X`是兩列具有時間`{t-1, t}`的值，`Y`是一列中具有時間`{t + 1}`的值。我們的學習算法假設通過找到時間`{t-1, t, t + 1}`的值之間的關系，可以學習時間`t + 1`的值。 ```py # reshape into X=t-1,t and Y=t+1 n_x=2 n_y=1 X_train, Y_train, X_test, Y_test = tsd.mvts_to_xy(train, test,n_x=n_x,n_y=n_y) ``` 有關將時間序列數據集轉換為監督學習問題的更多信息，[請訪問此鏈接](http://machinelearningmastery.com/convert-time-series-supervised-learning-problem-python/)。現在我們在我們的訓練數據集上構建和訓練模型： 1. 導入所需的 Keras 模塊： ```py from keras.models import Sequential from keras.layers import Dense from keras.optimizers import SGD ``` 1. 設置構建模型所需的超參數： ```py num_layers = 2 num_neurons = [8,8] n_epochs = 50 batch_size = 2 ``` 請注意，我們使用批量大小為 2，因為數據集非常小。我們使用兩層 MLP，每層只有八個神經元，因為我們的示例問題的規模很小。 1. 構建，編譯和訓練模型： ```py model = Sequential() model.add(Dense(num_neurons[0], activation='relu', input_shape=(n_x,))) model.add(Dense(num_neurons[1], activation='relu')) model.add(Dense(units=1)) model.summary() model.compile(loss='mse', optimizer='adam') model.fit(X_train, Y_train, batch_size=batch_size, epochs=n_epochs) ``` 請注意，我們使用 Adam 優化器而不是 SGD。您可能想要嘗試 TensorFlow 和 Keras 中可用的不同優化器。 1. 評估模型并打印均方誤差（MSE）和均方根誤差（RMSE）： ```py score = model.evaluate(X_test, Y_test) print('\nTest mse:', score) print('Test rmse:', math.sqrt(score)) ``` 我們得到以下輸出： ```py Test mse: 5619.24934188 Test rmse: 74.96165247566114 ``` 1. 使用我們的模型預測值并繪制它們，用于測試和訓練數據集： ```py # make predictions Y_train_pred = model.predict(X_train) Y_test_pred = model.predict(X_test) # shift train predictions for plotting Y_train_pred_plot = np.empty_like(dataset) Y_train_pred_plot[:, :] = np.nan Y_train_pred_plot[n_x-1:len(Y_train_pred)+n_x-1, :] = Y_train_pred # shift test predictions for plotting Y_test_pred_plot = np.empty_like(dataset) Y_test_pred_plot[:, :] = np.nan Y_test_pred_plot[len(Y_train_pred)+(n_x*2)-1:len(dataset)-1, :] = \ Y_test_pred # plot baseline and predictions plt.plot(dataset,label='Original Data') plt.plot(Y_train_pred_plot,label='Y_train_pred') plt.plot(Y_test_pred_plot,label='Y_test_pred') plt.legend() plt.show() ``` 我們得到以下關于原始和預測時間序列值的圖： ![](https://img.kancloud.cn/29/f8/29f89ff41dffc6764dacaaba37f1e613_880x578.png) 如你所見，這是一個非常好的估計。然而，在現實生活中，數據本質上是多變量和復雜的。因此，我們將在后面的章節中看到時間序列數據的循環神經網絡架構。 # 總結在本章中，我們了解了多層感知機。我們解釋了如何為分類和回歸問題構建和訓練 MLP 模型。我們使用純 TensorFlow，Keras 和 TFLearn 構建了 MLP 模型。對于分類，我們使用圖像數據，對于回歸，我們使用時間序列數據。構建和訓練 MLP 網絡模型的技術對于任何其他類型的數據（例如數字或文本）是相同的。然而，對于圖像數據集，CNN 架構已被證明是最佳架構，對于序列數據集，例如時間序列和文本，RNN 模型已被證明是最佳架構。雖然我們在本章中僅使用簡單的數據集示例來演示 MLP 架構，但在后面的章節中，我們將介紹具有一些大型和高級數據集的 CNN 和 RNN 架構。