Traduction du guide de présentation de Tensorflow.org. Ce guide vous donnera les bases pour commencer avec Keras. La lecture dure 10 minutes.
Importer tf.keras
tf.keras est une implémentation de la spécification API TensorFlow Keras. Il s'agit d'une API de haut niveau pour la création et la formation de modèles qui inclut une prise en charge de première classe pour les fonctionnalités spécifiques à TensorFlow telles que l'
exécution tf.data pipelines
tf.data et les
estimateurs .
tf.keras facilite l'utilisation de TensorFlow sans sacrifier la flexibilité et les performances.
Pour commencer, importez
tf.keras dans le cadre de votre configuration TensorFlow:
from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras
tf.keras peut exécuter n'importe quel code compatible Keras, mais gardez à l'esprit:
- La version de
tf.keras dans la dernière version de TensorFlow peut être différente de la dernière version de keras dans PyPI. Découvrez tf.keras.__version__ . - Lorsque vous enregistrez des poids de modèle,
tf.keras fait par défaut au format de point de contrôle. Passez le save_format='h5' pour utiliser HDF5 (ou ajoutez l'extension .h5 au .h5 du fichier).
Construisez un modèle simple
Modèle séquentiel
Dans Keras, vous collectez des
couches pour créer des
modèles . Un modèle est un graphique de couches (généralement). Le type de modèle le plus courant est la pile de couches:
tf.keras.Sequential model.
Nous construisons un réseau simple entièrement connecté (c'est-à -dire un perceptron multicouche):
from tensorflow.keras import layers model = tf.keras.Sequential()
Personnaliser les calques
De nombreuses variétés de couches
tf.keras.layers sont
tf.keras.layers . La plupart d'entre eux utilisent un constructeur d'arguments commun:
activation : définit la fonction d'activation de la couche. Ce paramètre spécifie le nom de la fonction intégrée ou de l'objet appelé. Le paramètre n'a pas de valeur par défaut.kernel_initializer et bias_initializer : schémas d'initialisation qui créent des pondérations de couche (noyau et décalage). Ce paramètre peut être le nom ou l'objet appelé. L'initialiseur par défaut est "Glorot uniform" .kernel_regularizer et bias_regularizer : schémas de régularisation ajoutés aux pondérations de couche (noyau et décalage), comme la régularisation L1 ou L2. Par défaut, la régularisation n'est pas définie.
Les exemples suivants d'instances des couches `tf.keras.layers.Dense` utilisent des arguments de constructeur:
Formation et Ă©valuation
Configuration de la formation
Une fois le modèle construit, configurez le processus d'apprentissage en appelant la méthode de
compile :
model = tf.keras.Sequential([
tf.keras.Model.compile accepte trois arguments importants:
optimizer : cet objet définit la procédure de formation. tf.keras.optimizers instances d' tf.keras.optimizers module tf.keras.optimizers , telles que tf.keras.optimizers.Adam ou tf.keras.optimizers.SGD . Si vous souhaitez simplement utiliser les options par défaut, vous pouvez également spécifier des optimiseurs avec des mots clés tels que 'adam' ou 'sgd' .loss : il s'agit d'une fonction qui est minimisée dans le processus d'apprentissage. Parmi les variations courantes figurent l'erreur standard ( mse ), categorical_crossentropy , binary_crossentropy . Les fonctions de perte sont spécifiées par nom ou en passant l'objet appelé à partir du module tf.keras.losses .metrics : utilisées pour surveiller la formation. Ce sont des noms de chaîne ou des objets appelés du module tf.keras.metrics .- De plus, pour vous assurer que le modèle est formé et évalué avec impatience, vérifiez que vous transmettez le paramètre
run_eagerly=True au compilateur
Ensuite, nous allons voir quelques exemples de configuration de modèle pour la formation:
Apprendre des données NumPy
Pour les jeux de données plus petits, utilisez les matrices de mémoire de NumPy pour former et évaluer le modèle. Le modèle est «formé» sur les données de formation en utilisant la méthode «fit»:
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)
tf.keras.Model.fit prend trois arguments importants:
epochs : L'apprentissage se décompose en * époques *. L'ère est une itération sur toutes les données d'entrée (cela se fait en petits lots).batch_size : lors de la transmission de données NumPy, le modèle décompose les données en blocs plus petits (lots) et itère sur ces blocs pendant la formation. Ce nombre indique la taille de chaque bloc de données. N'oubliez pas que le dernier bloc peut être plus petit si le nombre total d'enregistrements n'est pas divisé par la taille du lot.validation_data : lors du prototypage d'un modèle, vous souhaitez suivre facilement ses performances sur les données de validation. La transmission d'un tuple de données d'entrée et d'étiquettes avec cet argument permet au modèle d'afficher les valeurs de la fonction de perte et des métriques en mode de sortie pour les données transmises à la fin de chaque ère.
Voici un exemple utilisant
validation_data :
import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))
Formation à l'aide des jeux de données tf.data
Utilisez l'API Datasets pour mettre à l'échelle de grandes bases de données ou vous entraîner sur plusieurs appareils. Passez l'instance de `tf.data.Dataset` à la méthode
fit :
Étant donné que l'ensemble de
Dataset fournit des données par lots, ce morceau de code ne nécessite pas l'argument
batch_size .
Les jeux de données peuvent également être utilisés pour valider:
dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)
Évaluation et prédiction
Les
tf.keras.Model.predict tf.keras.Model.evaluate et
tf.keras.Model.predict peuvent utiliser les
tf.data.Dataset NumPy et
tf.data.Dataset .
Voici comment vous pouvez
estimer les pertes en mode de sortie et les métriques pour les données fournies:
Et voici comment
prédire la sortie du dernier niveau en mode de sortie pour les données fournies sous forme de tableau NumPy:
Construire des modèles complexes
L'API fonctionnelle
Le modèle
tf.keras.Sequential est une simple pile de couches avec laquelle vous ne pouvez pas imaginer un modèle arbitraire. Utilisez l'API fonctionnelle Keras pour créer des topologies de modèle complexes, telles que:
- Modèles à entrées multiples
- Modèles à sorties multiples,
- Modèles à couches communes (la même couche est appelée plusieurs fois),
- Modèles avec des flux de données incohérents (par exemple, relations résiduelles).
La construction d'un modèle avec une API fonctionnelle fonctionne comme suit:
- L'instance de couche est appelable et renvoie un tenseur.
- Les tenseurs d'entrée et de sortie sont utilisés pour déterminer l'instance de
tf.keras.Model - Ce modèle est entraîné comme le modèle `Sequential`.
L'exemple suivant utilise l'API fonctionnelle pour créer un réseau simple et entièrement connecté:
inputs = tf.keras.Input(shape=(32,))
Créez une instance du modèle avec ces entrées et sorties.
model = tf.keras.Model(inputs=inputs, outputs=predictions)
Modèles de sous-classement
Créez un modèle entièrement personnalisable en utilisant le sous-
tf.keras.Model et en définissant votre propre distribution directe. Créez des couches dans la méthode
__init__ et définissez-les en tant qu'attributs de l'instance de classe. Définissez la propagation directe dans la méthode d'
call .
La sous-classification d'un modèle est particulièrement utile lorsque l'exécution rapide est activée, car elle vous permet d'écrire impérativement la distribution directe.
Remarque: si vous souhaitez que votre modèle s'exécute
toujours impérativement, vous pouvez définir
dynamic=True lorsque vous appelez le
super constructeur.
Point clé: utilisez la bonne API pour travailler. Bien que la sous-classification d'un modèle offre une flexibilité, vous devez payer pour cela avec une plus grande complexité et un plus grand potentiel d'erreurs personnalisées. Si possible, choisissez l'API fonctionnelle.
L'exemple suivant montre un modèle tf.keras.Model sous-classé utilisant une distribution directe personnalisée, qui n'est pas obligatoire:
class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes
Créez une instance de la nouvelle classe de modèle:
model = MyModel(num_classes=10)
Couches personnalisées
Créez un calque personnalisé en sous-
tf.keras.layers.Layer et en appliquant les méthodes suivantes:
__init__ : spécifiez éventuellement les sous-couches à utiliser dans cette couche.- *
build : créer des poids de couche. Ajouter des poids à l'aide de la méthode add_weight call : définir la distribution directe.- Facultativement, la couche peut être sérialisée en implémentant la méthode
get_config et la méthode de la classe from_config .
Voici un exemple d'une couche utilisateur qui multiplie la matrice (
matmul ) alimentée à l'entrée avec la matrice du noyau:
class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape):
Créez un modèle en utilisant votre couche personnalisée:
model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')])
Kolbeki
Kolbek est un objet transféré au modèle pour personnaliser et élargir son comportement lors de l'entraînement. Vous pouvez écrire votre propre rappel personnalisé ou utiliser le
tf.keras.callbacks qui comprend:
tf.keras.callbacks.ModelCheckpoint : enregistrement des points d'arrêt du modèle à intervalles réguliers.
tf.keras.callbacks.LearningRateScheduler : modifiez dynamiquement l'Ă©tape d'apprentissage.
tf.keras.callbacks.EarlyStopping : arrêt de la formation lorsque le résultat de la validation cesse de s'améliorer.
tf.keras.callbacks.TensorBoard: Surveillance du comportement du modèle à l'aide
Tensorboard
Pour utiliser
tf.keras.callbacks.Callback , passez-le à la méthode d'
fit modèle:
callbacks = [
Sauvegarde et restauration
Enregistrer uniquement les valeurs de poids
Enregistrez et chargez les poids du modèle à l'aide de
tf.keras.Model.save_weights :
model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy'])
Par défaut, les poids du modèle sont enregistrés au format de point de contrôle TensorFlow. Les poids peuvent également être enregistrés au format Keras HDF5 (valeur par défaut pour l'implémentation universelle Keras):
Enregistrement de la configuration du modèle uniquement
La configuration du modèle peut être enregistrée - cela sérialise l'architecture du modèle sans aucun poids. Une configuration enregistrée peut restaurer et initialiser le même modèle, même sans code définissant le modèle d'origine. Keras prend en charge les formats de sérialisation JSON et YAML:
import json import pprint pprint.pprint(json.loads(json_string))
Restauration d'un modèle (réinitialisé) à partir de JSON:
fresh_model = tf.keras.models.model_from_json(json_string)
La sérialisation du modèle en YAML nécessite l'installation de `pyyaml`
avant d'importer TensorFlow :
yaml_string = model.to_yaml() print(yaml_string)
Restauration d'un modèle à partir de YAML:
fresh_model = tf.keras.models.model_from_yaml(yaml_string)
Remarque: les modèles sous-classés ne sont pas sérialisables, car leur architecture est définie par du code Python dans le corps de la méthode `call`.
Enregistrement du modèle entier dans un fichier
Le modèle entier peut être enregistré dans un fichier contenant les valeurs des poids, la configuration du modèle et même la configuration de l'optimiseur. Cela vous permettra de définir un point d'arrêt du modèle et de poursuivre la formation ultérieurement à partir exactement de la même position, même sans accès au code source.
# model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) # HDF5 model.save('my_model.h5') # . model = tf.keras.models.load_model('my_model.h5')
Exécution désireuse
L'exécution désireuse est un environnement de programmation impératif qui effectue des opérations immédiatement. Ceci n'est pas requis pour Keras, mais est pris en charge par
tf.keras et est utile pour vérifier votre programme et déboguer.
Tous les modèles de construction de l'API `tf.keras` sont compatibles avec une exécution rapide. Bien que les API `séquentielles et fonctionnelles puissent être utilisées, une exécution rapide est particulièrement utile lors de la
sous-classification d'un modèle et de la création de
couches personnalisées - ces API nécessitent que vous écriviez une distribution directe sous forme de code (au lieu des API qui créent des modèles en assemblant des couches existantes).
Distribution
Plusieurs GPU
tf.keras modèles
tf.keras peuvent être exécutés sur plusieurs GPU à l'aide de
tf.distribute.Strategy . Cette API fournit un apprentissage distribué sur plusieurs GPU sans pratiquement modifier le code existant.
Actuellement,
tf.distribute.MirroredStrategy seule stratégie de distribution prise en charge.
MirroredStrategy réplique les graphiques avec
apprentissage synchrone à l'aide de la réduction totale sur une seule machine. Pour utiliser `
distribute.Strategy , imbriquez l'installation, la conception et la compilation de l'optimiseur dans le
.scope() Strategy .scope() `, puis entraînez le modèle.
L'exemple suivant distribue
tf.keras.Model entre plusieurs GPU sur la mĂŞme machine.
Tout d'abord, nous définissons un modèle dans le domaine d'une stratégie distribuée:
strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()
Ensuite, nous formons le modèle sur les données comme d'habitude:
x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)
Après vérification, la traduction apparaîtra également sur Tensorflow.org. Si vous souhaitez participer à la traduction de la documentation du site Tensorflow.org en russe, veuillez nous contacter à titre personnel ou commentaires. Toutes corrections ou commentaires sont appréciés.