Docs ? 快速開始 ? Sequential 順序模型指引

開始使用 Keras Sequential 順序模型

順序模型是多個網(wǎng)絡(luò)層的線性堆疊。

你可以通過將網(wǎng)絡(luò)層實例的列表傳遞給 Sequential 的構(gòu)造器，來創(chuàng)建一個 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'))

指定輸入數(shù)據(jù)的尺寸

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

  • 傳遞一個 input_shape 參數(shù)給第一層。它是一個表示尺寸的元組 (一個由整數(shù)或 None 組成的元組，其中 None 表示可能為任何正整數(shù))。在 input_shape 中不包含數(shù)據(jù)的 batch 大小。
  • 某些 2D 層，例如 Dense，支持通過參數(shù) input_dim 指定輸入尺寸，某些 3D 時序?qū)又С?input_dim 和 input_length 參數(shù)。
  • 如果你需要為你的輸入指定一個固定的 batch 大?。ㄟ@對 stateful RNNs 很有用），你可以傳遞一個 batch_size 參數(shù)給一個層。如果你同時將 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))

模型編譯

在訓(xùn)練模型之前，您需要配置學(xué)習(xí)過程，這是通過 compile 方法完成的。它接收三個參數(shù)：

  • 優(yōu)化器 optimizer。它可以是現(xiàn)有優(yōu)化器的字符串標(biāo)識符，如 rmsprop 或 adagrad，也可以是 Optimizer 類的實例。詳見：optimizers。
  • 損失函數(shù) loss，模型試圖最小化的目標(biāo)函數(shù)。它可以是現(xiàn)有損失函數(shù)的字符串標(biāo)識符，如 categorical_crossentropy 或 mse，也可以是一個目標(biāo)函數(shù)。詳見：losses。
  • 評估標(biāo)準(zhǔn) metrics。對于任何分類問題，你都希望將其設(shè)置為 metrics = ['accuracy']。評估標(biāo)準(zhǔn)可以是現(xiàn)有的標(biāo)準(zhǔn)的字符串標(biāo)識符，也可以是自定義的評估標(biāo)準(zhǔn)函數(shù)。
# 多分類問題
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

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

# 自定義評估標(biāo)準(zhǔn)函數(shù)
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ùn)練

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

# 對于具有 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'])

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

# 訓(xùn)練模型，以 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'])

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

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

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

樣例

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

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

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

...以及更多。

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

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

# 生成虛擬數(shù)據(jù)
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 個隱藏神經(jīng)元的全連接層。
# 在第一層必須指定所期望的輸入數(shù)據(jù)尺寸：
# 在這里，是一個 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

# 生成虛擬數(shù)據(jù)
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 的卷積神經(jīng)網(wǎng)絡(luò)：

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

# 生成虛擬數(shù)據(jù)
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 層疊在一起，使模型能夠?qū)W習(xí)更高層次的時間表示。

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

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

data_dim = 16
timesteps = 8
num_classes = 10

# 期望輸入數(shù)據(jù)尺寸: (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ùn)練數(shù)據(jù)
x_train = np.random.random((1000, timesteps, data_dim))
y_train = np.random.random((1000, num_classes))

# 生成虛擬驗證數(shù)據(jù)
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 模型

有狀態(tài) (stateful) 的循環(huán)神經(jīng)網(wǎng)絡(luò)模型中，在一個 batch 的樣本處理完成后，其內(nèi)部狀態(tài)（記憶）會被記錄并作為下一個 batch 的樣本的初始狀態(tài)。這允許處理更長的序列，同時保持計算復(fù)雜度的可控性。

你可以在 FAQ 中查找更多關(guān)于 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

# 期望輸入數(shù)據(jù)尺寸: (batch_size, timesteps, data_dim)
# 請注意，我們必須提供完整的 batch_input_shape，因為網(wǎng)絡(luò)是有狀態(tài)的。
# 第 k 批數(shù)據(jù)的第 i 個樣本是第 k-1 批數(shù)據(jù)的第 i 個樣本的后續(xù)。
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ùn)練數(shù)據(jù)
x_train = np.random.random((batch_size * 10, timesteps, data_dim))
y_train = np.random.random((batch_size * 10, num_classes))

# 生成虛擬驗證數(shù)據(jù)
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))
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容