Descripción general
TFMA admite las siguientes métricas y gráficos:
- Métricas de keras estándar (
tf.keras.metrics.*
)- Tenga en cuenta que no necesita un modelo de keras para usar las métricas de keras. Las métricas se calculan fuera del gráfico en el haz usando las clases de métricas directamente.
Métricas y gráficos estándar de TFMA (
tfma.metrics.*
)Métricas de keras personalizadas (métricas derivadas de
tf.keras.metrics.Metric
)Métricas TFMA personalizadas (métricas derivadas de
tfma.metrics.Metric
) mediante combinadores de viga personalizados 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 varias clases/etiquetas:
- Binarización basada en ID de clase, top K, etc.
- Métricas agregadas basadas en promedios micro, promedios macro, etc.
TFMA también proporciona soporte integrado para métricas basadas en consultas/clasificación donde los ejemplos se agrupan por una clave de consulta automáticamente en la canalización.
Combinados, hay más de 50 métricas estándar y gráficos disponibles para una variedad de problemas que incluyen regresión, clasificación binaria, clasificación de múltiples clases/etiquetas, clasificación, etc.
Configuración
Hay dos formas de configurar métricas en TFMA: (1) utilizando tfma.MetricsSpec
o (2) creando instancias de tf.keras.metrics.*
y/o tfma.metrics.*
en python y utilizando 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
El siguiente es un ejemplo de configuración para un problema de regresión. Consulte los tf.keras.metrics.*
y tfma.metrics.*
para conocer las posibles métricas adicionales admitidas.
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 misma configuración se puede crear utilizando el siguiente código de 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)
Tenga en cuenta que esta configuración también está disponible llamando a tfma.metrics.default_regression_specs
.
Métricas de clasificación binaria
El siguiente es un ejemplo de configuración de configuración para un problema de clasificación binaria. Consulte los tf.keras.metrics.*
y tfma.metrics.*
para conocer las posibles métricas adicionales admitidas.
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 misma configuración se puede crear utilizando el siguiente código de 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)
Tenga en cuenta que esta configuración también está disponible llamando a tfma.metrics.default_binary_classification_specs
.
Métricas de clasificación multiclase/multietiqueta
La siguiente es una configuración de configuración de ejemplo para un problema de clasificación de varias clases. Consulte los tf.keras.metrics.*
y tfma.metrics.*
para conocer las posibles métricas adicionales admitidas.
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 misma configuración se puede crear utilizando el siguiente código de 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)
Tenga en cuenta que esta configuración también está disponible llamando a tfma.metrics.default_multi_class_classification_specs
.
Métricas binarizadas multiclase/multietiqueta
Las métricas multiclase/multietiqueta se pueden binarizar para generar métricas por clase, por top_k, etc. mediante 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 utilizando 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 multiclase/multietiqueta
Las métricas de varias clases/etiquetas múltiples se pueden agregar para producir un único valor agregado para una métrica de clasificación binaria mediante tfma.AggregationOptions
.
Tenga en cuenta que la configuración de agregación es independiente de la configuración de binarización, por lo que puede usar tfma.AggregationOptions
y tfma.BinarizationOptions
al mismo tiempo.
Promedio micro
El micropromedio se puede realizar mediante la opción micro_average
dentro de 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 utilizando 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))
El micropromedio también admite la configuración de top_k
donde solo se utilizan los valores k superiores 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 utilizando 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]}))
Promedio macro/macro ponderado
El promedio de macros se puede realizar mediante las opciones macro_average
o weighted_macro_average
dentro de tfma.AggregationOptions
. A menos que se use la configuración top_k
, la macro requiere configurar class_weights
para saber para qué clases calcular el promedio. Si no se proporciona un class_weight
, se asume 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 utilizando 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)}))
Al igual que el promedio micro, el promedio macro también admite la configuración de top_k
donde solo se utilizan los valores k superiores 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 utilizando 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
Las métricas basadas en consultas/clasificaciones se habilitan especificando la opción query_key
en las especificaciones de las 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 utilizando 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 multimodelo
TFMA admite la evaluación de múltiples modelos al mismo tiempo. Cuando se realiza una evaluación de varios modelos, se calcularán las 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 es necesario calcular las métricas para un subconjunto de modelos, establezca model_names
en 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
La API specs_from_metrics
también admite el paso de nombres de modelos:
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 referencia. Una forma sencilla de configurar el par de modelos candidato y de referencia 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 diferibles (actualmente solo las métricas de valor escalar, como la precisión y el 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 nombre de salida. Cuando se utilizan modelos de salida múltiple, los nombres de las salidas asociadas con un conjunto de métricas deben especificarse en la sección de nombres de salida de output_names
. Por ejemplo:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
output_names: ["my-output"]
...
}
""", tfma.EvalConfig()).metrics_specs
La API specs_from_metrics
también admite el paso de 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 agregando una sección de config
a la configuración de la métrica. La configuración se especifica utilizando la versión de cadena JSON de los parámetros que se pasarían al método de métricas __init__
(para facilitar el uso, se pueden omitir los corchetes '{' y '}' iniciales y finales). 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 es compatible 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 de métricas es una serie de claves/valores de métricas y/o claves/valores de gráficos en función de la configuración utilizada.
Claves métricas
Las MetricKeys se definen mediante un tipo de clave estructurada. Esta clave identifica de forma única cada uno de los siguientes aspectos de una métrica:
- Nombre de la 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 multiclase está binarizado)
Valor métrico
Los MetricValues se definen mediante un prototipo que encapsula los diferentes tipos de valores admitidos 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
: un contenedor para un tipo doble. -
bytes_value
: un valor de bytes. -
bounded_value
: representa un valor real que podría ser una estimación puntual, opcionalmente con límites aproximados de algún tipo. Tiene las propiedadesvalue
,lower_bound
yupper_bound
. -
value_at_cutoffs
: valor en los límites (p. ej., precisión@K, recuperación@K). Tienevalues
de propiedad, cada uno de los cuales tiene propiedadescutoff
yvalue
. -
confusion_matrix_at_thresholds
- Matriz de confusión en los umbrales. Tienematrices
de propiedades, cada una de las cuales tiene propiedades para valores de matriz dethreshold
,precision
,recall
y confusión, comofalse_negatives
. -
array_value
: para métricas que devuelven una matriz de valores.
Claves de trama
PlotKeys son similares a las claves métricas excepto que, por razones históricas, todos los valores de los gráficos se almacenan en un solo prototipo, por lo que la clave de gráfico no tiene nombre.
Valores de trazado
Todos los gráficos admitidos se almacenan en un solo prototipo llamado PlotData .
EvalResult
El resultado de una ejecución de evaluación es un tfma.EvalResult
. Este registro contiene slicing_metrics
que codifican la clave de la métrica como un dictado de varios niveles donde los niveles corresponden al nombre de salida, el ID de clase, el nombre de la métrica y el valor de la métrica, respectivamente. Esto está destinado a ser utilizado para la visualización de la interfaz de usuario en un portátil de Júpiter. Si se necesita acceso a los datos subyacentes, se debe usar el archivo de resultados de metrics
(consulte 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 haz.
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 métrica de keras personalizada, los usuarios deben ampliar tf.keras.metrics.Metric
con su implementación y luego asegurarse de que el módulo de la métrica esté disponible en el momento de la evaluación.
Tenga en cuenta que para las métricas añadidas después del guardado del modelo, TFMA solo admite métricas que toman la etiqueta (es decir, y_true), la predicción (y_pred) y el peso del ejemplo (sample_weight) como parámetros para el método update_state
.
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 una métrica TFMA personalizada, los usuarios deben ampliar tfma.metrics.Metric
con su implementación y luego asegurarse de que el módulo de la métrica esté disponible en el momento de la evaluación.
Métrico
Una implementación de tfma.metrics.Metric
se compone de un conjunto de kwargs que definen la configuración de las métricas junto con una función para crear los cálculos (posiblemente múltiples) necesarios para calcular el valor de las métricas. Hay dos tipos principales de cómputo que se pueden usar: tfma.metrics.MetricComputation
y tfma.metrics.DerivedMetricComputation
que se describen en las secciones a continuación. 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 se pasó al evaluador (útil para buscar configuraciones de 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 un modelo único)
-
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
- Clave de consulta utilizada si se calcula una métrica basada en consulta/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, salida y subclave, la utilidad tfma.metrics.merge_per_key_computations
se puede usar para realizar los mismos cálculos para cada una de estas entradas por separado.
cómputo métrico
Un MetricComputation
se compone de una combinación de preprocessors
y un combiner
. Los preprocessors
es una lista de preprocessor
, que es un beam.DoFn
que toma extractos como su entrada y genera el estado inicial que utilizará el combinador (consulte la arquitectura para obtener más información sobre qué son los extractos). Todos los preprocesadores se ejecutarán secuencialmente en el orden de la lista. Si los preprocessors
están vacíos, el combinador pasará StandardMetricInputs (las entradas de métricas estándar contienen etiquetas, predicciones y pesos de ejemplo). El combiner
es un beam.CombineFn
que toma una tupla de (slice key, salida del preprocesador) como entrada y genera una tupla de (slice_key, metric results dict) como resultado.
Tenga en cuenta que el corte ocurre entre los preprocessors
y el combiner
.
Tenga en cuenta que si un cálculo de métricas quiere utilizar ambas entradas de métricas estándar, pero aumentarlo con algunas de las características de los extractos de features
, entonces se puede usar el FeaturePreprocessor especial que combinará las características solicitadas de 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],
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}
Cálculo Métrico Derivado
Una DerivedMetricComputation
se compone de una función de resultado que se utiliza para calcular valores de métrica en función de la salida de otros cálculos de métrica. La función de resultado toma un dictado de valores calculados como entrada y genera un dictado de resultados de métricas 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 crear previamente y aprobar cálculos que se comparten entre varias métricas. El evaluador desduplicará automáticamente los cálculos que tengan la misma definición para que solo se ejecute un cálculo.
Ejemplo
Las métricas TJUR proporcionan un buen ejemplo de métricas derivadas.