Estimateurs

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Ce document présente tf.estimator , une API TensorFlow de haut niveau. Les estimateurs encapsulent les actions suivantes :

  • Entraînement
  • Évaluation
  • Prédiction
  • Exporter pour servir

TensorFlow implémente plusieurs estimateurs prédéfinis. Les estimateurs personnalisés sont toujours pris en charge, mais principalement en tant que mesure de rétrocompatibilité. Les estimateurs personnalisés ne doivent pas être utilisés pour le nouveau code . Tous les estimateurs, prédéfinis ou personnalisés, sont des classes basées sur la classe tf.estimator.Estimator .

Pour un exemple rapide, essayez les didacticiels Estimator . Pour un aperçu de la conception de l'API, consultez le livre blanc .

Installer

pip install -U tensorflow_datasets

import tempfile
import os

import tensorflow as tf
import tensorflow_datasets as tfds

Avantages

Semblable à un tf.keras.Model , un estimator est une abstraction au niveau du modèle. Le tf.estimator fournit certaines fonctionnalités actuellement encore en développement pour tf.keras . Ceux-ci sont:

  • Formation basée sur le serveur de paramètres
  • Intégration complète de TFX

Capacités des estimateurs

Les estimateurs offrent les avantages suivants :

  • Vous pouvez exécuter des modèles basés sur Estimator sur un hôte local ou sur un environnement multiserveur distribué sans modifier votre modèle. De plus, vous pouvez exécuter des modèles basés sur Estimator sur des CPU, des GPU ou des TPU sans recoder votre modèle.
  • Les estimateurs fournissent une boucle de formation distribuée sécurisée qui contrôle comment et quand :
    • Charger les données
    • Gérer les exceptions
    • Créer des fichiers de point de contrôle et récupérer des échecs
    • Enregistrer les résumés pour TensorBoard

Lors de l'écriture d'une application avec des estimateurs, vous devez séparer le pipeline d'entrée de données du modèle. Cette séparation simplifie les expériences avec différents ensembles de données.

Utilisation d'estimateurs prédéfinis

Les estimateurs prédéfinis vous permettent de travailler à un niveau conceptuel beaucoup plus élevé que les API TensorFlow de base. Vous n'avez plus à vous soucier de la création du graphique ou des sessions de calcul puisque les estimateurs gèrent toute la "plomberie" pour vous. De plus, les estimateurs prédéfinis vous permettent d'expérimenter différentes architectures de modèles en n'apportant que des modifications minimes au code. tf.estimator.DNNClassifier , par exemple, est une classe Estimator prédéfinie qui forme des modèles de classification basés sur des réseaux de neurones denses et à anticipation.

Un programme TensorFlow s'appuyant sur un estimateur prédéfini comprend généralement les quatre étapes suivantes :

1. Ecrire une fonction d'entrée

Par exemple, vous pouvez créer une fonction pour importer l'ensemble d'apprentissage et une autre fonction pour importer l'ensemble de test. Les estimateurs s'attendent à ce que leurs entrées soient formatées comme une paire d'objets :

  • Un dictionnaire dans lequel les clés sont des noms de caractéristiques et les valeurs sont des Tensors (ou SparseTensors) contenant les données de caractéristiques correspondantes
  • Un Tensor contenant un ou plusieurs libellés

L' input_fn doit renvoyer un tf.data.Dataset qui produit des paires dans ce format.

Par exemple, le code suivant crée un tf.data.Dataset à partir du fichier train.csv du jeu de données Titanic :

def train_input_fn():
  titanic_file = tf.keras.utils.get_file("train.csv", "https://storage.googleapis.com/tf-datasets/titanic/train.csv")
  titanic = tf.data.experimental.make_csv_dataset(
      titanic_file, batch_size=32,
      label_name="survived")
  titanic_batches = (
      titanic.cache().repeat().shuffle(500)
      .prefetch(tf.data.AUTOTUNE))
  return titanic_batches

Le input_fn est exécuté dans un tf.Graph et peut également renvoyer directement une paire (features_dics, labels) contenant des tenseurs de graphe, mais cela est sujet aux erreurs en dehors des cas simples comme le retour de constantes.

2. Définissez les colonnes de fonction.

