Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

TensorFlow-Modellanalyse

Ein Beispiel für eine Schlüsselkomponente von TensorFlow Extended (TFX)

Die TensorFlow-Modellanalyse (TFMA) ist eine Bibliothek zur Durchführung der Modellbewertung über verschiedene Datenscheiben hinweg. TFMA führt seine Berechnungen mit Apache Beam verteilt über große Datenmengen durch.

Dieses Beispiel-Colab-Notizbuch zeigt, wie TFMA verwendet werden kann, um die Leistung eines Modells in Bezug auf die Eigenschaften des Datensatzes zu untersuchen und zu visualisieren. Wir werden ein Modell verwenden, das wir zuvor trainiert haben, und jetzt können Sie mit den Ergebnissen spielen! Das Modell, das wir trainiert haben, war für das Chicago Taxi Example , das den von der Stadt Chicago veröffentlichten Taxi Trips-Datensatz verwendet . Durchsuchen Sie den vollständigen Datensatz in der BigQuery-Benutzeroberfläche .

Denken Sie als Modellierer und Entwickler darüber nach, wie diese Daten verwendet werden und welche potenziellen Vorteile und Schäden die Vorhersagen eines Modells verursachen können. Ein solches Modell könnte gesellschaftliche Vorurteile und Disparitäten verstärken. Ist eine Funktion für das Problem relevant, das Sie lösen möchten, oder führt sie zu Verzerrungen? Weitere Informationen finden Sie unter ML-Fairness .

Die Spalten im Datensatz sind:

pickup_community_area Fahrpreis trip_start_month
trip_start_hour trip_start_day trip_start_timestamp
pickup_latitude pickup_longitude dropoff_latitude
dropoff_longitude trip_miles pickup_census_tract
dropoff_census_tract Zahlungsart Unternehmen
trip_seconds dropoff_community_area Tipps

Installieren Sie Jupyter Extensions

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 

Installieren Sie TensorFlow Model Analysis (TFMA).

Dies zieht alle Abhängigkeiten ein und dauert eine Minute.

Hinweis: Um sicherzustellen, dass alle Abhängigkeiten ordnungsgemäß installiert sind, müssen Sie diesen Installationsschritt möglicherweise mehrmals ausführen, bevor keine Fehler auftreten.

# This setup was tested with TF 2.3 and TFMA 0.24 (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.'

print('Installing TensorFlow')
import tensorflow as tf
print('TF version: {}'.format(tf.__version__))

print('Installing Tensorflow Model Analysis and Dependencies')
!pip install -q tensorflow_model_analysis
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))
Installing TensorFlow
TF version: 2.3.1
Installing Tensorflow Model Analysis and Dependencies
ERROR: After October 2020 you may experience errors when installing or updating packages. This is because pip will change the way that it resolves dependency conflicts.

We recommend you use --use-feature=2020-resolver to test your packages with the new resolver before it becomes the default.

google-api-python-client 1.12.3 requires httplib2<1dev,>=0.15.0, but you'll have httplib2 0.9.2 which is incompatible.
Beam version: 2.24.0
TFMA version: 0.24.3

Laden Sie die Dateien

Wir werden eine TAR-Datei herunterladen, die alles enthält, was wir brauchen. Das beinhaltet:

  • Trainings- und Bewertungsdatensätze
  • Datenschema
  • Schulung und Bereitstellung gespeicherter Modelle (Keras und Schätzer) und Bewertung gespeicherter Modelle (Schätzer).
# 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  25.4M      0 --:--:-- --:--:-- --:--:-- 25.3M
Here's what we downloaded:
/tmp/tmpj6t03cp6:
saved_models-2.2

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

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

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

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

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

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

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

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

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

/tmp/tmpj6t03cp6/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/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

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

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

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

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

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

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

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

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

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

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

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

Analysieren Sie das Schema

Wir haben unter anderem ein Schema für unsere Daten heruntergeladen, das von TensorFlow Data Validation erstellt wurde . Lassen Sie uns das jetzt analysieren, damit wir es mit TFMA verwenden können.

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)

