Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten

Metriken und Diagramme zur Tensorflow-Modellanalyse

Überblick

TFMA unterstützt die folgenden Metriken und Diagramme:

  • Standard Keras Metriken ( tf.keras.metrics.* )
    • Beachten Sie, dass Sie kein Keras-Modell benötigen, um Keras-Metriken zu verwenden. Metriken werden außerhalb des Graphen im Balken berechnet, indem die Metrikklassen direkt verwendet werden.
  • Standard TFMA Metriken und Plots ( tfma.metrics.* )

  • Benutzerdefinierte Keras Metriken (Metriken abgeleitet von tf.keras.metrics.Metric )

  • Benutzerdefinierte TFMA Metriken (Metriken abgeleitet tfma.metrics.Metric ) von anderen Metriken benutzerdefinierten Strahlkombinierer oder Metriken abgeleitet).

TFMA bietet auch integrierte Unterstützung für die Konvertierung binärer Klassifizierungsmetriken zur Verwendung bei Problemen mit mehreren Klassen/mehreren Etiketten:

  • Binarisierung basierend auf Klassen-ID, Top K usw.
  • Aggregierte Metriken basierend auf Mikro-Mittelung, Makro-Mittelung usw.

TFMA bietet auch integrierte Unterstützung für abfrage-/rankingbasierte Metriken, bei denen die Beispiele automatisch in der Pipeline nach einem Abfrageschlüssel gruppiert werden.

Kombiniert stehen über 50 Standardmetriken und Diagramme für eine Vielzahl von Problemen zur Verfügung, einschließlich Regression, binäre Klassifikation, Multi-Class/Multi-Label-Klassifizierung, Ranking usw.

Aufbau

Es gibt zwei Möglichkeiten , um configure Metriken in TFMA: (1) unter Verwendung des tfma.MetricsSpec oder (2) durch Instanzen zu schaffen tf.keras.metrics.* und / oder tfma.metrics.* Klassen in Python und mit tfma.metrics.specs_from_metrics sie auf eine Liste von konvertieren tfma.MetricsSpec .

In den folgenden Abschnitten werden Beispielkonfigurationen für verschiedene Arten von Problemen beim maschinellen Lernen beschrieben.

Regressionsmetriken

