深入學習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 類的實例。詳見：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)

 

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

思路：

　　輸入數據：定義輸入一個二維數組（x1,x2），數據通過numpy來隨機產生，將輸出定義為0或者1，如果x1+x2<1，則y為1，否則y為0.

　　隱藏層：定義兩層隱藏層，隱藏層的參數為（2,3），兩行三列的矩陣，輸入數據通過隱藏層之后，輸出的數據為（1,3），t通過矩陣之間的乘法運算可以獲得輸出數據。

　　損失函數：使用交叉熵作為神經網絡的損失函數，常用的損失函數還有平方差。

　　優化函數：通過油畫函數來使得損失函數最小化，這里采用的是Adadelta算法進行優化，常用的有梯度下降算法。

　　輸出數據：將隱藏層的輸出數據通過（3,1）的參數，輸出一個一維向量，值的大小為0或者1.

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

# 生成數據，訓練數據和測試數據
# x_train/x_test 生成隨機的浮點數，x_train為1000行20列 x_test為100行20列
# 列數一定要一一對應，相當於特征個數要對應
# 此處的二元分類，可以不需要one_hot編譯，np.random.randint可以直接生成0 1 編碼
x_train = np.random.random((1000,20))
y_train = np.random.randint(2,size=(1000,1))
# print(x_train)
# print(y_train)
x_test = np.random.random((100,20))
y_test = np.random.randint(2,size=(100,1))

# 設計模型，通過add的方式疊起來
# 注意輸入時，初始網絡一定要給定輸入的特征維度input_dim 或者input_shape數據類型
# activition激活函數既可以在Dense網絡設置里，也可以單獨添加
model = Sequential()
model.add(Dense(64,input_dim=20,activation='relu'))
# Drop防止過擬合的數據處理方式
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)
print(score)

　　

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

 

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 數組。

10.3 異常

• ValueError: 如果生成器生成的數據格式不正確。

11 get_layer

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

 

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

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

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

11.1  參數

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

11.2 返回

一個層實例。

11.3  異常

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

 

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