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 類的例項。詳見：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 的樣本的初始狀態。這允許處理更長的序列，同時保持計算複雜度的可控性。

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: 如果提供的輸入資料與模型的期望資料不匹配，或者有狀態模型收到的數量不是批量大小的倍數。

5 train_on_batch

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

一批樣品的單次梯度更新。

5.1  Arguments

• x: 輸入資料，Numpy 陣列或列表（如果模型有多輸入）。
• y: 標籤，Numpy 陣列。
• class_weight: 將類別對映為權重的字典，用於在訓練時縮放損失函式。
• sample_weight: 樣本權重，Numpy 陣列。

5.2   返回

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

6 test_on_batch

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

   在一批樣本上評估模型。

6.1  引數

• x: 輸入資料，Numpy 陣列或列表（如果模型有多輸入）。
• y: 標籤，Numpy 陣列。
• sample_weight: 樣本權重，Numpy 陣列。

6.2  返回

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

7 predict_on_batch

predict_on_batch(self, x) 

返回一批樣本的模型預測值。

7.1  引數

• x: 輸入資料，Numpy 陣列或列表（如果模型有多輸入）。

7.2  返回

預測值的Numpy陣列

8 fit_generator

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) 

使用 Python 生成器或 Sequence 例項逐批生成的資料，按批次訓練模型。

生成器與模型並行執行，以提高效率。 例如，這可以讓你在 CPU 上對影象進行實時資料增強，以在 GPU 上訓練模型。

keras.utils.Sequence 的使用可以保證資料的順序， 以及當 use_multiprocessing=True 時 ，保證每個輸入在每個 epoch 只使用一次。

8.1  引數

• generator: 一個生成器或 Sequence (keras.utils.Sequence)。 生成器的輸出應該為以下之一：
• 一個 (inputs, targets) 元組
• 一個 (inputs, targets, sample_weights) 元組。 所有的陣列都必須包含同樣數量的樣本。生成器將無限地在資料集上迴圈。當執行到第 steps_per_epoch 時，記一個 epoch 結束。
• steps_per_epoch: 在宣告一個 epoch 完成並開始下一個 epoch 之前從 generator 產生的總步數（批次樣本）。它通常應該等於你的資料集的樣本數量除以批量大小。可選引數 Sequence：如果未指定，將使用len(generator) 作為步數。
• epochs: 整數，資料的迭代總輪數。請注意，與 initial_epoch 一起，引數 epochs 應被理解為 「最終輪數」。模型並不是訓練了 epochs 輪，而是到第 epochs 輪停止訓練。
• verbose: 日誌顯示模式。0，1 或 2。
• callbacks: 在訓練時呼叫的一系列回撥函式。
• validation_data: 它可以是以下之一：
• 驗證資料的生成器或 Sequence 例項
• 一個 (inputs, targets) 元組
• 一個 (inputs, targets, sample_weights) 元組。
• validation_steps: 僅當 validation_data 是一個生成器時才可用。 每個 epoch 結束時驗證集生成器產生的步數。它通常應該等於你的資料集的樣本數量除以批量大小。可選引數 Sequence：如果未指定，將使用len(generator) 作為步數。
• class_weight: 將類別對映為權重的字典。
• max_queue_size: 生成器佇列的最大尺寸。
• workers: 使用的最大程序數量。
• use_multiprocessing: 如果 True，則使用基於程序的多執行緒。 請注意，因為此實現依賴於多程序，所以不應將不可傳遞的引數傳遞給生成器，因為它們不能被輕易地傳遞給子程序。
• shuffle: 是否在每輪迭代之前打亂 batch 的順序。只能與 Sequence (keras.utils.Sequence) 例項同用。
• initial_epoch: 開始訓練的輪次（有助於恢復之前的訓練）。

8.2  返回

一個 History 物件。

8.3  異常

• ValueError: 如果生成器生成的資料格式不正確。

8.4  例

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)

 9 evaluate_generator

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

在資料生成器上評估模型。

這個生成器應該返回與 test_on_batch 所接收的同樣的資料。

9.1 引數

• generator: 生成器，生成 (inputs, targets) 或 (inputs, targets, sample_weights)
• steps: 在停止之前，來自 generator 的總步數 (樣本批次)。 可選引數 Sequence：如果未指定，將使用len(generator) 作為步數。
• max_queue_size: 生成器佇列的最大尺寸。
• workers: 使用的最大程序數量。
• use_multiprocessing: 如果 True，則使用基於程序的多執行緒。 請注意，因為此實現依賴於多程序，所以不應將不可傳遞的引數傳遞給生成器，因為它們不能被輕易地傳遞給子程序。

9.2  返回

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

9.3 異常

　　ValueError如果生成器生成的資料格式不正確

10 predict_generator

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

為來自資料生成器的輸入樣本生成預測。

這個生成器應該返回與 predict_on_batch 所接收的同樣的資料。

10.1  引數

• generator: 返回批量輸入樣本的生成器。
• steps: 在停止之前，來自 generator 的總步數 (樣本批次)。 可選引數 Sequence：如果未指定，將使用len(generator) 作為步數。
• max_queue_size: 生成器佇列的最大尺寸。
• workers: 使用的最大程序數量。
• use_multiprocessing: 如果 True，則使用基於程序的多執行緒。 請注意，因為此實現依賴於多程序，所以不應將不可傳遞的引數傳遞給生成器，因為它們不能被輕易地傳遞給子程序。
• verbose: 日誌顯示模式， 0 或 1。

10.2  返回

預測值的 Numpy 陣列。

• ValueError: 如果生成器生成的資料格式不正確。

11 get_layer

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

根據名稱（唯一）或索引值查詢網路層。

如果同時提供了 name 和 index，則 index 將優先。

根據網路層的名稱（唯一）或其索引返回該層。索引是基於水平圖遍歷的順序（自下而上）。

11.1  引數

• name: 字串，層的名字。
• index: 整數，層的索引。

11.2 返回

一個層例項。

11.3  異常

• ValueError: 如果層的名稱或索引不正確。

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