Im Folgenden sehen Sie ein Beispiel für die Konfiguration eines Regressionsproblems. Konsultieren Sie die tf.keras.metrics.* Und tfma.metrics.* Module für mögliche zusätzliche Metriken unterstützt.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "MeanSquaredError" }
    metrics { class_name: "Accuracy" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics {
      class_name: "CalibrationPlot"
      config: '"min_value": 0, "max_value": 10'
    }
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.MeanSquaredError(name='mse'),
    tf.keras.metrics.Accuracy(name='accuracy'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.CalibrationPlot(
        name='calibration', min_value=0, max_value=10)
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Beachten Sie, dass diese Einstellung durch den Aufruf auch mit Baumaßen ist tfma.metrics.default_regression_specs .

Metriken für die binäre Klassifikation

Im Folgenden sehen Sie ein Beispiel für die Konfiguration eines binären Klassifizierungsproblems. Konsultieren Sie die tf.keras.metrics.* Und tfma.metrics.* Module für mögliche zusätzliche Metriken unterstützt.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "ConfusionMatrixPlot" }
    metrics { class_name: "CalibrationPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.BinaryCrossentropy(name='binary_crossentropy'),
    tf.keras.metrics.BinaryAccuracy(name='accuracy'),
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    tf.keras.metrics.AUC(
        name='auc_precision_recall', curve='PR', num_thresholds=10000),
    tf.keras.metrics.Precision(name='precision'),
    tf.keras.metrics.Recall(name='recall'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.ConfusionMatrixPlot(name='confusion_matrix_plot'),
    tfma.metrics.CalibrationPlot(name='calibration_plot')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Beachten Sie, dass diese Einstellung durch den Aufruf auch mit Baumaßen ist tfma.metrics.default_binary_classification_specs .

Klassifikationsmetriken für mehrere Klassen/mehrere Etiketten

Im Folgenden sehen Sie ein Beispiel für eine Konfiguration für ein Klassifizierungsproblem mit mehreren Klassen. Konsultieren Sie die tf.keras.metrics.* Und tfma.metrics.* Module für mögliche zusätzliche Metriken unterstützt.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "SparseCategoricalCrossentropy" }
    metrics { class_name: "SparseCategoricalAccuracy" }
    metrics { class_name: "Precision" config: '"top_k": 1' }
    metrics { class_name: "Precision" config: '"top_k": 3' }
    metrics { class_name: "Recall" config: '"top_k": 1' }
    metrics { class_name: "Recall" config: '"top_k": 3' }
    metrics { class_name: "MultiClassConfusionMatrixPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.SparseCategoricalCrossentropy(
        name='sparse_categorical_crossentropy'),
    tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),
    tf.keras.metrics.Precision(name='precision', top_k=1),
    tf.keras.metrics.Precision(name='precision', top_k=3),
    tf.keras.metrics.Recall(name='recall', top_k=1),
    tf.keras.metrics.Recall(name='recall', top_k=3),
    tfma.metrics.MultiClassConfusionMatrixPlot(
        name='multi_class_confusion_matrix_plot'),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Beachten Sie, dass diese Einstellung durch den Aufruf auch mit Baumaßen ist tfma.metrics.default_multi_class_classification_specs .

Binarisierte Metriken mit mehreren Klassen/mehreren Labels

Multi-Klasse / Multi-Label - Metriken können digitalisiert werden Metriken pro Klasse zu produzieren, pro top_k, etc , die mit tfma.BinarizationOptions . Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    binarize: { class_ids: { values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] } }
    // Metrics to binarize
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    // Metrics to binarize
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, binarize=tfma.BinarizationOptions(
        class_ids={'values': [0,1,2,3,4,5,6,7,8,9]}))

Zusammengefasste Metriken mit mehreren Klassen/mit mehreren Etiketten

Multi-Klasse / kann Multi-Label - Metriken aggregiert werden , um einen einzigen zusammengefassten Wert für eine binäre Klassifizierung herzustellen Metrik unter Verwendung tfma.AggregationOptions .

Beachten Sie, dass die Aggregation Einstellungen unabhängig von Digitalisierungs Einstellungen, so dass Sie beide können tfma.AggregationOptions und tfma.BinarizationOptions zugleich.

Mikro-Durchschnitt

Micro Lungs kann mithilfe der durchgeführt werden micro_average Option innerhalb tfma.AggregationOptions . Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: { micro_average: true }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, aggregate=tfma.AggregationOptions(micro_average=True))

Micro Lungs unterstützt auch Einstellung top_k , wo nur die Top-k - Werte werden bei der Berechnung verwendet. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      micro_average: true
      top_k_list: { values: [1, 3] }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(micro_average=True,
                                      top_k_list={'values': [1, 3]}))

Makro / Gewichteter Makrodurchschnitt

Macro Lungs kann mit den durchgeführt werden macro_average oder weighted_macro_average Optionen innerhalb tfma.AggregationOptions . Es sei denn , top_k Einstellungen verwendet werden, erfordert Makro , um die Einstellung class_weights , um zu wissen , welche Klassen für den Mittelwert zu berechnen. Wenn ein class_weight nicht zur Verfügung gestellt wird , dann wird 0,0 angenommen. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      macro_average: true
      class_weights: { key: 0 value: 1.0 }
      class_weights: { key: 1 value: 1.0 }
      class_weights: { key: 2 value: 1.0 }
      class_weights: { key: 3 value: 1.0 }
      class_weights: { key: 4 value: 1.0 }
      class_weights: { key: 5 value: 1.0 }
      class_weights: { key: 6 value: 1.0 }
      class_weights: { key: 7 value: 1.0 }
      class_weights: { key: 8 value: 1.0 }
      class_weights: { key: 9 value: 1.0 }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(
        macro_average=True, class_weights={i: 1.0 for i in range(10)}))

