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

Architektur der Tensorflow-Modellanalyse

Überblick

Die TFMA-Pipeline (TensorFlow Model Analysis) ist wie folgt dargestellt:

TFMA-Pipeline

Die Pipeline besteht aus vier Hauptkomponenten:

  • Eingaben lesen
  • Extraktion
  • Auswertung
  • Ergebnisse schreiben

Diese Komponenten verwenden zwei Haupttypen: tfma.Extracts und tfma.evaluators.Evaluation . Der Typ tfma.Extracts repräsentiert Daten, die während der Pipeline-Verarbeitung extrahiert werden, während der Typ tfma.evaluators.Evaluation die Ausgabe der Auswertung der Extrakte an verschiedenen Punkten während des Extraktionsprozesses darstellt. Um eine flexible API bereitzustellen, handelt es sich bei diesen Typen lediglich um Dikte, bei denen die Schlüssel von verschiedenen Implementierungen definiert (für die Verwendung reserviert) werden. Die Typen sind wie folgt definiert:

# Extracts represent data extracted during pipeline processing.
# For example, the PredictExtractor stores the data for the
# features, labels, and predictions under the keys "features",
# "labels", and "predictions".
Extracts = Dict[Text, Any]

# Evaluation represents the output from evaluating extracts at
# particular point in the pipeline. The evaluation outputs are
# keyed by their associated output type. For example, the metric / plot
# dictionaries from evaluating metrics and plots will be stored under
# "metrics" and "plots" respectively.
Evaluation = Dict[Text, beam.pvalue.PCollection]

Beachten Sie, dass tfma.Extracts niemals direkt ausgeschrieben werden. Sie müssen immer einen Evaluator durchlaufen, um eine tfma.evaluators.Evaluation zu erstellen, die dann ausgeschrieben wird. Beachte auch , dass tfma.Extracts dicts ist , die in einem gespeicherten beam.pvalue.PCollection (dh beam.PTransform s nimmt als Eingabe beam.pvalue.PCollection[tfma.Extracts] ) , während ein tfma.evaluators.Evaluation ist ein dict deren Werte sind beam.pvalue.PCollection s (dh beam.PTransform s nehmen das Diktat selbst als Argument für die Eingabe von beam.value.PCollection ). Mit anderen Worten, die tfma.evaluators.Evaluation wird zur Pipeline-Konstruktionszeit verwendet, aber die tfma.Extracts werden zur Pipeline-Laufzeit verwendet.

Eingaben lesen

Die ReadInputs Stufe besteht aus einer Transformation, die Roheingaben (tf.train.Example, CSV, ...) aufnimmt und in Extrakte konvertiert. Heutzutage werden die Extrakte als rohe Eingabebytes dargestellt, die unter tfma.INPUT_KEY gespeichert tfma.INPUT_KEY . Die Extrakte können jedoch in jeder Form vorliegen, die mit der Extraktionspipeline kompatibel ist. tfma.Extracts bedeutet, dass tfma.Extracts als Ausgabe erstellt wird und diese Extrakte mit Downstream kompatibel sind Extraktoren. Es liegt an den verschiedenen Extraktoren, klar zu dokumentieren, was sie benötigen.

Extraktion

Der Extraktionsprozess ist eine Liste von beam.PTransform , die in Reihe ausgeführt werden. Die Extraktoren nehmen tfma.Extracts als Eingabe und geben tfma.Extracts als Ausgabe zurück. Der tfma.extractors.PredictExtractor Extraktor ist der tfma.extractors.PredictExtractor der den von der Transformation der tfma.extractors.PredictExtractor erzeugten tfma.extractors.PredictExtractor verwendet und ihn durch ein Modell führt, um Vorhersageextrakte zu erstellen. Benutzerdefinierte Extraktoren können jederzeit eingefügt werden, sofern ihre Transformationen der API tfma.Extracts in und tfma.Extracts out entsprechen. Ein Extraktor ist wie folgt definiert:

# An Extractor is a PTransform that takes Extracts as input and returns
# Extracts as output. A typical example is a PredictExtractor that receives
# an 'input' placeholder for input and adds additional 'predictions' extracts.
Extractor = NamedTuple('Extractor', [
    ('stage_name', Text),
    ('ptransform', beam.PTransform)])  # Extracts -> Extracts

Beachten Sie, dass es außerhalb ganz besonderer Fälle fast immer der Fall ist, dass eine tfma.Extracts in beam.pvalue.PCollection einem Beispiel aus dem Modell entspricht.

InputExtractor

