Analyse du modèle TensorFlow

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

Exemple de composant clé de TensorFlow Extended (TFX)

Tensorflow modèle d' analyse (TFMA) est une bibliothèque pour effectuer l' évaluation des modèles dans les différentes tranches de données. TFMA effectue ses calculs de manière répartie sur de grandes quantités de données en utilisant Apache faisceau .

Cet exemple de cahier Colab illustre comment TFMA peut être utilisé pour étudier et visualiser les performances d'un modèle par rapport aux caractéristiques de l'ensemble de données. Nous allons utiliser un modèle que nous avons formé précédemment, et maintenant vous pouvez jouer avec les résultats ! Le modèle que nous avons formé était pour le Chicago Taxi exemple , qui utilise le taxi Trips ensemble de données publié par la ville de Chicago. Explorez l'ensemble des données dans l' interface utilisateur BigQuery .

En tant que modélisateur et développeur, réfléchissez à la manière dont ces données sont utilisées et aux avantages et inconvénients potentiels que les prédictions d'un modèle peuvent entraîner. Un modèle comme celui-ci pourrait renforcer les préjugés et les disparités sociétaux. Une caractéristique est-elle pertinente pour le problème que vous souhaitez résoudre ou introduira-t-elle un biais ? Pour plus d' informations, lisez l' équité ML .

Les colonnes de l'ensemble de données sont :

zone_de_collecte_de_communauté tarif voyage_début_mois
trip_start_hour trip_start_day trip_start_timestamp
ramassage_latitude ramassage_longitude dropoff_latitude
dropoff_longitude voyage_miles pick_census_tract
dropoff_census_tract type de paiement entreprise
trip_secondes dropoff_community_area des astuces

Installer les extensions Jupyter

jupyter nbextension enable --py widgetsnbextension --sys-prefix 
jupyter nbextension install --py --symlink tensorflow_model_analysis --sys-prefix 
jupyter nbextension enable --py tensorflow_model_analysis --sys-prefix 

Installer l'analyse de modèle TensorFlow (TFMA)

Cela va extraire toutes les dépendances et prendra une minute.

# Upgrade pip to the latest, and install TFMA.
pip install -U pip
pip install tensorflow-model-analysis

Vous devez maintenant redémarrer le runtime avant d'exécuter les cellules ci-dessous.

# This setup was tested with TF 2.5 and TFMA 0.31 (using colab), but it should
# also work with the latest release.
import sys

# Confirm that we're using Python 3
assert sys.version_info.major==3, 'This notebook must be run using Python 3.'

import tensorflow as tf
print('TF version: {}'.format(tf.__version__))
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))
TF version: 2.4.4
Beam version: 2.34.0
TFMA version: 0.29.0

Charger les fichiers

Nous allons télécharger un fichier tar qui contient tout ce dont nous avons besoin. Qui comprend:

  • Ensembles de données de formation et d'évaluation
  • Schéma de données
  • Entraîner et servir les modèles sauvegardés (keras et estimateur) et évaluer les modèles sauvegardés (estimateur).
# Download the tar file from GCP and extract it
import io, os, tempfile
TAR_NAME = 'saved_models-2.2'
BASE_DIR = tempfile.mkdtemp()
DATA_DIR = os.path.join(BASE_DIR, TAR_NAME, 'data')
MODELS_DIR = os.path.join(BASE_DIR, TAR_NAME, 'models')
SCHEMA = os.path.join(BASE_DIR, TAR_NAME, 'schema.pbtxt')
OUTPUT_DIR = os.path.join(BASE_DIR, 'output')

!curl -O https://storage.googleapis.com/artifacts.tfx-oss-public.appspot.com/datasets/{TAR_NAME}.tar
!tar xf {TAR_NAME}.tar
!mv {TAR_NAME} {BASE_DIR}
!rm {TAR_NAME}.tar

print("Here's what we downloaded:")
!ls -R {BASE_DIR}
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 6800k  100 6800k    0     0  28.2M      0 --:--:-- --:--:-- --:--:-- 28.2M
Here's what we downloaded:
/tmp/tmp_at9q62d:
saved_models-2.2

/tmp/tmp_at9q62d/saved_models-2.2:
data  models  schema.pbtxt

