Metryki i wykresy analizy modelu Tensorflow

Przegląd

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

• Standardowe metryki tf.keras.metrics.* ( tf.keras.metrics.* )
  • Pamiętaj, że nie potrzebujesz modelu keras, aby używać metryk keras. Metryki są obliczane poza wykresem w belce przy użyciu bezpośrednio klas metryk.

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

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

• Niestandardowe metryki TFMA (metryki pochodzące z tfma.metrics.Metric ) przy użyciu niestandardowych tfma.metrics.Metric 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 na podstawie identyfikatora klasy, najwyższego K itp.
• Zagregowane wskaźniki 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.

W połączeniu istnieje ponad 50+ standardowych wskaźników i wykresów dostępnych dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wieloklasowej / wieloznakowej, rankingu itp.

Konfiguracja

Istnieją dwa sposoby konfigurowania metryk w TFMA: (1) za pomocą tfma.MetricsSpec lub (2) poprzez utworzenie instancji tf.keras.metrics.* I / lub tfma.metrics.* W Pythonie i użycie 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ę problemu z regresją. Sprawdź 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: "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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:

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)

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ę dotyczącą problemu z klasyfikacją binarną. Sprawdź 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: "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

Tę samą konfigurację można utworzyć przy użyciu następującego kodu w języku Python:

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)

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

Wieloklasowe / wieloznakowe metryki klasyfikacji

Poniżej przedstawiono przykładową konfigurację dla problemu klasyfikacji wieloklasowej. Sprawdź 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: "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

Tę samą konfigurację można utworzyć za pomocą następującego kodu w języku Python:

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)

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

Metryki binaryzowane dla wielu klas / wielu etykiet

Metryki wieloklasowe / wieloznakowe można binaryzować w celu uzyskania metryk według klasy, top_k itp. 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 w języku Python:

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

Wieloklasowe / wieloznakowe wskaźniki zagregowane

Metryki wielu klas / wielu etykiet można agregować w celu uzyskania pojedynczej zagregowanej wartości dla metryki klasyfikacji binarnej przy użyciu tfma.AggregationOptions .

Pamiętaj, że ustawienia agregacji są niezależne od ustawień binaryzacji, więc możesz używać jednocześnie tfma.AggregationOptions i tfma.BinarizationOptions .

Micro Average

Micro uśredniania można wykonać za pomocą micro_average opcję 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 w języku Python:

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

Uśrednianie mikro obsługuje również ustawienie top_k 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: {
      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ć za pomocą 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 przeprowadzić za pomocą opcji macro_average lub weighted_macro_average w tfma.AggregationOptions . O ile nie są używane ustawienia top_k , makro wymaga ustawienia class_weights , aby wiedzieć, dla których klas ma obliczyć średnią. Jeśli nie podano class_weight przyjmuje się 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 w języku Python:

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 mikro-uśrednianie, uśrednianie makr obsługuje również ustawienie top_k którym 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 w języku Python:

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 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 w języku Python:

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

Wskaźniki oceny wielu modeli

TFMA obsługuje ocenę wielu modeli w tym samym czasie. W przypadku oceny 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, należy ustawić model_names w parametrze 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

specs_from_metrics API 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 względem modelu bazowego. Prostym sposobem skonfigurowania pary modeli kandydata i linii bazowej 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/candiate/model',
      eval_config=eval_config),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path='/path/to/saved/baseline/model',
      eval_config=eval_config),
]

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 możliwych do porównania metryk (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).

Wielowyjściowe metryki modelu

TFMA obsługuje ocenę metryk w modelach, które mają różne wyniki. Modele wielowyjściowe przechowują prognozy wyjściowe w postaci dyktowania według nazwy wyjścia. Gdy stosowane są wielo-wyjściowe modelu, nazwy wyjść związanych z zestawem wskaźników muszą być określone w output_names części 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

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

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

Dostosowywanie ustawień danych

