Metryki i wykresy analizy modelu Tensorflow

Przegląd

TFMA obsługuje następujące metryki i wykresy:

• Standardowe metryki keras ( tf.keras.metrics.* )
  • Należy pamiętać, że do korzystania z metryk keras nie jest potrzebny model keras. Metryki są obliczane poza wykresem w belce przy użyciu bezpośrednio klas metryk.

• Standardowe metryki i wykresy TFMA ( tfma.metrics.* )

• Niestandardowe metryki keras (metryki pochodzące z tf.keras.metrics.Metric )

• Niestandardowe metryki TFMA (metryki pochodzące z tfma.metrics.Metric ) przy użyciu niestandardowych łączników belek lub metryki pochodzące z innych metryk).

TFMA zapewnia również wbudowaną obsługę konwersji metryk klasyfikacji binarnej do użytku z problemami z wieloma klasami/wieloma etykietami:

• Binaryzacja oparta na identyfikatorze klasy, top K itp.
• Zagregowane metryki oparte na uśrednianiu mikro, uśrednianiu makro itp.

TFMA zapewnia również wbudowaną obsługę metryk opartych na zapytaniach/rankingach, w których przykłady są automatycznie grupowane według klucza zapytania w potoku.

Łącznie dostępnych jest ponad 50 standardowych metryk i wykresów dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wieloklasowej / wieloetykietowej, rankingu itp.

Konfiguracja

Istnieją dwa sposoby konfigurowania metryk w TFMA: (1) za pomocą tfma.MetricsSpec lub (2) tworząc instancje tf.keras.metrics.* i/lub tfma.metrics.* w Pythonie i używając tfma.metrics.specs_from_metrics , aby przekonwertować je na listę tfma.MetricsSpec .

W poniższych sekcjach opisano przykładowe konfiguracje dla różnych typów problemów z uczeniem maszynowym.

Metryki regresji

Poniżej przedstawiono przykładową konfigurację konfiguracji problemu z regresją. Zapoznaj się z tf.keras.metrics.* i tfma.metrics.* , aby uzyskać informacje o obsługiwanych dodatkowych metrykach.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Zauważ, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_regression_specs .

Metryki klasyfikacji binarnej

Poniżej przedstawiono przykładową konfigurację konfiguracji problemu z klasyfikacją binarną. Zapoznaj się z tf.keras.metrics.* i tfma.metrics.* , aby uzyskać informacje o obsługiwanych dodatkowych metrykach.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Zauważ, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_binary_classification_specs .

Metryki klasyfikacji dla wielu klas/wielu etykiet

Poniżej przedstawiono przykładową konfigurację konfiguracji problemu z klasyfikacją wieloklasową. Zapoznaj się z tf.keras.metrics.* i tfma.metrics.* , aby uzyskać informacje o obsługiwanych dodatkowych metrykach.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Pamiętaj, że ta konfiguracja jest również dostępna przez wywołanie tfma.metrics.default_multi_class_classification_specs .

Metryki binarne dla wielu klas/wielu etykiet

Metryki wieloklasowe/wieloetykietowe można binaryzować w celu tworzenia metryk dla każdej klasy, top_k itd. przy użyciu tfma.BinarizationOptions . Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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]}))

Zagregowane metryki dla wielu klas/wielu etykiet

Metryki z wieloma klasami/wieloma etykietami można agregować w celu utworzenia jednej zagregowanej wartości dla metryki klasyfikacji binarnej przy użyciu tfma.AggregationOptions .

Należy pamiętać, że ustawienia agregacji są niezależne od ustawień binaryzacji, więc można jednocześnie używać zarówno tfma.AggregationOptions , jak i tfma.BinarizationOptions .

Średnia mikro

Mikrouśrednianie można wykonać za pomocą opcji micro_average w tfma.AggregationOptions . Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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

Mikrouśrednianie obsługuje również ustawienie top_k , w którym w obliczeniach używane są tylko najwyższe k wartości. Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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]}))

Średnia makro / ważona makro

Uśrednianie makr można wykonać za pomocą opcji macro_average lub weighted_macro_average w tfma.AggregationOptions . Jeśli nie są używane ustawienia top_k , makro wymaga ustawienia class_weights , aby wiedzieć, dla których klas obliczyć średnią. Jeśli class_weight nie zostanie podana, przyjmowana jest wartość 0,0. Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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

Podobnie jak uśrednianie mikro, uśrednianie makr obsługuje również ustawienie top_k , w którym w obliczeniach używane są tylko najwyższe wartości k. Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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]}))

Metryki oparte na zapytaniach / rankingach

Metryki oparte na zapytaniach/rankingach są włączane przez określenie opcji query_key w specyfikacjach metryk. Na przykład:

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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu Pythona:

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

Metryki oceny wielu modeli

TFMA obsługuje ocenę wielu modeli jednocześnie. Gdy przeprowadzana jest ocena wielu modeli, metryki zostaną obliczone dla każdego modelu. Na przykład:

from google.protobuf import text_format

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

Jeśli metryki muszą zostać obliczone dla podzbioru modeli, ustaw model_names w metric_specs . Na przykład:

