開始使用 Keras 函數(shù)式 API

開始使用 Keras 函數(shù)式 API

Keras 函數(shù)式 API 是定義復(fù)雜模型（如多輸出模型、有向無環(huán)圖，或具有共享層的模型）的方法。

這部分文檔假設(shè)你已經(jīng)對 Sequential 順序模型比較熟悉。

讓我們先從一些簡單的例子開始。

例一：全連接網(wǎng)絡(luò)

Sequential 模型可能是實現(xiàn)這種網(wǎng)絡(luò)的一個更好選擇，但這個例子能夠幫助我們進(jìn)行一些簡單的理解。

  • 網(wǎng)絡(luò)層的實例是可調(diào)用的，它以張量為參數(shù)，并且返回一個張量
  • 輸入和輸出均為張量，它們都可以用來定義一個模型（Model）
  • 這樣的模型同 Keras 的 Sequential 模型一樣，都可以被訓(xùn)練
from keras.layers import Input, Dense
from keras.models import Model

# 這部分返回一個張量
inputs = Input(shape=(784,))

# 層的實例是可調(diào)用的，它以張量為參數(shù)，并且返回一個張量
x = Dense(64, activation='relu')(inputs)
x = Dense(64, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)

# 這部分創(chuàng)建了一個包含輸入層和三個全連接層的模型
model = Model(inputs=inputs, outputs=predictions)
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(data, labels)  # 開始訓(xùn)練

所有的模型都可調(diào)用，就像網(wǎng)絡(luò)層一樣

利用函數(shù)式 API，可以輕易地重用訓(xùn)練好的模型：可以將任何模型看作是一個層，然后通過傳遞一個張量來調(diào)用它。注意，在調(diào)用模型時，您不僅重用模型的結(jié)構(gòu)，還重用了它的權(quán)重。

x = Input(shape=(784,))
# 這是可行的，并且返回上面定義的 10-way softmax。
y = model(x)

這種方式能允許我們快速創(chuàng)建可以處理序列輸入的模型。只需一行代碼，你就將圖像分類模型轉(zhuǎn)換為視頻分類模型。

from keras.layers import TimeDistributed

# 輸入張量是 20 個時間步的序列，
# 每一個時間為一個 784 維的向量
input_sequences = Input(shape=(20, 784))

# 這部分將我們之前定義的模型應(yīng)用于輸入序列中的每個時間步。
# 之前定義的模型的輸出是一個 10-way softmax，
# 因而下面的層的輸出將是維度為 10 的 20 個向量的序列。
processed_sequences = TimeDistributed(model)(input_sequences)

多輸入多輸出模型

以下是函數(shù)式 API 的一個很好的例子：具有多個輸入和輸出的模型。函數(shù)式 API 使處理大量交織的數(shù)據(jù)流變得容易。

來考慮下面的模型。我們試圖預(yù)測 Twitter 上的一條新聞標(biāo)題有多少轉(zhuǎn)發(fā)和點贊數(shù)。模型的主要輸入將是新聞標(biāo)題本身，即一系列詞語，但是為了增添趣味，我們的模型還添加了其他的輔助輸入來接收額外的數(shù)據(jù)，例如新聞標(biāo)題的發(fā)布的時間等。 該模型也將通過兩個損失函數(shù)進(jìn)行監(jiān)督學(xué)習(xí)。較早地在模型中使用主損失函數(shù)，是深度學(xué)習(xí)模型的一個良好正則方法。

模型結(jié)構(gòu)如下圖所示：

multi-input-multi-output-graph

讓我們用函數(shù)式 API 來實現(xiàn)它。

主要輸入接收新聞標(biāo)題本身，即一個整數(shù)序列（每個整數(shù)編碼一個詞）。 這些整數(shù)在 1 到 10,000 之間（10,000 個詞的詞匯表），且序列長度為 100 個詞。

from keras.layers import Input, Embedding, LSTM, Dense
from keras.models import Model

# 標(biāo)題輸入：接收一個含有 100 個整數(shù)的序列，每個整數(shù)在 1 到 10000 之間。
# 注意我們可以通過傳遞一個 "name" 參數(shù)來命名任何層。
main_input = Input(shape=(100,), dtype='int32', name='main_input')

# Embedding 層將輸入序列編碼為一個稠密向量的序列，
# 每個向量維度為 512。
x = Embedding(output_dim=512, input_dim=10000, input_length=100)(main_input)

