Esta página foi traduzida pela API Cloud Translation.

Métricas e gráficos de análise do modelo Tensorflow

Visão geral

TFMA suporta as seguintes métricas e gráficos:

Métricas keras padrão ( tf.keras.metrics.* )
- Observe que você não precisa de um modelo keras para usar métricas keras. As métricas são calculadas fora do gráfico em feixe usando as classes de métricas diretamente.
Métricas e gráficos padrão do TFMA ( tfma.metrics.* )
Métricas keras personalizadas (métricas derivadas de tf.keras.metrics.Metric )
Métricas TFMA personalizadas (métricas derivadas de tfma.metrics.Metric ) usando combinadores de feixe personalizados ou métricas derivadas de outras métricas).

O TFMA também fornece suporte integrado para conversão de métricas de classificação binária para uso com problemas multiclasse/multi-rótulo:

Binarização baseada no ID da classe, top K, etc.
Métricas agregadas baseadas em micro média, macro média, etc.

O TFMA também fornece suporte integrado para métricas baseadas em consulta/classificação, onde os exemplos são agrupados por uma chave de consulta automaticamente no pipeline.

Combinados, há mais de 50 métricas e gráficos padrão disponíveis para uma variedade de problemas, incluindo regressão, classificação binária, classificação multiclasse/multi-rótulo, classificação, etc.

Configuração

Existem duas maneiras de configurar métricas no TFMA: (1) usando tfma.MetricsSpec ou (2) criando instâncias das tf.keras.metrics.* e/ou tfma.metrics.* em python e usando tfma.metrics.specs_from_metrics para convertê-los em uma lista de tfma.MetricsSpec .

As seções a seguir descrevem exemplos de configurações para diferentes tipos de problemas de aprendizado de máquina.

Métricas de regressão

A seguir está um exemplo de configuração para um problema de regressão. Consulte os módulos tf.keras.metrics.* e tfma.metrics.* para possíveis métricas adicionais suportadas.

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

Esta mesma configuração pode ser criada usando o seguinte código 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)

Observe que esta configuração também está disponível chamando tfma.metrics.default_regression_specs .

Métricas de Classificação Binária

A seguir está um exemplo de configuração para um problema de classificação binária. Consulte os módulos tf.keras.metrics.* e tfma.metrics.* para possíveis métricas adicionais suportadas.

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

Esta mesma configuração pode ser criada usando o seguinte código 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)

Observe que esta configuração também está disponível chamando tfma.metrics.default_binary_classification_specs .

Métricas de classificação multiclasse/multirótulo

A seguir está um exemplo de configuração para um problema de classificação multiclasse. Consulte os módulos tf.keras.metrics.* e tfma.metrics.* para possíveis métricas adicionais suportadas.

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

Esta mesma configuração pode ser criada usando o seguinte código 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)

Observe que esta configuração também está disponível chamando tfma.metrics.default_multi_class_classification_specs .

Métricas binarizadas multiclasse/multirótulo

Métricas multiclasse/multirótulo podem ser binarizadas para produzir métricas por classe, por top_k, etc. usando tfma.BinarizationOptions . Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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]}))

Métricas agregadas multiclasse/multirótulo

Métricas multiclasse/multirótulo podem ser agregadas para produzir um único valor agregado para uma métrica de classificação binária usando tfma.AggregationOptions .

Observe que as configurações de agregação são independentes das configurações de binarização, portanto você pode usar tfma.AggregationOptions e tfma.BinarizationOptions ao mesmo tempo.

Micro Média

A micro média pode ser realizada usando a opção micro_average em tfma.AggregationOptions . Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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))

A micro média também suporta a configuração de top_k onde apenas os k valores principais são usados no cálculo. Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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 / Média Macro Ponderada

A média macro pode ser executada usando as opções macro_average ou weighted_macro_average em tfma.AggregationOptions . A menos que as configurações top_k sejam usadas, a macro requer a configuração de class_weights para saber para quais classes calcular a média. Se um class_weight não for fornecido, 0,0 será assumido. Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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)}))

Assim como a micro média, a macro média também suporta a configuração top_k , onde apenas os k valores principais são usados no cálculo. Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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]}))

Métricas baseadas em consulta/classificação

As métricas baseadas em consulta/classificação são habilitadas especificando a opção query_key nas especificações de métricas. Por exemplo:

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

Esta mesma configuração pode ser criada usando o seguinte código 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')

Métricas de avaliação multimodelo

TFMA oferece suporte à avaliação de vários modelos ao mesmo tempo. Quando a avaliação multimodelo é realizada, as métricas serão calculadas para cada modelo. Por exemplo:

from google.protobuf import text_format

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

Se as métricas precisarem ser calculadas para um subconjunto de modelos, defina model_names em metric_specs . Por exemplo:

from google.protobuf import text_format

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

A API specs_from_metrics também oferece suporte à passagem de nomes de modelos:

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

Métricas de comparação de modelos

O TFMA oferece suporte à avaliação de métricas de comparação de um modelo candidato em relação a um modelo de linha de base. Uma maneira simples de configurar o par de modelo candidato e de linha de base é passar um eval_shared_model com os nomes de modelo adequados (tfma.BASELINE_KEY e 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")

As métricas de comparação são calculadas automaticamente para todas as métricas diferenciáveis (atualmente apenas métricas de valor escalar, como precisão e AUC).

Métricas do modelo de múltiplas saídas

O TFMA oferece suporte à avaliação de métricas em modelos que possuem resultados diferentes. Os modelos de múltiplas saídas armazenam suas previsões de saída na forma de um ditado digitado pelo nome da saída. Quando modelos de múltiplas saídas são usados, os nomes das saídas associadas a um conjunto de métricas devem ser especificados na seção output_names do MetricsSpec. Por exemplo:

from google.protobuf import text_format

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

A API specs_from_metrics também suporta a passagem de nomes de saída:

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

Personalizando configurações de métricas

O TFMA permite personalizar as configurações usadas com diferentes métricas. Por exemplo, você pode querer alterar o nome, definir limites, etc. Isso é feito adicionando uma seção config à configuração da métrica. A configuração é especificada usando a versão da string JSON dos parâmetros que seriam passados para o método __init__ de métricas (para facilitar o uso, os colchetes iniciais e finais '{' e '}' podem ser omitidos). Por exemplo:

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

É claro que essa personalização também é suportada diretamente:

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

Resultados

A saída de uma avaliação métrica é uma série de chaves/valores métricos e/ou chaves/valores de gráfico com base na configuração usada.

Chaves métricas

MetricKeys são definidas usando um tipo de chave estruturada. Esta chave identifica exclusivamente cada um dos seguintes aspectos de uma métrica:

Nome da métrica ( auc , mean_label , etc)
Nome do modelo (usado apenas se for avaliação de vários modelos)
Nome de saída (usado somente se modelos de múltiplas saídas forem avaliados)
Subchave (por exemplo, ID da classe se o modelo multiclasse for binarizado)

Valor da métrica

MetricValues são definidos usando um proto que encapsula os diferentes tipos de valores suportados pelas diferentes métricas (por exemplo, double , ConfusionMatrixAtThresholds , etc).

Abaixo estão os tipos de valores de métrica suportados:

double_value - Um wrapper para um tipo duplo.
bytes_value - Um valor de bytes.
bounded_value - Representa um valor real que pode ser uma estimativa pontual, opcionalmente com algum tipo de limite aproximado. Possui propriedades value , lower_bound e upper_bound .
value_at_cutoffs - Valor nos pontos de corte (por exemplo, precisão@K, recall@K). Possui values de propriedade, cada um dos quais possui propriedades cutoff e value .
confusion_matrix_at_thresholds - Matriz de confusão nos limites. Possui matrices de propriedades, cada uma delas com propriedades para valores de threshold , precision , recall e matriz de confusão, como false_negatives .
array_value – Para métricas que retornam uma matriz de valores.

Chaves de plotagem

PlotKeys são semelhantes às chaves métricas, exceto que, por razões históricas, todos os valores dos gráficos são armazenados em um único proto, portanto a chave do gráfico não tem um nome.

Valores do gráfico

Todos os gráficos suportados são armazenados em um único proto chamado PlotData .

Resultado de avaliação

O retorno de uma execução de avaliação é tfma.EvalResult . Este registro contém slicing_metrics que codifica a chave métrica como um ditado multinível onde os níveis correspondem ao nome de saída, ID da classe, nome da métrica e valor da métrica, respectivamente. Destina-se a ser usado para exibição da IU em um notebook Júpiter. Se o acesso aos dados subjacentes for necessário, o arquivo de resultados metrics deverá ser usado (consulte métricas_for_slice.proto ).

Personalização

Além de métricas personalizadas que são adicionadas como parte de um keras salvo (ou EvalSavedModel legado). Existem duas maneiras de personalizar métricas no pós-salvamento do TFMA: (1) definindo uma classe de métrica keras personalizada e (2) definindo uma classe de métrica TFMA personalizada apoiada por um combinador de feixe.

Em ambos os casos, as métricas são configuradas especificando o nome da classe de métrica e do módulo associado. Por exemplo:

from google.protobuf import text_format

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

Métricas Keras personalizadas

Para criar uma métrica keras personalizada, os usuários precisam estender tf.keras.metrics.Metric com sua implementação e, em seguida, certificar-se de que o módulo da métrica esteja disponível no momento da avaliação.

Observe que para métricas adicionadas após o salvamento do modelo, o TFMA suporta apenas métricas que usam rótulo (ou seja, y_true), previsão (y_pred) e peso de exemplo (sample_weight) como parâmetros para o método update_state .

Exemplo de métrica Keras

Veja a seguir um exemplo de métrica keras personalizada:

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)

