Metryki i wykresy analizy modelu Tensorflow

Przegląd

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

  • Standardowe Keras metryk ( 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 TFMA metryki i działki ( tfma.metrics.* )

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

  • Niestandardowe TFMA (metryki pochodzące z tfma.metrics.Metric ) za pomocą wiązki zwrotnice zwyczaj lub dane pochodzące z innych danych).

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

  • Binaryzacja na podstawie identyfikatora klasy, top K itp.
  • Zagregowane dane na podstawie uśredniania mikro, uśredniania 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 wskaźników i wykresów dla różnych problemów, w tym regresji, klasyfikacji binarnej, klasyfikacji wieloklasowej/wieloetykietowej, rankingu itp.

Konfiguracja

Istnieją dwa sposoby, aby skonfigurować w TFMA danych: (1) za pomocą tfma.MetricsSpec lub (2), poprzez utworzenie wystąpień tf.keras.metrics.* i / lub tfma.metrics.* Klas w pytona i za pomocą tfma.metrics.specs_from_metrics konwertować je do listy 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 konfiguracji dla problemu z regresją. Skonsultować się z tf.keras.metrics.* I tfma.metrics.* Moduły dla ewentualnych dodatkowych metryk obsługiwane.

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ć za pomocą 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 dla problemu z klasyfikacją binarną. Skonsultować się z tf.keras.metrics.* I tfma.metrics.* Moduły dla ewentualnych dodatkowych metryk obsługiwane.

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ć za pomocą 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 wieloklasowej/wieloetykietowej

Poniżej znajduje się przykładowa konfiguracja konfiguracji dla problemu klasyfikacji wieloklasowej. Skonsultować się z tf.keras.metrics.* I tfma.metrics.* Moduły dla ewentualnych dodatkowych metryk obsługiwane.

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ć za pomocą 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)

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

Binarne metryki wieloklasowe/wieloetykietowe

Multi-Klasa / multi-label metryki można binaryzowany produkować metryk w klasie, za top_k itp używając 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ć za pomocą 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]}))

Metryki agregatów dla wielu klas/wielu etykiet

Metryki multi-klasa / multi-label mogą być łączone w celu wytworzenia pojedynczej zagregowaną wartość dla klasyfikacji binarnej metrycznym za pomocą tfma.AggregationOptions .

Należy pamiętać, że ustawienia są niezależne od agregacji binaryzacji ustawień, dzięki czemu można korzystać z obu tfma.AggregationOptions i tfma.BinarizationOptions w tym samym czasie.

Średnia mikro

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

Micro uśredniania obsługuje również ustawienie top_k gdzie tylko najlepszej wartości k są używane w obliczeniach. 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]}))

Makro / ważona średnia makro

Makro uśredniania można wykonać przy pomocy macro_average lub weighted_macro_average opcje ciągu tfma.AggregationOptions . Chyba top_k są używane ustawienia, makro wymaga ustawiania class_weights aby wiedzieć, które klasy obliczyć średnią dla. Jeśli class_weight nie jest wtedy 0,0 zakładano. 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ć 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(
        macro_average=True, class_weights={i: 1.0 for i in range(10)}))

Jak uśrednianie mikro, makro uśredniania obsługuje również ustawienie top_k gdzie tylko najlepszej wartości k są używane w obliczeniach. 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ć 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(macro_average=True,
                                      top_k_list={'values': [1, 3]}))

Wskaźniki oparte na zapytaniach / rankingach

Query / Ranking metryki oparte są włączone, określając query_key opcję metryk specyfikacji. 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ć za pomocą 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')

Wielomodelowe metryki oceny

TFMA wspiera ewaluację wielu modeli jednocześnie. W przypadku przeprowadzania oceny wielomodelowej 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żeli dane muszą być obliczane dla podzbioru modeli ustaw model_names w tej 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ż przechodzącej nazwy modeli:

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

