[PYTHON] Multi-Input / Multi-Output-Modell mit funktionaler API
Einführung
Erfahren Sie, wie Sie ein Basismodell und ein Multi-Input / Multi-Output-Modell mithilfe der Funktions-API von Keras implementieren.
Umgebung
Dieses Mal verwenden wir Keras, das in Tensorflow integriert ist.
tensorflow==2.3.0
Tor
--Funktionale API kann verwendet werden --Multiple Input / Multi-Output-Modell kann implementiert werden
Was ist eine funktionale API?
Damit können Sie flexiblere Modelle als das sequentielle Modell implementieren. Dieses Mal werden wir ein Multi-Input / Multi-Output-Modell aus den Modellen implementieren, die vom sequentiellen Modell nicht ausgedrückt werden können.
Grundlegende Verwendung
Zunächst werde ich die grundlegende Verwendung der funktionalen API erläutern. Da die funktionale API eine Methode zum Definieren eines Modells ist, sind Training, Bewertung und Vorhersage dieselben wie für das sequentielle Modell.
Eingabeebene
Definieren Sie zunächst die Eingabeebene mit "keras.Input".
inputs = keras.Input(shape=(128,))
Zwischenschicht / Ausgangsschicht
Sie können Ebenen wie unten gezeigt hinzufügen, und die letzte Ebene ist die Ausgabeebene.
x = layers.Dense(64, activation="relu")(inputs)
outputs = layers.Dense(10)(x)
Modellieren
Geben Sie nach dem Definieren der Ebenen die Eingabe- und Ausgabeebenen an, um das Modell zu erstellen.
model = keras.Model(inputs=inputs, outputs=outputs, name="model")
Vergleich mit dem sequentiellen Modell
Versuchen Sie, dasselbe Modell mit dem sequentiellen Modell und der funktionalen API zu implementieren.
Das zu implementierende Modell ist wie folgt.
Sequentielles Modell
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
model = Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(784,)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
Functional API
from tensorflow import keras
from tensorflow.keras import layers
inputs = keras.Input(shape=(784,))
x = layers.Dense(64, activation='relu')(inputs)
x = layers.Dense(64, activation='relu')(x)
outputs = layers.Dense(10, activation='softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)
Multi-Input / Multi-Output-Modell
Wir werden ein Multi-Input / Multi-Output-Modell mit der Functional API implementieren.
Multi-Input
Durch das Definieren mehrerer Eingabeebenen ist es möglich, mehrere Eingaben zu haben. Verwenden Sie "layer.concatenate", um mehrere Ebenen zu kombinieren.
inputs1 = keras.Input(shape=(64,), name="inputs1_name")
inputs2 = keras.Input(shape=(32,), name="inputs2_name")
x = layers.concatenate([inputs1, inputs2])
Multi-Output
Ebenen können verzweigt werden, indem die mittlere Ebene an mehrere Ebenen übergeben wird. Multi-Output wird erreicht, indem mehrere Ebenen als Endpunkte verwendet werden.
outputs1 = layers.Dense(64, name="outputs1_name")(x)
outputs2 = layers.Dense(32, name="outputs2_name")(X)
kompilieren
Wenn Sie mehrere Ausgabeebenen haben, können Sie für jede eine Verlustfunktion und ein Gewicht angeben.
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss={
"outputs1_name": keras.losses.BinaryCrossentropy(from_logits=True),
"outputs2_name": keras.losses.CategoricalCrossentropy(from_logits=True),
},
loss_weights=[1.0, 0.5],
)
Lernen
Sie können trainieren, indem Sie die Eingabedaten und Ausgabedaten (Ziel) mit dem Namen angeben, der der Ebene gegeben wurde.
model.fit(
{"inputs1_name": inputs1_data, "inputs2_name": inputs2_data},
{"outputs1_name": outputs1_targets, "outputs2_name": outputs2_targets},
epochs=2,
batch_size=32,
)
Konkretes Beispiel
Wir werden es anhand eines konkreten Beispiels umsetzen.
Hier werden aus Titel, Text und Tag der Anfrage des Kunden die Priorität der Anfrage und die entsprechende Abteilung vorhergesagt.
Eingang
--Titel
- Text --Etikett
Ausgabe
- Priorität
- Entsprechende Abteilung
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np
num_tags = 12
num_words = 10000
num_departments = 4
#Dummy-Daten erstellen
title_data = np.random.randint(num_words, size=(1280, 10))
body_data = np.random.randint(num_words, size=(1280, 100))
tags_data = np.random.randint(2, size=(1280, num_tags)).astype("float32")
priority_targets = np.random.random(size=(1280, 1))
dept_targets = np.random.randint(2, size=(1280, num_departments))
#Titelebene
title_input = keras.Input(
shape=(None,), name="title"
)
title_features = layers.Embedding(num_words, 64)(title_input)
title_features = layers.LSTM(128)(title_features)
#Körperschicht
body_input = keras.Input(shape=(None,), name="body")
body_features = layers.Embedding(num_words, 64)(body_input)
body_features = layers.LSTM(32)(body_features)
#Tag-Ebene
tags_input = keras.Input(
shape=(num_tags,), name="tags"
)
tags_features = layers.Dense(36, activation='relu')(tags_input)
#Ebenen verbinden
x = layers.concatenate([title_features, body_features, tags_features])
#Ausgabeschicht
priority_output = layers.Dense(1, name="priority")(x)
department_output = layers.Dense(num_departments, name="department")(x)
model = keras.Model(
inputs=[title_input, body_input, tags_input],
outputs=[priority_output, department_output],
)
#Kompilieren Sie das Modell
model.compile(
optimizer=keras.optimizers.RMSprop(1e-3),
loss={
"priority": keras.losses.BinaryCrossentropy(from_logits=True),
"department": keras.losses.CategoricalCrossentropy(from_logits=True),
},
loss_weights=[1.0, 0.5],
)
#Lernen
model.fit(
{"title": title_data, "body": body_data, "tags": tags_data},
{"priority": priority_targets, "department": dept_targets},
epochs=2,
batch_size=32,
)
Zusammenfassung
- Modelle mit mehreren Eingängen und mehreren Ausgängen können mithilfe der Funktions-API implementiert werden
Verweise
- Keras Functional API | TensorFlow Core
- [Deep Learning mit Python und Keras](https://www.amazon.co.jp/Python%E3%81%A8Keras%E3%81%AB%E3%82%88%E3%82%8B%E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0-Francois-Chollet / dp / 4839964262)
Recommended Posts