Метрики и графики анализа модели Tensorflow

Обзор

TFMA поддерживает следующие показатели и графики:

  • Стандартные метрики кераса ( tf.keras.metrics.* )
    • Обратите внимание, что для использования метрик keras вам не нужна модель keras. Метрики вычисляются вне графика в луче с использованием непосредственно классов метрик.

  • Стандартные метрики и графики TFMA ( tfma.metrics.* )

  • Пользовательские метрики keras (метрики, полученные из tf.keras.metrics.Metric )

  • Пользовательские метрики TFMA (метрики, полученные из tfma.metrics.Metric ) с использованием пользовательских объединителей лучей или метрики, полученные из других метрик).

TFMA также предоставляет встроенную поддержку преобразования метрик двоичной классификации для использования в задачах с несколькими классами и несколькими метками:

  • Бинаризация на основе идентификатора класса, вершины K и т. д.
  • Агрегированные показатели на основе микроусреднения, макроусреднения и т. д.

TFMA также предоставляет встроенную поддержку метрик на основе запросов/ранжирования, где примеры автоматически группируются по ключу запроса в конвейере.

В совокупности существует более 50+ стандартных показателей и графиков, доступных для различных задач, включая регрессию, бинарную классификацию, классификацию по нескольким классам/мультиметкам, ранжирование и т. д.

Конфигурация

Существует два способа настройки метрик в TFMA: (1) с использованием tfma.MetricsSpec или (2) путем создания экземпляров классов tf.keras.metrics.* и/или tfma.metrics.* в Python и использования tfma.metrics.specs_from_metrics чтобы преобразовать их в список tfma.MetricsSpec .

В следующих разделах описаны примеры конфигураций для различных типов задач машинного обучения.

Метрики регрессии

Ниже приведен пример настройки конфигурации для проблемы регрессии. Обратитесь к модулям tf.keras.metrics.* и tfma.metrics.* чтобы узнать о возможных дополнительных поддерживаемых метриках.

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

Эту же настройку можно создать, используя следующий код Python:

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)

Обратите внимание, что эту настройку также можно получить, вызвав tfma.metrics.default_regression_specs .

Метрики двоичной классификации

Ниже приведен пример настройки конфигурации для задачи двоичной классификации. Обратитесь к модулям tf.keras.metrics.* и tfma.metrics.* чтобы узнать о возможных дополнительных поддерживаемых метриках.

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

Эту же настройку можно создать, используя следующий код Python:

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)

Обратите внимание, что эту настройку также можно получить, вызвав tfma.metrics.default_binary_classification_specs .

Метрики классификации с несколькими классами и метками

Ниже приведен пример настройки конфигурации для задачи классификации нескольких классов. Обратитесь к модулям tf.keras.metrics.* и tfma.metrics.* чтобы узнать о возможных дополнительных поддерживаемых метриках.

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

Эту же настройку можно создать, используя следующий код Python:

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)

Обратите внимание, что эту настройку также можно получить, вызвав tfma.metrics.default_multi_class_classification_specs .

Бинаризованные метрики с несколькими классами и метками

Метрики с несколькими классами/мульти-метками можно преобразовать в бинарную форму для получения метрик для каждого класса, для каждого top_k и т. д. с помощью tfma.BinarizationOptions . Например:

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

Эту же настройку можно создать, используя следующий код 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]}))

Совокупные метрики с несколькими классами и метками

Метрики с несколькими классами и несколькими метками можно агрегировать для получения одного агрегированного значения для метрики двоичной классификации с помощью tfma.AggregationOptions .

Обратите внимание, что настройки агрегации не зависят от настроек бинаризации, поэтому вы можете использовать как tfma.AggregationOptions , так и tfma.BinarizationOptions одновременно.

Микро среднее

Микроусреднение можно выполнить с помощью параметра micro_average в tfma.AggregationOptions . Например:

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

Эту же настройку можно создать, используя следующий код 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))

Микроусреднение также поддерживает настройку top_k , при которой в вычислениях используются только верхние значения k. Например:

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

Эту же настройку можно создать, используя следующий код 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,
                                      top_k_list={'values': [1, 3]}))

Макро/взвешенное макросреднее

Усреднение макросов можно выполнить с помощью параметров macro_average или weighted_macro_average в tfma.AggregationOptions . Если не используются настройки top_k , макрос требует установки class_weights , чтобы знать, для каких классов вычислять среднее значение. Если class_weight не указан, предполагается 0,0. Например:

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

Эту же настройку можно создать, используя следующий код 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)}))

Как и микроусреднение, макроусреднение также поддерживает настройку top_k , при которой в вычислениях используются только значения k верхних значений. Например:

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