/tmp/tmp_at9q62d/saved_models-2.2/data:
eval  train

/tmp/tmp_at9q62d/saved_models-2.2/data/eval:
data.csv

/tmp/tmp_at9q62d/saved_models-2.2/data/train:
data.csv

/tmp/tmp_at9q62d/saved_models-2.2/models:
estimator  keras

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator:
eval_model_dir  serving_model_dir

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir:
1591221811

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811:
saved_model.pb  tmp.pbtxt  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir:
checkpoint
eval_chicago-taxi-eval
events.out.tfevents.1591221780.my-pipeline-b57vp-237544850
export
graph.pbtxt
model.ckpt-100.data-00000-of-00001
model.ckpt-100.index
model.ckpt-100.meta

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export:
chicago-taxi

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi:
1591221801

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras:
0  1  2

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/0:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/0/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/1:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/1/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/2:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/2/variables:
variables.data-00000-of-00001  variables.index

Analyser le schéma

Parmi les choses que nous avons téléchargé était un schéma pour nos données qui ont été créées par tensorflow Validation des données . Analysons cela maintenant afin que nous puissions l'utiliser avec TFMA.

import tensorflow as tf
from google.protobuf import text_format
from tensorflow.python.lib.io import file_io
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow.core.example import example_pb2

schema = schema_pb2.Schema()
contents = file_io.read_file_to_string(SCHEMA)
schema = text_format.Parse(contents, schema)

Utiliser le schéma pour créer des TFRecords

Nous devons donner à TFMA l'accès à notre ensemble de données, créons donc un fichier TFRecords. Nous pouvons utiliser notre schéma pour le créer, car il nous donne le type correct pour chaque fonctionnalité.

import csv

