# 五、TensorFlow 和 Keras 中的神經網絡和 MLP
神經網絡是一種受大腦結構和功能啟發的建模技術。正如大腦包含數百萬個被稱為神經元的微小互連單元一樣,今天的神經網絡由數百萬個分層排列的微小互連計算單元組成。由于神經網絡的計算單元僅存在于數字世界中,與大腦的物理神經元相反,它們也被稱為人工神經元。類似地,神經網絡(NN)也稱為人工神經網絡(ANN)。
在本章中,我們將進一步擴展以下主題:
* 感知機(人工神經元)
* 前饋神經網絡
* 用于圖像分類的**多層感知機**(**MLP**)
* 基于 TensorFlow 的用于 MNIST 圖像分類的 MLP
* 基于 Keras 的用于 MNIST 分類的 MLP
* 基于 TFLearn 的用于 MNIST 分類的 MLP
* 用于時間序列回歸的 MLP
# 感知機
讓我們了解神經網絡的最基本構建塊,**感知機**,也稱為**人工神經元**。感知機的概念起源于 Frank Rosenblatt 于 1962 年的作品。
您可能希望閱讀以下工作來探索神經網絡的起源:
Frank Rosenblatt,神經動力學原理:感知器和腦機制理論,斯巴達書籍,1962 年
在最簡化的視圖中,感知機被建模在生物神經元之后,使得它接收一個或多個輸入并將它們組合以產生輸出。
如下圖所示,感知機采用三個輸入并將它們相加以生成輸出`y`:

這種感知機太簡單了,不具備任何實際用途。因此,通過添加權重,偏差和激活函數的概念來增強它。將權重添加到每個輸入以獲得加權和。如果加權和`Σw[i]x[i]`小于閾值,則輸出為 0,否則輸出為 1:

閾值稱為**偏差**。讓我們將偏差移到等式的左邊,用`b`表示它,`Σw·x`代表`w`和`x`的向量點積。感知機的等式現在變為如下:

感知機現在看起來像下圖:
?Simple perceptron with weights and bias
到目前為止,神經元是一個線性函數。為了使這個神經元產生非線性決策邊界,通過稱為**激活**或傳遞函數的非線性函數運行求和輸出。有許多流行的激活函數可用:
* `ReLU`:**整流線性單元**,將值平滑到范圍`(0, x)`,

* `sigmoid`:**Sigmoid** 將值平滑到`(0, 1)`,

* `tanh`:**雙曲正切**將值平滑到`(-1, 1)`,

使用激活函數,感知機的等式變為:

其中`φ(·)`是激活函數。
神經元看起來像下圖:

# 多層感知機
當我們將人工神經元連接在一起時,基于明確定義的結構,我們將其稱為神經網絡。這是一個神經元最簡單的神經網絡:
Neural network with one neuron
我們連接神經元,使得一層的輸出成為下一層的輸入,直到最后一層的輸出成為最終輸出。這種神經網絡被稱為**前饋神經網絡(FFNN)**。由于這些 FFNN 由連接在一起的神經元層組成,因此它們被稱為**多層感知機(MLP)**或**深度神經網絡(DNN)**。
作為示例,下圖中描繪的 MLP 具有三個特征作為輸入:兩個隱藏層,每個神經元包含五個神經元,一個輸出 y。神經元完全連接到下一層的神經元。這些層也稱為致密層或仿射層,并且這種模型也稱為順序模型。

