深入學習keras中Sequential模型及方法

Sequential 序貫模型

序貫模型是函式式模型的簡略版，為最簡單的線性、從頭到尾的結構順序，不分叉，是多個網路層的線性堆疊。

Keras實現了很多層，包括core核心層，Convolution卷積層、Pooling池化層等非常豐富有趣的網路結構。

我們可以通過將層的列表傳遞給Sequential的建構函式，來建立一個Sequential模型。

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

model = Sequential([
Dense(32, input_shape=(784,)),
Activation('relu'),
Dense(10),
Activation('softmax'),
])

也可以使用.add()方法將各層新增到模型中：

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

指定輸入資料的尺寸

模型需要知道它所期待的輸入的尺寸（shape）。出於這個原因，序貫模型中的第一層（只有第一層，因為下面的層可以自動的推斷尺寸）需要接收關於其輸入尺寸的資訊，後面的各個層則可以自動的推匯出中間資料的shape，因此不需要為每個層都指定這個引數。有以下幾種方法來做到這一點：

• 傳遞一個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,)))

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

下面三種方法也是嚴格等價的

model = Sequential()
model.add(LSTM(32, input_shape=(10, 64)))


model = Sequential()
model.add(LSTM(32, batch_input_shape=(None, 10, 64)))


model = Sequential()
model.add(LSTM(32, input_length=10, input_dim=64))

編譯

在訓練模型之前，我們需要配置學習過程，這是通過compile方法完成的，他接收三個引數：

• 優化器 optimizer： 它可以是現有優化器的字串識別符號，如 rmsprop  或 adagrad ，也可以是 Optimizer 類的例項。詳見：ofollow,noindex" target="_blank">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])

訓練

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)

# 對於具有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

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

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 模型

有狀態的迴圈神經網路模型中，在一個 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))

Sequential模型方法

1  compile

compile(self, optimizer, loss=None, metrics=None, loss_weights=None,
 sample_weight_mode=None, weighted_metrics=None, target_tensors=None)

用於配置訓練模型。

1.1 引數

• optimizer : 字串（優化器名）或者優化器物件。詳見 optimizers 。
• loss : 字串（目標函式名）或目標函式。詳見 losses 。 如果模型具有多個輸出，則可以通過傳遞損失函式的字典或列表，在每個輸出上使用不同的損失。模型將最小化的損失值將是所有單個損失的總和。
• metrics : 在訓練和測試期間的模型評估標準。通常你會使用 metrics = ['accuracy'] 。 要為多輸出模型的不同輸出指定不同的評估標準，還可以傳遞一個字典，如 metrics = {'output_a'：'accuracy'} 。
• sample_weight_mode : 如果你需要執行按時間步取樣權重（2D 權重），請將其設定為 temporal 。 預設為 None ，為取樣權重（1D）。如果模型有多個輸出，則可以通過傳遞 mode 的字典或列表，以在每個輸出上使用不同的 sample_weight_mode 。
• weighted_metrics : 在訓練和測試期間，由 sample_weight 或 class_weight 評估和加權的度量標準列表。
• target_tensors : 預設情況下，Keras 將為模型的目標建立一個佔位符，在訓練過程中將使用目標資料。相反，如果你想使用自己的目標張量（反過來說，Keras 在訓練期間不會載入這些目標張量的外部 Numpy 資料），您可以通過 target_tensors  引數指定它們。它應該是單個張量（對於單輸出 Sequential 模型）。
• **kwargs : 當使用 Theano/CNTK 後端時，這些引數被傳入 K.function 。當使用 TensorFlow 後端時，這些引數被傳遞到 tf.Session.run 。

1.2  異常

ValueError: 如果 optimizer, loss, metrics 或 sample_weight_mode 這些引數不合法。

2 fit

fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1,
 callbacks=None, validation_split=0.0, validation_data=None, 
shuffle=True, class_weight=None, sample_weight=None,
 initial_epoch=0, steps_per_epoch=None, validation_steps=None)

以固定數量的輪次（資料集上的迭代）訓練模型。

2.1 引數

