¡El Día de la Comunidad de ML es el 9 de noviembre! Únase a nosotros para recibir actualizaciones de TensorFlow, JAX, y más Más información

Gráficos y métricas de análisis del modelo de Tensorflow

Visión general

TFMA admite las siguientes métricas y gráficos:

  • Estándar Keras métricas ( tf.keras.metrics.* )
    • Tenga en cuenta que no necesita un modelo de keras para usar métricas de keras. Las métricas se calculan fuera del gráfico en haz utilizando las clases de métricas directamente.
  • Estándar TFMA métricas y parcelas ( tfma.metrics.* )

  • Las métricas personalizadas Keras (métricas derivadas de tf.keras.metrics.Metric )

  • Métricas TFMA Custom (métricas derivadas de tfma.metrics.Metric ) usando combinadores de haz de encargo o métricas derivadas de otras métricas).

TFMA también proporciona soporte integrado para convertir métricas de clasificación binaria para su uso con problemas de múltiples clases / etiquetas:

  • Binarización basada en ID de clase, top K, etc.
  • Métricas agregadas basadas en micropromedio, macropromedio, etc.

TFMA también proporciona soporte integrado para métricas basadas en consultas / rankings donde los ejemplos se agrupan automáticamente por una clave de consulta en la canalización.

Combinados, hay más de 50 métricas y gráficos estándar disponibles para una variedad de problemas, incluida la regresión, la clasificación binaria, la clasificación de múltiples clases / etiquetas múltiples, clasificación, etc.

Configuración

Hay dos maneras a las métricas de configurar en TFMA: (1) utilizando el tfma.MetricsSpec o (2) mediante la creación de instancias de tf.keras.metrics.* y / o tfma.metrics.* Clases en Python y usando tfma.metrics.specs_from_metrics para convertirlos en una lista de tfma.MetricsSpec .

Las siguientes secciones describen configuraciones de ejemplo para diferentes tipos de problemas de aprendizaje automático.

Métricas de regresión

La siguiente es una configuración de ejemplo para un problema de regresión. Consultar el tf.keras.metrics.* Y tfma.metrics.* Módulos para posibles métricas adicionales compatibles.

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

Esta misma configuración se puede crear usando el siguiente código de 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)

Tenga en cuenta que esta configuración también está disponible llamando tfma.metrics.default_regression_specs .

Métricas de clasificación binaria

La siguiente es una configuración de ejemplo para un problema de clasificación binaria. Consultar el tf.keras.metrics.* Y tfma.metrics.* Módulos para posibles métricas adicionales compatibles.

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

Esta misma configuración se puede crear usando el siguiente código de 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)

Tenga en cuenta que esta configuración también está disponible llamando tfma.metrics.default_binary_classification_specs .

Métricas de clasificación de múltiples clases / múltiples etiquetas

La siguiente es una configuración de ejemplo para un problema de clasificación de clases múltiples. Consultar el tf.keras.metrics.* Y tfma.metrics.* Módulos para posibles métricas adicionales compatibles.

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

Esta misma configuración se puede crear usando el siguiente código de 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)

Tenga en cuenta que esta configuración también está disponible llamando tfma.metrics.default_multi_class_classification_specs .

Métricas binarizadas de múltiples clases / múltiples etiquetas

Métricas multi-clase / multi-etiqueta en binarios se pueden producir métricas por clase, por top_k, etc utilizando tfma.BinarizationOptions . Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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 varias clases / etiquetas

Métricas multi-clase / multi-etiqueta se pueden agregar para producir un solo valor agregado para una clasificación binaria métrica utilizando tfma.AggregationOptions .

Tenga en cuenta que la configuración de agregación son independientes de binarización configuración para poder utilizar ambos tfma.AggregationOptions y tfma.BinarizationOptions al mismo tiempo.

Micro promedio

Micro promedio se puede realizar mediante el uso de la micro_average opción dentro tfma.AggregationOptions . Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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))

Promediado Micro también es compatible con la configuración top_k donde sólo los valores de k superiores se utilizan en el cálculo. Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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 / Promedio macro ponderado

Promediado macro se puede realizar mediante el uso de las macro_average o weighted_macro_average opciones dentro tfma.AggregationOptions . A menos que top_k se utilizan los ajustes, macro requiere el establecimiento de las class_weights con el fin de saber qué clases para calcular la media de. Si un class_weight no se proporciona a continuación, se supone 0,0. Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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 promedio micro, macro promediación también es compatible con la configuración top_k donde sólo los valores de k superiores se utilizan en el cálculo. Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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 basadas en consultas / clasificación

Consulta / clasificación métricas basadas están habilitados mediante la especificación de la query_key opción en las especificaciones métricas. Por ejemplo:

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 misma configuración se puede crear usando el siguiente código de 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 evaluación de modelos múltiples

