Treten Sie der SIG TFX-Addons-Community bei und helfen Sie, TFX noch besser zu machen!
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Erste Schritte mit der TensorFlow-Modellanalyse

Überblick

TensorFlow Model Analysis (TFMA) ist eine Bibliothek zur Durchführung der Modellbewertung.

  • Für : Ingenieure für maschinelles Lernen oder Datenwissenschaftler
  • wer : möchte ihre TensorFlow-Modelle analysieren und verstehen
  • Es ist : eine eigenständige Bibliothek oder Komponente einer TFX-Pipeline
  • das : bewertet Modelle für große Datenmengen auf verteilte Weise anhand derselben im Training definierten Metriken. Diese Metriken werden über Datenscheiben verglichen und in Jupyter- oder Colab-Notizbüchern visualisiert.
  • Im Gegensatz zu : einigen Tools zur Modellinspektion wie Tensorboard, die Modellintrospektion anbieten

TFMA führt seine Berechnungen mit Apache Beam verteilt über große Datenmengen durch. In den folgenden Abschnitten wird beschrieben, wie Sie eine grundlegende TFMA-Evaluierungspipeline einrichten. Weitere Informationen zur zugrunde liegenden Implementierung finden Sie in der Architektur .

Wenn Sie einfach nur loslegen und loslegen möchten, lesen Sie unser Colab- Notizbuch.

Diese Seite kann auch von tensorflow.org aus angesehen werden .

Unterstützte Modelltypen

TFMA unterstützt Tensorflow-basierte Modelle, kann jedoch problemlos erweitert werden, um auch andere Frameworks zu unterstützen. In der Vergangenheit musste für TFMA ein EvalSavedModel erstellt werden, um TFMA verwenden zu können. Die neueste Version von TFMA unterstützt jedoch je nach den Anforderungen des Benutzers mehrere Modelltypen. Das Einrichten eines EvalSavedModel sollte nur erforderlich sein, wenn ein tf.estimator basiertes Modell verwendet wird und benutzerdefinierte Trainingszeitmetriken erforderlich sind.

Beachten Sie, dass TFMA die zur Trainingszeit hinzugefügten Metriken nicht mehr automatisch auswertet, da TFMA jetzt basierend auf dem Serving-Modell ausgeführt wird. Die Ausnahme in diesem Fall besteht darin, dass ein Keras-Modell verwendet wird, da Keras die neben dem gespeicherten Modell verwendeten Metriken speichert. Wenn dies jedoch eine schwierige Anforderung ist, ist das neueste TFMA abwärtskompatibel, sodass ein EvalSavedModel weiterhin in einer TFMA-Pipeline ausgeführt werden kann.

In der folgenden Tabelle sind die standardmäßig unterstützten Modelle zusammengefasst:

Modelltyp Trainingszeitmetriken Metriken nach dem Training
TF2 (Keras) Y * Y.
TF2 (generisch) N / A Y.
EvalSavedModel (Schätzer) Y. Y.
Keine (pd.DataFrame usw.) N / A Y.
  • Trainingszeitmetriken beziehen sich auf Metriken, die zur Trainingszeit definiert und mit dem Modell gespeichert wurden (entweder TFMA EvalSavedModel oder Keras gespeichertes Modell). Metriken nach dem Training beziehen sich auf Metriken, die über tfma.MetricConfig hinzugefügt tfma.MetricConfig .
  • Generische TF2-Modelle sind benutzerdefinierte Modelle, die Signaturen exportieren, die zur Inferenz verwendet werden können und weder auf Keras noch auf Schätzer basieren.

Siehe FAQ für weitere Informationen nicht , wie zum Einrichten und Konfigurieren dieser unterschiedlichen Modelltypen.

Konfiguration

Vor dem Ausführen einer Evaluierung ist ein geringer Setup-Aufwand erforderlich. Zunächst muss ein tfma.EvalConfig Objekt definiert werden, das Spezifikationen für das Modell, die Metriken und die Slices enthält, die ausgewertet werden sollen. Zweitens muss ein tfma.EvalSharedModel erstellt werden, das auf das tatsächliche Modell (oder die tatsächlichen Modelle) verweist, die während der Auswertung verwendet werden sollen. Sobald diese definiert wurden, wird die Auswertung durchgeführt, indem tfma.run_model_analysis mit einem geeigneten Datensatz tfma.run_model_analysis wird. Weitere Informationen finden Sie in der Installationsanleitung .

Wenn Sie in einer TFX-Pipeline ausgeführt werden, finden Sie im TFX- Handbuch Informationen zum Konfigurieren von TFMA für die Ausführung als TFX- Evaluator- Komponente.

Beispiele

Einzelmodellbewertung

Im Folgenden wird tfma.run_model_analysis , um eine Auswertung für ein Serving-Modell durchzuführen. Eine Erläuterung der verschiedenen erforderlichen Einstellungen finden Sie in der Installationsanleitung .

# 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" }
    # ... 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)

Erstellen Sie für die verteilte Auswertung eine Apache Beam- Pipeline mit einem verteilten Runner. Verwenden tfma.ExtractEvaluateAndWriteResults in der Pipeline tfma.ExtractEvaluateAndWriteResults zur Auswertung und zum tfma.ExtractEvaluateAndWriteResults der Ergebnisse. Die Ergebnisse können zur Visualisierung mit tfma.load_eval_result geladen werden.

Zum Beispiel:

# 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)

Modell Bestätigung

Aktualisieren Sie die Konfiguration, um eine Modellvalidierung für einen Kandidaten und eine Basislinie durchzuführen, um eine Schwellenwerteinstellung tfma.run_model_analysis , und übergeben Sie zwei Modelle an tfma.run_model_analysis .

Zum Beispiel:

# 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)

Visualisierung

Die TFMA-Bewertungsergebnisse können mithilfe der in TFMA enthaltenen Frontend-Komponenten in einem Jupyter-Notizbuch visualisiert werden. Zum Beispiel:

TFMA Slicing Metrics Browser .

Mehr Informationen