Эту же настройку можно создать, используя следующий код 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]}))

Метрики на основе запросов/рейтинга

Метрики на основе запросов/рейтинга включаются путем указания параметра query_key в спецификациях метрик. Например:

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

Эту же настройку можно создать, используя следующий код 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')

Метрики оценки нескольких моделей

TFMA поддерживает одновременную оценку нескольких моделей. При выполнении оценки нескольких моделей метрики будут рассчитываться для каждой модели. Например:

from google.protobuf import text_format

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

Если метрики необходимо вычислить для подмножества моделей, установите model_names в metric_specs . Например:

from google.protobuf import text_format

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

API specs_from_metrics также поддерживает передачу имен моделей: 

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

Метрики сравнения моделей

TFMA поддерживает оценку показателей сравнения модели-кандидата с базовой моделью. Простой способ настроить пару моделей-кандидатов и базовых моделей — передать eval_shared_model с соответствующими именами моделей (tfma.BASELINE_KEY и 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")

Показатели сравнения вычисляются автоматически для всех различающихся показателей (в настоящее время только для показателей скалярных значений, таких как точность и AUC).

Метрики модели с несколькими выходами

TFMA поддерживает оценку показателей моделей с разными выходными данными. Модели с несколькими выходами хранят свои прогнозы на выходе в виде словаря с ключом по имени выхода. При использовании моделей с несколькими выходами имена выходов, связанных с набором метрик, должны быть указаны в разделе output_names MetricsSpec. Например:

from google.protobuf import text_format

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

API specs_from_metrics также поддерживает передачу выходных имен: 

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

Настройка параметров метрик

TFMA позволяет настраивать параметры, используемые с различными метриками. Например, вы можете захотеть изменить имя, установить пороговые значения и т. д. Это делается путем добавления раздела config в конфигурацию метрики. Конфигурация указывается с использованием строковой версии параметров JSON, которая будет передана в метод метрики __init__ (для удобства использования ведущие и конечные скобки «{» и «}» можно опустить). Например:

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

Эта настройка, конечно, также поддерживается напрямую:

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

Выходы

Результатом оценки метрики является серия ключей/значений метрики и/или ключей/значений графика на основе используемой конфигурации.

Метрические ключи

MetricKeys определяются с использованием типа структурированного ключа. Этот ключ однозначно идентифицирует каждый из следующих аспектов метрики:

  • Имя метрики ( auc , mean_label и т. д.)
  • Название модели (используется только при оценке нескольких моделей)
  • Имя выхода (используется только при оценке моделей с несколькими выходами)
  • Дополнительный ключ (например, идентификатор класса, если модель с несколькими классами бинаризирована)

Значение показателя

MetricValues ​​определяются с использованием прототипа, который инкапсулирует различные типы значений, поддерживаемые разными метриками (например, double , ConfusionMatrixAtThresholds и т. д.).

Ниже приведены поддерживаемые типы значений метрик:

  • double_value — оболочка для типа double.
  • bytes_value — значение в байтах.
  • bounded_value — представляет реальное значение, которое может быть точечной оценкой, при необходимости с какими-либо приблизительными границами. Имеет свойства value , lower_bound и upper_bound .
  • value_at_cutoffs — значение в точках отсечения (например, точность@K, отзыв@K). Имеет values свойств, каждое из которых имеет свойства cutoff и value .
  • confusion_matrix_at_thresholds — матрица неточностей на порогах. Имеет matrices свойств, каждая из которых имеет свойства для значений threshold , precision , recall и матрицы путаницы, например false_negatives .
  • array_value — для метрик, которые возвращают массив значений.

Ключи сюжета

PlotKeys аналогичны ключам метрик, за исключением того, что по историческим причинам все значения графиков хранятся в одном прототипе, поэтому ключ графика не имеет имени.

График значений

Все поддерживаемые графики хранятся в одном прототипе под названием PlotData .

EvalResult

Результатом выполнения оценки является tfma.EvalResult . Эта запись содержит slicing_metrics , которые кодируют ключ метрики как многоуровневый словарь, где уровни соответствуют выходному имени, идентификатору класса, имени метрики и значению метрики соответственно. Он предназначен для отображения пользовательского интерфейса в ноутбуке Jupiter. Если необходим доступ к базовым данным, вместо этого следует использовать файл результатов metrics (см. metrics_for_slice.proto ).

Кастомизация

В дополнение к пользовательским метрикам, которые добавляются как часть сохраненного кераса (или устаревшей модели EvalSavedModel). Существует два способа настройки метрик при сохранении постов TFMA: (1) путем определения пользовательского класса метрик keras и (2) путем определения пользовательского класса метрик TFMA, поддерживаемого объединителем лучей.

В обоих случаях метрики настраиваются путем указания имени класса метрики и связанного с ним модуля. Например:

from google.protobuf import text_format

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

Пользовательские метрики Keras

Чтобы создать собственную метрику keras, пользователям необходимо расширить tf.keras.metrics.Metric своей реализацией, а затем убедиться, что модуль метрики доступен во время оценки.

Обратите внимание, что для метрик, добавленных после сохранения модели, TFMA поддерживает только метрики, которые принимают метку (т. е. y_true), прогноз (y_pred) и примерный вес (sample_weight) в качестве параметров метода update_state .

Пример метрики Keras

Ниже приведен пример пользовательской метрики 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)