from google.protobuf import text_format

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

Interfejs API specs_from_metrics obsługuje również przekazywanie nazw modeli:

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

Metryki porównania modeli

TFMA obsługuje ocenę metryk porównawczych dla modelu kandydującego z modelem bazowym. Prostym sposobem skonfigurowania pary modelu kandydującego i modelu bazowego jest przekazanie eval_shared_model z odpowiednimi nazwami modeli (tfma.BASELINE_KEY i tfma.CANDIDATE_KEY):

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

Metryki porównawcze są obliczane automatycznie dla wszystkich metryk różnicowalnych (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).

Metryki modelu z wieloma wyjściami

TFMA obsługuje ocenę metryk w modelach, które mają różne wyniki. Modele wielowyjściowe przechowują swoje prognozy wyjściowe w postaci dyktowanej nazwy wyjściowej. Gdy używane są modele z wieloma wyjściami, nazwy wyników powiązanych z zestawem metryk muszą być określone w sekcji output_names w MetricsSpec. Na przykład:

from google.protobuf import text_format

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

Interfejs API specs_from_metrics obsługuje również przekazywanie nazw danych wyjściowych:

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

Dostosowywanie ustawień metryki

TFMA umożliwia dostosowanie ustawień, które są używane z różnymi metrykami. Na przykład możesz chcieć zmienić nazwę, ustawić progi itp. Odbywa się to poprzez dodanie sekcji config do konfiguracji metryki. Konfiguracja jest określona przy użyciu wersji ciągu JSON parametrów, które zostaną przekazane do metody metrics __init__ (dla ułatwienia można pominąć nawiasy początkowe i końcowe „{” i „}”). Na przykład:

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

To dostosowanie jest oczywiście obsługiwane bezpośrednio:

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

Wyjścia

Wynikiem oceny metryki jest seria kluczy/wartości metryki i/lub kluczy/wartości wykresu na podstawie użytej konfiguracji.

Klucze metryczne

MetricKeys są definiowane przy użyciu typu klucza strukturalnego. Ten klucz jednoznacznie identyfikuje każdy z następujących aspektów metryki:

• Nazwa metryki ( auc , mean_label , itp.)
• Nazwa modelu (używana tylko w przypadku oceny wielu modeli)
• Nazwa wyjścia (używana tylko w przypadku oceny modeli z wieloma wyjściami)
• Klucz podrzędny (np. identyfikator klasy, jeśli model wieloklasowy jest binaryzowany)

Wartość metryczna

MetricValues ​​są definiowane przy użyciu proto, które hermetyzuje różne typy wartości obsługiwane przez różne metryki (np. double , ConfusionMatrixAtThresholds itp.).

Poniżej znajdują się obsługiwane typy wartości metryk:

• double_value — opakowanie dla typu podwójnego.
• bytes_value — Wartość w bajtach.
• bounded_value — reprezentuje rzeczywistą wartość, która może być oszacowaniem punktowym, opcjonalnie z pewnymi przybliżonymi granicami. Ma właściwości value , lower_bound i upper_bound .
• value_at_cutoffs — Wartość w punktach odcięcia (np. precyzja@K, przywołanie@K). Ma values właściwości, z których każda ma właściwości cutoff i value .
• confusion_matrix_at_thresholds — Matryca zamieszania na progach. Ma matrices właściwości, z których każda ma właściwości dla threshold , precision , recall i pomyłek, takich jak false_negatives .
• array_value — dla metryk, które zwracają tablicę wartości.

Klucze fabuły

PlotKeys są podobne do kluczy metrycznych, z wyjątkiem tego, że ze względów historycznych wszystkie wartości wykresów są przechowywane w jednym proto, więc klucz wykresu nie ma nazwy.

Wartości działek

Wszystkie obsługiwane wykresy są przechowywane w jednym prototypie o nazwie PlotData .

Wynik oceny

Zwrot z przebiegu oceny to tfma.EvalResult . Ten rekord zawiera slicing_metrics , które kodują klucz metryki jako wielopoziomowy zapis, w którym poziomy odpowiadają odpowiednio nazwie danych wyjściowych, identyfikatorowi klasy, nazwie metryki i wartości metryki. Jest to przeznaczone do wyświetlania interfejsu użytkownika w notebooku Jupiter. Jeśli potrzebny jest dostęp do danych bazowych, zamiast tego należy użyć pliku wyników metrics (patrz metrics_for_slice.proto ).

Dostosowywanie

Oprócz metryk niestandardowych, które są dodawane jako część zapisanych keras (lub starszego modelu EvalSavedModel). Istnieją dwa sposoby dostosowywania metryk podczas zapisywania danych TFMA: (1) definiując niestandardową klasę metryk keras i (2) definiując niestandardową klasę metryk TFMA wspieraną przez łącznik belek.

W obu przypadkach metryki są konfigurowane przez określenie nazwy klasy metryki i powiązanego modułu. Na przykład:

from google.protobuf import text_format

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

Niestandardowe metryki Keras

Aby utworzyć niestandardową metrykę keras, użytkownicy muszą rozszerzyć tf.keras.metrics.Metric o swoją implementację, a następnie upewnić się, że moduł metryki jest dostępny w czasie oceny.

