introduction

Apprenez à implémenter un modèle de base et un modèle multi-entrées / multi-sorties à l'aide de l'API fonctionnelle de Keras.

environnement

Cette fois, nous utilisons Keras intégré à Tensorflow.

tensorflow==2.3.0

objectif

Une API fonctionnelle peut être utilisée --Un modèle d'entrée / sortie multiple peut être implémenté

Qu'est-ce que l'API fonctionnelle?

Il vous permet d'implémenter des modèles plus flexibles que le modèle séquentiel. Cette fois, nous allons implémenter un modèle multi-entrées / multi-sorties parmi les modèles qui ne peuvent pas être exprimés par le modèle séquentiel.

Utilisation de base

Tout d'abord, je vais vous expliquer l'utilisation de base de l'API fonctionnelle. Puisque l'API fonctionnelle est un moyen de définir un modèle, l'entraînement, l'évaluation et la prédiction sont les mêmes que pour le modèle séquentiel.

Couche d'entrée

Tout d'abord, définissez la couche d'entrée avec keras.Input.

inputs = keras.Input(shape=(128,))

Couche intermédiaire / couche de sortie

Vous pouvez ajouter des couches comme indiqué ci-dessous, et la dernière couche sera la couche de sortie.

x = layers.Dense(64, activation="relu")(inputs)
outputs = layers.Dense(10)(x)

La modélisation

Après avoir défini les couches, spécifiez les couches d'entrée et de sortie pour créer le modèle.

model = keras.Model(inputs=inputs, outputs=outputs, name="model")

Comparaison avec le modèle séquentiel

Essayez d'implémenter le même modèle avec le modèle séquentiel et l'API fonctionnelle.

Le modèle à mettre en œuvre est le suivant.

Modèle séquentiel

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)

Modèle multi-entrées / multi-sorties

Nous allons implémenter un modèle multi-entrées / multi-sorties avec l'API fonctionnelle.

Multi-entrée

En définissant plusieurs couches d'entrée, il est possible d'avoir plusieurs entrées. Utilisez layer.concatenate pour combiner plusieurs couches.

inputs1 = keras.Input(shape=(64,), name="inputs1_name")
inputs2 = keras.Input(shape=(32,), name="inputs2_name")

x = layers.concatenate([inputs1, inputs2])

Multi-sortie

Les couches peuvent être ramifiées en passant la couche intermédiaire à plusieurs couches. La multi-sortie est obtenue en ayant plusieurs couches comme points d'extrémité.

outputs1 = layers.Dense(64, name="outputs1_name")(x)
outputs2 = layers.Dense(32, name="outputs2_name")(X)

compiler

Si vous avez plusieurs couches de sortie, vous pouvez spécifier une fonction de perte et un poids pour chacun.

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],
)

Apprentissage

Vous pouvez vous entraîner en spécifiant les données d'entrée et les données de sortie (cible) avec le nom donné à la couche.

model.fit(
    {"inputs1_name": inputs1_data, "inputs2_name": inputs2_data},
    {"outputs1_name": outputs1_targets, "outputs2_name": outputs2_targets},
    epochs=2,
    batch_size=32,
)

Exemple concret

Nous allons l'implémenter à l'aide d'un exemple concret.

Ici, à partir du titre, du corps et de l'étiquette de la demande du client, la priorité de la demande et le service correspondant sont prédits.

contribution

--Titre

Texte --Marque

production

priorité
Département correspondant

from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

num_tags = 12
num_words = 10000
num_departments = 4

#Créer des données factices
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))

#Calque de titre
title_input = keras.Input(
    shape=(None,), name="title"
)
title_features = layers.Embedding(num_words, 64)(title_input)
title_features = layers.LSTM(128)(title_features)

#Couche corporelle
body_input = keras.Input(shape=(None,), name="body")
body_features = layers.Embedding(num_words, 64)(body_input)
body_features = layers.LSTM(32)(body_features)

#Couche de tag
tags_input = keras.Input(
    shape=(num_tags,), name="tags"
)
tags_features = layers.Dense(36, activation='relu')(tags_input)

#Joindre des couches
x = layers.concatenate([title_features, body_features, tags_features])

#Couche de sortie
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],
)

#Compilez le modèle
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],
)

#Apprentissage
model.fit(
    {"title": title_data, "body": body_data, "tags": tags_data},
    {"priority": priority_targets, "department": dept_targets},
    epochs=2,
    batch_size=32,
)

Résumé

Les modèles multi-entrées / multi-sorties peuvent être implémentés à l'aide de l'API fonctionnelle

Les références

Keras Functional API | TensorFlow Core
[Apprentissage en profondeur avec Python et 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-François-Chollet / dp / 4839964262)

[PYTHON] Modèle multi-entrées / multi-sorties avec API fonctionnelle