Wie Mikrolungs, Makro Lungs unterstützt auch Einstellung top_k , wo nur die Top-k - Werte verwendet werden , bei der Berechnung. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      macro_average: true
      top_k_list: { values: [1, 3] }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(macro_average=True,
                                      top_k_list={'values': [1, 3]}))

Abfrage-/Ranking-basierte Metriken

Query / Ranking basiert Metriken werden durch Angabe der aktivierten query_key Option in den Metriken Spezifikationen. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    query_key: "doc_id"
    metrics {
      class_name: "NDCG"
      config: '"gain_key": "gain", "top_k_list": [1, 2]'
    }
    metrics { class_name: "MinLabelPosition" }
  }
""", tfma.EvalConfig()).metrics_specs

Das gleiche Setup kann mit dem folgenden Python-Code erstellt werden:

metrics = [
    tfma.metrics.NDCG(name='ndcg', gain_key='gain', top_k_list=[1, 2]),
    tfma.metrics.MinLabelPosition(name='min_label_position')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics, query_key='doc_id')

Bewertungsmetriken für mehrere Modelle

TFMA unterstützt die gleichzeitige Bewertung mehrerer Modelle. Wenn eine Bewertung mit mehreren Modellen durchgeführt wird, werden Metriken für jedes Modell berechnet. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    # no model_names means all models
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Wenn Metriken für eine Teilmenge von Modellen berechnet werden müssen, setzen model_names in dem metric_specs . Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    model_names: ["my-model1"]
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Die specs_from_metrics API unterstützt auch Modellnamen übergeben:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, model_names=['my-model1'])

Modellvergleichsmetriken

TFMA unterstützt die Bewertung von Vergleichsmetriken für ein Kandidatenmodell mit einem Basismodell. Eine einfache Möglichkeit zum Einrichten des Kandidaten- und Basismodellpaars besteht darin, ein eval_shared_model mit den richtigen Modellnamen (tfma.BASELINE_KEY und tfma.CANDIDATE_KEY) weiterzugeben:


eval_config = text_format.Parse("""
  model_specs {
    # ... model_spec without names ...
  }
  metrics_spec {
    # ... metrics ...
  }
""", tfma.EvalConfig())

eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path='/path/to/saved/candidate/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),
]

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="/path/for/output")

Vergleichsmetriken werden automatisch für alle differenzierbaren Metriken berechnet (derzeit nur Skalarwertmetriken wie Genauigkeit und AUC).

Multi-Output-Modellmetriken

TFMA unterstützt die Auswertung von Metriken für Modelle mit unterschiedlichen Ausgaben. Modelle mit mehreren Ausgaben speichern ihre Ausgabevorhersagen in Form eines Diktats, das nach dem Ausgabenamen eingegeben wird. Beim Multi-Output - Modell verwendet werden, die Namen der Ausgänge mit einer Gruppe von Metriken zugeordnet muss in dem angegeben werden output_names Abschnitt des MetricsSpec. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    output_names: ["my-output"]
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Die specs_from_metrics API unterstützt auch Ausgangsnamen übergeben:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, output_names=['my-output'])

Anpassen der Metrikeinstellungen

TFMA ermöglicht die Anpassung der Einstellungen, die mit verschiedenen Metriken verwendet werden. Zum Beispiel könnten Sie den Namen, die festgelegten Schwellenwerte ändern, usw. Dies wird durch das Hinzufügen eines getan wird config Abschnitts des Metrik - Konfig. Die Config angegeben wird , um die JSON - String - Version der Parameter verwenden, die auf die Metriken weitergegeben würden __init__ (Nutzungs die Vorder- und Hinter für eine einfache ‚{‘ und ‚}‘ Klammern weggelassen werden kann) Verfahren. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics {
      class_name: "ConfusionMatrixAtThresholds"
      config: '"thresholds": [0.3, 0.5, 0.8]'
    }
  }
""", tfma.MetricsSpec()).metrics_specs