Należy zauważyć, że w przypadku metryk dodanych po zapisaniu modelu TFMA obsługuje tylko metryki, które przyjmują etykietę (tj. y_true), predykcję (y_pred) i przykładową wagę (sample_weight) jako parametry metody update_state .

Przykład metryczny Keras

Poniżej znajduje się przykład niestandardowego wskaźnika keras:

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)

Niestandardowe metryki TFMA

Aby utworzyć niestandardową metrykę TFMA, użytkownicy muszą rozszerzyć tfma.metrics.Metric wraz ze swoją implementacją, a następnie upewnić się, że moduł metryki jest dostępny w czasie oceny.

Metryczny

Implementacja tfma.metrics.Metric składa się z zestawu kwarg, które definiują konfigurację metryk wraz z funkcją tworzenia obliczeń (ewentualnie wielu) potrzebnych do obliczenia wartości metryki. Istnieją dwa główne typy obliczeń, których można użyć: tfma.metrics.MetricComputation i tfma.metrics.DerivedMetricComputation , które opisano w poniższych sekcjach. Funkcja, która tworzy te obliczenia, otrzyma jako dane wejściowe następujące parametry:

• eval_config: tfam.EvalConfig
  • Konfiguracja eval przekazana do ewaluatora (przydatna do wyszukiwania ustawień specyfikacji modelu, takich jak klucz przewidywania do użycia itp.).
• model_names: List[Text]
  • Lista nazw modeli do obliczenia metryk (Brak w przypadku jednego modelu)
• output_names: List[Text] .
  • Lista nazw danych wyjściowych do obliczenia metryk (Brak w przypadku pojedynczego modelu)
• sub_keys: List[tfma.SubKey] .
  • Lista kluczy podrzędnych (identyfikator klasy, górne K itp.) do obliczania metryk dla (lub brak)
• aggregation_type: tfma.AggregationType
  • Typ agregacji w przypadku obliczania metryki agregacji.
• class_weights: Dict[int, float] .
  • Wagi klas, które mają być używane podczas obliczania metryki agregacji.
• query_key: Text
  • Klucz zapytania używany podczas obliczania metryki opartej na zapytaniu/rankingu.

Jeśli metryka nie jest powiązana z co najmniej jednym z tych ustawień, może pozostawić te parametry poza definicją sygnatury.

Jeśli metryka jest obliczana w ten sam sposób dla każdego modelu, wyjścia i klucza podrzędnego, wówczas narzędzie tfma.metrics.merge_per_key_computations może być użyte do wykonania tych samych obliczeń dla każdego z tych danych wejściowych oddzielnie.

Obliczenia metryczne

MetricComputation składa się z kombinacji preprocessors i combiner . preprocessors to lista preprocessor , która jest beam.DoFn , która przyjmuje wyciągi jako dane wejściowe i wyprowadza stan początkowy, który będzie używany przez program łączący (więcej informacji na temat tego, czym są wyciągi, można znaleźć w architekturze ). Wszystkie preprocesory będą wykonywane sekwencyjnie w kolejności na liście. Jeśli preprocessors są puste, sumator zostanie przekazany StandardMetricInputs (standardowe dane wejściowe metryki zawierają etykiety, prognozy i wagi_przykładów). beam.CombineFn combiner która pobiera krotkę (slice key, wyjście preprocesora) jako dane wejściowe i wyprowadza krotkę (slice_key, metric Results dict) jako wynik.

Należy zauważyć, że cięcie odbywa się między preprocessors a combiner łączącym.

Zauważ, że jeśli obliczenie metryki chce wykorzystać oba standardowe dane wejściowe metryki, ale rozszerzyć je o kilka cech z ekstraktów features , to można użyć specjalnego FeaturePreprocessora , który połączy żądane cechy z wielu sumatorów w jeden wspólna wartość StandardMetricsInputs, która jest przekazywana do wszystkich sumatorów (kombinatory są odpowiedzialne za odczytanie interesujących ich cech i ignorowanie reszty).

Przykład

Poniżej znajduje się bardzo prosty przykład definicji metryki TFMA do obliczania 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],
          preprocessors=[_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}

Pochodne obliczenia metryczne

DerivedMetricComputation składa się z funkcji wyniku, która jest używana do obliczania wartości metryki na podstawie danych wyjściowych innych obliczeń metryki. Funkcja wyniku pobiera dyktando obliczonych wartości jako dane wejściowe i wyprowadza dyktando wyników dodatkowych metryk.

Należy zauważyć, że dopuszczalne (zalecane) jest uwzględnienie obliczeń, od których zależy obliczenie pochodne, na liście obliczeń tworzonych przez metrykę. Pozwala to uniknąć konieczności wstępnego tworzenia i przekazywania obliczeń, które są współużytkowane przez wiele metryk. Ewaluator automatycznie usunie zduplikowane obliczenia, które mają tę samą definicję, więc faktycznie zostanie uruchomione tylko jedno obliczenie.

Przykład

Metryki TJUR stanowią dobry przykład metryk pochodnych.