Verwenden Sie das Schema, um TFRecords zu erstellen

Wir müssen TFMA Zugriff auf unser Dataset gewähren, also erstellen wir eine TFRecords-Datei. Wir können unser Schema verwenden, um es zu erstellen, da es uns für jedes Feature den richtigen Typ gibt.

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/tmpj6t03cp6/train_data.rio

TFMA einrichten und ausführen

TFMA unterstützt eine Reihe verschiedener Modelltypen, darunter TF-Keras-Modelle, Modelle, die auf generischen TF2-Signatur-APIs basieren, sowie TF-Schätzer-basierte Modelle. Das Handbuch get_started enthält die vollständige Liste der unterstützten Modelltypen und alle Einschränkungen. In diesem Beispiel wird gezeigt, wie ein Keras-basiertes Modell sowie ein Schätzer-basiertes Modell konfiguriert werden, das als EvalSavedModel . In den FAQ finden Sie Beispiele für andere Konfigurationen.

TFMA bietet Unterstützung für die Berechnung von Metriken, die zur Trainingszeit verwendet wurden (dh integrierte Metriken), sowie von Metriken, die nach dem Speichern des Modells als Teil der TFMA-Konfigurationseinstellungen definiert wurden. Für unsere keras Setup werden wir zeigen unsere Kennzahlen und Diagramme manuell als Teil unserer Konfiguration (siehe Hinzufügen von Metriken Leitfaden für Informationen über die Kennzahlen und Diagramme , die unterstützt werden). Für die Einrichtung des Schätzers verwenden wir die integrierten Metriken, die mit dem Modell gespeichert wurden. Unsere Setups enthalten auch eine Reihe von Slicing-Spezifikationen, die in den folgenden Abschnitten ausführlicher erläutert werden.

