![]() | ![]() | ![]() | ![]() |
Ce guide est destiné aux utilisateurs des API TensorFlow de bas niveau. Si vous utilisez les API de haut niveau ( tf.keras
), il se peut que vous tf.keras
que peu ou pas d'action à entreprendre pour rendre votre code entièrement compatible avec TensorFlow 2.x:
- Vérifiez le taux d'apprentissage par défaut de votre optimiseur .
- Notez que le «nom» auquel les métriques sont consignées peut avoir changé .
Il est toujours possible d'exécuter du code 1.x, non modifié ( sauf pour contrib ), dans TensorFlow 2.x:
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
Cependant, cela ne vous permet pas de profiter de la plupart des améliorations apportées à TensorFlow 2.x. Ce guide vous aidera à mettre à jour votre code, le rendant plus simple, plus performant et plus facile à maintenir.
Script de conversion automatique
La première étape, avant d'essayer d'implémenter les modifications décrites dans ce guide, consiste à essayer d'exécuter le script de mise à niveau .
Cela exécutera une première passe lors de la mise à niveau de votre code vers TensorFlow 2.x mais cela ne peut pas rendre votre code idiomatique à la v2. Votre code peut toujours utiliser les points de terminaison tf.compat.v1
pour accéder aux espaces réservés, aux sessions, aux collections et à d'autres fonctionnalités de style 1.x.
Changements de comportement de haut niveau
Si votre code fonctionne dans TensorFlow 2.x à l'aide de tf.compat.v1.disable_v2_behavior
, vous devrez peut-être corriger des changements de comportement globaux. Les principaux changements sont:
Eager execution,
v1.enable_eager_execution()
: Tout code qui utilise implicitement untf.Graph
échouera. Assurez-vous d'encapsuler ce code dans unwith tf.Graph().as_default()
.Variables de ressources,
v1.enable_resource_variables()
: Certains codes peuvent dépendre de comportements non déterministes activés par les variables de référence TensorFlow. Les variables de ressource sont verrouillées lors de l'écriture et offrent ainsi des garanties de cohérence plus intuitives.- Cela peut changer le comportement dans les cas extrêmes.
- Cela peut créer des copies supplémentaires et peut avoir une utilisation de la mémoire plus élevée.
- Cela peut être désactivé en passant
use_resource=False
au constructeurtf.Variable
.
v1.enable_v2_tensorshape()
tensorielles,v1.enable_v2_tensorshape()
: TensorFlow 2.x simplifie le comportement des formes tensorielles. Au lieu det.shape[0].value
vous pouvez diret.shape[0]
. Ces changements doivent être minimes et il est logique de les corriger immédiatement. Reportez-vous à la section TensorShape pour des exemples.Flux de contrôle,
v1.enable_control_flow_v2()
: l'implémentation du flux de contrôle TensorFlow 2.x a été simplifiée et produit ainsi différentes représentations graphiques. Veuillez signaler les bogues pour tout problème.
Créer du code pour TensorFlow 2.x
Ce guide présente plusieurs exemples de conversion de code TensorFlow 1.x en TensorFlow 2.x. Ces modifications permettront à votre code de tirer parti des optimisations des performances et des appels d'API simplifiés.
Dans chaque cas, le motif est:
1. Remplacez les appels v1.Session.run
Chaque appel v1.Session.run
doit être remplacé par une fonction Python.
- Les
feed_dict
etv1.placeholder
deviennent des arguments de fonction. - Les
fetches
deviennent la valeur de retour de la fonction. - Pendant la conversion, une exécution rapide permet un débogage facile avec des outils Python standard tels que
pdb
.
Après cela, ajoutez un décorateur tf.function
pour le faire fonctionner efficacement dans le graphe. Consultez le guide des autographes pour plus d'informations sur son fonctionnement.
Notez que:
Contrairement à
v1.Session.run
, unetf.function
a une signature de retour fixe et renvoie toujours toutes les sorties. Si cela entraîne des problèmes de performances, créez deux fonctions distinctes.Il n'y a pas besoin de
tf.control_dependencies
ou d'opérations similaires: unetf.function
se comporte comme si elle était exécutée dans l'ordre d'écriture.tf.Variable
affectationstf.Variable
ettf.assert
s, par exemple, sont exécutées automatiquement.
La section des modèles de conversion contient un exemple fonctionnel de ce processus de conversion.
2. Utilisez des objets Python pour suivre les variables et les pertes
Tout suivi de variable basé sur le nom est fortement déconseillé dans TensorFlow 2.x. Utilisez des objets Python pour suivre les variables.
Utilisez tf.Variable
au lieu de v1.get_variable
.
Chaque v1.variable_scope
doit être converti en objet Python. En général, ce sera l'un des:
Si vous avez besoin d'agréger des listes de variables (comme tf.Graph.get_collection(tf.GraphKeys.VARIABLES)
), utilisez les .variables
et .trainable_variables
des objets Layer
et Model
.
Ces classes Layer
et Model
implémentent plusieurs autres propriétés qui suppriment le besoin de collections globales. Leur propriété .losses
peut remplacer l'utilisation de la collection tf.GraphKeys.LOSSES
.
Reportez-vous aux guides Keras pour plus de détails.
3. Améliorez vos boucles d'entraînement
Utilisez l'API de plus haut niveau qui convient à votre cas d'utilisation. Préférez tf.keras.Model.fit
à la création de vos propres boucles d'entraînement.
Ces fonctions de haut niveau gèrent une grande partie des détails de bas niveau qui pourraient être faciles à manquer si vous écrivez votre propre boucle d'entraînement. Par exemple, ils collectent automatiquement les pertes de régularisation et définissent l'argument training=True
lors de l'appel du modèle.
4. Mettez à niveau vos pipelines d'entrée de données
Utilisez les ensembles de données tf.data
pour l'entrée de données. Ces objets sont efficaces, expressifs et s'intègrent bien avec tensorflow.
Ils peuvent être transmis directement à la méthode tf.keras.Model.fit
.
model.fit(dataset, epochs=5)
Ils peuvent être itérés sur Python directement standard:
for example_batch, label_batch in dataset:
break
5. compat.v1
symboles compat.v1
Le module tf.compat.v1
contient l'API TensorFlow 1.x complète, avec sa sémantique d'origine.
Le script de mise à niveau de TensorFlow 2.x convertira les symboles en leurs équivalents v2 si une telle conversion est sûre, c'est-à-dire s'il peut déterminer que le comportement de la version TensorFlow 2.x est exactement équivalent (par exemple, il renomme v1.arg_max
à tf.argmax
, puisque ce sont la même fonction).
Une fois le script de mise à niveau terminé avec un morceau de code, il est probable qu'il y ait de nombreuses mentions de compat.v1
. Cela vaut la peine de parcourir le code et de les convertir manuellement en l'équivalent v2 (cela devrait être mentionné dans le journal s'il y en a un).
Conversion de modèles
Variables de bas niveau et exécution des opérateurs
Exemples d'utilisation d'API de bas niveau:
- Utilisation de portées variables pour contrôler la réutilisation.
- Création de variables avec
v1.get_variable
. - Accéder aux collections explicitement.
Accéder implicitement aux collections avec des méthodes telles que:
Utilisation de
v1.placeholder
pour configurer les entrées graphiques.Exécution de graphiques avec
Session.run
.Initialisation manuelle des variables.
Avant de convertir
Voici à quoi ces modèles peuvent ressembler dans le code utilisant TensorFlow 1.x.
import tensorflow as tf
import tensorflow.compat.v1 as v1
import tensorflow_datasets as tfds
g = v1.Graph()
with g.as_default():
in_a = v1.placeholder(dtype=v1.float32, shape=(2))
in_b = v1.placeholder(dtype=v1.float32, shape=(2))
def forward(x):
with v1.variable_scope("matmul", reuse=v1.AUTO_REUSE):
W = v1.get_variable("W", initializer=v1.ones(shape=(2,2)),
regularizer=lambda x:tf.reduce_mean(x**2))
b = v1.get_variable("b", initializer=v1.zeros(shape=(2)))
return W * x + b
out_a = forward(in_a)
out_b = forward(in_b)
reg_loss=v1.losses.get_regularization_loss(scope="matmul")
with v1.Session(graph=g) as sess:
sess.run(v1.global_variables_initializer())
outs = sess.run([out_a, out_b, reg_loss],
feed_dict={in_a: [1, 0], in_b: [0, 1]})
print(outs[0])
print()
print(outs[1])
print()
print(outs[2])
[[1. 0.] [1. 0.]] [[0. 1.] [0. 1.]] 1.0
Après la conversion
Dans le code converti:
- Les variables sont des objets Python locaux.
- La fonction
forward
définit toujours le calcul. - L'appel
Session.run
est remplacé par un appel àforward
. - Le décorateur optionnel
tf.function
peut être ajouté pour la performance. - Les régularisations sont calculées manuellement, sans faire référence à aucune collection globale.
- Il n'y a pas d'utilisation de sessions ou d'espaces réservés .
W = tf.Variable(tf.ones(shape=(2,2)), name="W")
b = tf.Variable(tf.zeros(shape=(2)), name="b")
@tf.function
def forward(x):
return W * x + b
out_a = forward([1,0])
print(out_a)
tf.Tensor( [[1. 0.] [1. 0.]], shape=(2, 2), dtype=float32)
out_b = forward([0,1])
regularizer = tf.keras.regularizers.l2(0.04)
reg_loss=regularizer(W)
Modèles basés sur tf.layers
Le module v1.layers
est utilisé pour contenir des fonctions de couche qui s'appuyaient sur v1.variable_scope
pour définir et réutiliser des variables.
Avant de convertir
def model(x, training, scope='model'):
with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
x = v1.layers.conv2d(x, 32, 3, activation=v1.nn.relu,
kernel_regularizer=lambda x:0.004*tf.reduce_mean(x**2))
x = v1.layers.max_pooling2d(x, (2, 2), 1)
x = v1.layers.flatten(x)
x = v1.layers.dropout(x, 0.1, training=training)
x = v1.layers.dense(x, 64, activation=v1.nn.relu)
x = v1.layers.batch_normalization(x, training=training)
x = v1.layers.dense(x, 10)
return x
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
train_out = model(train_data, training=True)
test_out = model(test_data, training=False)
print(train_out)
print()
print(test_out)
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/convolutional.py:414: UserWarning: `tf.layers.conv2d` is deprecated and will be removed in a future version. Please Use `tf.keras.layers.Conv2D` instead. warnings.warn('`tf.layers.conv2d` is deprecated and ' /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/base_layer.py:2273: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead. warnings.warn('`layer.apply` is deprecated and ' tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32) tf.Tensor( [[ 0.379358 -0.55901194 0.48704922 0.11619566 0.23902717 0.01691487 0.07227738 0.14556988 0.2459927 0.2501198 ]], shape=(1, 10), dtype=float32) /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/pooling.py:310: UserWarning: `tf.layers.max_pooling2d` is deprecated and will be removed in a future version. Please use `tf.keras.layers.MaxPooling2D` instead. warnings.warn('`tf.layers.max_pooling2d` is deprecated and ' /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:329: UserWarning: `tf.layers.flatten` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Flatten` instead. warnings.warn('`tf.layers.flatten` is deprecated and ' /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:268: UserWarning: `tf.layers.dropout` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dropout` instead. warnings.warn('`tf.layers.dropout` is deprecated and ' /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/core.py:171: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead. warnings.warn('`tf.layers.dense` is deprecated and ' /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/legacy_tf_layers/normalization.py:308: UserWarning: `tf.layers.batch_normalization` is deprecated and will be removed in a future version. Please use `tf.keras.layers.BatchNormalization` instead. In particular, `tf.control_dependencies(tf.GraphKeys.UPDATE_OPS)` should not be used (consult the `tf.keras.layers.BatchNormalization` documentation). '`tf.layers.batch_normalization` is deprecated and '
Après la conversion
- La simple pile de couches s'intègre parfaitement dans
tf.keras.Sequential
. (Pour des modèles plus complexes, consultez les couches et modèles personnalisés et les guides API fonctionnels .) - Le modèle suit les variables et les pertes de régularisation.
- La conversion était un-à-un car il y a un mappage direct de
v1.layers
verstf.keras.layers
.
La plupart des arguments sont restés les mêmes. Mais notez les différences:
- L'argument d'
training
est transmis à chaque couche par le modèle lors de son exécution. - Le premier argument de la fonction de
model
origine (l'entréex
) a disparu. En effet, les calques d'objets séparent la construction du modèle de l'appel du modèle.
Notez également que:
- Si vous utilisez des régulariseurs ou des initialiseurs de
tf.contrib
, ceux-ci ont plus de changements d'arguments que d'autres. - Le code n'écrit plus dans les collections, donc des fonctions comme
v1.losses.get_regularization_loss
nev1.losses.get_regularization_loss
plus ces valeurs, ce qui pourrait interrompre vos boucles d'entraînement.
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, 3, activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.04),
input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dropout(0.1),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Dense(10)
])
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
train_out = model(train_data, training=True)
print(train_out)
tf.Tensor([[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]], shape=(1, 10), dtype=float32)
test_out = model(test_data, training=False)
print(test_out)
tf.Tensor( [[-0.2145557 -0.22979769 -0.14968733 0.01208701 -0.07569927 0.3475932 0.10718458 0.03482988 -0.04309493 -0.10469118]], shape=(1, 10), dtype=float32)
# Here are all the trainable variables
len(model.trainable_variables)
8
# Here is the regularization loss
model.losses
[<tf.Tensor: shape=(), dtype=float32, numpy=0.08174552>]
Variables mixtes & v1.layers
Le code existant mélange souvent des variables et des opérations TensorFlow 1.x de niveau inférieur avec des v1.layers
niveau v1.layers
.
Avant de convertir
def model(x, training, scope='model'):
with v1.variable_scope(scope, reuse=v1.AUTO_REUSE):
W = v1.get_variable(
"W", dtype=v1.float32,
initializer=v1.ones(shape=x.shape),
regularizer=lambda x:0.004*tf.reduce_mean(x**2),
trainable=True)
if training:
x = x + W
else:
x = x + W * 0.5
x = v1.layers.conv2d(x, 32, 3, activation=tf.nn.relu)
x = v1.layers.max_pooling2d(x, (2, 2), 1)
x = v1.layers.flatten(x)
return x
train_out = model(train_data, training=True)
test_out = model(test_data, training=False)
Après la conversion
Pour convertir ce code, suivez le modèle de mappage de couches en couches comme dans l'exemple précédent.
Le schéma général est:
- Collectez les paramètres de couche dans
__init__
. - Construisez les variables dans
build
. - Exécutez les calculs en cours d'
call
et renvoyez le résultat.
La v1.variable_scope
est essentiellement une couche à part entière. tf.keras.layers.Layer
donc en tant que tf.keras.layers.Layer
. Consultez le guide Créer de nouveaux calques et modèles via le guide de sous-classification pour plus de détails.
# Create a custom layer for part of the model
class CustomLayer(tf.keras.layers.Layer):
def __init__(self, *args, **kwargs):
super(CustomLayer, self).__init__(*args, **kwargs)
def build(self, input_shape):
self.w = self.add_weight(
shape=input_shape[1:],
dtype=tf.float32,
initializer=tf.keras.initializers.ones(),
regularizer=tf.keras.regularizers.l2(0.02),
trainable=True)
# Call method will sometimes get used in graph mode,
# training will get turned into a tensor
@tf.function
def call(self, inputs, training=None):
if training:
return inputs + self.w
else:
return inputs + self.w * 0.5
custom_layer = CustomLayer()
print(custom_layer([1]).numpy())
print(custom_layer([1], training=True).numpy())
[1.5] [2.]
train_data = tf.ones(shape=(1, 28, 28, 1))
test_data = tf.ones(shape=(1, 28, 28, 1))
# Build the model including the custom layer
model = tf.keras.Sequential([
CustomLayer(input_shape=(28, 28, 1)),
tf.keras.layers.Conv2D(32, 3, activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
])
train_out = model(train_data, training=True)
test_out = model(test_data, training=False)
Quelques points à noter:
Les modèles et couches Keras sous-classés doivent s'exécuter à la fois dans les graphiques v1 (pas de dépendances de contrôle automatique) et en mode hâte:
- Enveloppez l'
call
dans une fonctiontf.function
pour obtenir l'autographe et les dépendances de contrôle automatique.
- Enveloppez l'
N'oubliez pas d'accepter un argument d'
training
àcall
:- Parfois, c'est un
tf.Tensor
- Parfois, c'est un booléen Python
- Parfois, c'est un
Créez des variables de modèle dans constructor ou
Model.build
utilisant `self.add_weight:- Dans
Model.build
vous avez accès à la forme d'entrée, vous pouvez donc créer des poids avec la forme correspondante - L'utilisation de
tf.keras.layers.Layer.add_weight
permet à Keras de suivre les variables et les pertes de régularisation
- Dans
Ne gardez pas
tf.Tensors
dans vos objets:- Ils peuvent être créés soit dans une
tf.function
soit dans le contexte désireux, et ces tenseurs se comportent différemment - Utilisez
tf.Variable
s pour state, elles sont toujours utilisables dans les deux contextes -
tf.Tensors
Lestf.Tensors
sont uniquement pour les valeurs intermédiaires
- Ils peuvent être créés soit dans une
Une note sur Slim et contrib.layers
Une grande quantité de code TensorFlow 1.x plus ancien utilise la bibliothèque Slim , qui était fournie avec TensorFlow 1.x en tant que tf.contrib.layers
. En tant que module contrib
, il n'est plus disponible dans TensorFlow 2.x, même dans tf.compat.v1
. La conversion de code à l'aide de Slim en TensorFlow 2.x est plus v1.layers
que la conversion de référentiels utilisant des v1.layers
. En fait, il peut être judicieux de convertir d'abord votre code Slim en v1.layers
, puis de le convertir en Keras.
- Supprimez
arg_scopes
, tous lesarg_scopes
doivent être explicites. - Si vous les utilisez, divisez
normalizer_fn
etactivation_fn
dans leurs propres couches. - Les couches de conversion séparables correspondent à une ou plusieurs couches Keras différentes (couches Keras en profondeur, ponctuelles et séparables).
- Les
v1.layers
Slim etv1.layers
ont des noms d'argument et des valeurs par défaut différents. - Certains arguments ont des échelles différentes.
- Si vous utilisez des modèles pré-entraînés Slim, essayez les modèles pré-traimés de
tf.keras.applications
partir detf.keras.applications
ou lestf.keras.applications
TensorFlow 2.x de TF Hub exportés à partir du code Slim d'origine.
Certaines couches de tf.contrib
peut-être pas été déplacées vers le noyau TensorFlow, mais ont plutôt été déplacées vers le package TensorFlow Addons .
Entraînement
Il existe de nombreuses façons d'alimenter des données dans un modèle tf.keras
. Ils accepteront les générateurs Python et les tableaux Numpy en entrée.
La méthode recommandée pour tf.data
données à un modèle consiste à utiliser le package tf.data
, qui contient une collection de classes hautes performances pour manipuler les données.
Si vous utilisez toujours tf.queue
, ceux-ci sont désormais uniquement pris en charge en tant que structures de données et non en tant que pipelines d'entrée.
Utilisation des ensembles de données TensorFlow
Le package TensorFlow Datasets ( tfds
) contient des utilitaires pour charger des ensembles de données prédéfinis en tanttf.data.Dataset
.
Pour cet exemple, vous pouvez charger l'ensemble de données MNIST à l'aide de tfds
:
datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
Downloading and preparing dataset mnist/3.0.1 (download: 11.06 MiB, generated: 21.00 MiB, total: 32.06 MiB) to /home/kbuilder/tensorflow_datasets/mnist/3.0.1... Warning:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your local data directory. If you'd instead prefer to read directly from our public GCS bucket (recommended if you're running on GCP), you can instead pass `try_gcs=True` to `tfds.load` or set `data_dir=gs://tfds-data/datasets`. Dataset mnist downloaded and prepared to /home/kbuilder/tensorflow_datasets/mnist/3.0.1. Subsequent calls will reuse this data.
Préparez ensuite les données pour la formation:
- Redimensionnez chaque image.
- Mélangez l'ordre des exemples.
- Collectez des lots d'images et d'étiquettes.
BUFFER_SIZE = 10 # Use a much larger value for real code
BATCH_SIZE = 64
NUM_EPOCHS = 5
def scale(image, label):
image = tf.cast(image, tf.float32)
image /= 255
return image, label
Pour garder l'exemple court, coupez le jeu de données pour ne renvoyer que 5 lots:
train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
test_data = mnist_test.map(scale).batch(BATCH_SIZE)
STEPS_PER_EPOCH = 5
train_data = train_data.take(STEPS_PER_EPOCH)
test_data = test_data.take(STEPS_PER_EPOCH)
image_batch, label_batch = next(iter(train_data))
Utiliser les boucles d'entraînement Keras
Si vous n'avez pas besoin d'un contrôle de bas niveau de votre processus d'entraînement, il est recommandé d'utiliser les méthodes intégrées d' fit
, d' evaluate
et de predict
Keras. Ces méthodes fournissent une interface uniforme pour entraîner le modèle quelle que soit l'implémentation (séquentielle, fonctionnelle ou sous-classée).
Les avantages de ces méthodes comprennent:
- Ils acceptent les tableaux Numpy, les générateurs Python et,
tf.data.Datasets
. - Ils appliquent automatiquement la régularisation et les pertes d'activation.
- Ils prennent en charge
tf.distribute
pour la formation multi-appareils . - Ils prennent en charge les callables arbitraires en tant que pertes et métriques.
- Ils prennent en charge les rappels tels que
tf.keras.callbacks.TensorBoard
et les rappels personnalisés. - Ils sont performants et utilisent automatiquement les graphiques TensorFlow.
Voici un exemple d'entraînement d'un modèle à l'aide d'un jeu de Dataset
. (Pour plus de détails sur son fonctionnement, consultez la section tutoriels .)
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, 3, activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.02),
input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dropout(0.1),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Dense(10)
])
# Model is the full model w/o custom layers
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
model.fit(train_data, epochs=NUM_EPOCHS)
loss, acc = model.evaluate(test_data)
print("Loss {}, Accuracy {}".format(loss, acc))
Epoch 1/5 5/5 [==============================] - 1s 9ms/step - loss: 2.0191 - accuracy: 0.3608 Epoch 2/5 5/5 [==============================] - 0s 9ms/step - loss: 0.4736 - accuracy: 0.9059 Epoch 3/5 5/5 [==============================] - 0s 8ms/step - loss: 0.2973 - accuracy: 0.9626 Epoch 4/5 5/5 [==============================] - 0s 9ms/step - loss: 0.2108 - accuracy: 0.9911 Epoch 5/5 5/5 [==============================] - 0s 8ms/step - loss: 0.1791 - accuracy: 0.9874 5/5 [==============================] - 0s 6ms/step - loss: 1.5504 - accuracy: 0.7500 Loss 1.5504140853881836, Accuracy 0.75
Écrivez votre propre boucle
Si l'étape d'entraînement du modèle Keras fonctionne pour vous, mais que vous avez besoin de plus de contrôle en dehors de cette étape, envisagez d'utiliser la méthode tf.keras.Model.train_on_batch
, dans votre propre boucle d'itération de données.
Rappelez-vous: De nombreuses choses peuvent être implémentées sous forme de tf.keras.callbacks.Callback
.
Cette méthode présente de nombreux avantages des méthodes mentionnées dans la section précédente, mais donne à l'utilisateur le contrôle de la boucle externe.
Vous pouvez également utiliser tf.keras.Model.test_on_batch
ou tf.keras.Model.evaluate
pour vérifier les performances pendant l'entraînement.
Pour continuer à entraîner le modèle ci-dessus:
# Model is the full model w/o custom layers
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
for epoch in range(NUM_EPOCHS):
# Reset the metric accumulators
model.reset_metrics()
for image_batch, label_batch in train_data:
result = model.train_on_batch(image_batch, label_batch)
metrics_names = model.metrics_names
print("train: ",
"{}: {:.3f}".format(metrics_names[0], result[0]),
"{}: {:.3f}".format(metrics_names[1], result[1]))
for image_batch, label_batch in test_data:
result = model.test_on_batch(image_batch, label_batch,
# Return accumulated metrics
reset_metrics=False)
metrics_names = model.metrics_names
print("\neval: ",
"{}: {:.3f}".format(metrics_names[0], result[0]),
"{}: {:.3f}".format(metrics_names[1], result[1]))
train: loss: 0.138 accuracy: 1.000 train: loss: 0.161 accuracy: 1.000 train: loss: 0.159 accuracy: 0.969 train: loss: 0.241 accuracy: 0.953 train: loss: 0.172 accuracy: 0.969 eval: loss: 1.550 accuracy: 0.800 train: loss: 0.086 accuracy: 1.000 train: loss: 0.094 accuracy: 1.000 train: loss: 0.090 accuracy: 1.000 train: loss: 0.119 accuracy: 0.984 train: loss: 0.099 accuracy: 1.000 eval: loss: 1.558 accuracy: 0.841 train: loss: 0.076 accuracy: 1.000 train: loss: 0.068 accuracy: 1.000 train: loss: 0.061 accuracy: 1.000 train: loss: 0.076 accuracy: 1.000 train: loss: 0.076 accuracy: 1.000 eval: loss: 1.536 accuracy: 0.841 train: loss: 0.059 accuracy: 1.000 train: loss: 0.056 accuracy: 1.000 train: loss: 0.058 accuracy: 1.000 train: loss: 0.054 accuracy: 1.000 train: loss: 0.055 accuracy: 1.000 eval: loss: 1.497 accuracy: 0.863 train: loss: 0.053 accuracy: 1.000 train: loss: 0.049 accuracy: 1.000 train: loss: 0.044 accuracy: 1.000 train: loss: 0.049 accuracy: 1.000 train: loss: 0.045 accuracy: 1.000 eval: loss: 1.463 accuracy: 0.878
Personnalisez l'étape de formation
Si vous avez besoin de plus de flexibilité et de contrôle, vous pouvez l'obtenir en implémentant votre propre boucle d'entraînement. Il y a trois étapes:
- Itérez sur un générateur Python ou
tf.data.Dataset
pour obtenir des lots d'exemples. - Utilisez
tf.GradientTape
pour collecter les dégradés. - Utilisez l'un des
tf.keras.optimizers
pour appliquer des mises à jour de poids aux variables du modèle.
Rappelles toi:
- Incluez toujours un argument d'
training
sur la méthode d'call
des couches et des modèles sous-classés. - Assurez-vous d'appeler le modèle avec l'argument d'
training
correctement défini. - En fonction de l'utilisation, les variables de modèle peuvent ne pas exister tant que le modèle n'est pas exécuté sur un lot de données.
- Vous devez gérer manuellement des éléments tels que les pertes de régularisation pour le modèle.
Notez les simplifications relatives à la v1:
- Il n'est pas nécessaire d'exécuter des initialiseurs de variables. Les variables sont initialisées à la création.
- Il n'est pas nécessaire d'ajouter des dépendances de contrôle manuel. Même dans les opérations
tf.function
agissent comme en mode hâte.
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, 3, activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.02),
input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dropout(0.1),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Dense(10)
])
optimizer = tf.keras.optimizers.Adam(0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
@tf.function
def train_step(inputs, labels):
with tf.GradientTape() as tape:
predictions = model(inputs, training=True)
regularization_loss=tf.math.add_n(model.losses)
pred_loss=loss_fn(labels, predictions)
total_loss=pred_loss + regularization_loss
gradients = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
for epoch in range(NUM_EPOCHS):
for inputs, labels in train_data:
train_step(inputs, labels)
print("Finished epoch", epoch)
Finished epoch 0 Finished epoch 1 Finished epoch 2 Finished epoch 3 Finished epoch 4
Métriques et pertes de style nouveau
Dans TensorFlow 2.x, les métriques et les pertes sont des objets. Ceux-ci fonctionnent à la fois avec empressement et dans tf.function
s.
Un objet de perte est appelable et attend les (y_true, y_pred) comme arguments:
cce = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
cce([[1, 0]], [[-1.0,3.0]]).numpy()
4.01815
Un objet métrique a les méthodes suivantes:
-
Metric.update_state()
: ajoute de nouvelles observations. -
Metric.result()
: récupère le résultat actuel de la métrique, compte tenu des valeurs observées. -
Metric.reset_states()
:Metric.reset_states()
toutes les observations.
L'objet lui-même est appelable. L'appel met à jour l'état avec de nouvelles observations, comme avec update_state
, et renvoie le nouveau résultat de la métrique.
Vous n'avez pas besoin d'initialiser manuellement les variables d'une métrique, et comme TensorFlow 2.x a des dépendances de contrôle automatique, vous n'avez pas non plus à vous en préoccuper.
Le code ci-dessous utilise une métrique pour suivre la perte moyenne observée dans une boucle d'apprentissage personnalisée.
# Create the metrics
loss_metric = tf.keras.metrics.Mean(name='train_loss')
accuracy_metric = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
@tf.function
def train_step(inputs, labels):
with tf.GradientTape() as tape:
predictions = model(inputs, training=True)
regularization_loss=tf.math.add_n(model.losses)
pred_loss=loss_fn(labels, predictions)
total_loss=pred_loss + regularization_loss
gradients = tape.gradient(total_loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Update the metrics
loss_metric.update_state(total_loss)
accuracy_metric.update_state(labels, predictions)
for epoch in range(NUM_EPOCHS):
# Reset the metrics
loss_metric.reset_states()
accuracy_metric.reset_states()
for inputs, labels in train_data:
train_step(inputs, labels)
# Get the metric results
mean_loss=loss_metric.result()
mean_accuracy = accuracy_metric.result()
print('Epoch: ', epoch)
print(' loss: {:.3f}'.format(mean_loss))
print(' accuracy: {:.3f}'.format(mean_accuracy))
Epoch: 0 loss: 0.139 accuracy: 0.997 Epoch: 1 loss: 0.116 accuracy: 1.000 Epoch: 2 loss: 0.105 accuracy: 0.997 Epoch: 3 loss: 0.089 accuracy: 1.000 Epoch: 4 loss: 0.078 accuracy: 1.000
Noms des métriques Keras
Dans TensorFlow 2.x, les modèles Keras sont plus cohérents sur la gestion des noms de métriques.
Maintenant , quand vous passez une chaîne dans la liste des paramètres, cette chaîne exacte est utilisée comme indicateur du name
. Ces noms sont visibles dans l'objet historique renvoyé par model.fit
et dans les journaux passés à keras.callbacks
. est défini sur la chaîne que vous avez transmise dans la liste de métriques.
model.compile(
optimizer = tf.keras.optimizers.Adam(0.001),
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics = ['acc', 'accuracy', tf.keras.metrics.SparseCategoricalAccuracy(name="my_accuracy")])
history = model.fit(train_data)
5/5 [==============================] - 1s 8ms/step - loss: 0.0901 - acc: 0.9923 - accuracy: 0.9923 - my_accuracy: 0.9923
history.history.keys()
dict_keys(['loss', 'acc', 'accuracy', 'my_accuracy'])
Cela diffère des versions précédentes où le passage de metrics=["accuracy"]
entraînerait dict_keys(['loss', 'acc'])
Optimiseurs Keras
Les optimiseurs de v1.train
, tels que v1.train.AdamOptimizer
et v1.train.GradientDescentOptimizer
, ont des équivalents dans tf.keras.optimizers
.
Convertir v1.train
en keras.optimizers
Voici quelques éléments à garder à l'esprit lors de la conversion de vos optimiseurs:
- La mise à niveau de vos optimiseurs peut rendre les anciens points de contrôle incompatibles .
- Tous les epsilons sont désormais définis par défaut sur
1e-7
au lieu de1e-8
(ce qui est négligeable dans la plupart des cas d'utilisation). -
v1.train.GradientDescentOptimizer
peut être directement remplacé partf.keras.optimizers.SGD
. -
v1.train.MomentumOptimizer
peut être directement remplacé par l'optimiseurSGD
à l'aide de l'argument momentum:tf.keras.optimizers.SGD(..., momentum=...)
. -
v1.train.AdamOptimizer
peut être converti pour utilisertf.keras.optimizers.Adam
. Les argumentsbeta1
etbeta2
ont été renommésbeta_1
etbeta_2
. -
v1.train.RMSPropOptimizer
peut être converti entf.keras.optimizers.RMSprop
. L'argumentdecay
a été renommé enrho
. -
v1.train.AdadeltaOptimizer
peut être converti directement entf.keras.optimizers.Adadelta
. -
tf.train.AdagradOptimizer
peut être converti directement entf.keras.optimizers.Adagrad
. -
tf.train.FtrlOptimizer
peut être converti directement entf.keras.optimizers.Ftrl
. Les argumentsaccum_name
etlinear_name
ont été supprimés. -
tf.contrib.AdamaxOptimizer
ettf.contrib.NadamOptimizer
peuvent être convertis directement entf.keras.optimizers.Adamax
ettf.keras.optimizers.Nadam
, respectivement. Lesbeta1
etbeta2
arguments ont été renommésbeta_1
etbeta_2
.
Nouveaux tf.keras.optimizers
par défaut pour certains tf.keras.optimizers
Il n'y a aucun changement pour les optimizers.SGD
, optimizers.Adam
ou optimizers.RMSprop
.
Les taux d'apprentissage par défaut suivants ont changé:
-
optimizers.Adagrad
de 0,01 à 0,001 -
optimizers.Adadelta
de 1.0 à 0.001 -
optimizers.Adamax
de 0,002 à 0,001 -
optimizers.Nadam
de 0,002 à 0,001
TensorBoard
TensorFlow 2.x inclut des modifications importantes de l'API tf.summary
utilisée pour écrire des données récapitulatives pour la visualisation dans TensorBoard. Pour une introduction générale au nouveau tf.summary
, plusieurs didacticiels utilisent l'API TensorFlow 2.x. Cela inclut un guide de migration TensorBoard TensorFlow 2.x.
Sauvegarde et chargement
Compatibilité des points de contrôle
TensorFlow 2.x utilise des points de contrôle basés sur des objets .
Les points de contrôle basés sur les noms à l'ancienne peuvent toujours être chargés, si vous êtes prudent. Le processus de conversion de code peut entraîner des changements de nom de variable, mais il existe des solutions de contournement.
L'approche la plus simple consiste à aligner les noms du nouveau modèle avec les noms du point de contrôle:
- Les variables ont toujours un argument de
name
vous pouvez définir. - Modèles KERAS prennent également un
name
argument qu'ils fixent comme préfixe pour leurs variables. - La fonction
v1.name_scope
peut être utilisée pour définir des préfixes de nom de variable. Ceci est très différent detf.variable_scope
. Il n'affecte que les noms et ne suit pas les variables et ne les réutilise pas.
Si cela ne fonctionne pas pour votre cas d'utilisation, essayez la fonction v1.train.init_from_checkpoint
. Il prend un argument assignment_map
, qui spécifie le mappage des anciens noms aux nouveaux noms.
Le référentiel TensorFlow Estimator comprend un outil de conversion pour mettre à niveau les points de contrôle des estimateurs prédéfinis de TensorFlow 1.x vers 2.0. Il peut servir d'exemple pour créer un outil pour un cas d'utilisation similaire.
Compatibilité des modèles enregistrés
Il n'y a pas de problèmes de compatibilité significatifs pour les modèles enregistrés.
- Les modèles enregistrés TensorFlow 1.x fonctionnent dans TensorFlow 2.x.
- Les modèles enregistrés TensorFlow 2.x fonctionnent dans TensorFlow 1.x si toutes les opérations sont prises en charge.
Un Graph.pb ou Graph.pbtxt
Il n'existe aucun moyen simple de mettre à niveau un fichier Graph.pb
brut vers TensorFlow 2.x. Votre meilleur pari est de mettre à jour le code qui a généré le fichier.
Mais, si vous avez un "graphe figé" (un tf.Graph
où les variables ont été transformées en constantes), alors il est possible de le convertir en une fonction concrete_function
utilisant la fonction v1.wrap_function
:
def wrap_frozen_graph(graph_def, inputs, outputs):
def _imports_graph_def():
tf.compat.v1.import_graph_def(graph_def, name="")
wrapped_import = tf.compat.v1.wrap_function(_imports_graph_def, [])
import_graph = wrapped_import.graph
return wrapped_import.prune(
tf.nest.map_structure(import_graph.as_graph_element, inputs),
tf.nest.map_structure(import_graph.as_graph_element, outputs))
Par exemple, voici un graphique frozed pour Inception v1, à partir de 2016:
path = tf.keras.utils.get_file(
'inception_v1_2016_08_28_frozen.pb',
'http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz',
untar=True)
Downloading data from http://storage.googleapis.com/download.tensorflow.org/models/inception_v1_2016_08_28_frozen.pb.tar.gz 24698880/24695710 [==============================] - 1s 0us/step
Chargez le tf.GraphDef
:
graph_def = tf.compat.v1.GraphDef()
loaded = graph_def.ParseFromString(open(path,'rb').read())
Enveloppez-le dans une fonction concrete_function
:
inception_func = wrap_frozen_graph(
graph_def, inputs='input:0',
outputs='InceptionV1/InceptionV1/Mixed_3b/Branch_1/Conv2d_0a_1x1/Relu:0')
Passez-lui un tenseur comme entrée:
input_img = tf.ones([1,224,224,3], dtype=tf.float32)
inception_func(input_img).shape
TensorShape([1, 28, 28, 96])
Estimateurs
Formation avec les estimateurs
Les estimateurs sont pris en charge dans TensorFlow 2.x.
Lorsque vous utilisez des estimateurs, vous pouvez utiliser input_fn
, tf.estimator.TrainSpec
et tf.estimator.EvalSpec
de TensorFlow 1.x.
Voici un exemple utilisant input_fn
avec train et évaluer les spécifications.
Création des spécifications input_fn et train / eval
# Define the estimator's input_fn
def input_fn():
datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)
mnist_train, mnist_test = datasets['train'], datasets['test']
BUFFER_SIZE = 10000
BATCH_SIZE = 64
def scale(image, label):
image = tf.cast(image, tf.float32)
image /= 255
return image, label[..., tf.newaxis]
train_data = mnist_train.map(scale).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
return train_data.repeat()
# Define train and eval specs
train_spec = tf.estimator.TrainSpec(input_fn=input_fn,
max_steps=STEPS_PER_EPOCH * NUM_EPOCHS)
eval_spec = tf.estimator.EvalSpec(input_fn=input_fn,
steps=STEPS_PER_EPOCH)
Utilisation d'une définition de modèle Keras
Il existe quelques différences dans la manière de construire vos estimateurs dans TensorFlow 2.x.
Il est recommandé de définir votre modèle à l'aide de Keras, puis d'utiliser l'utilitaire tf.keras.estimator.model_to_estimator
pour transformer votre modèle en estimateur. Le code ci-dessous montre comment utiliser cet utilitaire lors de la création et de la formation d'un estimateur.
def make_model():
return tf.keras.Sequential([
tf.keras.layers.Conv2D(32, 3, activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.02),
input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dropout(0.1),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Dense(10)
])
model = make_model()
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
estimator = tf.keras.estimator.model_to_estimator(
keras_model = model
)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config. INFO:tensorflow:Using default config. Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2 Warning:tensorflow:Using temporary folder as model directory: /tmp/tmp0erq3im2 INFO:tensorflow:Using the Keras model provided. INFO:tensorflow:Using the Keras model provided. /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/backend.py:434: UserWarning: `tf.keras.backend.set_learning_phase` is deprecated and will be removed after 2020-10-11. To update it, simply pass a True/False value to the `training` argument of the `__call__` method of your layer or model. warnings.warn('`tf.keras.backend.set_learning_phase` is deprecated and ' INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp0erq3im2', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version. Instructions for updating: Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts. Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/training_util.py:236: Variable.initialized_value (from tensorflow.python.ops.variables) is deprecated and will be removed in a future version. Instructions for updating: Use Variable.read_value. Variables in 2.X are initialized automatically both in eager and graph (inside tf.defun) contexts. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={}) INFO:tensorflow:Warm-starting with WarmStartSettings: WarmStartSettings(ckpt_to_initialize_from='/tmp/tmp0erq3im2/keras/keras_model.ckpt', vars_to_warm_start='.*', var_name_to_vocab_info={}, var_name_to_prev_var_name={}) INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt INFO:tensorflow:Warm-starting from: /tmp/tmp0erq3im2/keras/keras_model.ckpt INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES. INFO:tensorflow:Warm-starting variables only in TRAINABLE_VARIABLES. INFO:tensorflow:Warm-started 8 variables. INFO:tensorflow:Warm-started 8 variables. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt. INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp0erq3im2/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:loss = 2.4717796, step = 0 INFO:tensorflow:loss = 2.4717796, step = 0 INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt. INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmp0erq3im2/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/keras/engine/training.py:2325: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically. warnings.warn('`Model.state_updates` will be removed in a future version. ' INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:17Z INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25 INFO:tensorflow:Restoring parameters from /tmp/tmp0erq3im2/model.ckpt-25 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Inference Time : 0.86556s INFO:tensorflow:Inference Time : 0.86556s INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18 INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:18 INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676 INFO:tensorflow:Saving dict for global step 25: accuracy = 0.6, global_step = 25, loss = 1.6160676 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmp0erq3im2/model.ckpt-25 INFO:tensorflow:Loss for final step: 0.37597787. INFO:tensorflow:Loss for final step: 0.37597787. ({'accuracy': 0.6, 'loss': 1.6160676, 'global_step': 25}, [])
Utilisation d'un model_fn
personnalisé
Si vous avez un estimateur personnalisé model_fn
existant que vous devez gérer, vous pouvez convertir votre model_fn
pour utiliser un modèle Keras.
Cependant, pour des raisons de compatibilité, un model_fn
personnalisé model_fn
toujours en mode graphique de style 1.x. Cela signifie qu'il n'y a aucune exécution hâtive et aucune dépendance de contrôle automatique.
Model_fn personnalisé avec des modifications minimes
Pour que votre model_fn
personnalisé fonctionne dans TensorFlow 2.x, si vous préférez des modifications minimes au code existant, les symboles tf.compat.v1
tels que les optimizers
et les metrics
peuvent être utilisés.
L'utilisation d'un modèle Keras dans un model_fn
personnalisé est similaire à son utilisation dans une boucle d'entraînement personnalisée:
- Définissez la phase d'
training
manière appropriée, en fonction de l'argumentmode
. - Transmettez explicitement les
trainable_variables
du modèle à l'optimiseur.
Mais il existe des différences importantes, par rapport à une boucle personnalisée :
- Au lieu d'utiliser
Model.losses
, extrayez les pertes en utilisantModel.get_losses_for
. - Extrayez les mises à jour du modèle à l'aide de
Model.get_updates_for
.
Le code suivant crée un estimateur à partir d'un model_fn
personnalisé, illustrant toutes ces préoccupations.
def my_model_fn(features, labels, mode):
model = make_model()
optimizer = tf.compat.v1.train.AdamOptimizer()
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
training = (mode == tf.estimator.ModeKeys.TRAIN)
predictions = model(features, training=training)
if mode == tf.estimator.ModeKeys.PREDICT:
return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
total_loss=loss_fn(labels, predictions) + tf.math.add_n(reg_losses)
accuracy = tf.compat.v1.metrics.accuracy(labels=labels,
predictions=tf.math.argmax(predictions, axis=1),
name='acc_op')
update_ops = model.get_updates_for(None) + model.get_updates_for(features)
minimize_op = optimizer.minimize(
total_loss,
var_list=model.trainable_variables,
global_step=tf.compat.v1.train.get_or_create_global_step())
train_op = tf.group(minimize_op, update_ops)
return tf.estimator.EstimatorSpec(
mode=mode,
predictions=predictions,
loss=total_loss,
train_op=train_op, eval_metric_ops={'accuracy': accuracy})
# Create the Estimator & Train
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config. INFO:tensorflow:Using default config. Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpifj8mysl INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpifj8mysl', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt. INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpifj8mysl/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:loss = 3.0136237, step = 0 INFO:tensorflow:loss = 3.0136237, step = 0 INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt. INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpifj8mysl/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:20Z INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25 INFO:tensorflow:Restoring parameters from /tmp/tmpifj8mysl/model.ckpt-25 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Inference Time : 0.97406s INFO:tensorflow:Inference Time : 0.97406s INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21 INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:21 INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872 INFO:tensorflow:Saving dict for global step 25: accuracy = 0.59375, global_step = 25, loss = 1.6248872 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpifj8mysl/model.ckpt-25 INFO:tensorflow:Loss for final step: 0.35726172. INFO:tensorflow:Loss for final step: 0.35726172. ({'accuracy': 0.59375, 'loss': 1.6248872, 'global_step': 25}, [])
model_fn
personnalisé avec les symboles TensorFlow 2.x
Si vous souhaitez vous débarrasser de tous les symboles TensorFlow 1.x et mettre à niveau votre model_fn
personnalisé vers TensorFlow 2.x, vous devez mettre à jour l'optimiseur et les métriques vers tf.keras.optimizers
et tf.keras.metrics
.
Dans le model_fn
personnalisé, en plus des modifications ci-dessus, d'autres mises à niveau doivent être effectuées:
- Utilisez
tf.keras.optimizers
au lieu dev1.train.Optimizer
. -
tf.keras.optimizers
lestf.keras.optimizers
trainable_variables
du modèle autf.keras.optimizers
. - Pour calculer le
train_op/minimize_op
,- Utilisez
Optimizer.get_updates
si la perte estTensor
perte scalaire (non appelable). Le premier élément de la liste renvoyée est letrain_op/minimize_op
souhaité. - Si la perte est un appelable (comme une fonction), utilisez
Optimizer.minimize
pour obtenir letrain_op/minimize_op
.
- Utilisez
- Utilisez
tf.keras.metrics
au lieu detf.compat.v1.metrics
pour l'évaluation.
Pour l'exemple ci-dessus de my_model_fn
, le code migré avec les symboles TensorFlow 2.x est affiché comme my_model_fn
:
def my_model_fn(features, labels, mode):
model = make_model()
training = (mode == tf.estimator.ModeKeys.TRAIN)
loss_obj = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
predictions = model(features, training=training)
# Get both the unconditional losses (the None part)
# and the input-conditional losses (the features part).
reg_losses = model.get_losses_for(None) + model.get_losses_for(features)
total_loss=loss_obj(labels, predictions) + tf.math.add_n(reg_losses)
# Upgrade to tf.keras.metrics.
accuracy_obj = tf.keras.metrics.Accuracy(name='acc_obj')
accuracy = accuracy_obj.update_state(
y_true=labels, y_pred=tf.math.argmax(predictions, axis=1))
train_op = None
if training:
# Upgrade to tf.keras.optimizers.
optimizer = tf.keras.optimizers.Adam()
# Manually assign tf.compat.v1.global_step variable to optimizer.iterations
# to make tf.compat.v1.train.global_step increased correctly.
# This assignment is a must for any `tf.train.SessionRunHook` specified in
# estimator, as SessionRunHooks rely on global step.
optimizer.iterations = tf.compat.v1.train.get_or_create_global_step()
# Get both the unconditional updates (the None part)
# and the input-conditional updates (the features part).
update_ops = model.get_updates_for(None) + model.get_updates_for(features)
# Compute the minimize_op.
minimize_op = optimizer.get_updates(
total_loss,
model.trainable_variables)[0]
train_op = tf.group(minimize_op, *update_ops)
return tf.estimator.EstimatorSpec(
mode=mode,
predictions=predictions,
loss=total_loss,
train_op=train_op,
eval_metric_ops={'Accuracy': accuracy_obj})
# Create the Estimator and train.
estimator = tf.estimator.Estimator(model_fn=my_model_fn)
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
INFO:tensorflow:Using default config. INFO:tensorflow:Using default config. Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6 Warning:tensorflow:Using temporary folder as model directory: /tmp/tmpc93qfnv6 INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpc93qfnv6', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true graph_options { rewrite_options { meta_optimizer_iterations: ONE } } , '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_checkpoint_save_graph_def': True, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1} INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Not using Distribute Coordinator. INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Running training and evaluation locally (non-distributed). INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. INFO:tensorflow:Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 600. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0... INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt. INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpc93qfnv6/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0... INFO:tensorflow:loss = 2.5293791, step = 0 INFO:tensorflow:loss = 2.5293791, step = 0 INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 25... INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt. INFO:tensorflow:Saving checkpoints for 25 into /tmp/tmpc93qfnv6/model.ckpt. INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 25... INFO:tensorflow:Calling model_fn. INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z INFO:tensorflow:Starting evaluation at 2021-01-06T02:31:24Z INFO:tensorflow:Graph was finalized. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25 INFO:tensorflow:Restoring parameters from /tmp/tmpc93qfnv6/model.ckpt-25 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [1/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [2/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [3/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [4/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Evaluation [5/5] INFO:tensorflow:Inference Time : 0.86534s INFO:tensorflow:Inference Time : 0.86534s INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25 INFO:tensorflow:Finished evaluation at 2021-01-06-02:31:25 INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661 INFO:tensorflow:Saving dict for global step 25: Accuracy = 0.59375, global_step = 25, loss = 1.7570661 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25 INFO:tensorflow:Saving 'checkpoint_path' summary for global step 25: /tmp/tmpc93qfnv6/model.ckpt-25 INFO:tensorflow:Loss for final step: 0.47094986. INFO:tensorflow:Loss for final step: 0.47094986. ({'Accuracy': 0.59375, 'loss': 1.7570661, 'global_step': 25}, [])
Estimateurs préfabriqués
Les estimateurs prédéfinis de la famille tf.estimator.DNN*
, tf.estimator.Linear*
et tf.estimator.DNNLinearCombined*
sont toujours pris en charge dans l'API TensorFlow 2.x. Cependant, certains arguments ont changé:
-
input_layer_partitioner
: supprimé dans la v2. -
loss_reduction
: mis à jour verstf.keras.losses.Reduction
au lieu detf.compat.v1.losses.Reduction
. Sa valeur par défaut est également modifiée entf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE
partir detf.compat.v1.losses.Reduction.SUM
. -
optimizer
,dnn_optimizer
etlinear_optimizer
: cet argument a été mis à jour verstf.keras.optimizers
au lieu detf.compat.v1.train.Optimizer
.
Pour migrer les modifications ci-dessus:
- Aucune migration n'est nécessaire pour
input_layer_partitioner
car laDistribution Strategy
le gérera automatiquement dans TensorFlow 2.x. - Pour
loss_reduction
, vérifieztf.keras.losses.Reduction
pour les options prises en charge. - Pour les arguments de l'
optimizer
:- Si vous ne: 1) passez pas dans l'
optimizer
, l'argumentdnn_optimizer
oulinear_optimizer
, ou 2) spécifiez l'argument de l'optimizer
sous forme destring
dans votre code, alors vous n'avez rien à changer cartf.keras.optimizers
est utilisé par défaut . - Sinon, vous devez le mettre à jour depuis
tf.compat.v1.train.Optimizer
vers sestf.keras.optimizers
correspondants.
- Si vous ne: 1) passez pas dans l'
Convertisseur de point de contrôle
La migration vers keras.optimizers
interrompra les points de contrôle enregistrés à l'aide de TensorFlow 1.x, car tf.keras.optimizers
génère un ensemble différent de variables à enregistrer dans les points de contrôle. Pour rendre l'ancien point de contrôle réutilisable après votre migration vers TensorFlow 2.x, essayez l' outil de conversion de point de contrôle .
curl -O https://raw.githubusercontent.com/tensorflow/estimator/master/tensorflow_estimator/python/estimator/tools/checkpoint_converter.py
% Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 100 15165 100 15165 0 0 40656 0 --:--:-- --:--:-- --:--:-- 40656
L'outil a une aide intégrée:
python checkpoint_converter.py -h
2021-01-06 02:31:26.297951: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0 usage: checkpoint_converter.py [-h] {dnn,linear,combined} source_checkpoint source_graph target_checkpoint positional arguments: {dnn,linear,combined} The type of estimator to be converted. So far, the checkpoint converter only supports Canned Estimator. So the allowed types include linear, dnn and combined. source_checkpoint Path to source checkpoint file to be read in. source_graph Path to source graph file to be read in. target_checkpoint Path to checkpoint file to be written out. optional arguments: -h, --help show this help message and exit
TensorShape
Cette classe a été simplifiée pour contenir des int
s, au lieu des objets tf.compat.v1.Dimension
. Il n'est donc pas nécessaire d'appeler .value
pour obtenir un int
.
Les objets tf.compat.v1.Dimension
individuels sont toujours accessibles à partir de tf.TensorShape.dims
.
Les éléments suivants illustrent les différences entre TensorFlow 1.x et TensorFlow 2.x.
# Create a shape and choose an index
i = 0
shape = tf.TensorShape([16, None, 256])
shape
TensorShape([16, None, 256])
Si vous aviez cela dans TensorFlow 1.x:
value = shape[i].value
Ensuite, faites ceci dans TensorFlow 2.x:
value = shape[i]
value
16
Si vous aviez cela dans TensorFlow 1.x:
for dim in shape:
value = dim.value
print(value)
Ensuite, faites ceci dans TensorFlow 2.x:
for value in shape:
print(value)
16 None 256
Si vous aviez cela dans TensorFlow 1.x (ou avez utilisé toute autre méthode de dimension):
dim = shape[i]
dim.assert_is_compatible_with(other_dim)
Ensuite, faites ceci dans TensorFlow 2.x:
other_dim = 16
Dimension = tf.compat.v1.Dimension
if shape.rank is None:
dim = Dimension(None)
else:
dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
True
shape = tf.TensorShape(None)
if shape:
dim = shape.dims[i]
dim.is_compatible_with(other_dim) # or any other dimension method
La valeur booléenne d'un tf.TensorShape
est True
si le rang est connu, False
sinon.
print(bool(tf.TensorShape([]))) # Scalar
print(bool(tf.TensorShape([0]))) # 0-length vector
print(bool(tf.TensorShape([1]))) # 1-length vector
print(bool(tf.TensorShape([None]))) # Unknown-length vector
print(bool(tf.TensorShape([1, 10, 100]))) # 3D tensor
print(bool(tf.TensorShape([None, None, None]))) # 3D tensor with no known dimensions
print()
print(bool(tf.TensorShape(None))) # A tensor with unknown rank.
True True True True True True False
Autres changements
Supprimer
tf.colocate_with
: les algorithmes de placement des appareils de TensorFlow se sont considérablement améliorés. Cela ne devrait plus être nécessaire. Si sa suppression entraîne une dégradation des performances, veuillez signaler un bogue .Remplacez l'utilisation de
v1.ConfigProto
par les fonctions équivalentes detf.config
.
Conclusions
Le processus global est:
- Exécutez le script de mise à niveau.
- Supprimez les symboles contrib.
- Basculez vos modèles vers un style orienté objet (Keras).
- Utilisez les
tf.keras
formation et d'évaluationtf.keras
outf.estimator
là où vous le pouvez. - Sinon, utilisez des boucles personnalisées, mais veillez à éviter les sessions et les collections.
Il faut un peu de travail pour convertir le code en TensorFlow 2.x idiomatique, mais chaque changement entraîne:
- Moins de lignes de code.
- Clarté et simplicité accrues.
- Débogage plus facile.