Chaque tf.feature_column identifie un nom de fonctionnalité, son type et tout prétraitement d'entrée.

Par exemple, l'extrait de code suivant crée trois colonnes de caractéristiques.

  • La première utilise la fonction d' age directement comme entrée à virgule flottante.
  • La seconde utilise la fonction de class comme entrée catégorique.
  • La troisième utilise l' embark_town comme entrée catégorique, mais utilise l' hashing trick pour éviter d'avoir à énumérer les options et à définir le nombre d'options.

Pour plus d'informations, consultez le didacticiel sur les colonnes de fonctions .

age = tf.feature_column.numeric_column('age')
cls = tf.feature_column.categorical_column_with_vocabulary_list('class', ['First', 'Second', 'Third']) 
embark = tf.feature_column.categorical_column_with_hash_bucket('embark_town', 32)

3. Instanciez l'estimateur prédéfini pertinent.

Par exemple, voici un exemple d'instanciation d'un estimateur préfabriqué nommé LinearClassifier :

model_dir = tempfile.mkdtemp()
model = tf.estimator.LinearClassifier(
    model_dir=model_dir,
    feature_columns=[embark, cls, age],
    n_classes=2
)

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpl24pp3cp', '_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}

Pour plus d'informations, vous pouvez consulter le didacticiel sur le classificateur linéaire .

4. Appelez une méthode de formation, d'évaluation ou d'inférence.

Tous les estimateurs fournissent des méthodes d' train , d' evaluate et de predict .

model = model.train(input_fn=train_input_fn, steps=100)

WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/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.
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/engine/base_layer_v1.py:1684: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.
  warnings.warn('`layer.add_variable` is deprecated and '
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/optimizer_v2/ftrl.py:147: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.
Instructions for updating:
Call initializer instance with the dtype argument instead of passing it to the constructor
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmpl24pp3cp/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 0.6931472, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 100...
INFO:tensorflow:Saving checkpoints for 100 into /tmp/tmpl24pp3cp/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 100...
INFO:tensorflow:Loss for final step: 0.6319582.
2021-09-22 20:49:10.453286: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

result = model.evaluate(train_input_fn, steps=10)

for key, value in result.items():
  print(key, ":", value)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2021-09-22T20:49:11
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpl24pp3cp/model.ckpt-100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/10]
INFO:tensorflow:Evaluation [2/10]
INFO:tensorflow:Evaluation [3/10]
INFO:tensorflow:Evaluation [4/10]
INFO:tensorflow:Evaluation [5/10]
INFO:tensorflow:Evaluation [6/10]
INFO:tensorflow:Evaluation [7/10]
INFO:tensorflow:Evaluation [8/10]
INFO:tensorflow:Evaluation [9/10]
INFO:tensorflow:Evaluation [10/10]
INFO:tensorflow:Inference Time : 0.74609s
INFO:tensorflow:Finished evaluation at 2021-09-22-20:49:12
INFO:tensorflow:Saving dict for global step 100: accuracy = 0.734375, accuracy_baseline = 0.640625, auc = 0.7373913, auc_precision_recall = 0.64306235, average_loss = 0.563341, global_step = 100, label/mean = 0.359375, loss = 0.563341, precision = 0.734375, prediction/mean = 0.3463129, recall = 0.40869564
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 100: /tmp/tmpl24pp3cp/model.ckpt-100
accuracy : 0.734375
accuracy_baseline : 0.640625
auc : 0.7373913
auc_precision_recall : 0.64306235
average_loss : 0.563341
label/mean : 0.359375
loss : 0.563341
precision : 0.734375
prediction/mean : 0.3463129
recall : 0.40869564
global_step : 100
2021-09-22 20:49:12.168629: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

for pred in model.predict(train_input_fn):
  for key, value in pred.items():
    print(key, ":", value)
  break

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpl24pp3cp/model.ckpt-100
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
logits : [-1.5173098]
logistic : [0.17985801]
probabilities : [0.820142   0.17985801]
class_ids : [0]
classes : [b'0']
all_class_ids : [0 1]
all_classes : [b'0' b'1']
2021-09-22 20:49:13.076528: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.

Avantages des estimateurs préfabriqués