# LSTM 層把向量序列轉(zhuǎn)換成單個向量，
# 它包含整個序列的上下文信息
lstm_out = LSTM(32)(x)

在這里，我們插入輔助損失，使得即使在模型主損失很高的情況下，LSTM 層和 Embedding 層都能被平穩(wěn)地訓(xùn)練。

auxiliary_output = Dense(1, activation='sigmoid', name='aux_output')(lstm_out)

此時，我們將輔助輸入數(shù)據(jù)與 LSTM 層的輸出連接起來，輸入到模型中：

auxiliary_input = Input(shape=(5,), name='aux_input')
x = keras.layers.concatenate([lstm_out, auxiliary_input])

# 堆疊多個全連接網(wǎng)絡(luò)層
x = Dense(64, activation='relu')(x)
x = Dense(64, activation='relu')(x)
x = Dense(64, activation='relu')(x)

# 最后添加主要的邏輯回歸層
main_output = Dense(1, activation='sigmoid', name='main_output')(x)

然后定義一個具有兩個輸入和兩個輸出的模型：

model = Model(inputs=[main_input, auxiliary_input], outputs=[main_output, auxiliary_output])

現(xiàn)在編譯模型，并給輔助損失分配一個 0.2 的權(quán)重。如果要為不同的輸出指定不同的 loss_weights 或 loss，可以使用列表或字典。 在這里，我們給 loss 參數(shù)傳遞單個損失函數(shù)，這個損失將用于所有的輸出。

model.compile(optimizer='rmsprop', loss='binary_crossentropy',
              loss_weights=[1., 0.2])

我們可以通過傳遞輸入數(shù)組和目標(biāo)數(shù)組的列表來訓(xùn)練模型：

model.fit([headline_data, additional_data], [labels, labels],
          epochs=50, batch_size=32)

由于輸入和輸出均被命名了（在定義時傳遞了一個 name 參數(shù)），我們也可以通過以下方式編譯模型：

model.compile(optimizer='rmsprop',
              loss={'main_output': 'binary_crossentropy', 'aux_output': 'binary_crossentropy'},
              loss_weights={'main_output': 1., 'aux_output': 0.2})

# 然后使用以下方式訓(xùn)練：
model.fit({'main_input': headline_data, 'aux_input': additional_data},
          {'main_output': labels, 'aux_output': labels},
          epochs=50, batch_size=32)

共享網(wǎng)絡(luò)層

函數(shù)式 API 的另一個用途是使用共享網(wǎng)絡(luò)層的模型。我們來看看共享層。

來考慮推特推文數(shù)據(jù)集。我們想要建立一個模型來分辨兩條推文是否來自同一個人（例如，通過推文的相似性來對用戶進(jìn)行比較）。

實現(xiàn)這個目標(biāo)的一種方法是建立一個模型，將兩條推文編碼成兩個向量，連接向量，然后添加邏輯回歸層；這將輸出兩條推文來自同一作者的概率。模型將接收一對對正負(fù)表示的推特數(shù)據(jù)。

由于這個問題是對稱的，編碼第一條推文的機(jī)制應(yīng)該被完全重用來編碼第二條推文（權(quán)重及其他全部）。這里我們使用一個共享的 LSTM 層來編碼推文。

讓我們使用函數(shù)式 API 來構(gòu)建它。首先我們將一條推特轉(zhuǎn)換為一個尺寸為 (280, 256) 的矩陣，即每條推特 280 字符，每個字符為 256 維的 one-hot 編碼向量 （取 256 個常用字符）。

import keras
from keras.layers import Input, LSTM, Dense
from keras.models import Model

tweet_a = Input(shape=(280, 256))
tweet_b = Input(shape=(280, 256))

要在不同的輸入上共享同一個層，只需實例化該層一次，然后根據(jù)需要傳入你想要的輸入即可：

# 這一層可以輸入一個矩陣，并返回一個 64 維的向量
shared_lstm = LSTM(64)

# 當(dāng)我們重用相同的圖層實例多次，圖層的權(quán)重也會被重用 (它其實就是同一層)
encoded_a = shared_lstm(tweet_a)
encoded_b = shared_lstm(tweet_b)

# 然后再連接兩個向量：
merged_vector = keras.layers.concatenate([encoded_a, encoded_b], axis=-1)