TFMA admite la evaluación de varios modelos al mismo tiempo. Cuando se realiza una evaluación de modelos múltiples, se calcularán métricas para cada modelo. Por ejemplo:

from google.protobuf import text_format

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

Si métricas necesitan ser calculado para un subconjunto de modelos, establecer model_names en los metric_specs . Por ejemplo:

from google.protobuf import text_format

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

El specs_from_metrics API también soporta pasar nombres de modelo:

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

Métricas de comparación de modelos

TFMA admite la evaluación de métricas de comparación para un modelo candidato frente a un modelo de línea de base. Una forma sencilla de configurar el par de modelo candidato y base es pasar un eval_shared_model con los nombres de modelo adecuados (tfma.BASELINE_KEY y 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")

Las métricas de comparación se calculan automáticamente para todas las métricas diferenciables (actualmente solo métricas de valor escalar, como precisión y AUC).

Métricas del modelo de salida múltiple

TFMA admite la evaluación de métricas en modelos que tienen diferentes resultados. Los modelos de salida múltiple almacenan sus predicciones de salida en forma de un dictado codificado por el nombre de la salida. Cuando se utilizan de modelo con múltiples salidas, los nombres de las salidas asociadas a un conjunto de métricas deben ser especificados en el output_names sección del MetricsSpec. Por ejemplo:

from google.protobuf import text_format

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

El specs_from_metrics API también soporta pasar nombres de salida:

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

Personalización de la configuración de métricas

TFMA permite personalizar la configuración que se utiliza con diferentes métricas. Por ejemplo es posible que desee cambiar el nombre, establecer umbrales, etc. Esto se hace mediante la adición de una config sección para la configuración métrica. El config se especifica utilizando la versión de cadena JSON de los parámetros que se transmiten a las métricas __init__ método (por facilidad de uso el ataque y de salida '{' y '}' entre paréntesis pueden omitirse). Por ejemplo:

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

Por supuesto, esta personalización también se admite directamente:

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

Salidas

El resultado de una evaluación métrica es una serie de claves / valores métricos y / o claves / valores de trazado según la configuración utilizada.

Claves métricas

MetricKeys se definen utilizando un tipo de clave estructurada. Esta clave identifica de forma única cada uno de los siguientes aspectos de una métrica:

  • Nombre de métrica ( auc , mean_label , etc)
  • Nombre del modelo (solo se usa si se evalúa con varios modelos)
  • Nombre de salida (solo se usa si se evalúan modelos de múltiples salidas)
  • Subclave (por ejemplo, ID de clase si el modelo de varias clases está binarizado)

Valor métrico

MetricValues se definen utilizando un proto que encapulates los diferentes tipos de valor soportados por las diferentes métricas (por ejemplo, double , ConfusionMatrixAtThresholds , etc).

A continuación, se muestran los tipos de valores de métrica admitidos:

  • double_value - Una envoltura para un tipo doble.
  • bytes_value - Un bytes de valor.
  • bounded_value - Representa un valor real, que podría ser una estimación puntual, opcionalmente con límites aproximados de algún tipo. Tiene propiedades value , lower_bound , y upper_bound .
  • value_at_cutoffs - Valor en puntos de corte (por ejemplo, la precisión @ K, recuerdo @ K). Tiene la propiedad values , cada uno de los cuales tiene propiedades cutoff y value .
  • confusion_matrix_at_thresholds - Matriz de confusión en los umbrales. Tiene la propiedad matrices , cada uno de los cuales tiene propiedades para threshold , precision , recall , y los valores de matriz de confusión tales como false_negatives .
  • array_value - Para las métricas que devuelven una matriz de valores.

Llaves de trama

PlotKeys son similares a las llaves métricas, salvo que por razones históricas todos los valores parcelas se almacenan en una sola proto por lo que la clave del gráfico no tiene un nombre.

Trazar valores

Todas las parcelas compatibles se almacenan en una sola llamada proto PlotData .

EvalResult

El regreso de un proceso de evaluación es un tfma.EvalResult . Este registro contiene slicing_metrics que codifican la clave métrica como un diccionario de varios niveles, donde los niveles corresponden a nombre de salida, identificador de clase, nombre de la métrica, y el valor de métrica, respectivamente. Está destinado a ser utilizado para la visualización de la interfaz de usuario en un portátil Jupiter. Si el acceso a los datos subyacentes son necesarias las metrics resultan archivo se debe utilizar en su lugar (ver metrics_for_slice.proto ).

Personalización

Además de las métricas personalizadas que se agregan como parte de un keras guardado (o EvalSavedModel heredado). Hay dos formas de personalizar las métricas en el guardado posterior de TFMA: (1) definiendo una clase de métrica de keras personalizada y (2) definiendo una clase de métrica de TFMA personalizada respaldada por un combinador de haces.

En ambos casos, las métricas se configuran especificando el nombre de la clase de métrica y el módulo asociado. Por ejemplo:

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 crear una costumbre Keras métrica, los usuarios necesitan para extender tf.keras.metrics.Metric con su aplicación y luego asegurarse de que el módulo de la métrica está disponible en el momento de la evaluación.

Obsérvese que para las métricas de agregados modelo post Guardar, TFMA sólo soporta métricas que toman etiqueta (es decir y_true), la predicción (y_pred), y el ejemplo de peso (sample_weight) como parámetros a la update_state método.

Ejemplo de métrica de Keras

El siguiente es un ejemplo de una métrica de 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 crear un TFMA métrica personalizada, los usuarios necesitan para extender tfma.metrics.Metric con su aplicación y luego asegurarse de que el módulo de la métrica está disponible en el momento de la evaluación.

Métrico

A tfma.metrics.Metric aplicación se compone de un conjunto de kwargs que definen la configuración métricas junto con una función para la creación de los cálculos (posiblemente múltiples) necesarios para calcuate el valor métricas. Hay dos tipos de cálculo principales que se pueden utilizar: tfma.metrics.MetricComputation y tfma.metrics.DerivedMetricComputation que se describen en las siguientes secciones. A la función que crea estos cálculos se le pasarán los siguientes parámetros como entrada:

  • eval_config: tfam.EvalConfig
    • La configuración de evaluación pasó al evaluador (útil para buscar la configuración de las especificaciones del modelo, como la clave de predicción para usar, etc.).
  • model_names: List[Text]
    • Lista de nombres de modelos para calcular métricas (Ninguno si es un solo modelo)
  • output_names: List[Text] .
    • Lista de nombres de salida para calcular métricas (Ninguno si es de un solo modelo)
  • sub_keys: List[tfma.SubKey] .
    • Lista de subclaves (ID de clase, K superior, etc.) para calcular métricas (o ninguna)
  • aggregation_type: tfma.AggregationType
    • Tipo de agregación si se calcula una métrica de agregación.
  • class_weights: Dict[int, float] .
    • Ponderaciones de clase para usar si se calcula una métrica de agregación.
  • query_key: Text
    • La clave de consulta se utiliza si se calcula una métrica basada en consultas / clasificación.

Si una métrica no está asociada con una o más de estas configuraciones, puede dejar esos parámetros fuera de su definición de firma.

Si una métrica se calcula de la misma manera para cada modelo, de salida, y la clave de sub, a continuación, la utilidad tfma.metrics.merge_per_key_computations se pueden utilizar para realizar las mismas computaciones para cada una de estas entradas por separado.

Computación métrica

Un MetricComputation se compone de una combinación de un preprocessor y un combiner . El preprocessor es un beam.DoFn que toma extractos como su entrada y envía el estado inicial que se utilizará por el combinador (ver la arquitectura para obtener más información sobre cuáles son extractos). Si un preprocessor no está definida, el combinador se pasará StandardMetricInputs (entradas métricas estándar contiene etiquetas, predicciones y example_weights). El combiner es un beam.CombineFn que toma una tupla de (tecla de rebanada, la salida del preprocesador) como su entrada y salida a una tupla de (slice_key, resultados métricas dict) como su resultado.

Tenga en cuenta que rebanar sucede entre el preprocessor y combiner .

Tenga en cuenta que si un cómputo métrico quiere hacer uso tanto de las entradas métricas estándar, sino incrementarla con algunas de las características de las features los extractos, a continuación, el especial FeaturePreprocessor se puede utilizar la que se fusionarán las características solicitadas desde múltiples combinadores en una sola Valor compartido de StandardMetricsInputs que se pasa a todos los combinadores (los combinadores son responsables de leer las características que les interesan e ignorar el resto).

Ejemplo

El siguiente es un ejemplo muy simple de definición de métrica TFMA para calcular el 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

Un DerivedMetricComputation se compone de una función de resultados que se utiliza para calcular los valores de indicadores basados en la producción de otros cómputos métricos. La función de resultado toma un dictado de valores calculados como su entrada y genera un dictado de resultados métricos adicionales.

Tenga en cuenta que es aceptable (recomendado) incluir los cálculos de los que depende un cálculo derivado en la lista de cálculos creados por una métrica. Esto evita tener que pre-crear y pasar cálculos que se comparten entre múltiples métricas. El evaluador deducirá automáticamente los cálculos que tengan la misma definición, de modo que solo se ejecute realmente un cálculo.

Ejemplo

Las métricas tjur proporciona un buen ejemplo de indicadores derivados.