• x : 訓練資料的 Numpy 陣列。 如果模型中的輸入層被命名，你也可以傳遞一個字典，將輸入層名稱對映到 Numpy 陣列。 如果從本地框架張量饋送（例如 TensorFlow 資料張量）資料，x 可以是 None （預設）。
• y : 目標（標籤）資料的 Numpy 陣列。 如果模型中的輸出層被命名，你也可以傳遞一個字典，將輸出層名稱對映到 Numpy 陣列。 如果從本地框架張量饋送（例如 TensorFlow 資料張量）資料，y 可以是 None （預設）。
• batch_size : 整數或 None 。每次提度更新的樣本數。如果未指定，預設為 32.
• epochs : 整數。訓練模型迭代輪次。一個輪次是在整個 x  或 y  上的一輪迭代。請注意，與 initial_epoch  一起，epochs  被理解為 「最終輪次」。模型並不是訓練了 epochs 輪，而是到第 epochs  輪停止訓練。
• verbose : 0, 1 或 2。日誌顯示模式。 0 = 安靜模式, 1 = 進度條, 2 = 每輪一行。
• callbacks : 一系列的 keras.callbacks.Callback  例項。一系列可以在訓練時使用的回撥函式。詳見 callbacks 。
• validation_split : 在 0 和 1 之間浮動。用作驗證集的訓練資料的比例。模型將分出一部分不會被訓練的驗證資料，並將在每一輪結束時評估這些驗證資料的誤差和任何其他模型指標。驗證資料是混洗之前 x  和y  資料的最後一部分樣本中。
• validation_data : 元組 (x_val，y_val)  或元組 (x_val，y_val，val_sample_weights) ，用來評估損失，以及在每輪結束時的任何模型度量指標。模型將不會在這個資料上進行訓練。這個引數會覆蓋 validation_split 。
• shuffle : 布林值（是否在每輪迭代之前混洗資料）或者 字串 (batch )。batch  是處理 HDF5 資料限制的特殊選項，它對一個 batch 內部的資料進行混洗。當 steps_per_epoch 非 None  時，這個引數無效。
• class_weight : 可選的字典，用來對映類索引（整數）到權重（浮點）值，用於加權損失函式（僅在訓練期間）。這可能有助於告訴模型 「更多關注」來自代表性不足的類的樣本。
• sample_weight : 訓練樣本的可選 Numpy 權重陣列，用於對損失函式進行加權（僅在訓練期間）。您可以傳遞與輸入樣本長度相同的平坦（1D）Numpy 陣列（權重和樣本之間的 1：1 對映），或者在時序資料的情況下，可以傳遞尺寸為 (samples, sequence_length)  的 2D 陣列，以對每個樣本的每個時間步施加不同的權重。在這種情況下，你應該確保在 compile()  中指定 sample_weight_mode="temporal" 。
• initial_epoch : 開始訓練的輪次（有助於恢復之前的訓練）。
• steps_per_epoch : 在宣告一個輪次完成並開始下一個輪次之前的總步數（樣品批次）。使用 TensorFlow 資料張量等輸入張量進行訓練時，預設值 None  等於資料集中樣本的數量除以 batch 的大小，如果無法確定，則為 1。
• validation_steps : 只有在指定了 steps_per_epoch 時才有用。停止前要驗證的總步數（批次樣本）。

2.2  返回

一個History 物件。其 History.history 屬性是連續 epoch 訓練損失和評估值，以及驗證集損失和評估值的記錄（如果適用）。

2.3  異常

• RuntimeError : 如果模型從未編譯。
• ValueError : 在提供的輸入資料與模型期望的不匹配的情況下。

3  evaluate

evaluate(self, x=None, y=None, batch_size=None, verbose=1,
 sample_weight=None, steps=None)

在測試模式，返回誤差值和評估標準值。

計算逐批次進行。

3.1  引數

• x : 輸入資料，Numpy 陣列或列表（如果模型有多輸入）。 如果從本地框架張量饋送（例如 TensorFlow 資料張量）資料，x 可以是 None （預設）。
• y : 標籤，Numpy 陣列。 如果從本地框架張量饋送（例如 TensorFlow 資料張量）資料，y 可以是 None （預設）。
• batch_size : 整數。每次梯度更新的樣本數。如果未指定，預設為 32。
• verbose : 日誌顯示模式，0 或 1。
• sample_weight : 樣本權重，Numpy 陣列。
• steps : 整數或 None 。 宣告評估結束之前的總步數（批次樣本）。預設值 None 。

3.2  返回

標量測試誤差（如果模型沒有評估指標）或標量列表（如果模型計算其他指標）。 屬性model.metrics_names 將提供標量輸出的顯示標籤。

4  predict

predict(self, x, batch_size=None, verbose=0, steps=None)

為輸入樣本生成輸出預測。

計算逐批次進行。

4.1 引數

• x : 輸入資料，Numpy 陣列。
• batch_size : 整數。如未指定，預設為 32。
• verbose : 日誌顯示模式，0 或 1。
• steps : 宣告預測結束之前的總步數（批次樣本）。預設值 None 。

4.2 返回

預測的 Numpy 陣列。

4.3  異常

• ValueError : 如果提供的輸入資料與模型的期望資料不匹配，或者有狀態模型收到的數量不是批量大小的倍數。

train_on_batch(self, x, y, class_weight=None, sample_weight=None)

test_on_batch(self, x, y, sample_weight=None)

predict_on_batch(self, x)

it_generator(self, generator, steps_per_epoch=None, epochs=1, 
verbose=1, callbacks=None, validation_data=None, validation_steps=None, 
class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, 
shuffle=True, initial_epoch=0)

def generate_arrays_from_file(path):
while 1:
f = open(path)
for line in f:
# 從檔案中的每一行生成輸入資料和標籤的 numpy 陣列
x, y = process_line(line)
yield (x, y)
f.close()

model.fit_generator(generate_arrays_from_file('/my_file.txt'),
steps_per_epoch=1000, epochs=10)

evaluate_generator(self, generator, steps=None, max_queue_size=10,
 workers=1, use_multiprocessing=False)

predict_generator(self, generator, steps=None, max_queue_size=10,
 workers=1, use_multiprocessing=False, verbose=0)

get_layer(self, name=None, index=None)

此文是本人自己的學習筆記，參考Keras官方文件，如有侵權請聯絡，謝謝!