# 再在上面添加一個邏輯回歸層
predictions = Dense(1, activation='sigmoid')(merged_vector)

# 定義一個連接推特輸入和預(yù)測的可訓(xùn)練的模型
model = Model(inputs=[tweet_a, tweet_b], outputs=predictions)

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])
model.fit([data_a, data_b], labels, epochs=10)

讓我們暫停一會，看看如何讀取共享層的輸出或輸出尺寸。

層「節(jié)點」的概念

每當(dāng)你在某個輸入上調(diào)用一個層時，都將創(chuàng)建一個新的張量（層的輸出），并且為該層添加一個「節(jié)點」，將輸入張量連接到輸出張量。當(dāng)多次調(diào)用同一個圖層時，該圖層將擁有多個節(jié)點索引 (0, 1, 2...)。

在之前版本的 Keras 中，可以通過 layer.get_output() 來獲得層實例的輸出張量，或者通過 layer.output_shape 來獲取其輸出形狀?，F(xiàn)在你依然可以這么做（除了 get_output() 已經(jīng)被 output 屬性替代）。但是如果一個層與多個輸入連接呢？

只要一個層僅僅連接到一個輸入，就不會有困惑，.output 會返回層的唯一輸出：

a = Input(shape=(280, 256))

lstm = LSTM(32)
encoded_a = lstm(a)

assert lstm.output == encoded_a

但是如果該層有多個輸入，那就會出現(xiàn)問題：

a = Input(shape=(280, 256))
b = Input(shape=(280, 256))

lstm = LSTM(32)
encoded_a = lstm(a)
encoded_b = lstm(b)

lstm.output


>> AttributeError: Layer lstm_1 has multiple inbound nodes,
hence the notion of "layer output" is ill-defined.
Use `get_output_at(node_index)` instead.

好吧，通過下面的方法可以解決：

assert lstm.get_output_at(0) == encoded_a
assert lstm.get_output_at(1) == encoded_b

夠簡單，對吧？

input_shape 和 output_shape 這兩個屬性也是如此：只要該層只有一個節(jié)點，或者只要所有節(jié)點具有相同的輸入/輸出尺寸，那么「層輸出/輸入尺寸」的概念就被很好地定義，并且將由 layer.output_shape / layer.input_shape 返回。但是比如說，如果將一個 Conv2D 層先應(yīng)用于尺寸為 (32，32，3) 的輸入，再應(yīng)用于尺寸為 (64, 64, 3) 的輸入，那么這個層就會有多個輸入/輸出尺寸，你將不得不通過指定它們所屬節(jié)點的索引來獲取它們：

a = Input(shape=(32, 32, 3))
b = Input(shape=(64, 64, 3))

conv = Conv2D(16, (3, 3), padding='same')
conved_a = conv(a)

# 到目前為止只有一個輸入，以下可行：
assert conv.input_shape == (None, 32, 32, 3)

conved_b = conv(b)
# 現(xiàn)在 `.input_shape` 屬性不可行，但是這樣可以：
assert conv.get_input_shape_at(0) == (None, 32, 32, 3)
assert conv.get_input_shape_at(1) == (None, 64, 64, 3)

更多的例子

代碼示例仍然是起步的最佳方式，所以這里還有更多的例子。

Inception 模型

有關(guān) Inception 結(jié)構(gòu)的更多信息，請參閱 Going Deeper with Convolutions。

from keras.layers import Conv2D, MaxPooling2D, Input

input_img = Input(shape=(256, 256, 3))

tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1)

tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(input_img)
tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2)

tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(input_img)
tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3)

output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1)

卷積層上的殘差連接

有關(guān)殘差網(wǎng)絡(luò) (Residual Network) 的更多信息，請參閱 Deep Residual Learning for Image Recognition。

from keras.layers import Conv2D, Input

# 輸入張量為 3 通道 256x256 圖像
x = Input(shape=(256, 256, 3))
# 3 輸出通道（與輸入通道相同）的 3x3 卷積核
y = Conv2D(3, (3, 3), padding='same')(x)
# 返回 x + y
z = keras.layers.add([x, y])

共享視覺模型

該模型在兩個輸入上重復(fù)使用同一個圖像處理模塊，以判斷兩個 MNIST 數(shù)字是否為相同的數(shù)字。