Métricas TFMA personalizadas

Para criar uma métrica TFMA personalizada, os usuários precisam estender tfma.metrics.Metric com sua implementação e depois certificar-se de que o módulo da métrica esteja disponível no momento da avaliação.

Métrica

Uma implementação tfma.metrics.Metric é composta por um conjunto de kwargs que definem a configuração das métricas junto com uma função para criar os cálculos (possivelmente múltiplos) necessários para calcular o valor da métrica. Existem dois tipos principais de computação que podem ser usados: tfma.metrics.MetricComputation e tfma.metrics.DerivedMetricComputation que são descritos nas seções abaixo. A função que cria esses cálculos receberá os seguintes parâmetros como entrada:

eval_config: tfam.EvalConfig
- A configuração eval passada para o avaliador (útil para procurar configurações de especificações do modelo, como chave de previsão a ser usada, etc.).
model_names: List[Text]
- Lista de nomes de modelos para calcular métricas (Nenhum se for modelo único)
output_names: List[Text] .
- Lista de nomes de saída para calcular métricas (Nenhum se for modelo único)
sub_keys: List[tfma.SubKey] .
- Lista de subchaves (ID de classe, K principais, etc.) para calcular métricas (ou Nenhuma)
aggregation_type: tfma.AggregationType
- Tipo de agregação se estiver computando uma métrica de agregação.
class_weights: Dict[int, float] .
- Pesos de classe a serem usados ao calcular uma métrica de agregação.
query_key: Text
- Chave de consulta usada para calcular uma métrica baseada em consulta/classificação.

Se uma métrica não estiver associada a uma ou mais dessas configurações, ela poderá deixar esses parâmetros fora de sua definição de assinatura.

Se uma métrica for calculada da mesma maneira para cada modelo, saída e subchave, o utilitário tfma.metrics.merge_per_key_computations poderá ser usado para realizar os mesmos cálculos para cada uma dessas entradas separadamente.

Computação Métrica

Um MetricComputation é composto por uma combinação de preprocessors e um combiner . Os preprocessors são uma lista de preprocessor , que é um beam.DoFn que recebe extrações como entrada e gera o estado inicial que será usado pelo combinador (veja arquitetura para mais informações sobre o que são extrações). Todos os pré-processadores serão executados sequencialmente na ordem da lista. Se os preprocessors estiverem vazios, o combinador receberá StandardMetricInputs (as entradas de métricas padrão contêm rótulos, previsões e pesos_de_exemplo). O combiner é um beam.CombineFn que recebe uma tupla de (slice key, pré-processador output) como entrada e gera uma tupla de (slice_key, metric results dict) como resultado.

Observe que o fatiamento acontece entre os preprocessors e combiner .

Observe que se um cálculo métrico quiser fazer uso de ambas as entradas métricas padrão, mas aumentá-lo com alguns dos recursos das extrações features , então o FeaturePreprocessor especial pode ser usado, o que mesclará os recursos solicitados de vários combinadores em um único valor compartilhado de StandardMetricsInputs que é passado para todos os combinadores (os combinadores são responsáveis por ler os recursos nos quais estão interessados e ignorar o resto).

Exemplo

A seguir está um exemplo muito simples de definição de métrica TFMA para calcular o ExampleCount:

class ExampleCount(tfma.metrics.Metric):

  def __init__(self, name: Text = 'example_count'):
    super(ExampleCount, self).__init__(_example_count, name=name)


def _example_count(
    name: Text = 'example_count') -> tfma.metrics.MetricComputations:
  key = tfma.metrics.MetricKey(name=name)
  return [
      tfma.metrics.MetricComputation(
          keys=[key],
          preprocessors=[_ExampleCountPreprocessor()],
          combiner=_ExampleCountCombiner(key))
  ]


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

Computação Métrica Derivada

Uma DerivedMetricComputation é composta por uma função de resultado usada para calcular valores métricos com base na saída de outros cálculos métricos. A função de resultado recebe um ditado de valores calculados como entrada e gera um ditado de resultados de métricas adicionais.

Observe que é aceitável (recomendado) incluir os cálculos dos quais um cálculo derivado depende na lista de cálculos criados por uma métrica. Isso evita a necessidade de pré-criar e transmitir cálculos que são compartilhados entre várias métricas. O avaliador eliminará automaticamente a duplicação de cálculos que tenham a mesma definição para que apenas um cálculo seja realmente executado.

Exemplo

As métricas do TJUR fornecem um bom exemplo de métricas derivadas.