讓我們重溫一下我們之前探索過的一些示例數據集,并在 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()
```
我們得到以下關于原始和預測時間序列值的圖:

如你所見,這是一個非常好的估計。然而,在現實生活中,數據本質上是多變量和復雜的。因此,我們將在后面的章節中看到時間序列數據的循環神經網絡架構。
# 總結
在本章中,我們了解了多層感知機。我們解釋了如何為分類和回歸問題構建和訓練 MLP 模型。我們使用純 TensorFlow,Keras 和 TFLearn 構建了 MLP 模型。對于分類,我們使用圖像數據,對于回歸,我們使用時間序列數據。
構建和訓練 MLP 網絡模型的技術對于任何其他類型的數據(例如數字或文本)是相同的。然而,對于圖像數據集,CNN 架構已被證明是最佳架構,對于序列數據集,例如時間序列和文本,RNN 模型已被證明是最佳架構。
雖然我們在本章中僅使用簡單的數據集示例來演示 MLP 架構,但在后面的章節中,我們將介紹具有一些大型和高級數據集的 CNN 和 RNN 架構。
- TensorFlow 1.x 深度學習秘籍
- 零、前言
- 一、TensorFlow 簡介
- 二、回歸
- 三、神經網絡:感知器
- 四、卷積神經網絡
- 五、高級卷積神經網絡
- 六、循環神經網絡
- 七、無監督學習
- 八、自編碼器
- 九、強化學習
- 十、移動計算
- 十一、生成模型和 CapsNet
- 十二、分布式 TensorFlow 和云深度學習
- 十三、AutoML 和學習如何學習(元學習)
- 十四、TensorFlow 處理單元
- 使用 TensorFlow 構建機器學習項目中文版
- 一、探索和轉換數據
- 二、聚類
- 三、線性回歸
- 四、邏輯回歸
- 五、簡單的前饋神經網絡
- 六、卷積神經網絡
- 七、循環神經網絡和 LSTM
- 八、深度神經網絡
- 九、大規模運行模型 -- GPU 和服務
- 十、庫安裝和其他提示
- TensorFlow 深度學習中文第二版
- 一、人工神經網絡
- 二、TensorFlow v1.6 的新功能是什么?
- 三、實現前饋神經網絡
- 四、CNN 實戰
- 五、使用 TensorFlow 實現自編碼器
- 六、RNN 和梯度消失或爆炸問題
- 七、TensorFlow GPU 配置
- 八、TFLearn
- 九、使用協同過濾的電影推薦
- 十、OpenAI Gym
- TensorFlow 深度學習實戰指南中文版
- 一、入門
- 二、深度神經網絡
- 三、卷積神經網絡
- 四、循環神經網絡介紹
- 五、總結
- 精通 TensorFlow 1.x
- 一、TensorFlow 101
- 二、TensorFlow 的高級庫
- 三、Keras 101
- 四、TensorFlow 中的經典機器學習
- 五、TensorFlow 和 Keras 中的神經網絡和 MLP
- 六、TensorFlow 和 Keras 中的 RNN
- 七、TensorFlow 和 Keras 中的用于時間序列數據的 RNN
- 八、TensorFlow 和 Keras 中的用于文本數據的 RNN
- 九、TensorFlow 和 Keras 中的 CNN
- 十、TensorFlow 和 Keras 中的自編碼器
- 十一、TF 服務:生產中的 TensorFlow 模型
- 十二、遷移學習和預訓練模型
- 十三、深度強化學習
- 十四、生成對抗網絡
- 十五、TensorFlow 集群的分布式模型
- 十六、移動和嵌入式平臺上的 TensorFlow 模型
- 十七、R 中的 TensorFlow 和 Keras
- 十八、調試 TensorFlow 模型
- 十九、張量處理單元
- TensorFlow 機器學習秘籍中文第二版
- 一、TensorFlow 入門
- 二、TensorFlow 的方式
- 三、線性回歸
- 四、支持向量機
- 五、最近鄰方法
- 六、神經網絡
- 七、自然語言處理
- 八、卷積神經網絡
- 九、循環神經網絡
- 十、將 TensorFlow 投入生產
- 十一、更多 TensorFlow
- 與 TensorFlow 的初次接觸
- 前言
- 1.?TensorFlow 基礎知識
- 2. TensorFlow 中的線性回歸
- 3. TensorFlow 中的聚類
- 4. TensorFlow 中的單層神經網絡
- 5. TensorFlow 中的多層神經網絡
- 6. 并行
- 后記
- TensorFlow 學習指南
- 一、基礎
- 二、線性模型
- 三、學習
- 四、分布式
- TensorFlow Rager 教程
- 一、如何使用 TensorFlow Eager 構建簡單的神經網絡
- 二、在 Eager 模式中使用指標
- 三、如何保存和恢復訓練模型
- 四、文本序列到 TFRecords
- 五、如何將原始圖片數據轉換為 TFRecords
- 六、如何使用 TensorFlow Eager 從 TFRecords 批量讀取數據
- 七、使用 TensorFlow Eager 構建用于情感識別的卷積神經網絡(CNN)
- 八、用于 TensorFlow Eager 序列分類的動態循壞神經網絡
- 九、用于 TensorFlow Eager 時間序列回歸的遞歸神經網絡
- TensorFlow 高效編程
- 圖嵌入綜述:問題,技術與應用
- 一、引言
- 三、圖嵌入的問題設定
- 四、圖嵌入技術
- 基于邊重構的優化問題
- 應用
- 基于深度學習的推薦系統:綜述和新視角
- 引言
- 基于深度學習的推薦:最先進的技術
- 基于卷積神經網絡的推薦
- 關于卷積神經網絡我們理解了什么
- 第1章概論
- 第2章多層網絡
- 2.1.4生成對抗網絡
- 2.2.1最近ConvNets演變中的關鍵架構
- 2.2.2走向ConvNet不變性
- 2.3時空卷積網絡
- 第3章了解ConvNets構建塊
- 3.2整改
- 3.3規范化
- 3.4匯集
- 第四章現狀
- 4.2打開問題
- 參考
- 機器學習超級復習筆記
- Python 遷移學習實用指南
- 零、前言
- 一、機器學習基礎
- 二、深度學習基礎
- 三、了解深度學習架構
- 四、遷移學習基礎
- 五、釋放遷移學習的力量
- 六、圖像識別與分類
- 七、文本文件分類
- 八、音頻事件識別與分類
- 九、DeepDream
- 十、自動圖像字幕生成器
- 十一、圖像著色
- 面向計算機視覺的深度學習
- 零、前言
- 一、入門
- 二、圖像分類
- 三、圖像檢索
- 四、對象檢測
- 五、語義分割
- 六、相似性學習
- 七、圖像字幕
- 八、生成模型
- 九、視頻分類
- 十、部署
- 深度學習快速參考
- 零、前言
- 一、深度學習的基礎
- 二、使用深度學習解決回歸問題
- 三、使用 TensorBoard 監控網絡訓練
- 四、使用深度學習解決二分類問題
- 五、使用 Keras 解決多分類問題
- 六、超參數優化
- 七、從頭開始訓練 CNN
- 八、將預訓練的 CNN 用于遷移學習
- 九、從頭開始訓練 RNN
- 十、使用詞嵌入從頭開始訓練 LSTM
- 十一、訓練 Seq2Seq 模型
- 十二、深度強化學習
- 十三、生成對抗網絡
- TensorFlow 2.0 快速入門指南
- 零、前言
- 第 1 部分:TensorFlow 2.00 Alpha 簡介
- 一、TensorFlow 2 簡介
- 二、Keras:TensorFlow 2 的高級 API
- 三、TensorFlow 2 和 ANN 技術
- 第 2 部分:TensorFlow 2.00 Alpha 中的監督和無監督學習
- 四、TensorFlow 2 和監督機器學習
- 五、TensorFlow 2 和無監督學習
- 第 3 部分:TensorFlow 2.00 Alpha 的神經網絡應用
- 六、使用 TensorFlow 2 識別圖像
- 七、TensorFlow 2 和神經風格遷移
- 八、TensorFlow 2 和循環神經網絡
- 九、TensorFlow 估計器和 TensorFlow HUB
- 十、從 tf1.12 轉換為 tf2
- TensorFlow 入門
- 零、前言
- 一、TensorFlow 基本概念
- 二、TensorFlow 數學運算
- 三、機器學習入門
- 四、神經網絡簡介
- 五、深度學習
- 六、TensorFlow GPU 編程和服務
- TensorFlow 卷積神經網絡實用指南
- 零、前言
- 一、TensorFlow 的設置和介紹
- 二、深度學習和卷積神經網絡
- 三、TensorFlow 中的圖像分類
- 四、目標檢測與分割
- 五、VGG,Inception,ResNet 和 MobileNets
- 六、自編碼器,變分自編碼器和生成對抗網絡
- 七、遷移學習
- 八、機器學習最佳實踐和故障排除
- 九、大規模訓練
- 十、參考文獻