Metryki porównawcze modeli

TFMA obsługuje ocenę metryk porównawczych dla modelu kandydującego z modelem podstawowym. Prostym sposobem na skonfigurowanie 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ównania są obliczane automatycznie dla wszystkich metryk z możliwością różnicowania (obecnie tylko metryki wartości skalarnych, takie jak dokładność i AUC).

Metryki modelu wielowyjściowego

TFMA obsługuje ocenę metryk w modelach, które mają różne wyniki. Modele wielowyjściowe przechowują swoje prognozy wyjściowe w formie dyktatu z kluczem według nazwy wyjściowej. 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ż przechodzącej nazwy wyjściowych:

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

Dostosowywanie ustawień metryk

TFMA umożliwia dostosowanie ustawień używanych z różnymi metrykami. Na przykład może chcesz zmienić nazwę, ustalonych progów itp Odbywa się to poprzez dodanie config sekcję do config metrycznym. Config określa się w postaci łańcucha JSON parametrów, które mają być przekazane do metryki __init__ metodą (na łatwość użycia natarcia i spływu „{” oraz „}”, wsporniki mogą być pominięte). 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

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

Klucze metryczne

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

  • Metric nazwisko ( auc , mean_label , etc)
  • Nazwa modelu (używana tylko w przypadku oceny wielomodelowej)
  • Nazwa wyjścia (używana tylko wtedy, gdy oceniane są modele z wieloma wyjściami)
  • Klucz podrzędny (np. identyfikator klasy, jeśli model wieloklasowy jest zbinaryzowany)

Wartość metryki

MetricValues są zdefiniowane przy użyciu proto że encapulates różne rodzaje obsługiwanej przez różne dane (na przykład double , ConfusionMatrixAtThresholds itp).

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

  • double_value - owinięcie na podwójne typu.
  • bytes_value - bajty wartość.
  • bounded_value - przedstawia rzeczywistą wartość, która może być oszacowaniem punktowo, ewentualnie w przybliżonych granicach pewnego rodzaju. Posiada właściwości value , lower_bound i upper_bound .
  • value_at_cutoffs - Value at odcięcia (np precyzja @ K @ K recall). Ma własności values , z których każdy posiada właściwości cutoff oraz value .
  • confusion_matrix_at_thresholds - matryca dezorientacji progów. Ma właściwości matrices , z których każda posiada właściwości threshold , precision , recall i wartości macierzy błędów, takich jak false_negatives .
  • array_value - dla danych powracających tablicę wartości.

Klawisze działki

PlotKeys są podobne do kluczy metrycznych chyba że ze względów historycznych wszystkie wartości działki są przechowywane w jednym proto więc kluczem działka nie ma nazwy.

Wykres wartości

Wszystkie obsługiwane Działki są przechowywane w jednym proto zwanego PlotData .

Wynik oceny

