【471】Keras 深度神經網絡實現

參考：Keras 中文文檔

參考：開始使用 Keras Sequential 順序模型

---

 

　　Keras 的核心數據結構是 model，一種組織網絡層的方式。最簡單的模型是 Sequential 順序模型，它由多個網絡層線性堆疊。對於更復雜的結構，你應該使用 Keras 函數式 API，它允許構建任意的神經網絡圖。

一、架構設計

　　Sequential 模型如下所示：

from keras.models import Sequential

model = Sequential()

　　可以簡單地使用 .add() 來堆疊模型：（100 x 64 x 10）

from keras.layers import Dense

model.add(Dense(units=64, activation='relu', input_dim=100))
model.add(Dense(units=10, activation='softmax'))

　　or

from keras.models import Sequential
from keras.layers import Dense, Activation

model.add(Dense(64, input_dim=100))
model.add(Activation('relu'))
model.add(Dense(10))
model.add(Activation('softmax'))

　　也可以通過如下方式實現，將 Dense 與 Activation 分開，整體放在一起：

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential([
    Dense(64, input_shape=(100,)),
    Activation('relu'),
    Dense(10),
    Activation('softmax'),
])

　　Dense 是用來構建 fully connected 的神經網絡，

• units 是神經元的個數，第一個就是對應於 hidden layer，可以省略
• activation 是激活函數的選擇
• input_dim 是輸入層的神經元個數，標量
• input_shape 需要用 tuple 來表示，如 input_shape=(100,)

　　模型需要知道它所期望的輸入的尺寸。出於這個原因，順序模型中的第一層（且只有第一層，因為下面的層可以自動地推斷尺寸）需要接收關於其輸入尺寸的信息。有幾種方法來做到這一點：

• 傳遞一個 input_shape 參數給第一層。它是一個表示尺寸的元組 (一個由整數或 None 組成的元組，其中 None 表示可能為任何正整數)。在 input_shape 中不包含數據的 batch 大小。
• 某些 2D 層，例如 Dense，支持通過參數 input_dim 指定輸入尺寸，某些 3D 時序層支持 input_dim 和 input_length 參數。
• 如果你需要為你的輸入指定一個固定的 batch 大小（這對 stateful RNNs 很有用），你可以傳遞一個 batch_size 參數給一個層。如果你同時將 batch_size=32 和 input_shape=(6, 8) 傳遞給一個層，那么每一批輸入的尺寸就為 (32，6，8)。

　　因此，下面的代碼片段是等價的：

model = Sequential()
model.add(Dense(32, input_shape=(784,)))

　　or

model = Sequential()
model.add(Dense(32, input_dim=784))

　　

二、模型編譯

　　在完成了模型的構建后, 可以使用 .compile() 來配置學習過程：（可以直接填寫字符串也可以通過 Keras 內部提供的屬性值）

model.compile(loss='categorical_crossentropy',
              optimizer='sgd',
              metrics=['accuracy'])

　　其中：

• loss 是損失函數的選擇
• optimizer 是優化方法的選擇
• metrics 是度量標准的選擇

　　如果需要，你還可以進一步地配置你的優化器。Keras 的核心原則是使事情變得相當簡單，同時又允許用戶在需要的時候能夠進行完全的控制（終極的控制是源代碼的易擴展性）。

model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

　　在訓練模型之前，您需要配置學習過程，這是通過 compile 方法完成的。它接收三個參數：

• 優化器 optimizer。它可以是現有優化器的字符串標識符，如 rmsprop 或 adagrad，也可以是 Optimizer 類的實例。詳見：optimizers。
• 損失函數 loss，模型試圖最小化的目標函數。它可以是現有損失函數的字符串標識符，如 categorical_crossentropy 或 mse，也可以是一個目標函數。詳見：losses。
• 評估標准 metrics。對於任何分類問題，你都希望將其設置為 metrics = ['accuracy']。評估標准可以是現有的標准的字符串標識符，也可以是自定義的評估標准函數。

# 多分類問題
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 二分類問題
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# 均方誤差回歸問題
model.compile(optimizer='rmsprop',
              loss='mse')

