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, bezpośrednio przy użyciu 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 sumatorów wiązek lub metryk pochodzących z innych metryk).

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

  • Binaryzacja oparta na identyfikatorze klasy, górnym K itp.
  • Zagregowane metryki oparte na mikrouśrednianiu, makrouśrednianiu itp.

TFMA zapewnia także wbudowaną obsługę metryk opartych na zapytaniach/rankingach, gdzie przykłady są automatycznie grupowane w potoku według klucza zapytania.

W sumie dostępnych jest ponad 50 standardowych metryk i wykresów dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wielu klas/wieloetykiet, rankingów itp.

Konfiguracja

Istnieją dwa sposoby konfigurowania metryk w TFMA: (1) przy użyciu tfma.MetricsSpec lub (2) tworząc instancje klas 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 znajduje się przykładowa konfiguracja problemu regresji. Sprawdź moduły tf.keras.metrics.* i tfma.metrics.* aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.

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)

Należy pamiętać, że tę konfigurację można również uzyskać, wywołując tfma.metrics.default_regression_specs .

Metryki klasyfikacji binarnej

Poniżej znajduje się przykładowa konfiguracja konfiguracji problemu klasyfikacji binarnej. Sprawdź moduły tf.keras.metrics.* i tfma.metrics.* aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.

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)

Należy pamiętać, że tę konfigurację można również uzyskać, wywołując tfma.metrics.default_binary_classification_specs .

Metryki klasyfikacji wieloklasowej/wieloetykietowej

Poniżej znajduje się przykładowa konfiguracja konfiguracji dla problemu klasyfikacji wieloklasowej. Sprawdź moduły tf.keras.metrics.* i tfma.metrics.* aby uzyskać informacje na temat możliwych dodatkowych obsługiwanych metryk.

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)

Należy pamiętać, że tę konfigurację można również uzyskać, wywołując tfma.metrics.default_multi_class_classification_specs .

Metryki binarne dla wielu klas i wielu etykiet

Metryki obejmujące wiele klas/wiele etykiet można binaryzować w celu utworzenia metryk według klasy, top_k itp. przy użyciu metody 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 i wielu etykiet

Metryki wielu klas/wiele etykiet można agregować w celu utworzenia pojedynczej 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, dlatego można jednocześnie używać zarówno tfma.AggregationOptions , jak i tfma.BinarizationOptions .

Mikro średnia

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 , gdzie w obliczeniach używane są tylko górne wartości k. 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]}))

Makro / Średnia ważona makro

Uśrednianie makro można wykonać przy użyciu opcji macro_average lub weighted_macro_average w ramach tfma.AggregationOptions . O ile nie są używane ustawienia top_k , makro wymaga ustawienia class_weights , aby wiedzieć, dla których klas obliczyć średnią. Jeśli nie podano class_weight , przyjmuje się 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 mikrouśrednianie, uśrednianie makro obsługuje również ustawienie top_k , gdzie w obliczeniach używane są tylko górne 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/rankingu

Metryki oparte na zapytaniach/rankingach można włączyć, określając opcję 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. Jeśli 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 trzeba obliczyć metryki 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 wspiera ocenę metryk porównawczych dla modelu kandydującego z modelem bazowym. Prostym sposobem skonfigurowania pary modelu kandydującego i modelu bazowego jest przekazanie modelu 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, które można różnicować (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).

Metryki modelu wielowyjściowego

TFMA obsługuje ocenę metryk modeli, które mają różne wyniki. Modele z wieloma wyjściami przechowują swoje przewidywania wyników w formie słownika oznaczonego nazwą wyjścia. W przypadku stosowania modeli z wieloma wynikami nazwy wyników powiązane z zestawem metryk muszą zostać określone w sekcji output_names specyfikacji 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 wyjściowych: 

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

Dostosowywanie ustawień metryk