Diese Anpassung wird natürlich auch direkt unterstützt:

metrics = [
   tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Ausgänge

Die Ausgabe einer Metrikauswertung ist eine Reihe von Metrikschlüsseln/-werten und/oder Plotschlüsseln/-werten basierend auf der verwendeten Konfiguration.

Metrikschlüssel

MetricKeys ist eine strukturierte Schlüsseltyp definiert ist . Dieser Schlüssel identifiziert jeden der folgenden Aspekte einer Metrik eindeutig:

  • Metric Name ( auc , mean_label , usw.)
  • Modellname (nur verwendet bei Multi-Modell-Evaluation)
  • Ausgabename (wird nur verwendet, wenn Multi-Output-Modelle ausgewertet werden)
  • Unterschlüssel (z. B. Klassen-ID, wenn das Mehrklassenmodell binarisiert ist)

Metrikwert

MetricValues definiert eine proto verwenden , das die verschiedenen Wertetypen encapulates durch die unterschiedlichen Metriken unterstützt (zB double , ConfusionMatrixAtThresholds , etc).

Im Folgenden sind die unterstützten Messwerttypen aufgeführt:

  • double_value - Ein Wrapper für einen Doppeltyp.
  • bytes_value - A Bytes Wert.
  • bounded_value - Stell einen realen Wert, der eine punktuelle Schätzung sein könnte, gegebenenfalls mit dem ungefähren Grenzen irgendeine Art. Hat Eigenschaften value , lower_bound und upper_bound .
  • value_at_cutoffs - Wert bei Cutoffs (zB Präzision @ K, Rückruf @ K). Hat Eigenschaft values , von denen jede Eigenschaften cutoff und value .
  • confusion_matrix_at_thresholds - Konfusionsmatrix bei Schwellen. Hat die Eigenschaft matrices , von denen jede für die Eigenschaften hat threshold , precision , recall und Konfusionsmatrix Werte wie false_negatives .
  • array_value - für Metriken , die ein Array von Werten zurück.

Plotschlüssel

PlotKeys sind ähnlich wie metrische Schlüssel , außer dass aus historischen Gründen alle Grundwerte in einem einzigen proto gespeichert werden , so dass die Handlung Schlüssel keinen Namen haben.

Plotwerte

Alle die unterstützten Diagramme sind in einem einzigen Proto genannt gespeichert PlotData .

Bewertungsergebnis

Die Rückkehr von einem Auswertungslauf ist ein tfma.EvalResult . Dieser Datensatz enthält slicing_metrics , die die Metrik Schlüssel als ein mehrstufiges dict in denen die Werte entsprechen den Ausgabenamen bzw. Klassen - ID, metric Name und metrischen Wert kodieren. Dies ist für die UI-Anzeige in einem Jupiter-Notebook vorgesehen. Wenn der Zugriff auf die zugrunde liegenden Daten werden die benötigten metrics führen sollte Datei stattdessen verwendet werden (siehe metrics_for_slice.proto ).

Anpassung

Zusätzlich zu benutzerdefinierten Metriken, die als Teil eines gespeicherten Keras (oder eines älteren EvalSavedModel) hinzugefügt werden. Es gibt zwei Möglichkeiten, Metriken beim TFMA-Nachspeichern anzupassen: (1) durch Definieren einer benutzerdefinierten Keras-Metrikklasse und (2) durch Definieren einer benutzerdefinierten TFMA-Metrikklasse, die von einem Strahlkombinierer unterstützt wird.

In beiden Fällen werden die Metriken durch Angabe des Namens der Metrikklasse und des zugehörigen Moduls konfiguriert. Zum Beispiel:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "MyMetric" module: "my.module"}
  }