Zwrot z przebiegu ewaluacji jest tfma.EvalResult . Ta płyta zawiera slicing_metrics które kodują klucz metryczny jako dict wielopoziomowego, gdzie poziomy odpowiadają nazwy wyjścia, klasa ID, nazwy i wartości metrycznych, metrycznych odpowiednio. Jest to przeznaczone do wyświetlania interfejsu użytkownika w notebooku Jupiter. Jeżeli dostęp do danych źródłowych jest potrzebne metrics wynikają plik powinien być stosowany zamiast (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 w zapisie TFMA: (1) przez zdefiniowanie niestandardowej klasy metryk keras oraz (2) przez zdefiniowanie niestandardowej klasy metryk TFMA wspieranej przez moduł łączenia wiązki.

W obu przypadkach metryki są konfigurowane przez określenie nazwy klasy metryki i skojarzonego 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ć niestandardowy Keras metryczny, użytkownicy muszą przedłużyć tf.keras.metrics.Metric z ich wdrożenia, a następnie upewnij się, że moduł metryka jest dostępna w czasie oceny.

Należy pamiętać, że dla metryk dodanych po modelu oszczędzania, TFMA obsługuje tylko dane, które mają etykietę (tj y_true), przewidywania (y_pred), a przykładem waga (sample_weight) jako parametry do update_state metody.

Przykład metryczny Keras

Oto 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ą TFMA metryczny, użytkownicy muszą przedłużyć tfma.metrics.Metric z ich wdrożenia, a następnie upewnij się, że moduł metryka jest dostępna w czasie oceny.

Metryczny

tfma.metrics.Metric realizacja składa się z zestawu kwargs określających konfigurację metryki wraz z funkcją tworzenia obliczeń (ewentualnie kilka) potrzebne do calcuate wartość metryki. Istnieją dwa główne rodzaje obliczeń, które mogą być stosowane: tfma.metrics.MetricComputation i tfma.metrics.DerivedMetricComputation , które są opisane w poniższych sekcjach. Funkcja, która tworzy te obliczenia, otrzyma jako dane wejściowe następujące parametry:

  • eval_config: tfam.EvalConfig
    • Konfiguracja oceny przekazana do oceniającego (przydatna do wyszukiwania ustawień specyfikacji modelu, takich jak klucz przewidywania do użycia itp.).
  • model_names: List[Text]
    • Lista nazw modeli do obliczania metryk (Brak w przypadku jednego modelu)
  • output_names: List[Text] .
    • Lista nazw danych wyjściowych do obliczania metryk (Brak w przypadku pojedynczego modelu)
  • sub_keys: List[tfma.SubKey] .
    • Lista kluczy podrzędnych (identyfikator klasy, top K itp.) do obliczania metryk (lub Brak)
  • aggregation_type: tfma.AggregationType
    • Typ agregacji w przypadku obliczania metryki agregacji.
  • class_weights: Dict[int, float] .
    • Wagi klas do użycia 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ą podpisu.

Jeśli metryka jest obliczana w ten sam sposób dla każdego modelu, wyjściowego i klucz sub, następnie użytkowych tfma.metrics.merge_per_key_computations może być używany do wykonywania tych samych obliczeń dla każdej z tych wejść osobno.

Obliczanie metryczne

MetricComputation składa się z kombinacji preprocessor oraz combiner . preprocessor jest beam.DoFn że trwa ekstraktów jako wejścia i wyjścia stanu początkowego, który będzie używany przez sumator (patrz architekturę uzyskać więcej informacji na temat jakie są wyciągi). Jeśli preprocessor nie jest zdefiniowana, to sumator zostanie przekazany StandardMetricInputs (Standard wejścia metrycznych zawiera etykiety, prognoz oraz example_weights). 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.

Zauważ, że krojenie dzieje między preprocessor i combiner .

Zauważ, że jeśli metryki obliczenie chce skorzystać zarówno standardowych wejść metrycznych, ale rozszerzyć go kilka cech z features ekstraktów, wówczas specjalny FeaturePreprocessor można stosować które połączą żądane funkcje z wielu elementów łączących w jeden współdzieloną wartość StandardMetricsInputs, która jest przekazywana do wszystkich łączników (łączacze 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: 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}

Obliczenie pochodnej metryczne

DerivedMetricComputation składa się z funkcji wynikowej, która jest używana do obliczania wartości metryki oparte na wyjściu innych obliczeń metrycznych. Funkcja wyniku pobiera dyktat obliczonych wartości jako dane wejściowe i wyprowadza dykt 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ń utworzonych przez metrykę. Pozwala to uniknąć konieczności wstępnego tworzenia i przekazywania obliczeń, które są współużytkowane przez wiele metryk. Oceniający automatycznie usunie duplikaty obliczeń, które mają tę samą definicję, więc tylko jedno obliczenie zostanie uruchomione.

Przykład

Te dane TJUR stanowi dobry przykład danych pochodzących.