Der tfma.extractors.InputExtractor wird verwendet, um Roh-Features, Roh-Labels und Roh-Beispielgewichte aus tf.train.Example zu extrahieren. Beispieldatensätze zur Verwendung beim Schneiden und Berechnen von Metriken. Standardmäßig werden die Werte unter den features , labels und example_weights der Extraktionsschlüssel gespeichert. Modellbeschriftungen mit einer Ausgabe und Beispielgewichte werden direkt als np.ndarray Werte gespeichert. Modellbeschriftungen mit np.ndarray Ausgaben und Beispielgewichte werden als Diktate von np.ndarray Werten gespeichert (durch den Ausgabenamen np.ndarray ). Wenn eine Bewertung mit mehreren Modellen durchgeführt wird, werden die Beschriftungen und Beispielgewichte weiter in ein anderes Diktat eingebettet (durch den Modellnamen verschlüsselt).

PredictExtractor

Die tfma.extractors.PredictExtractor läuft Modellvorhersagen und speichert sie unter den wichtigsten predictions in der tfma.Extracts dict. Modellvorhersagen mit einer Ausgabe werden direkt als vorhergesagte Ausgabewerte gespeichert. Modellvorhersagen mit mehreren Ausgaben werden als Diktat der Ausgabewerte gespeichert (durch den Ausgabenamen verschlüsselt). Wenn eine Bewertung mit mehreren Modellen durchgeführt wird, wird die Vorhersage weiter in ein anderes Diktat eingebettet (durch den Modellnamen verschlüsselt). Der tatsächlich verwendete Ausgabewert hängt vom Modell ab (z. B. die Rückgabeausgaben des TF-Schätzers in Form eines Diktats, während Keras np.ndarray Werte np.ndarray ).

SliceKeyExtractor

Der tfma.extractors.SliceKeyExtractor verwendet die Slicing-Spezifikation, um basierend auf den extrahierten Features zu bestimmen, welche Slices für jede Beispieleingabe gelten, und fügt die entsprechenden Slicing-Werte zu den Extrakten hinzu, um sie später von den Evaluatoren zu verwenden.

Auswertung

Bei der Bewertung wird ein Extrakt entnommen und bewertet. Während es üblich ist, eine Bewertung am Ende der Extraktionspipeline durchzuführen, gibt es Anwendungsfälle, die eine frühere Bewertung im Extraktionsprozess erfordern. Als solche sind Evaluatoren den Extraktoren zugeordnet, gegen deren Ausgabe sie bewertet werden sollten. Ein Evaluator ist wie folgt definiert:

# An evaluator is a PTransform that takes Extracts as input and
# produces an Evaluation as output. A typical example of an evaluator
# is the MetricsAndPlotsEvaluator that takes the 'features', 'labels',
# and 'predictions' extracts from the PredictExtractor and evaluates
# them using post export metrics to produce metrics and plots dictionaries.
Evaluator = NamedTuple('Evaluator', [
  ('stage_name', Text),
  ('run_after', Text),              # Extractor.stage_name
  ('ptransform', beam.PTransform)]) # Extracts -> Evaluation

Beachten Sie, dass ein Evaluator ein beam.PTransform , der tfma.Extracts als Eingaben verwendet. Nichts hindert eine Implementierung daran, im Rahmen des Evaluierungsprozesses zusätzliche Transformationen für die Extrakte durchzuführen. Im Gegensatz zu Extraktoren, die ein tfma.Extracts , gibt es keine Einschränkungen hinsichtlich der Arten von Ausgaben, die ein Evaluator erzeugen kann, obwohl die meisten Evaluatoren auch ein Diktat zurückgeben (z. B. Metriknamen und -werte).

MetricsAndPlotsEvaluator

Der tfma.evaluators.MetricsAndPlotsEvaluator features , labels und predictions als Eingabe, führt sie durch tfma.slicer.FanoutSlices , um sie nach Slices zu gruppieren, und führt dann Metriken und Diagrammberechnungen durch. Es erzeugt Ausgaben in Form von Wörterbüchern mit Metriken und zeichnet Schlüssel und Werte (diese werden später in serialisierte Protos konvertiert, die von tfma.writers.MetricsAndPlotsWriter ausgegeben werden).

Ergebnisse schreiben

In der Phase WriteResults wird die Auswertungsausgabe auf die Festplatte geschrieben. WriteResults verwendet Writer, um die Daten basierend auf den Ausgabeschlüsseln zu schreiben. Beispielsweise kann eine tfma.evaluators.Evaluation Schlüssel für metrics und plots . Diese werden dann den Metriken und Plot-Wörterbüchern zugeordnet, die als "Metriken" und "Plots" bezeichnet werden. Die Autoren geben an, wie jede Datei geschrieben werden soll:

# A writer is a PTransform that takes evaluation output as input and
# serializes the associated PCollections of data to a sink.
Writer = NamedTuple('Writer', [
  ('stage_name', Text),
  ('ptransform', beam.PTransform)])    # Evaluation -> PDone

MetricsAndPlotsWriter

Wir stellen einen tfma.writers.MetricsAndPlotsWriter , der die Metriken konvertiert und Wörterbücher in serialisierte Protos zeichnet und auf die Festplatte schreibt.