# 自定義評估標准函數
import keras.backend as K

def mean_pred(y_true, y_pred):
    return K.mean(y_pred)

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy', mean_pred])

　　

三、模型訓練

　　現在，你可以批量地在訓練數據上進行迭代了：

# x_train 和 y_train 是 Numpy 數組 -- 就像在 Scikit-Learn API 中一樣。
model.fit(x_train, y_train, epochs=5, batch_size=32)

　　或者，你可以手動地將批次的數據提供給模型：

model.train_on_batch(x_batch, y_batch)

　　只需一行代碼就能評估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

　　或者對新的數據生成預測：

classes = model.predict(x_test, batch_size=128)

　　Keras 模型在輸入數據和標簽的 Numpy 矩陣上進行訓練。為了訓練一個模型，你通常會使用 fit 函數。文檔詳見此處。

# 對於具有 2 個類的單輸入模型（二進制分類）：

model = Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

# 生成虛擬數據
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(2, size=(1000, 1))

# 訓練模型，以 32 個樣本為一個 batch 進行迭代
model.fit(data, labels, epochs=10, batch_size=32)

　　or

# 對於具有 10 個類的單輸入模型（多分類分類）：

model = Sequential()
model.add(Dense(32, activation='relu', input_dim=100))
model.add(Dense(10, activation='softmax'))
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 生成虛擬數據
import numpy as np
data = np.random.random((1000, 100))
labels = np.random.randint(10, size=(1000, 1))

# 將標簽轉換為分類的 one-hot 編碼
one_hot_labels = keras.utils.to_categorical(labels, num_classes=10)

# 訓練模型，以 32 個樣本為一個 batch 進行迭代
model.fit(data, one_hot_labels, epochs=10, batch_size=32)

　　

四、樣例

　　這里有幾個可以幫助你起步的例子！

　　在 examples 目錄 中，你可以找到真實數據集的示例模型：

• CIFAR10 小圖片分類：具有實時數據增強的卷積神經網絡 (CNN)
• IMDB 電影評論情感分類：基於詞序列的 LSTM
• Reuters 新聞主題分類：多層感知器 (MLP)
• MNIST 手寫數字分類：MLP & CNN
• 基於 LSTM 的字符級文本生成

　　...以及更多。

　　基於多層感知器 (MLP) 的 softmax 多分類：

import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation
from keras.optimizers import SGD

# 生成虛擬數據
import numpy as np
x_train = np.random.random((1000, 20))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10)
x_test = np.random.random((100, 20))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)

model = Sequential()
# Dense(64) 是一個具有 64 個隱藏神經元的全連接層。
# 在第一層必須指定所期望的輸入數據尺寸：
# 在這里，是一個 20 維的向量。
model.add(Dense(64, activation='relu', input_dim=20))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
              optimizer=sgd,
              metrics=['accuracy'])

model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)
score = model.evaluate(x_test, y_test, batch_size=128)

　　

　　基於多層感知器的二分類：

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Dropout

# 生成虛擬數據
x_train = np.random.random((1000, 20))
y_train = np.random.randint(2, size=(1000, 1))
x_test = np.random.random((100, 20))
y_test = np.random.randint(2, size=(100, 1))

model = Sequential()
model.add(Dense(64, input_dim=20, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model.fit(x_train, y_train,
          epochs=20,
          batch_size=128)
score = model.evaluate(x_test, y_test, batch_size=128)

　　

　　類似 VGG 的卷積神經網絡：

import numpy as np
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import SGD

# 生成虛擬數據
x_train = np.random.random((100, 100, 100, 3))
y_train = keras.utils.to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10)
x_test = np.random.random((20, 100, 100, 3))
y_test = keras.utils.to_categorical(np.random.randint(10, size=(20, 1)), num_classes=10)

model = Sequential()
# 輸入: 3 通道 100x100 像素圖像 -> (100, 100, 3) 張量。
# 使用 32 個大小為 3x3 的卷積濾波器。
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(100, 100, 3)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)

