O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Plots e métricas de análise de modelo do Tensorflow

Visão geral

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

  • Padrão Keras métricas ( 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.
  • Padrão TFMA métricas e parcelas ( tfma.metrics.* )

  • As métricas personalizadas keras (métricas derivados de tf.keras.metrics.Metric )

  • Métricas costume TFMA (métricas derivados de tfma.metrics.Metric ) usando combinadores de feixe costume ou métricas derivadas de outras métricas).

TFMA também fornece suporte integrado para conversão de métricas de classificação binária para uso com problemas de várias classes / vários rótulos:

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

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, 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 multi-classe / multi-rótulo, classificação, etc.

Configuração

Há duas maneiras de métricas configurar no TFMA: (1) usando o tfma.MetricsSpec ou (2) através da criação de instâncias de tf.keras.metrics.* e / ou tfma.metrics.* Classes 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 as tf.keras.metrics.* E tfma.metrics.* Módulos para possíveis métricas adicionais suportados.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "MeanSquaredError" }
    metrics { class_name: "Accuracy" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics {
      class_name: "CalibrationPlot"
      config: '"min_value": 0, "max_value": 10'
    }
  }
""", tfma.EvalConfig()).metrics_specs

Essa mesma configuração pode ser criada usando o seguinte código Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.MeanSquaredError(name='mse'),
    tf.keras.metrics.Accuracy(name='accuracy'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.CalibrationPlot(
        name='calibration', min_value=0, max_value=10)
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Note que esta configuração também está disponível pelo telefone 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 as tf.keras.metrics.* E tfma.metrics.* Módulos para possíveis métricas adicionais suportados.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "ConfusionMatrixPlot" }
    metrics { class_name: "CalibrationPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Essa mesma configuração pode ser criada usando o seguinte código Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.BinaryCrossentropy(name='binary_crossentropy'),
    tf.keras.metrics.BinaryAccuracy(name='accuracy'),
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    tf.keras.metrics.AUC(
        name='auc_precision_recall', curve='PR', num_thresholds=10000),
    tf.keras.metrics.Precision(name='precision'),
    tf.keras.metrics.Recall(name='recall'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.ConfusionMatrixPlot(name='confusion_matrix_plot'),
    tfma.metrics.CalibrationPlot(name='calibration_plot')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Note que esta configuração também está disponível pelo telefone tfma.metrics.default_binary_classification_specs .

Métricas de classificação multiclasse / multiclasse

A seguir está um exemplo de configuração para um problema de classificação de várias classes. Consulte as tf.keras.metrics.* E tfma.metrics.* Módulos para possíveis métricas adicionais suportados.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "SparseCategoricalCrossentropy" }
    metrics { class_name: "SparseCategoricalAccuracy" }
    metrics { class_name: "Precision" config: '"top_k": 1' }
    metrics { class_name: "Precision" config: '"top_k": 3' }
    metrics { class_name: "Recall" config: '"top_k": 1' }
    metrics { class_name: "Recall" config: '"top_k": 3' }
    metrics { class_name: "MultiClassConfusionMatrixPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Essa mesma configuração pode ser criada usando o seguinte código Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.SparseCategoricalCrossentropy(
        name='sparse_categorical_crossentropy'),
    tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),
    tf.keras.metrics.Precision(name='precision', top_k=1),
    tf.keras.metrics.Precision(name='precision', top_k=3),
    tf.keras.metrics.Recall(name='recall', top_k=1),
    tf.keras.metrics.Recall(name='recall', top_k=3),
    tfma.metrics.MultiClassConfusionMatrixPlot(
        name='multi_class_confusion_matrix_plot'),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Note que esta configuração também está disponível pelo telefone tfma.metrics.default_multi_class_classification_specs .

Métricas binárias multiclasse / multiclasse

Métricas múltiplas classes / multi-etiqueta pode ser binarizados para produzir métricas por classe, por top_k, etc usando os 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 multiclasse / multiclasse

Métricas / multi-etiqueta Multi-classe podem ser agregados para produzir um único valor agregado para uma classificação binária métrica usando tfma.AggregationOptions .

Note-se que as configurações de agregação são independentes de binarização configurações para que você possa usar os dois tfma.AggregationOptions e tfma.BinarizationOptions ao mesmo tempo.

Micro Média

Micro média pode ser executada usando o micro_average opção dentro 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))

Micro média também suporta a configuração top_k onde apenas os valores de k de topo são utilizados 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

Média macro pode ser executada usando as macro_average ou weighted_macro_average opções dentro tfma.AggregationOptions . A menos que top_k configurações são usadas, macro requer definir os class_weights a fim de saber quais as classes para calcular a média. Se um class_weight não é fornecido, em seguida, 0,0 é 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)}))

Como micro cálculo da média, média macro também suporta a configuração top_k onde apenas os valores de k de topo são utilizados 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

Consulta / classificação métricas baseadas estão habilitados especificando o query_key opção nas especificações 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 de vários modelos

TFMA suporta a avaliação de vários modelos ao mesmo tempo. Quando a avaliação de vários modelos é realizada, as métricas sã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 precisam ser computados para um subconjunto de modelos, definir model_names nas 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

O specs_from_metrics API também suporta passar os nomes dos modelos:

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

Métricas de comparação de modelos

TFMA suporta a 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 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 de comparação (atualmente, apenas as métricas de valor escalar, como precisão e AUC).

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

TFMA suporta a 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 dicionário codificado pelo nome da saída. Quando são usados multi-saída do modelo, os nomes das saídas associadas a um conjunto de métricas deve ser especificado no output_names seção 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

O specs_from_metrics API também suporta passar nomes de saída:

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

Personalização das configurações de métricas

TFMA permite personalizar as configurações que são usadas com diferentes métricas. Por exemplo, você pode querer alterar o nome, limiares estabelecidos, etc. Isso é feito adicionando uma config seção para a configuração de métrica. A configuração é especificada utilizando a versão de cadeia JSON dos parâmetros que seriam passados para as métricas __init__ método (para facilidade de utilização do ataque e de fuga '{' e '}' suportes 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

Obviamente, 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 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 definidos usando um tipo de chave estruturado. Esta chave identifica exclusivamente cada um dos seguintes aspectos de uma métrica:

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

Valor métrico

MetricValues são definidas utilizando um proto que encapulates os diferentes tipos de valor suportados pelas métricas diferentes (por exemplo, double , ConfusionMatrixAtThresholds , etc).

Abaixo estão os tipos de valor de métrica com suporte:

  • double_value - de uma capa para um tipo de casal.
  • bytes_value - A bytes valor.
  • bounded_value - Representa um valor real que poderia ser uma estimativa pontual, opcionalmente com limites aproximados de algum tipo. Tem propriedades value , lower_bound e upper_bound .
  • value_at_cutoffs - Value at cortes (por exemplo, precisão @ K, recordação @ K). Tem a propriedade values , cada um dos quais tem propriedades cutoff e value .
  • confusion_matrix_at_thresholds - matriz de confusão nas soleiras. Tem a propriedade matrices , cada um dos quais tem propriedades para threshold , precision , recall , e os valores matriz de confusão, como false_negatives .
  • array_value - Para métricas que devolvem uma matriz de valores.

Chaves de enredo

PlotKeys são semelhantes às chaves métricas, exceto que por razões históricas todos os valores parcelas são armazenadas em um único proto assim que a chave enredo não tem um nome.

Valores do gráfico

Todas as parcelas suportados são armazenadas em um único proto chamado PlotData .

EvalResult

O retorno de um prazo de avaliação é um tfma.EvalResult . Esta ficha contém slicing_metrics que codificam a chave métrica como um dicionário de multi-nível, onde os níveis correspondem a saída nome, identificação de classe, nome da métrica, e valor da métrica, respectivamente. Destina-se a ser usado para exibição da IU em um notebook Jupiter. Se o acesso aos dados subjacentes são necessárias as metrics resultar arquivo deve ser usado em vez (ver metrics_for_slice.proto ).

Costumização

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

Em ambos os casos, as métricas são configuradas especificando o nome da classe da 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 Keras personalizadas

Para criar um personalizado Keras métrica, os usuários precisam estender tf.keras.metrics.Metric com a sua implementação e, em seguida, certifique-se o módulo do métrica está disponível em tempo de avaliação.

Note-se que para as métricas adicionados modelo pós excepto, TFMA suporta apenas métricas que levam etiqueta (isto é, y_true), predição (y_pred), e peso exemplo (sample_weight) como parâmetros para o update_state método.

Exemplo Keras Metric

A seguir está um exemplo de uma 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 um TFMA costume métrica, os usuários precisam estender tfma.metrics.Metric com a sua implementação e, em seguida, certifique-se o módulo do métrica está disponível em tempo de avaliação.

Métrica

Um tfma.metrics.Metric aplicação é constituída por um conjunto de kwargs que definem a configuração métricas junto com uma função para criar as computações (possivelmente múltiplos) necessários para calcuate o valor métricas. 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 de modelo, como chave de predição a ser usada, etc).
  • model_names: List[Text]
    • Lista de nomes de modelo para calcular as métricas (Nenhum se modelo único)
  • output_names: List[Text] .
    • Lista de nomes de saída para calcular métricas (Nenhum se modelo único)
  • sub_keys: List[tfma.SubKey] .
    • Lista de subchaves (classe ID, top K, etc) para calcular métricas para (ou nenhum)
  • 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 ​​se estiver computando uma métrica de agregação.
  • query_key: Text
    • Chave de consulta usada se estiver computando uma métrica baseada em consulta / classificação.

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

Se uma métrica é calculado da mesma forma para cada modelo, a saída, e sub-chave, em seguida, o utilitário tfma.metrics.merge_per_key_computations pode ser usado para realizar os mesmos cálculos para cada uma destas entradas separadamente.

MetricComputation

Um MetricComputation é constituído por uma combinação de um preprocessor e um combiner . O preprocessor é um beam.DoFn que leva extratos como sua entrada e emite o estado inicial que será usado pelo combinador (veja arquitectura para mais informações sobre o que são extratos). Se um preprocessor não está definido, então o combinador será passado StandardMetricInputs (entradas métricas padrão contém rótulos, predições e example_weights). O combiner é uma beam.CombineFn que leva um tuplo de (chave de fatia, de saída pré-processador) como sua entrada e emite um tuplo de (slice_key, resultados métricas Dict) como seu resultado.

Note-se que o corte acontece entre o preprocessor e combiner .

Note que se um cálculo métrico quer fazer uso de ambas as entradas métricas padrão, mas aumentá-la com algumas das características dos features extratos, então o especial FeaturePreprocessor pode ser usado que irá mesclar as características solicitadas 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 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],
          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}

DerivedMetricComputation

Um DerivedMetricComputation é constituído por uma função de resultado que é usado para calcular os valores da métrica com base na saída de outros cálculos métricas. A função de resultado leva um dicionário de valores calculados como sua entrada e emite um dicionário de resultados métricos 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 irá desduplicar automaticamente os cálculos que têm a mesma definição, de forma que apenas um cálculo seja realmente executado.

Exemplo

As métricas tjur fornece um bom exemplo de métricas derivadas.