Cette page a été traduite par l'API Cloud Translation.

Switch to English

Migrez votre code TensorFlow 1 vers TensorFlow 2

Voir sur TensorFlow.org

Exécuter dans Google Colab

Afficher la source sur GitHub

Télécharger le cahier

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 nombreuses 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 résoudre des changements de comportement globaux. Les principaux changements sont:

Eager execution, v1.enable_eager_execution() : Tout code qui utilise implicitement un tf.Graph échouera. Assurez-vous d'encapsuler ce code dans un with 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 ressources 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 constructeur tf.Variable .
v1.enable_v2_tensorshape() tensorielles, v1.enable_v2_tensorshape() : TensorFlow 2.x simplifie le comportement des formes tensorielles. Au lieu de t.shape[0].value vous pouvez dire t.shape[0] . Ces changements doivent être minimes et il est logique de les corriger immédiatement. Reportez-vous à la section TensorShape pour obtenir 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 et v1.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.

Noter que:

Contrairement à v1.Session.run , une tf.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: une tf.function se comporte comme si elle était exécutée dans l'ordre d'écriture. tf.Variable affectations tf.Variable et tf.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 règle générale, 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 fonctionne pour 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 un grand nombre de 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:
- v1.global_variables
- v1.losses.get_regularization_loss
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ée x ) a disparu. En effet, les couches 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 ne v1.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)

# Here is the regularization loss
model.losses

[<tf.Tensor: shape=(), dtype=float32, numpy=0.08174552>]

