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

Visão geral

O 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 as métricas keras. As métricas são calculadas fora do gráfico no feixe usando as classes de métricas diretamente.

  • Métricas e gráficos padrão do TFMA ( tfma.metrics.* )

  • Métricas personalizadas de keras (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 converter métricas de classificação binária para uso com problemas multiclasse/multirrótulo:

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

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

Combinados, existem 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/multirótulo, classificação, etc.

Configuração

Existem duas maneiras de configurar métricas no TFMA: (1) usando tfma.MetricsSpec ou (2) criando instâncias de 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 configurações de exemplo 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 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

Essa 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 essa 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 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

Essa 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 essa configuração também está disponível chamando tfma.metrics.default_binary_classification_specs .

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

A seguir está um exemplo de configuração para um problema de classificação multiclasse. Consulte os 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

Essa 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 essa configuração também está disponível chamando tfma.metrics.default_multi_class_classification_specs .

Métricas Binarizadas Multi-classe/Multi-rótulo

Métricas de várias classes/vários rótulos 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

Essa 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 de várias classes/vários rótulos

As métricas de várias classes/vários rótulos 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.

Micromédia

A média micro pode ser executada 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

Essa 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 média micro também suporta a definição de top_k , onde apenas os valores k 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

Essa 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 de 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

Essa 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 média micro, a média macro também suporta a definição de top_k , onde apenas os valores k 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

Essa 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

Métricas baseadas em consulta/classificação são ativadas 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

Essa 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

O 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 suporta a passagem de nomes de modelo:

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 para um modelo candidato em relação a um modelo de linha de base. Uma maneira simples de configurar o par candidato e modelo de linha de base é passar um eval_shared_model com os nomes de modelo apropriados (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 de modelo de várias saídas

O TFMA oferece suporte à avaliação de métricas em modelos que têm saídas diferentes. Os modelos de múltiplas saídas armazenam suas previsões de saída na forma de um dict digitado pelo nome da saída. Quando modelos de várias 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 oferece suporte à 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 customizar as configurações que são usadas com diferentes métricas. Por exemplo, você pode querer alterar o nome, definir limites, etc. Isso é feito adicionando uma seção de config à configuração da métrica. A configuração é especificada usando a versão de string JSON dos parâmetros que seriam passados ​​para o método __init__ de métrica (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)

Saídas

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

Chaves Métricas

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

  • Nome da métrica ( mean_label auc etc)
  • Nome do modelo (usado somente se avaliação multimodelo)
  • Nome da saída (usado apenas se modelos de várias 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 valor suportados pelas diferentes métricas (por exemplo, double , ConfusionMatrixAtThresholds , etc).

Abaixo estão os tipos de valor 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 limites aproximados de algum tipo. Tem as propriedades value , lower_bound e upper_bound .
  • value_at_cutoffs - Valor nos cortes (por exemplo, precisão@K, rechamada@K). Tem values de propriedade, cada um dos quais tem cutoff e value de propriedades.
  • confusion_matrix_at_thresholds - Matriz de confusão nos limiares. Possui matrices de propriedades, cada uma 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

As 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 possui um nome.

Valores de plotagem

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

EvalResult

O retorno de uma execução de avaliação é um tfma.EvalResult . Este registro contém slicing_metrics que codificam a chave de métrica como um ditado de vários níveis em que os níveis correspondem ao nome de saída, ID de classe, nome de métrica e valor de métrica, respectivamente. Destina-se a ser usado para exibição da interface do usuário em um notebook Jupiter. Se o acesso aos dados subjacentes for necessário, o arquivo de resultados de metrics deve ser usado (consulte métricas_for_slice.proto ).

Costumização

Além das métricas personalizadas que são adicionadas como parte de um keras salvo (ou EvalSavedModel herdado). Há duas maneiras de personalizar as métricas no pós-salvamento do TFMA: (1) definindo uma classe de métrica de keras personalizada e (2) definindo uma classe de métricas de 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 o 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 personalizadas de Keras

Para criar uma métrica personalizada de keras, 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 uma métrica personalizada de 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)

Métricas personalizadas de TFMA

Para criar uma métrica TFMA personalizada, os usuários precisam estender tfma.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.

Métrica

Uma implementação tfma.metrics.Metric é composta por um conjunto de kwargs que definem a configuração da métrica junto com uma função para criar os cálculos (possivelmente múltiplos) necessários para calcular o valor da métrica. Há dois tipos principais de computação que podem ser usados: tfma.metrics.MetricComputation e tfma.metrics.DerivedMetricComputation , 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 de avaliação passada para o avaliador (útil para procurar configurações de especificação do modelo, como chave de previsão a ser usada etc.).
  • model_names: List[Text]
    • Lista de nomes de modelo para calcular métricas (nenhuma se for um modelo único)
  • output_names: List[Text] .
    • Lista de nomes de saída para calcular métricas (Nenhuma se for modelo único)
  • sub_keys: List[tfma.SubKey] .
    • Lista de subchaves (class ID, top K, etc) para computar métricas (ou None)
  • aggregation_type: tfma.AggregationType
    • Tipo de agregação se estiver calculando 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 ao computar 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 executar os mesmos cálculos para cada uma dessas entradas separadamente.

Computação Métrica

Uma MetricComputation é composta de uma combinação de pré- preprocessors e um combiner . The preprocessors é uma lista de preprocessor , que é um beam.DoFn que recebe extrações como entrada e gera como saída o estado inicial que será usado pelo combinador (consulte arquitetura para obter 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 -processadores estiverem vazios, o combinador receberá StandardMetricInputs (as entradas de métrica padrão contêm rótulos, previsões e example_weights). O combiner é um beam.CombineFn que recebe uma tupla de (slice key, saída do pré-processador) como entrada e gera uma tupla de (slice_key, metric results dict) como resultado.

Observe que o fatiamento ocorre entre os pré- preprocessors e o combiner .

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

Exemplo

Veja a seguir 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 _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}

DerivedMetricComputation

Uma DerivedMetricComputation é composta por uma função de resultado que é usada para calcular valores métricos com base na saída de outros cálculos métricos. A função de resultado usa um dict de valores calculados como sua entrada e gera um dict 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 ter que pré-criar e passar cálculos que são compartilhados entre várias métricas. O avaliador eliminará automaticamente os cálculos que têm 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.