from keras.layers import Conv2D, MaxPooling2D, Input, Dense, Flatten
from keras.models import Model

# 首先，定義視覺模型
digit_input = Input(shape=(27, 27, 1))
x = Conv2D(64, (3, 3))(digit_input)
x = Conv2D(64, (3, 3))(x)
x = MaxPooling2D((2, 2))(x)
out = Flatten()(x)

vision_model = Model(digit_input, out)

# 然后，定義區(qū)分?jǐn)?shù)字的模型
digit_a = Input(shape=(27, 27, 1))
digit_b = Input(shape=(27, 27, 1))

# 視覺模型將被共享，包括權(quán)重和其他所有
out_a = vision_model(digit_a)
out_b = vision_model(digit_b)

concatenated = keras.layers.concatenate([out_a, out_b])
out = Dense(1, activation='sigmoid')(concatenated)

classification_model = Model([digit_a, digit_b], out)

視覺問答模型

當(dāng)被問及關(guān)于圖片的自然語言問題時，該模型可以選擇正確的單詞作答。

它通過將問題和圖像編碼成向量，然后連接兩者，在上面訓(xùn)練一個邏輯回歸，來從詞匯表中挑選一個可能的單詞作答。

from keras.layers import Conv2D, MaxPooling2D, Flatten
from keras.layers import Input, LSTM, Embedding, Dense
from keras.models import Model, Sequential

# 首先，讓我們用 Sequential 來定義一個視覺模型。
# 這個模型會把一張圖像編碼為向量。
vision_model = Sequential()
vision_model.add(Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=(224, 224, 3)))
vision_model.add(Conv2D(64, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Conv2D(128, (3, 3), activation='relu', padding='same'))
vision_model.add(Conv2D(128, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
vision_model.add(Conv2D(256, (3, 3), activation='relu'))
vision_model.add(Conv2D(256, (3, 3), activation='relu'))
vision_model.add(MaxPooling2D((2, 2)))
vision_model.add(Flatten())

# 現(xiàn)在讓我們用視覺模型來得到一個輸出張量：
image_input = Input(shape=(224, 224, 3))
encoded_image = vision_model(image_input)

# 接下來，定義一個語言模型來將問題編碼成一個向量。
# 每個問題最長 100 個詞，詞的索引從 1 到 9999.
question_input = Input(shape=(100,), dtype='int32')
embedded_question = Embedding(input_dim=10000, output_dim=256, input_length=100)(question_input)
encoded_question = LSTM(256)(embedded_question)

# 連接問題向量和圖像向量：
merged = keras.layers.concatenate([encoded_question, encoded_image])

# 然后在上面訓(xùn)練一個 1000 詞的邏輯回歸模型：
output = Dense(1000, activation='softmax')(merged)

# 最終模型：
vqa_model = Model(inputs=[image_input, question_input], outputs=output)

# 下一步就是在真實數(shù)據(jù)上訓(xùn)練模型。

視頻問答模型

現(xiàn)在我們已經(jīng)訓(xùn)練了圖像問答模型，我們可以很快地將它轉(zhuǎn)換為視頻問答模型。在適當(dāng)?shù)挠?xùn)練下，你可以給它展示一小段視頻（例如 100 幀的人體動作），然后問它一個關(guān)于這段視頻的問題（例如，「這個人在做什么運動？」 -> 「足球」）。

from keras.layers import TimeDistributed

video_input = Input(shape=(100, 224, 224, 3))
# 這是基于之前定義的視覺模型（權(quán)重被重用）構(gòu)建的視頻編碼
encoded_frame_sequence = TimeDistributed(vision_model)(video_input)  # 輸出為向量的序列
encoded_video = LSTM(256)(encoded_frame_sequence)  # 輸出為一個向量

# 這是問題編碼器的模型級表示，重復(fù)使用與之前相同的權(quán)重：
question_encoder = Model(inputs=question_input, outputs=encoded_question)

# 讓我們用它來編碼這個問題：
video_question_input = Input(shape=(100,), dtype='int32')
encoded_video_question = question_encoder(video_question_input)

# 這就是我們的視頻問答模式：
merged = keras.layers.concatenate([encoded_video, encoded_video_question])
output = Dense(1000, activation='softmax')(merged)
video_qa_model = Model(inputs=[video_input, video_question_input], outputs=output)
?著作權(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)容