""", tfma.EvalConfig()).metrics_specs

Benutzerdefinierte Keras-Metriken

So erstellen Sie eine benutzerdefinierte Keras Metrik, müssen die Benutzer erweitern tf.keras.metrics.Metric mit deren Umsetzung und dann stellen Sie sicher , dass die Metrik des Moduls ist bei der Auswertung zur Verfügung.

Man beachte , dass Post - Modell für Metriken hinzugefügt Speichern, TFMA nur Metriken unterstützt , die Etikettennehmen (dh y_true), Vorhersage (y_pred) und Beispiel Gewicht (sample_weight) als Parameter an die update_state Methode.

Keras-Metrikbeispiel

Im Folgenden finden Sie ein Beispiel für eine benutzerdefinierte Keras-Metrik:

class MyMetric(tf.keras.metrics.Mean):

  def __init__(self, name='my_metric', dtype=None):
    super(MyMetric, self).__init__(name=name, dtype=dtype)

  def update_state(self, y_true, y_pred, sample_weight=None):
    return super(MyMetric, self).update_state(
        y_pred, sample_weight=sample_weight)

Benutzerdefinierte TFMA-Metriken

Um eine benutzerdefinierte TFMA Metrik zu erstellen, müssen Benutzer erweitern tfma.metrics.Metric mit deren Umsetzung und dann stellen Sie sicher , dass die Metrik des Moduls ist bei der Auswertung zur Verfügung.

Metrisch

Ein tfma.metrics.Metric Implementierung eines Satz von kwargs dass die Metriken Konfiguration zusammen mit einer Funktion definieren , die aus für die Erstellung der Berechnungen (möglicherweise mehrere) benötigt , um den Metrikwert calcuate. Es gibt zwei Hauptrechenarten , die verwendet werden können: tfma.metrics.MetricComputation und tfma.metrics.DerivedMetricComputation , die in den folgenden Abschnitten beschrieben werden. Der Funktion, die diese Berechnungen erstellt, werden die folgenden Parameter als Eingabe übergeben:

  • eval_config: tfam.EvalConfig
    • Die an den Evaluator übergebene Evaluierungskonfiguration (nützlich zum Nachschlagen von Modellspezifikationseinstellungen wie dem zu verwendenden Vorhersageschlüssel usw.).
  • model_names: List[Text]
    • Liste der Modellnamen zum Berechnen von Metriken (Keine bei Einzelmodell)
  • output_names: List[Text] .
    • Liste der Ausgabenamen zum Berechnen von Metriken (Keine bei Einzelmodell)
  • sub_keys: List[tfma.SubKey] .
    • Liste der Unterschlüssel (Klassen-ID, oberstes K usw.), für die Metriken berechnet werden sollen (oder Keine)
  • aggregation_type: tfma.AggregationType
    • Art der Aggregation, wenn eine Aggregationsmetrik berechnet wird.
  • class_weights: Dict[int, float] .
    • Zu verwendende Klassengewichtungen, wenn eine Aggregationsmetrik berechnet wird.
  • query_key: Text
    • Abfrageschlüssel, der verwendet wird, wenn eine auf Abfrage/Ranking basierende Metrik berechnet wird.

Wenn eine Metrik nicht mit einer oder mehreren dieser Einstellungen verknüpft ist, kann sie diese Parameter aus ihrer Signaturdefinition herauslassen.

Wenn eine Metrik auf die gleiche Weise für jedes Modell berechnet wird, Ausgangs- und Nebenschlüssel, so sind die Gebrauchs tfma.metrics.merge_per_key_computations kann verwendet werden , um die gleichen Berechnungen für jeden dieser Eingänge separat durchzuführen.

MetrikBerechnung

Ein MetricComputation besteht aus einer Kombination aus einem aus preprocessor - combiner preprocessor und einen combiner . Der preprocessor - beam.DoFn preprocessor ist ein beam.DoFn , die Extrakte als seine Eingabe und gibt den Ausgangszustand nimmt , die durch den Kombinierer verwendet werden (siehe Architektur für weitere Informationen darüber , was sind Auszüge). Wenn ein preprocessor nicht definiert ist, dann wird der Kombinierer geleitet wird StandardMetricInputs (Standard - metrische Eingaben enthalten Etiketten, Vorhersagen, und example_weights). Der combiner ist eine beam.CombineFn , die ein Tupel von (slice key, Präprozessorausgabe) als Eingabe nimmt und gibt ein Tupel von (slice_key, metric Ergebnisse dict) als Ergebnis.

Beachten Sie, dass Slicing zwischen dem geschieht preprocessor und combiner .

Beachten Sie, dass , wenn eine Metrikberechnungs- will Verwendung von sowohl den Standard - metrischen Eingaben machen, aber es mit ein paar der Merkmale aus den vermehren features extrahiert, dann die spezielle FeaturePreprocessor kann verwendet werden , die die gewünschten Funktionen aus mehreren Kombinierern zu einem einzigen verschmelzen Shared StandardMetricsInputs-Wert, der an alle Combiner übergeben wird (die Combiner sind dafür verantwortlich, die Features zu lesen, an denen sie interessiert sind, und den Rest zu ignorieren).

Beispiel

Das Folgende ist ein sehr einfaches Beispiel für die TFMA-Metrikdefinition zur Berechnung des ExampleCount:

class ExampleCount(tfma.metrics.Metric):

  def __init__(self, name: Text = 'example_count'):
    super(ExampleCount, self).__init__(_example_count, name=name)


def _example_count(
    name: Text = 'example_count') -> tfma.metrics.MetricComputations:
  key = tfma.metrics.MetricKey(name=name)
  return [
      tfma.metrics.MetricComputation(
          keys=[key],
          preprocessor=_ExampleCountPreprocessor(),
          combiner=_ExampleCountCombiner(key))
  ]


class _ExampleCountPreprocessor(beam.DoFn):

  def process(self, extracts: tfma.Extracts) -> Iterable[int]:
    yield 1


class _ExampleCountCombiner(beam.CombineFn):

  def __init__(self, metric_key: tfma.metrics.MetricKey):
    self._metric_key = metric_key

  def create_accumulator(self) -> int:
    return 0

  def add_input(self, accumulator: int, state: int) -> int:
    return accumulator + state

  def merge_accumulators(self, accumulators: Iterable[int]) -> int:
    accumulators = iter(accumulators)
    result = next(accumulator)
    for accumulator in accumulators:
      result += accumulator
    return result

  def extract_output(self,
                     accumulator: int) -> Dict[tfma.metrics.MetricKey, int]:
    return {self._metric_key: accumulator}

Abgeleitete metrische Berechnung

A DerivedMetricComputation ist aus einer Ergebnisfunktion aus , die verwendet wird Metrikwert zu berechnen auf der Ausgabe von anderen Metrikberechnungen basieren. Die Ergebnisfunktion verwendet als Eingabe ein Diktat berechneter Werte und gibt ein Diktat zusätzlicher Metrikergebnisse aus.

Beachten Sie, dass es akzeptabel (empfohlen) ist, die Berechnungen, von denen eine abgeleitete Berechnung abhängt, in die Liste der von einer Metrik erstellten Berechnungen aufzunehmen. Dadurch wird vermieden, dass Berechnungen, die von mehreren Metriken gemeinsam genutzt werden, vorab erstellt und weitergegeben werden müssen. Der Evaluator dedupliziert automatisch Berechnungen mit derselben Definition, sodass nur eine Berechnung ausgeführt wird.

Beispiel

Die tjur Metriken liefert ein gutes Beispiel von abgeleiteten Metriken.