Пользовательские метрики TFMA

Чтобы создать собственную метрику TFMA, пользователям необходимо расширить tfma.metrics.Metric своей реализацией, а затем убедиться, что модуль метрики доступен во время оценки.

Метрика

Реализация tfma.metrics.Metric состоит из набора kwargs, которые определяют конфигурацию метрик, а также функции для создания вычислений (возможно, нескольких), необходимых для вычисления значения метрики. Можно использовать два основных типа вычислений: tfma.metrics.MetricComputation и tfma.metrics.DerivedMetricComputation , которые описаны в разделах ниже. Функция, которая создает эти вычисления, будет передавать в качестве входных данных следующие параметры:

  • eval_config: tfam.EvalConfig
    • Конфигурация оценки передается оценщику (полезно для поиска настроек спецификации модели, таких как используемый ключ прогнозирования и т. д.).
  • model_names: List[Text]
    • Список названий моделей для вычисления показателей (нет, если одна модель)
  • output_names: List[Text] .
    • Список имен выходных данных для вычисления показателей (нет, если одна модель)
  • sub_keys: List[tfma.SubKey] .
    • Список дополнительных ключей (идентификатор класса, верхний K и т. д.) для вычисления показателей (или нет)
  • aggregation_type: tfma.AggregationType
    • Тип агрегирования при вычислении метрики агрегирования.
  • class_weights: Dict[int, float] .
    • Веса классов, используемые при вычислении метрики агрегирования.
  • query_key: Text
    • Ключ запроса, используемый при вычислении метрики на основе запроса/ранжирования.

Если метрика не связана с одним или несколькими из этих параметров, эти параметры могут быть исключены из определения сигнатуры.

Если метрика вычисляется одинаково для каждой модели, выходных данных и дополнительного ключа, то утилиту tfma.metrics.merge_per_key_computations можно использовать для выполнения одних и тех же вычислений для каждого из этих входных данных отдельно.

Метрические вычисления

MetricComputation состоит из комбинации preprocessors и combiner . preprocessors — это список preprocessor , который представляет собой beam.DoFn , который принимает экстракты в качестве входных данных и выводит начальное состояние, которое будет использоваться объединителем (дополнительную информацию о том, что такое экстракты, см. в разделе «Архитектура» ). Все препроцессоры будут выполняться последовательно в порядке списка. Если preprocessors пусты, то объединителю будут переданы StandardMetricInputs (стандартные входные метрики содержат метки, прогнозы и example_weights). combiner представляет собой beam.CombineFn , который принимает кортеж (ключ среза, выходные данные препроцессора) в качестве входных данных и выводит кортеж из (slice_key, dict результатов метрики) в качестве результата.

Обратите внимание, что нарезка происходит между preprocessors и combiner .

Обратите внимание, что если при вычислении метрики необходимо использовать оба стандартных входных параметра, но дополнить их несколькими функциями из извлеченных features , то можно использовать специальный FeaturePreprocessor , который объединит запрошенные функции от нескольких объединителей в одну. общее значение StandardMetricsInputs, которое передается всем объединителям (объединители несут ответственность за чтение интересующих их функций и игнорирование остальных).

Пример

Ниже приведен очень простой пример определения метрики TFMA для вычисления SampleCount: 

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}

Вычисление производной метрики

DerivedMetricComputation состоит из функции результата, которая используется для расчета значений метрик на основе результатов других вычислений метрик. Функция результата принимает набор вычисленных значений в качестве входных данных и выводит набор дополнительных результатов метрик.

Обратите внимание, что допустимо (рекомендуется) включать вычисления, от которых зависит производное вычисление, в список вычислений, созданных метрикой. Это позволяет избежать необходимости предварительного создания и передачи вычислений, которые используются несколькими метриками. Оценщик автоматически выполнит дедупликацию вычислений, имеющих одинаковое определение, так что фактически будет запущено только одно вычисление.

Пример

Метрики TJUR представляют собой хороший пример производных метрик.