datafile = os.path.join(DATA_DIR, 'eval', 'data.csv')
reader = csv.DictReader(open(datafile, 'r'))
examples = []
for line in reader:
  example = example_pb2.Example()
  for feature in schema.feature:
    key = feature.name
    if feature.type == schema_pb2.FLOAT:
      example.features.feature[key].float_list.value[:] = (
          [float(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.INT:
      example.features.feature[key].int64_list.value[:] = (
          [int(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.BYTES:
      example.features.feature[key].bytes_list.value[:] = (
          [line[key].encode('utf8')] if len(line[key]) > 0 else [])
  # Add a new column 'big_tipper' that indicates if tips was > 20% of the fare. 
  # TODO(b/157064428): Remove after label transformation is supported for Keras.
  big_tipper = float(line['tips']) > float(line['fare']) * 0.2
  example.features.feature['big_tipper'].float_list.value[:] = [big_tipper]
  examples.append(example)

tfrecord_file = os.path.join(BASE_DIR, 'train_data.rio')
with tf.io.TFRecordWriter(tfrecord_file) as writer:
  for example in examples:
    writer.write(example.SerializeToString())

!ls {tfrecord_file}
/tmp/tmp_at9q62d/train_data.rio

Configurer et exécuter TFMA

TFMA prend en charge un certain nombre de types de modèles différents, notamment les modèles TF Keras, les modèles basés sur les API de signature TF2 génériques, ainsi que les modèles basés sur l'estimateur TF. Le get_started guide présente la liste complète des types de modèles pris en charge et les restrictions. Pour cet exemple , nous allons montrer comment configurer un modèle basé keras ainsi qu'un modèle basé sur l' estimateur qui a été enregistré en tant que EvalSavedModel . Voir la FAQ des exemples d'autres configurations.

TFMA prend en charge le calcul des métriques utilisées au moment de l'entraînement (c'est-à-dire les métriques intégrées) ainsi que les métriques définies après l'enregistrement du modèle dans le cadre des paramètres de configuration de TFMA. Pour notre keras configuration , nous démontrerons nos ajouter des mesures et des parcelles manuellement dans le cadre de notre configuration (voir paramètres Guide des informations sur les mesures et les parcelles qui sont pris en charge). Pour la configuration de l'estimateur, nous utiliserons les métriques intégrées qui ont été enregistrées avec le modèle. Nos configurations incluent également un certain nombre de spécifications de tranchage qui sont discutées plus en détail dans les sections suivantes.

Après avoir créé un tfma.EvalConfig et tfma.EvalSharedModel nous pouvons exécuter TFMA en utilisant tfma.run_model_analysis . Cela va créer un tfma.EvalResult que nous pouvons utiliser plus tard pour rendre nos mesures et des parcelles.

Keras

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
keras_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # For keras (and serving models) we need to add a `label_key`.
    label_key: "big_tipper"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our keras model.
keras_model_path = os.path.join(MODELS_DIR, 'keras', '2')
keras_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=keras_model_path,
    eval_config=keras_eval_config)

keras_output_path = os.path.join(OUTPUT_DIR, 'keras')

# Run TFMA
keras_eval_result = tfma.run_model_analysis(
    eval_shared_model=keras_eval_shared_model,
    eval_config=keras_eval_config,
    data_location=tfrecord_file,
    output_path=keras_output_path)
2021-12-04 10:18:15.463173: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] Could not load dynamic library 'libcusolver.so.10'; dlerror: libcusolver.so.10: cannot open shared object file: No such file or directory
2021-12-04 10:18:15.464249: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1757] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

estimateur

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
estimator_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # To use EvalSavedModel set `signature_name` to "eval".
    signature_name: "eval"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our eval saved model.
estimator_base_model_path = os.path.join(
    MODELS_DIR, 'estimator', 'eval_model_dir')
estimator_model_path = os.path.join(
    estimator_base_model_path, os.listdir(estimator_base_model_path)[0])
estimator_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=estimator_model_path,
    eval_config=estimator_eval_config)

estimator_output_path = os.path.join(OUTPUT_DIR, 'estimator')

# Run TFMA
estimator_eval_result = tfma.run_model_analysis(
    eval_shared_model=estimator_eval_shared_model,
    eval_config=estimator_eval_config,
    data_location=tfrecord_file,
    output_path=estimator_output_path)
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.
INFO:tensorflow:Restoring parameters from /tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
INFO:tensorflow:Restoring parameters from /tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.

Visualisation des métriques et des tracés

Maintenant que nous avons exécuté l'évaluation, examinons nos visualisations à l'aide de TFMA. Pour les exemples suivants, nous allons visualiser les résultats de l'exécution de l'évaluation sur le modèle keras. Pour voir le modèle basé sur l' estimateur mise à jour du eval_result au point notre estimator_eval_result variable.

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Métriques de rendu

Pour des mesures de vue que vous utilisez tfma.view.render_slicing_metrics

Par défaut , les vues affichent l' Overall tranche. Pour voir une tranche particulière , vous pouvez utiliser le nom de la colonne (par le réglage slicing_column ) ou fournir un tfma.SlicingSpec .

La visualisation des métriques prend en charge les interactions suivantes :

  • Cliquez et faites glisser pour effectuer un panoramique
  • Faites défiler pour zoomer
  • Faites un clic droit pour réinitialiser la vue
  • Survolez le point de données souhaité pour voir plus de détails.
  • Choisissez parmi quatre types de vues différents à l'aide des sélections en bas.

Par exemple, nous établirons slicing_column regarder la trip_start_hour fonction de nos précédentes slicing_specs .

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_hour')
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_hour:2', …

Aperçu des tranches

La visualisation par défaut est le Slices Vue d' ensemble lorsque le nombre de tranches est faible. Il affiche les valeurs des métriques pour chaque tranche. Étant donné que nous avons sélectionné trip_start_hour ci - dessus, il nous montre des paramètres tels que la précision et l' ASC pour chaque heure, ce qui nous permet de rechercher des problèmes spécifiques à certaines heures et pas d' autres.

Dans la visualisation ci-dessus :

  • Essayez trier la colonne de fonction, qui est notre trip_start_hours fonction, en cliquant sur l' en- tête de colonne
  • Essayez le tri par la précision, et notez que la précision de quelques - unes des heures avec des exemples est 0, ce qui peut indiquer un problème

Le graphique nous permet également de sélectionner et d'afficher différentes métriques dans nos tranches.

  • Essayez de sélectionner différentes métriques dans le menu "Afficher"
  • Essayez de sélectionner le rappel dans le menu « Afficher », et notez que le rappel pour quelques - unes des heures avec des exemples est 0, ce qui peut indiquer un problème

Il est également possible de définir un seuil pour filtrer les tranches avec un plus petit nombre d'exemples, ou "poids". Vous pouvez saisir un nombre minimum d'exemples ou utiliser le curseur.

Histogramme des métriques

Ce point de vue prend également en charge un Histogramme Metrics comme une visualisation alternative, qui est également l'affichage par défaut lorsque le nombre de tranches est grande. Les résultats seront divisés en seaux et le nombre de tranches / poids total / les deux peuvent être visualisés. Les colonnes peuvent être triées en cliquant sur l'en-tête de colonne. Les tranches avec de petits poids peuvent être filtrées en définissant le seuil. Un filtrage supplémentaire peut être appliqué en faisant glisser la bande grise. Pour réinitialiser la plage, double-cliquez sur la bande. Le filtrage peut également être utilisé pour supprimer les valeurs aberrantes dans la visualisation et les tableaux de métriques. Cliquez sur l'icône d'engrenage pour passer à une échelle logarithmique au lieu d'une échelle linéaire.

  • Essayez de sélectionner "Metrics Histogram" dans le menu Visualisation

Plus de tranches

Notre première tfma.EvalConfig a créé une liste de slicing_specs , que nous pouvons visualiser par des informations de tranche de mise à jour est passé à tfma.view.render_slicing_metrics . Ici , nous allons sélectionner la trip_start_day tranche (jours de la semaine). Essayez de changer le trip_start_day à trip_start_month et de rendre à nouveau pour examiner les différentes tranches.

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_day')
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day:3', '…

TFMA prend également en charge la création de croisements de caractéristiques pour analyser des combinaisons de caractéristiques. Nos paramètres d' origine ont créé une croix trip_start_hour et trip_start_day :

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_hour', 'trip_start_day']))
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Le croisement des deux colonnes crée beaucoup de combinaisons ! Allons rétrécissent vers le bas notre croix suffit de regarder les voyages qui commencent à midi. Ensuite Sélectionnons binary_accuracy de la visualisation:

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_day'], feature_values={'trip_start_hour': '12'}))
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Tracés de rendu

Toutes les parcelles qui ont été ajoutés à la tfma.EvalConfig que la formation post metric_specs peuvent être affichées en utilisant tfma.view.render_plot .

Comme pour les métriques, les tracés peuvent être visualisés par tranche. Contrairement à des mesures, seules parcelles pour une valeur de tranche particulière peuvent être affichés de sorte que le tfma.SlicingSpec doit être utilisé et il doit spécifier un nom et une valeur caractéristique de tranche. Si aucune tranche est fourni, les parcelles pour l' Overall tranche est utilisé.

Dans l'exemple ci - dessous , nous affichons les CalibrationPlot et ConfusionMatrixPlot parcelles qui ont été calculées pour la trip_start_hour:1 tranche.

tfma.view.render_plot(
    eval_result,
    tfma.SlicingSpec(feature_values={'trip_start_hour': '1'}))
PlotViewer(config={'sliceName': 'trip_start_hour:1', 'metricKeys': {'calibrationPlot': {'metricName': 'calibra…

Suivi des performances du modèle au fil du temps

Votre ensemble de données d'entraînement sera utilisé pour entraîner votre modèle et, espérons-le, sera représentatif de votre ensemble de données de test et des données qui seront envoyées à votre modèle en production. Cependant, bien que les données des demandes d'inférence puissent rester les mêmes que vos données d'entraînement, dans de nombreux cas, elles commenceront à changer suffisamment pour que les performances de votre modèle changent.

Cela signifie que vous devez surveiller et mesurer les performances de votre modèle de manière continue, afin que vous puissiez être au courant des changements et y réagir. Voyons comment TFMA peut vous aider.

Let charge 3 pistes de modèle et que l' utilisation TFMA pour voir comment ils se comparent à l' aide render_time_series .

# Note this re-uses the EvalConfig from the keras setup.

# Run eval on each saved model
output_paths = []
for i in range(3):
  # Create a tfma.EvalSharedModel that points at our saved model.
  eval_shared_model = tfma.default_eval_shared_model(
      eval_saved_model_path=os.path.join(MODELS_DIR, 'keras', str(i)),
      eval_config=keras_eval_config)

  output_path = os.path.join(OUTPUT_DIR, 'time_series', str(i))
  output_paths.append(output_path)

  # Run TFMA
  tfma.run_model_analysis(eval_shared_model=eval_shared_model,
                          eval_config=keras_eval_config,
                          data_location=tfrecord_file,
                          output_path=output_path)
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Tout d'abord, nous allons imaginer que nous avons formé et déployé notre modèle hier, et maintenant nous voulons voir comment il se comporte avec les nouvelles données qui arrivent aujourd'hui. La visualisation commencera par afficher l'AUC. Depuis l'interface utilisateur, vous pouvez :

  • Ajoutez d'autres métriques à l'aide du menu "Ajouter des séries de métriques".
  • Fermez les graphiques indésirables en cliquant sur x
  • Survolez les points de données (les extrémités des segments de ligne dans le graphique) pour obtenir plus de détails
eval_results_from_disk = tfma.load_eval_results(output_paths[:2])

tfma.view.render_time_series(eval_results_from_disk)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Maintenant, nous allons imaginer qu'un autre jour s'est écoulé et nous voulons voir comment cela se passe avec les nouvelles données qui arrivent aujourd'hui, par rapport aux deux jours précédents :

eval_results_from_disk = tfma.load_eval_results(output_paths)

tfma.view.render_time_series(eval_results_from_disk)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Validation du modèle

TFMA peut être configuré pour évaluer plusieurs modèles en même temps. En général, cela est fait pour comparer un nouveau modèle à une référence (comme le modèle actuellement en service) afin de déterminer quelles sont les différences de performances dans les métriques (par exemple, AUC, etc.) par rapport à la référence. Lorsque les seuils sont configurés, TFMA produira un tfma.ValidationResult enregistrement indiquant si la performance correspond expecations.

Reconfigurons notre évaluation Keras pour comparer deux modèles : un candidat et une référence. Nous allons également valider la performance du candidat contre la ligne de base en définissant une tmfa.MetricThreshold sur la mesure de l' ASC.

# Setup tfma.EvalConfig setting
eval_config_with_thresholds = text_format.Parse("""
  ## Model information
  model_specs {
    name: "candidate"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
  }
  model_specs {
    name: "baseline"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
    is_baseline: true
  }

  ## Post training metric information
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics {
      class_name: "AUC"
      threshold {
        # Ensure that AUC is always > 0.9
        value_threshold {
          lower_bound { value: 0.9 }
        }
        # Ensure that AUC does not drop by more than a small epsilon
        # e.g. (candidate - baseline) > -1e-10 or candidate > baseline - 1e-10
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_keys: ["trip_start_month"]
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create tfma.EvalSharedModels that point at our keras models.
candidate_model_path = os.path.join(MODELS_DIR, 'keras', '2')
baseline_model_path = os.path.join(MODELS_DIR, 'keras', '1')
eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path=candidate_model_path,
      eval_config=eval_config_with_thresholds),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path=baseline_model_path,
      eval_config=eval_config_with_thresholds),
]

validation_output_path = os.path.join(OUTPUT_DIR, 'validation')

# Run TFMA
eval_result_with_validation = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config_with_thresholds,
    data_location=tfrecord_file,
    output_path=validation_output_path)
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Lors de l'exécution d'évaluations avec un ou plusieurs modèles par rapport à une ligne de base, TFMA ajoute automatiquement des métriques de différence pour toutes les métriques calculées pendant l'évaluation. Ces paramètres sont nommés d' après la métrique mais correspondant _diff ajouté au nom métrique.

Jetons un œil aux métriques produites par notre run :

tfma.view.render_time_series(eval_result_with_validation)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Regardons maintenant le résultat de nos contrôles de validation. Pour voir les résultats de la validation que nous utilisons tfma.load_validator_result . Pour notre exemple, la validation échoue car l'AUC est inférieure au seuil.

validation_result = tfma.load_validation_result(validation_output_path)
print(validation_result.validation_ok)
False