Variables mixtes et `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 fonction tf.function pour obtenir des dépendances d'autographe et de contrôle automatique.
N'oubliez pas d'accepter un argument d' training à call :
- Parfois, c'est un tf.Tensor
- Parfois, c'est un booléen Python
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
Ne gardez pas tf.Tensors dans vos objets:
- Ils peuvent être créés soit dans une fonction tf.function soit dans le contexte impatient, et ces tenseurs se comportent différemment
- Utilisez tf.Variable s pour state, elles sont toujours utilisables dans les deux contextes
- tf.Tensors ne sont que pour les valeurs intermédiaires

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 les arg_scopes doivent être explicites.
Si vous les utilisez, divisez normalizer_fn et activation_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 et v1.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é-formés de Keras à partir de tf.keras.applications ou les tf.keras.applications TensorFlow 2.x de TF Hub exportés à partir du code Slim d'origine.

Certaines couches 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 .

Formation

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.

Ensuite, préparez 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, dé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 la façon dont cela fonctionne, consultez la section des didacticiels .)

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 outf.data.Dataset pour obtenir des lots d'exemples.
Utiliseztf.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 de 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.
Selon 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 tf.function opérations agissent comme en mode impatient.

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 le (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 dans 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 de 1e-8 (ce qui est négligeable dans la plupart des cas d'utilisation).
v1.train.GradientDescentOptimizer peut être directement remplacé par tf.keras.optimizers.SGD .
v1.train.MomentumOptimizer peut être directement remplacé par l'optimiseur SGD utilisant l'argument momentum: tf.keras.optimizers.SGD(..., momentum=...) .
v1.train.AdamOptimizer peut être converti pour utiliser tf.keras.optimizers.Adam . Les arguments beta1 et beta2 ont été renommés beta_1 et beta_2 .
v1.train.RMSPropOptimizer peut être converti en tf.keras.optimizers.RMSprop . L'argument decay a été renommé en rho .
v1.train.AdadeltaOptimizer peut être converti directement en tf.keras.optimizers.Adadelta .
tf.train.AdagradOptimizer peut être converti directement en tf.keras.optimizers.Adagrad .
tf.train.FtrlOptimizer peut être converti directement en tf.keras.optimizers.Ftrl . Les arguments accum_name et linear_name ont été supprimés.
tf.contrib.AdamaxOptimizer et tf.contrib.NadamOptimizer peuvent être convertis directement en tf.keras.optimizers.Adamax et tf.keras.optimizers.Nadam , respectivement. Les beta1 et beta2 arguments ont été renommés beta_1 et beta_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 faites attention. 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. C'est très différent de tf.variable_scope . Cela 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'y a pas de 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'argument mode .
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 utilisant Model.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 apportées:

Utilisez tf.keras.optimizers au lieu de v1.train.Optimizer .
tf.keras.optimizers les tf.keras.optimizers trainable_variables du modèle au tf.keras.optimizers .
Pour calculer le train_op/minimize_op ,
- Utilisez Optimizer.get_updates si la perte est un Tensor perte scalaire (non appelable) .Use Optimizer.get_updates if the loss is scalar loss Tensor (not a callable). Le premier élément de la liste renvoyée est le train_op/minimize_op souhaité.
- Si la perte est un appelable (comme une fonction), utilisez Optimizer.minimize pour obtenir le train_op/minimize_op .
Utilisez tf.keras.metrics au lieu de tf.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 vers tf.keras.losses.Reduction au lieu de tf.compat.v1.losses.Reduction . Sa valeur par défaut est également modifiée en tf.keras.losses.Reduction.SUM_OVER_BATCH_SIZE partir de tf.compat.v1.losses.Reduction.SUM .
optimizer , dnn_optimizer et linear_optimizer : cet argument a été mis à jour vers tf.keras.optimizers au lieu de tf.compat.v1.train.Optimizer .

Pour migrer les modifications ci-dessus:

Aucune migration n'est nécessaire pour input_layer_partitioner car la Distribution Strategy le gérera automatiquement dans TensorFlow 2.x.
Pour loss_reduction , vérifiez tf.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'argument dnn_optimizer ou linear_optimizer , ou 2) spécifiez l'argument de l' optimizer sous forme de string dans votre code, vous n'avez rien à changer car tf.keras.optimizers est utilisé par défaut .
- Sinon, vous devez le mettre à jour de tf.compat.v1.train.Optimizer vers ses tf.keras.optimizers correspondants.

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 cela dans TensorFlow 2.x:

value = shape[i]
value

Si vous aviez cela dans TensorFlow 1.x:

for dim in shape:
    value = dim.value
    print(value)

Ensuite, faites cela 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, procédez comme suit 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 cas contraire.

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 de tf.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'évaluation tf.keras ou tf.estimator lorsque 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.

Migrez votre code TensorFlow 1 vers TensorFlow 2

Script de conversion automatique

Changements de comportement de haut niveau

Créer du code pour TensorFlow 2.x

1. Remplacez les appels v1.Session.run

2. Utilisez des objets Python pour suivre les variables et les pertes

3. Améliorez vos boucles d'entraînement

4. Mettez à niveau vos pipelines d'entrée de données

5. compat.v1 symboles compat.v1

Conversion de modèles

Variables de bas niveau et exécution des opérateurs

Avant de convertir

Après la conversion

Modèles basés sur tf.layers

Avant de convertir

Après la conversion

Variables mixtes et v1.layers

Avant de convertir

Après la conversion

Une note sur Slim et contrib.layers

Formation

Utilisation des ensembles de données TensorFlow

Utiliser les boucles d'entraînement Keras

Écrivez votre propre boucle

Personnalisez l'étape de formation

Métriques et pertes de style nouveau

Noms des métriques Keras

Optimiseurs Keras

Convertir v1.train en keras.optimizers

Nouveaux tf.keras.optimizers par défaut pour certains tf.keras.optimizers

TensorBoard

Sauvegarde et chargement

Compatibilité des points de contrôle

Compatibilité des modèles enregistrés

Un Graph.pb ou Graph.pbtxt

Estimateurs

Formation avec les estimateurs

Création des spécifications input_fn et train / eval

Utilisation d'une définition de modèle Keras

Utilisation d'un model_fn personnalisé

Model_fn personnalisé avec des modifications minimes

model_fn personnalisé avec les symboles TensorFlow 2.x

Estimateurs préfabriqués

Convertisseur de point de contrôle

TensorShape

Autres changements

Conclusions

1. Remplacez les appels `v1.Session.run`

5. `compat.v1` symboles `compat.v1`

Modèles basés sur `tf.layers`

Variables mixtes et `v1.layers`

Convertir `v1.train` en `keras.optimizers`

Nouveaux `tf.keras.optimizers` par défaut pour certains `tf.keras.optimizers`

Utilisation d'un `model_fn` personnalisé

`model_fn` personnalisé avec les symboles TensorFlow 2.x