TFMA umożliwia dostosowywanie ustawień używanych z różnymi metrykami. Na przykład możesz chcieć zmienić nazwę, ustawić progi itp. Można to zrobić, dodając sekcję config do konfiguracji metryki. Konfiguracja jest określana przy użyciu wersji ciągu JSON parametrów, która zostanie przekazana do metody metryki __init__ (dla ułatwienia można pominąć początkowe i końcowe nawiasy „{” 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 również 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

Dane wyjściowe oceny metryki to seria kluczy/wartości metrycznych i/lub kluczy/wartości wykresu w oparciu o zastosowaną konfigurację.

Klucze metryczne

MetricKeys są definiowane przy użyciu typu klucza strukturalnego. Klucz ten 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 wyniku (używana tylko wtedy, gdy oceniane są modele z wieloma wynikami)
  • Klucz podrzędny (np. identyfikator klasy, jeśli model wieloklasowy jest binarny)

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 double.
  • bytes_value — wartość w bajtach.
  • bounded_value — reprezentuje wartość rzeczywistą, która może być oszacowaniem punktowym, opcjonalnie z pewnego rodzaju 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, wycofanie@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. Posiada matrices właściwości, z których każda ma właściwości dla wartości threshold , precision , recall i nieporozumień, takich jak false_negatives .
  • array_value — dla metryk zwracających tablicę wartości.

Klucze fabuły

PlotKeys są podobne do kluczy metrycznych, z tą różnicą, ż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łki

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

Wynik oceny

Wynik z przebiegu ewaluacyjnego to tfma.EvalResult . Ten rekord zawiera slicing_metrics , które kodują klucz metryki jako wielopoziomowy słownik, w którym poziomy odpowiadają odpowiednio nazwie wyjściowej, identyfikatorowi klasy, nazwie metryki i wartości metryki. Ma to służyć 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 (zobacz metrics_for_slice.proto ).

Personalizacja

Oprócz niestandardowych metryk dodawanych w ramach zapisanych keras (lub starszego modelu EvalSavedModel). Istnieją dwa sposoby dostosowywania metryk w zapisie końcowym TFMA: (1) poprzez zdefiniowanie niestandardowej klasy metryki keras i (2) poprzez zdefiniowanie niestandardowej klasy metryk TFMA wspieranej przez moduł łączenia wiązek.

W obu przypadkach metryki konfiguruje się poprzez 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 momencie oceny.

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

Przykład metryki Kerasa

Poniżej znajduje się przykład niestandardowej metryki 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 wskaźniki TFMA

Aby utworzyć niestandardową metrykę TFMA, użytkownicy muszą rozszerzyć tfma.metrics.Metric o 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ów definiujących konfigurację metryk wraz z funkcją tworzenia obliczeń (ewentualnie wielu) potrzebnych do obliczenia wartości metryk. Można zastosować dwa główne typy obliczeń: tfma.metrics.MetricComputation i tfma.metrics.DerivedMetricComputation , które opisano w poniższych sekcjach. Do funkcji tworzącej te obliczenia zostaną przekazane następujące parametry jako dane wejściowe:

  • eval_config: tfam.EvalConfig
    • Konfiguracja eval przekazana do oceniającego (przydatna do wyszukiwania ustawień specyfikacji modelu, takich jak klucz przewidywania, którego należy użyć itp.).
  • model_names: List[Text]
    • Lista nazw modeli, dla których obliczane są metryki (brak w przypadku pojedynczego modelu)
  • output_names: List[Text] .
    • Lista nazw wyników, dla których obliczane są metryki (brak w przypadku pojedynczego modelu)
  • sub_keys: List[tfma.SubKey] .
    • Lista podkluczy (identyfikator klasy, górne K itp.), dla których obliczane są metryki (lub Brak)
  • aggregation_type: tfma.AggregationType
    • Typ agregacji w przypadku obliczania metryki agregacji.
  • class_weights: Dict[int, float] .
    • Wagi klas używane przy obliczaniu metryki agregacji.
  • query_key: Text
    • Klucz zapytania używany podczas obliczania metryki opartej na zapytaniu/rankingu.

Jeśli metryka nie jest powiązana z jednym lub większą liczbą tych ustawień, może pozostawić te parametry poza definicją sygnatury.

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

Obliczenia metryczne

MetricComputation składa się z kombinacji preprocessors i combiner . preprocessors to lista preprocessor , która jest beam.DoFn , która pobiera ekstrakty jako dane wejściowe i wyprowadza stan początkowy, który będzie używany przez sumator (zobacz architekturę , aby uzyskać więcej informacji o tym, czym są ekstrakty). Wszystkie preprocesory zostaną wykonane sekwencyjnie w kolejności podanej na liście. Jeśli preprocessors są puste, do sumatora zostaną przesłane StandardMetricInputs (standardowe dane wejściowe metryki zawierają etykiety, przewidywania i przykładowe wagi). combiner jest beam.CombineFn , która jako dane wejściowe pobiera krotkę (klucz plasterka, wyjście preprocesora) i jako wynik wyprowadza krotkę (klucz_plasterka, wynik metryki).

Zauważ, że cięcie odbywa się pomiędzy preprocessors i combiner .

Należy zauważyć, że jeśli obliczenia metryczne chcą wykorzystać oba standardowe dane wejściowe metryczne, ale rozszerzyć je o kilka funkcji z ekstraktów features , wówczas można użyć specjalnego FeaturePreprocessor , który połączy żądane cechy z wielu sumatorów w jeden wspólna wartość StandardMetricsInputs, która jest przekazywana do wszystkich sumatorów (sumatory są odpowiedzialne za odczytywanie interesujących ich funkcji i ignorowanie reszty).

Przykład

Poniżej znajduje się bardzo prosty przykład definicji metryki TFMA do obliczania NumberCount: 

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 ExampleCountTest(tfma.test.testutil.TensorflowModelAnalysisTest):

  def testExampleCount(self):
    metric = ExampleCount()
    computations = metric.computations(example_weighted=False)
    computation = computations[0]

    with beam.Pipeline() as pipeline:
      result = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'PreProcess' >> beam.ParDo(computation.preprocessors[0])
          | 'Process' >> beam.Map(tfma.metrics.to_standard_metric_inputs)
          | 'AddSlice' >> beam.Map(lambda x: ((), x))
          | 'ComputeMetric' >> beam.CombinePerKey(computation.combiner)
      )

      def check_result(got):
        try:
          self.assertLen(got, 1)
          got_slice_key, got_metrics = got[0]
          self.assertEqual(got_slice_key, ())
          key = computation.keys[0]
          self.assertIn(key, got_metrics)
          self.assertAlmostEqual(got_metrics[key], expected_value, places=5)
        except AssertionError as err:
          raise util.BeamAssertException(err)

      util.assert_that(result, check_result, label='result')

class _ExampleCountPreprocessor(beam.DoFn):

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


class _ExampleCountPreprocessorTest(unittest.TestCase):

  def testExampleCountPreprocessor(self):
    ...  # Init the test case here
    with beam.Pipeline() as pipeline:
      updated_pcoll = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'Preprocess'
          >> beam.ParDo(
              _ExampleCountPreprocessor()
          )
      )

      beam_testing_util.assert_that(
          updated_pcoll,
          lambda result: ...,  # Assert the test case
      )


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}

Obliczenia pochodne

DerivedMetricComputation składa się z funkcji wynikowej, która służy do obliczania wartości metryki na podstawie danych wyjściowych innych obliczeń metryki. Funkcja wyniku przyjmuje na wejściu dyktat obliczonych wartości i generuje wynik dodatkowych wyników metryki.

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ółdzielone przez wiele metryk. Osoba oceniająca automatycznie usunie duplikat obliczeń o tej samej definicji, tak aby faktycznie zostało przeprowadzone tylko jedno obliczenie.

Przykład

Metryki TJUR stanowią dobry przykład metryk pochodnych.