Premiers pas avec l'analyse de modèle TensorFlow

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Aperçu

TensorFlow Model Analysis (TFMA) est une bibliothèque permettant d'effectuer une évaluation de modèle.

  • Pour : Ingénieurs en Machine Learning ou Data Scientists
  • qui : veulent analyser et comprendre leurs modèles TensorFlow
  • c'est : une bibliothèque autonome ou un composant d'un pipeline TFX
  • qui : évalue des modèles sur de grandes quantités de données de manière distribuée sur les mêmes métriques définies en apprentissage. Ces métriques sont comparées sur des tranches de données et visualisées dans des notebooks Jupyter ou Colab.
  • contrairement à : certains outils d'introspection de modèle comme le tensorboard qui offrent l'introspection de modèle

TFMA effectue ses calculs de manière distribuée sur de grandes quantités de données à l'aide d' Apache Beam . Les sections suivantes décrivent comment configurer un pipeline d'évaluation TFMA de base. Voir l'architecture plus de détails sur l'implémentation sous-jacente.

Si vous voulez juste vous lancer et commencer, consultez notre cahier Colab .

Cette page peut également être consultée depuis tensorflow.org .

Types de modèles pris en charge

TFMA est conçu pour prendre en charge les modèles basés sur tensorflow, mais peut également être facilement étendu pour prendre en charge d'autres frameworks. Historiquement, TFMA nécessitait la création d'un EvalSavedModel pour utiliser TFMA, mais la dernière version de TFMA prend en charge plusieurs types de modèles en fonction des besoins de l'utilisateur. La configuration d'un EvalSavedModel ne devrait être requise que si un modèle basé sur tf.estimator est utilisé et que des métriques de temps de formation personnalisées sont requises.

Notez que, comme TFMA s'exécute désormais sur la base du modèle de diffusion, TFMA n'évaluera plus automatiquement les métriques ajoutées au moment de la formation. L'exception à ce cas est si un modèle keras est utilisé puisque keras enregistre les métriques utilisées avec le modèle enregistré. Cependant, s'il s'agit d'une exigence stricte, le dernier TFMA est rétrocompatible, de sorte qu'un EvalSavedModel peut toujours être exécuté dans un pipeline TFMA.

Le tableau suivant récapitule les modèles pris en charge par défaut :

Type de modèle Mesures du temps de formation Mesures post-formation
TF2 (kéras) O* Oui
TF2 (générique) N / A Oui
EvalSavedModel (estimateur) Oui Oui
Aucun (pd.DataFrame, etc.) N / A Oui
  • Les métriques de temps de formation font référence aux métriques définies au moment de la formation et enregistrées avec le modèle (soit TFMA EvalSavedModel, soit le modèle enregistré keras). Les métriques post-formation font référence aux métriques ajoutées via tfma.MetricConfig .
  • Les modèles TF2 génériques sont des modèles personnalisés qui exportent des signatures pouvant être utilisées pour l'inférence et ne sont basés ni sur des keras ni sur un estimateur.

Voir FAQ pour plus d'informations sur la façon d'installer et de configurer ces différents types de modèles.

Installer

Avant d'exécuter une évaluation, une petite quantité de configuration est nécessaire. Tout d'abord, un objet tfma.EvalConfig doit être défini qui fournit des spécifications pour le modèle, les métriques et les tranches à évaluer. Deuxièmement, un tfma.EvalSharedModel doit être créé qui pointe vers le ou les modèles réels à utiliser lors de l'évaluation. Une fois ceux-ci définis, l'évaluation est effectuée en appelant tfma.run_model_analysis avec un jeu de données approprié. Pour plus de détails, consultez le guide de configuration .

En cas d'exécution dans un pipeline TFX, consultez le guide TFX pour savoir comment configurer TFMA pour qu'il s'exécute en tant que composant TFX Evaluator .

Exemples

Évaluation d'un modèle unique

Ce qui suit utilise tfma.run_model_analysis pour effectuer une évaluation sur un modèle de service. Pour une explication des différents réglages nécessaires, consultez le guide de configuration .

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

eval_result = tfma.run_model_analysis(
    eval_shared_model=eval_shared_model,
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location='/path/to/file/containing/tfrecords',
    output_path='/path/for/output')

tfma.view.render_slicing_metrics(eval_result)

Pour une évaluation distribuée, construisez un pipeline Apache Beam à l'aide d'un exécuteur distribué. Dans le pipeline, utilisez tfma.ExtractEvaluateAndWriteResults pour l'évaluation et pour écrire les résultats. Les résultats peuvent être chargés pour être visualisés à l'aide tfma.load_eval_result .

Par exemple:

# To run the pipeline.
from google.protobuf import text_format
from tfx_bsl.tfxio import tf_example_record

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

output_path = '/path/for/output'

tfx_io = tf_example_record.TFExampleRecord(
    file_pattern=data_location, raw_record_column_name=tfma.ARROW_INPUT_COLUMN)

with beam.Pipeline(runner=...) as p:
  _ = (p
       # You can change the source as appropriate, e.g. read from BigQuery.
       # This assumes your data is a TFRecords file containing records in the
       # tf.train.Example format. If using EvalSavedModel then use the following
       # instead: 'ReadData' >> beam.io.ReadFromTFRecord(file_pattern=...)
       | 'ReadData' >> tfx_io.BeamSource()
       | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
            eval_shared_model=eval_shared_model,
            eval_config=eval_config,
            output_path=output_path))

# To load and visualize results.
# Note that this code should be run in a Jupyter Notebook.
result = tfma.load_eval_result(output_path)
tfma.view.render_slicing_metrics(result)

Validation du modèle

Pour effectuer la validation du modèle par rapport à un candidat et à une ligne de base, mettez à jour la configuration pour inclure un paramètre de seuil et transmettez deux modèles à tfma.run_model_analysis .

Par exemple:

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics {
      class_name: "AUC"
      threshold {
        value_threshold {
          lower_bound { value: 0.9 }
        }
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path='/path/to/saved/candiate/model',
      eval_config=eval_config),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path='/path/to/saved/baseline/model',
      eval_config=eval_config),
]

output_path = '/path/for/output'

eval_result = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location='/path/to/file/containing/tfrecords',
    output_path=output_path)

tfma.view.render_slicing_metrics(eval_result)
tfma.load_validation_result(output_path)

Visualisation

Les résultats de l'évaluation TFMA peuvent être visualisés dans un bloc-notes Jupyter à l'aide des composants frontaux inclus dans TFMA. Par exemple:

Navigateur de métriques de découpage TFMA .

Plus d'information