Wenn Sie ein anderes Serialisierungsformat verwenden möchten, können Sie einen benutzerdefinierten Writer erstellen und diesen stattdessen verwenden. Da die an die tfma.evaluators.Evaluation übergebene tfma.evaluators.Evaluation die Ausgabe für alle Evaluatoren zusammen enthält, wird eine tfma.writers.Write bereitgestellt, die Writer in ihren ptransform Implementierungen verwenden können, um die entsprechenden beam.PCollection s basierend auf einem auszuwählen Ausgabetaste (siehe unten für ein Beispiel).

Anpassung

Die Methode tfma.run_model_analysis verwendet Argumente für Extraktoren, Evaluatoren und Writer, um die von der Pipeline verwendeten extractors , evaluators und writers anzupassen. Wenn keine Argumente tfma.default_writers werden, werden standardmäßig tfma.default_extractors , tfma.default_evaluators und tfma.default_writers verwendet.

Kundenspezifische Extraktoren

Um einen benutzerdefinierten Extraktor zu erstellen, erstellen Sie einen tfma.extractors.Extractor Typ, der einen beam.PTransform nimmt tfma.Extracts als Eingabe und gibt tfma.Extracts als Ausgabe zurück. Beispiele für Extraktoren finden Sie unter tfma.extractors .

Benutzerdefinierte Evaluatoren

Um einen benutzerdefinierten Auswerter zu erstellen, erstellen Sie eine tfma.evaluators.Evaluator Typ, der eine hüllt beam.PTransform nehmen tfma.Extracts als Eingabe und Rückkehr tfma.evaluators.Evaluation als Ausgabe. Ein sehr einfacher Evaluator nimmt möglicherweise einfach das eingehende tfma.Extracts und gibt es zum Speichern in einer Tabelle aus. Genau das macht der tfma.evaluators.AnalysisTableEvaluator . Ein komplizierterer Evaluator führt möglicherweise eine zusätzliche Verarbeitung und Datenaggregation durch. Siehe den tfma.evaluators.MetricsAndPlotsEvaluator als Beispiel.

Beachten Sie, dass der tfma.evaluators.MetricsAndPlotsEvaluator selbst angepasst werden kann, um benutzerdefinierte Metriken zu unterstützen (weitere Informationen finden Sie unter Metriken ).

Benutzerdefinierte Autoren

Um einen benutzerdefinierten Writer zu erstellen, erstellen Sie einen tfma.writers.Writer Typ, der einen beam.PTransform mit tfma.evaluators.Evaluation als Eingabe und Rückgabe beam.pvalue.PDone als Ausgabe. Das folgende Beispiel zeigt einen Writer zum Schreiben von TFRecords mit Metriken:

tfma.writers.Writer(
  stage_name='WriteTFRecord(%s)' % tfma.METRICS_KEY,
  ptransform=tfma.writers.Write(
    key=tfma.METRICS_KEY,
    ptransform=beam.io.WriteToTFRecord(file_path_prefix=output_file))

Die Eingaben eines Schreibers hängen von der Ausgabe des zugehörigen Bewerters ab. Für das obige Beispiel ist die Ausgabe ein serialisierter Proto, der vom tfma.evaluators.MetricsAndPlotsEvaluator . Ein Writer für den tfma.evaluators.AnalysisTableEvaluator ist für das Schreiben eines beam.pvalue.PCollection von tfma.Extracts .

Beachten Sie, dass ein Writer über den verwendeten Ausgabeschlüssel (z. B. tfma.METRICS_KEY , tfma.ANALYSIS_KEY usw.) der Ausgabe eines Evaluators tfma.ANALYSIS_KEY ist.

Schritt für Schritt Beispiel

Das Folgende ist ein Beispiel für die Schritte bei der Gewinnung und Auswertung Pipeline , wenn sowohl die tfma.evaluators.MetricsAndPlotsEvaluator und tfma.evaluators.AnalysisTableEvaluator verwendet:

run_model_analysis(
    ...
    extractors=[
        tfma.extractors.InputExtractor(...),
        tfma.extractors.PredictExtractor(...),
        tfma.extractors.SliceKeyExtrator(...)
    ],
    evaluators=[
        tfma.evaluators.MetricsAndPlotsEvaluator(...),
        tfma.evaluators.AnalysisTableEvaluator(...)
    ])

ReadInputs

# Out
Extracts {
  'input': bytes                 # CSV, Proto, ...
}

ExtractAndEvaluate

# In:  ReadInputs Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
}
# In:  InputExtractor Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
}
# In: PredictExtractor Extracts
# Out:
Extracts {
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
  'slice_key': Tuple[bytes...]      # Slice
}
# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
}
# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'analysis': PCollection[Extracts] # Final Extracts
}

WriteResults

# In:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
  'analysis': PCollection[Extracts] # Final Extracts
}
# Out: metrics, plots, and analysis files