TFMA umożliwia dostosowywanie ustawień używanych 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ślana przy użyciu ciągów JSON w wersji parametrów, które zostaną przekazane do metody __init__ metryk (dla ułatwienia użycia 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

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

Klucze metryczne

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

• Metric nazwisko ( auc , mean_label , etc)
• Nazwa modelu (używana tylko w przypadku oceny wielu modeli)
• Nazwa wyniku (używana tylko wtedy, gdy oceniane są modele wielowyjściowe)
• Podklucz (np. Identyfikator klasy, jeśli model wieloklasowy jest zbinaryzowany)

Wartość metryczna

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

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

• double_value - opakowanie dla typu double.
• bytes_value - wartość w bajtach.
• bounded_value - reprezentuje rzeczywistą wartość, która może być oszacowaniem punktowym, opcjonalnie z przybliżonymi granicami pewnego rodzaju. Ma właściwości value , lower_bound i upper_bound .
• value_at_cutoffs - Wartość przy odcięciach (np. precyzja @ K, przywracanie @ K). Ma values właściwości, z których każda ma value cutoff i value właściwości.
• confusion_matrix_at_thresholds - macierz nieporozumień przy progach. Ma matrices właściwości, z których każda ma właściwości threshold , precision , recall i wartości macierzy pomyłki, takie jak false_negatives .
• array_value - dla metryk zwracających tablicę wartości.

Klucze działki

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 protokole, więc klucz wykresu nie ma nazwy.

Wykres wartości

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

EvalResult

Wynik z przebiegu oceny to tfma.EvalResult . Ten rekord zawiera slicing_metrics które kodują klucz metryki jako slicing_metrics wielopoziomowe, gdzie poziomy odpowiadają odpowiednio nazwie wyjściowej, identyfikatorze klasy, nazwie metryki i wartości metryki. Jest przeznaczony do wyświetlania interfejsu użytkownika w notebooku Jupiter. Jeśli potrzebny jest dostęp do danych źródłowych, należy zamiast tego użyć pliku wyników metrics (patrz metrics_for_slice.proto ).

Dostosowywanie

Oprócz niestandardowych metryk, które są dodawane jako część zapisanych keras (lub starszej wersji EvalSavedModel). Istnieją dwa sposoby dostosowania metryk w zapisywaniu postu TFMA: (1) przez zdefiniowanie niestandardowej klasy metryki keras i (2) przez zdefiniowanie niestandardowej klasy metryk TFMA wspartej przez łącznik wiązek.

W obu przypadkach metryki konfiguruje się, określając nazwę klasy metryki i skojarzonego z nią 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 dane Keras

Aby utworzyć niestandardową metrykę keras, użytkownicy muszą rozszerzyć tf.keras.metrics.Metric o ich 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 danych Keras

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 metryki TFMA

Aby utworzyć niestandardową metrykę TFMA, użytkownicy muszą rozszerzyć tfma.metrics.Metric o ich 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 kwargs, które definiują konfigurację metryk, wraz z funkcją do tworzenia obliczeń (prawdopodobnie 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 zostały opisane w poniższych sekcjach. Funkcja, która tworzy te obliczenia, otrzyma następujące parametry jako dane wejściowe:

• eval_config: tfam.EvalConfig
  • Konfiguracja eval przekazana do oceniającego (przydatne do wyszukiwania ustawień specyfikacji modelu, takich jak klucz prognozy do użycia itp.).
• model_names: List[Text]
  • Lista nazw modeli, dla których mają zostać obliczone metryki (brak w przypadku jednego modelu)
• output_names: List[Text] .
  • Lista nazw wyjściowych, dla których mają zostać obliczone metryki (brak w przypadku jednego modelu)
• sub_keys: List[tfma.SubKey] .
  • Lista kluczy podrzędnych (identyfikator klasy, górne K itp.) Do obliczenia metryk dla (lub Brak)
• aggregation_type: tfma.AggregationType
  • Typ agregacji w przypadku obliczania metryki agregacji.
• class_weights: Dict[int, float] .
  • Wagi klas do użycia w przypadku 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 swoją definicją sygnatury.

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

MetricComputation

MetricComputation składa się z kombinacji preprocessor i combiner . preprocessor to beam.DoFn który pobiera ekstrakty jako dane wejściowe i wyświetla stan początkowy, który będzie używany przez sumator (więcej informacji na temat tego, czym są ekstrakty, znajduje się w architekturze ). Jeśli preprocessor nie jest zdefiniowany, to do sumatora zostanie przekazany StandardMetricInputs (standardowe dane wejściowe metryki zawierają etykiety, prognozy i przykładowe wagi). combiner jest beam.CombineFn że trwa krotka (klawisz plaster wyjściowy preprocesor) jako wejścia i wyjścia krotka (slice_key, wyniki metryczne dict) jako jej wynik.

Zwróć uwagę, że dzielenie odbywa się między preprocessor a combiner .

Zwróć uwagę, że jeśli obliczenia metryczne chcą korzystać z obu standardowych danych wejściowych metryki, ale rozszerzyć je o kilka funkcji z ekstraktów features , można użyć specjalnego narzędzia FeaturePreprocessor, który połączy żądane funkcje z wielu kombinatorów w jeden wspólna wartość StandardMetricsInputs, która jest przekazywana do wszystkich łączników (kombinatory są odpowiedzialne za odczytywanie interesujących ich funkcji i ignorowanie pozostałych).

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],
          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: List[int]) -> int:
    result = 0
    for accumulator in accumulators:
      result += accumulator
    return result

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

DerivedMetricComputation

DerivedMetricComputation składa się z funkcji DerivedMetricComputation używanej do obliczania wartości metryki na podstawie danych wyjściowych innych obliczeń metryki. Funkcja result pobiera dyktowanie obliczonych wartości jako dane wejściowe i generuje dyktowanie dodatkowych wyników metryki.

Należy zauważyć, że dopuszczalne (zalecane) jest uwzględnienie obliczeń, od których zależy wyliczenie pochodne, na liście obliczeń utworzonych 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 obliczenia, które mają taką samą definicję, więc tylko jedno obliczenie jest faktycznie wykonywane.

Przykład

Metryki TJUR stanowią dobry przykład metryk pochodnych.