Nach dem Erstellen von tfma.EvalConfig und tfma.EvalSharedModel wir TFMA mit tfma.run_model_analysis . Dadurch wird ein tfma.EvalResult das wir später zum Rendern unserer Metriken und Diagramme verwenden können.

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)
​​
WARNING:absl:Tensorflow version (2.3.1) 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: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.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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)`

Schätzer

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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/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.6/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/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

INFO:tensorflow:Restoring parameters from /tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/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.6/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.

Visualisierung von Metriken und Plots

Nachdem wir die Evaluierung durchgeführt haben, werfen wir einen Blick auf unsere Visualisierungen mit TFMA. In den folgenden Beispielen werden die Ergebnisse der Auswertung des Keras-Modells visualisiert. Um das auf Schätzern basierende Modell eval_result , aktualisieren Sie das eval_result , dass es auf unsere estimator_eval_result Variable zeigt.

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Metriken rendern

Zum Anzeigen von Metriken verwenden Sie tfma.view.render_slicing_metrics

Standardmäßig wird in den Ansichten das Overall Slice angezeigt. Um ein bestimmtes Slice anzuzeigen, können Sie entweder den Namen der Spalte verwenden (indem Sie slicing_column ) oder eine tfma.SlicingSpec .

Die Metrikvisualisierung unterstützt die folgenden Interaktionen:

  • Klicken und ziehen Sie, um zu schwenken
  • Scrollen Sie zum Zoomen
  • Klicken Sie mit der rechten Maustaste, um die Ansicht zurückzusetzen
  • Bewegen Sie den Mauszeiger über den gewünschten Datenpunkt, um weitere Details anzuzeigen.
  • Wählen Sie aus vier verschiedenen Arten von Ansichten die Auswahl unten aus.

Zum Beispiel setzen wir slicing_column , dass die trip_start_hour Funktion aus unseren vorherigen 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', …

Slices Übersicht

Die Standardvisualisierung ist die Slices-Übersicht, wenn die Anzahl der Slices gering ist. Es zeigt die Werte der Metriken für jedes Slice. Da wir oben trip_start_hour ausgewählt trip_start_hour , werden uns Metriken wie Genauigkeit und AUC für jede Stunde trip_start_hour , trip_start_hour wir nach Problemen suchen können, die für einige Stunden spezifisch sind und nicht für andere.

In der obigen Visualisierung:

  • Versuchen Sie, die Feature-Spalte zu sortieren, bei der es sich um unser trip_start_hours Feature handelt, indem Sie auf die Spaltenüberschrift klicken
  • Versuchen Sie, nach Genauigkeit zu sortieren, und beachten Sie, dass die Genauigkeit für einige Stunden mit Beispielen 0 ist, was auf ein Problem hinweisen kann

Das Diagramm ermöglicht es uns auch, verschiedene Metriken in unseren Slices auszuwählen und anzuzeigen.

  • Versuchen Sie, verschiedene Metriken aus dem Menü "Anzeigen" auszuwählen
  • Versuchen Sie, im Menü " Anzeigen " die Option "Rückruf" auszuwählen, und beachten Sie, dass der Rückruf für einige Stunden mit Beispielen 0 ist, was auf ein Problem hinweisen kann

Es ist auch möglich, einen Schwellenwert festzulegen, um Slices mit einer geringeren Anzahl von Beispielen oder "Gewichten" herauszufiltern. Sie können eine Mindestanzahl von Beispielen eingeben oder den Schieberegler verwenden.

Metrik-Histogramm

Diese Ansicht unterstützt auch ein Metrikhistogramm als alternative Visualisierung. Dies ist auch die Standardansicht, wenn die Anzahl der Slices groß ist. Die Ergebnisse werden in Eimer unterteilt und die Anzahl der Scheiben / Gesamtgewichte / beide können visualisiert werden. Spalten können durch Klicken auf die Spaltenüberschrift sortiert werden. Scheiben mit kleinen Gewichten können durch Einstellen des Schwellenwerts herausgefiltert werden. Weitere Filterung kann durch Ziehen des grauen Bandes angewendet werden. Doppelklicken Sie auf das Band, um den Bereich zurückzusetzen. Durch Filtern können auch Ausreißer in der Visualisierung und in den Metriktabellen entfernt werden. Klicken Sie auf das Zahnradsymbol, um zu einer logarithmischen Skala anstelle einer linearen Skala zu wechseln.

  • Versuchen Sie, im Menü "Visualisierung" die Option "Metrik-Histogramm" auszuwählen

Weitere Scheiben

Unsere anfängliche tfma.EvalConfig hat eine ganze Liste von slicing_specs , die wir durch Aktualisieren der an tfma.view.render_slicing_metrics Slice-Informationen tfma.view.render_slicing_metrics . Hier wählen wir das Slice trip_start_day (Wochentage) aus. Versuchen Sie, trip_start_day in trip_start_day zu trip_start_month und erneut zu rendern, um verschiedene Slices zu untersuchen.

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

TFMA unterstützt auch das Erstellen von Feature-Kreuzen, um Kombinationen von Features zu analysieren. Unsere ursprünglichen Einstellungen haben ein Kreuz trip_start_hour und 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…

Durch das Überqueren der beiden Spalten entstehen viele Kombinationen! Lassen Sie uns unser Kreuz eingrenzen, um nur Ausflüge zu betrachten, die am Mittag beginnen . binary_accuracy in der Visualisierung die binary_accuracy aus:

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…

Diagramme rendern

Alle Diagramme, die der tfma.EvalConfig als tfma.EvalConfig nach dem Training metric_specs können mit tfma.view.render_plot angezeigt werden.

Wie bei Metriken können Diagramme nach Slice angezeigt werden. Im Gegensatz zu Metriken können nur Diagramme für einen bestimmten Slice-Wert angezeigt werden, sodass tfma.SlicingSpec verwendet werden muss und sowohl der Name als auch der Wert eines Slice-Features angegeben werden müssen. Wenn kein Slice bereitgestellt wird, werden die Diagramme für das Overall Slice verwendet.

Im folgenden Beispiel werden die Diagramme CalibrationPlot und ConfusionMatrixPlot trip_start_hour:1 , die für das Slice trip_start_hour:1 berechnet wurden.

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…

Verfolgung der Modellleistung im Zeitverlauf

Ihr Trainingsdatensatz wird zum Trainieren Ihres Modells verwendet und ist hoffentlich repräsentativ für Ihren Testdatensatz und die Daten, die in der Produktion an Ihr Modell gesendet werden. Während die Daten in Inferenzanforderungen dieselben wie Ihre Trainingsdaten bleiben können, werden sie sich in vielen Fällen so stark ändern, dass sich die Leistung Ihres Modells ändert.

Das bedeutet, dass Sie die Leistung Ihres Modells kontinuierlich überwachen und messen müssen, damit Sie Änderungen erkennen und darauf reagieren können. Lassen Sie uns einen Blick darauf werfen, wie TFMA helfen kann.

Laden wir 3 verschiedene Modellläufe und verwenden TFMA, um zu sehen, wie sie mit render_time_series verglichen werden.

# 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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Zuerst stellen wir uns vor, dass wir unser Modell gestern trainiert und bereitgestellt haben, und jetzt wollen wir sehen, wie es mit den neuen Daten funktioniert, die heute eingehen. Die Visualisierung beginnt mit der Anzeige der AUC. Über die Benutzeroberfläche können Sie:

  • Fügen Sie weitere Metriken über das Menü "Metrikreihen hinzufügen" hinzu.
  • Schließen Sie unerwünschte Diagramme, indem Sie auf x klicken
  • Bewegen Sie den Mauszeiger über Datenpunkte (die Enden der Liniensegmente im Diagramm), um weitere Details zu erhalten
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': {'': {'': {'calibration': {'doubleValue': …

Jetzt stellen wir uns vor, dass ein weiterer Tag vergangen ist, und wir möchten sehen, wie sich die heute eingehenden neuen Daten im Vergleich zu den beiden vorherigen Tagen verhalten:

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': {'': {'': {'calibration': {'doubleValue': …

Modell Bestätigung

TFMA kann so konfiguriert werden, dass mehrere Modelle gleichzeitig ausgewertet werden. In der Regel wird dies durchgeführt, um ein neues Modell mit einer Basislinie (z. B. dem aktuell bereitgestellten Modell) zu vergleichen und festzustellen, wie sich die Leistungsunterschiede bei Metriken (z. B. AUC usw.) auf die Basislinie beziehen. Wenn Schwellenwerte konfiguriert sind, erstellt TFMA einen tfma.ValidationResult Datensatz, der angibt, ob die Leistung den Erwartungen entspricht.

Lassen Sie uns unsere Keras-Bewertung neu konfigurieren, um zwei Modelle zu vergleichen: einen Kandidaten und eine Basislinie. Wir werden auch die Leistung des Kandidaten anhand der Basislinie validieren, indem tmfa.MetricThreshold einen tmfa.MetricThreshold für die AUC-Metrik tmfa.MetricThreshold .

# 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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/evaluators/metrics_validator.py:66: RuntimeWarning: invalid value encountered in true_divide
  ratio = diff / metrics[key.make_baseline_key(baseline_model_name)]

Wenn Auswertungen mit einem oder mehreren Modellen anhand einer Basislinie ausgeführt werden, fügt TFMA automatisch Diff-Metriken für alle während der Evaluierung berechneten Metriken hinzu. Diese Metriken werden nach der entsprechenden Metrik benannt, wobei jedoch _diff an den _diff angehängt wird.

Werfen wir einen Blick auf die von unserem Lauf erzeugten Metriken:

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

Schauen wir uns nun die Ergebnisse unserer Validierungsprüfungen an. Um die Validierungsergebnissetfma.load_validator_result wirtfma.load_validator_result . In unserem Beispiel schlägt die Validierung fehl, da die AUC unter dem Schwellenwert liegt.

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