model.fit(x_train, y_train, batch_size=32, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=32)

　　

　　基於 LSTM 的序列分類：

from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.layers import Embedding
from keras.layers import LSTM

max_features = 1024

model = Sequential()
model.add(Embedding(max_features, output_dim=256))
model.add(LSTM(128))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model.fit(x_train, y_train, batch_size=16, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=16)

　　

　　基於 1D 卷積的序列分類：

from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.layers import Embedding
from keras.layers import Conv1D, GlobalAveragePooling1D, MaxPooling1D

seq_length = 64

model = Sequential()
model.add(Conv1D(64, 3, activation='relu', input_shape=(seq_length, 100)))
model.add(Conv1D(64, 3, activation='relu'))
model.add(MaxPooling1D(3))
model.add(Conv1D(128, 3, activation='relu'))
model.add(Conv1D(128, 3, activation='relu'))
model.add(GlobalAveragePooling1D())
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

model.fit(x_train, y_train, batch_size=16, epochs=10)
score = model.evaluate(x_test, y_test, batch_size=16)

　　

　　基於棧式 LSTM 的序列分類

　　在這個模型中，我們將 3 個 LSTM 層疊在一起，使模型能夠學習更高層次的時間表示。

　　前兩個 LSTM 返回完整的輸出序列，但最后一個只返回輸出序列的最后一步，從而降低了時間維度（即將輸入序列轉換成單個向量）。

from keras.models import Sequential
from keras.layers import LSTM, Dense
import numpy as np

data_dim = 16
timesteps = 8
num_classes = 10

# 期望輸入數據尺寸: (batch_size, timesteps, data_dim)
model = Sequential()
model.add(LSTM(32, return_sequences=True,
               input_shape=(timesteps, data_dim)))  # 返回維度為 32 的向量序列
model.add(LSTM(32, return_sequences=True))  # 返回維度為 32 的向量序列
model.add(LSTM(32))  # 返回維度為 32 的單個向量
model.add(Dense(10, activation='softmax'))

model.compile(loss='categorical_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# 生成虛擬訓練數據
x_train = np.random.random((1000, timesteps, data_dim))
y_train = np.random.random((1000, num_classes))

# 生成虛擬驗證數據
x_val = np.random.random((100, timesteps, data_dim))
y_val = np.random.random((100, num_classes))

model.fit(x_train, y_train,
          batch_size=64, epochs=5,
          validation_data=(x_val, y_val))

　　

　　"stateful" 渲染的的棧式 LSTM 模型

　　有狀態 (stateful) 的循環神經網絡模型中，在一個 batch 的樣本處理完成后，其內部狀態（記憶）會被記錄並作為下一個 batch 的樣本的初始狀態。這允許處理更長的序列，同時保持計算復雜度的可控性。你可以在 FAQ 中查找更多關於 stateful RNNs 的信息。

from keras.models import Sequential
from keras.layers import LSTM, Dense
import numpy as np

data_dim = 16
timesteps = 8
num_classes = 10
batch_size = 32

# 期望輸入數據尺寸: (batch_size, timesteps, data_dim)
# 請注意，我們必須提供完整的 batch_input_shape，因為網絡是有狀態的。
# 第 k 批數據的第 i 個樣本是第 k-1 批數據的第 i 個樣本的后續。
model = Sequential()
model.add(LSTM(32, return_sequences=True, stateful=True,
               batch_input_shape=(batch_size, timesteps, data_dim)))
model.add(LSTM(32, return_sequences=True, stateful=True))
model.add(LSTM(32, stateful=True))
model.add(Dense(10, activation='softmax'))

model.compile(loss='categorical_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# 生成虛擬訓練數據
x_train = np.random.random((batch_size * 10, timesteps, data_dim))
y_train = np.random.random((batch_size * 10, num_classes))

# 生成虛擬驗證數據
x_val = np.random.random((batch_size * 3, timesteps, data_dim))
y_val = np.random.random((batch_size * 3, num_classes))

model.fit(x_train, y_train,
          batch_size=batch_size, epochs=5, shuffle=False,
          validation_data=(x_val, y_val))