Aperçu
TFMA prend en charge les métriques et les graphiques suivants :
- Métriques Keras standard (
tf.keras.metrics.*
)- Notez que vous n'avez pas besoin d'un modèle keras pour utiliser les métriques keras. Les métriques sont calculées en dehors du graphique dans le faisceau en utilisant directement les classes de métriques.
Métriques et graphiques TFMA standard (
tfma.metrics.*
)Métriques Keras personnalisées (métriques dérivées de
tf.keras.metrics.Metric
)Métriques TFMA personnalisées (métriques dérivées de
tfma.metrics.Metric
) utilisant des combinateurs de faisceaux personnalisés ou des métriques dérivées d'autres métriques).
TFMA fournit également une prise en charge intégrée pour la conversion des métriques de classification binaires à utiliser avec des problèmes multi-classes/multi-étiquettes :
- Binarisation basée sur l'ID de classe, le top K, etc.
- Mesures agrégées basées sur la moyenne micro, la moyenne macro, etc.
TFMA fournit également une prise en charge intégrée des métriques basées sur les requêtes/classement où les exemples sont automatiquement regroupés par une clé de requête dans le pipeline.
Ensemble, il existe plus de 50 métriques et graphiques standard disponibles pour une variété de problèmes, y compris la régression, la classification binaire, la classification multi-classes/multi-étiquettes, le classement, etc.
Configuration
Il existe deux façons de configurer les métriques dans TFMA : (1) en utilisant tfma.MetricsSpec
ou (2) en créant des instances des tf.keras.metrics.*
et/ou tfma.metrics.*
en python et en utilisant tfma.metrics.specs_from_metrics
pour les convertir en une liste de tfma.MetricsSpec
.
Les sections suivantes décrivent des exemples de configurations pour différents types de problèmes d'apprentissage automatique.
Métriques de régression
Voici un exemple de configuration de configuration pour un problème de régression. Consultez les tf.keras.metrics.*
et tfma.metrics.*
pour d'éventuelles mesures supplémentaires prises en charge.
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
Cette même configuration peut être créée à l'aide du code python suivant :
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)
Notez que cette configuration est également disponible en appelant tfma.metrics.default_regression_specs
.
Métriques de classification binaire
Voici un exemple de configuration de configuration pour un problème de classification binaire. Consultez les tf.keras.metrics.*
et tfma.metrics.*
pour d'éventuelles mesures supplémentaires prises en charge.
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
Cette même configuration peut être créée à l'aide du code python suivant :
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)
Notez que cette configuration est également disponible en appelant tfma.metrics.default_binary_classification_specs
.
Métriques de classification multi-classes/multi-étiquettes
Voici un exemple de configuration de configuration pour un problème de classification multiclasse. Consultez les tf.keras.metrics.*
et tfma.metrics.*
pour d'éventuelles mesures supplémentaires prises en charge.
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
Cette même configuration peut être créée à l'aide du code python suivant :
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)
Notez que cette configuration est également disponible en appelant tfma.metrics.default_multi_class_classification_specs
.
Métriques binarisées multi-classes/multi-étiquettes
Les métriques multi-classes/multi-étiquettes peuvent être binarisées pour produire des métriques par classe, par top_k, etc. à l'aide de tfma.BinarizationOptions
. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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étriques agrégées multi-classes/multi-étiquettes
Les métriques multi-classes/multi-étiquettes peuvent être agrégées pour produire une seule valeur agrégée pour une métrique de classification binaire à l'aide de tfma.AggregationOptions
.
Notez que les paramètres d'agrégation sont indépendants des paramètres de binarisation, vous pouvez donc utiliser à la fois tfma.AggregationOptions
et tfma.BinarizationOptions
.
Micro Moyenne
Le micro calcul de la moyenne peut être effectué à l'aide de l'option micro_average
dans tfma.AggregationOptions
. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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))
La micro-moyenne prend également en charge la définition de top_k
où seules les valeurs k supérieures sont utilisées dans le calcul. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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 / Moyenne macro pondérée
La moyenne des macros peut être effectuée à l'aide des options macro_average
ou weighted_macro_average
dans tfma.AggregationOptions
. À moins que les paramètres top_k
ne soient utilisés, la macro nécessite de définir les class_weights
afin de savoir pour quelles classes calculer la moyenne. Si un class_weight
n'est pas fourni, alors 0,0 est supposé. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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)}))
Comme la moyenne micro, la moyenne macro prend également en charge la définition de top_k
où seules les valeurs k supérieures sont utilisées dans le calcul. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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étriques basées sur les requêtes / classements
Les métriques basées sur les requêtes/le classement sont activées en spécifiant l'option query_key
dans les spécifications des métriques. Par example:
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
Cette même configuration peut être créée à l'aide du code python suivant :
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étriques d'évaluation multi-modèles
TFMA prend en charge l'évaluation de plusieurs modèles en même temps. Lorsque l'évaluation multi-modèle est effectuée, les métriques sont calculées pour chaque modèle. Par example:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
# no model_names means all models
...
}
""", tfma.EvalConfig()).metrics_specs
Si des métriques doivent être calculées pour un sous-ensemble de modèles, définissez model_names
dans metric_specs
. Par example:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
model_names: ["my-model1"]
...
}
""", tfma.EvalConfig()).metrics_specs
L'API specs_from_metrics
prend également en charge la transmission des noms de modèle :
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, model_names=['my-model1'])
Métriques de comparaison de modèles
TFMA prend en charge l'évaluation des métriques de comparaison pour un modèle candidat par rapport à un modèle de référence. Un moyen simple de configurer la paire de modèles candidat et de référence consiste à transmettre un eval_shared_model avec les noms de modèle appropriés (tfma.BASELINE_KEY et 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")
Les métriques de comparaison sont calculées automatiquement pour toutes les métriques diff-ables (actuellement uniquement les métriques de valeur scalaire telles que la précision et l'AUC).
Métriques du modèle à sorties multiples
TFMA prend en charge l'évaluation des métriques sur des modèles qui ont des sorties différentes. Les modèles à sorties multiples stockent leurs prédictions de sortie sous la forme d'un dict indexé par le nom de la sortie. Lorsque des modèles à sorties multiples sont utilisés, les noms des sorties associées à un ensemble de métriques doivent être spécifiés dans la section output_names
de MetricsSpec. Par example:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
output_names: ["my-output"]
...
}
""", tfma.EvalConfig()).metrics_specs
L'API specs_from_metrics
prend également en charge la transmission des noms de sortie :
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, output_names=['my-output'])
Personnalisation des paramètres de mesure
TFMA permet de personnaliser les paramètres utilisés avec différentes métriques. Par exemple, vous souhaiterez peut-être modifier le nom, définir des seuils, etc. Cela se fait en ajoutant une section de config
à la métrique config. La configuration est spécifiée à l'aide de la version de chaîne JSON des paramètres qui seraient transmis à la méthode __init__
des métriques (pour faciliter l'utilisation, les crochets '{' et '}' de début et de fin peuvent être omis). Par example:
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
Cette personnalisation est bien entendu également prise en charge directement :
metrics = [
tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
Les sorties
La sortie d'une évaluation de métrique est une série de clés/valeurs de métrique et/ou de clés/valeurs de tracé basées sur la configuration utilisée.
Clés métriques
Les MetricKeys sont définies à l'aide d'un type de clé structurée. Cette clé identifie de manière unique chacun des aspects suivants d'une métrique :
- Nom de la métrique (
auc
,mean_label
, etc.) - Nom du modèle (utilisé uniquement en cas d'évaluation multi-modèle)
- Nom de la sortie (utilisé uniquement si des modèles multi-sorties sont évalués)
- Sous-clé (par exemple, ID de classe si le modèle multi-classes est binarisé)
Valeur métrique
Les MetricValues sont définies à l'aide d'un proto qui encapsule les différents types de valeurs pris en charge par les différentes métriques (par exemple double
, ConfusionMatrixAtThresholds
, etc.).
Vous trouverez ci-dessous les types de valeurs de métrique pris en charge :
-
double_value
- Un wrapper pour un type double. -
bytes_value
- Une valeur d'octets. -
bounded_value
- Représente une valeur réelle qui pourrait être une estimation ponctuelle, éventuellement avec des limites approximatives d'une certaine sorte. Possède les propriétésvalue
,lower_bound
etupper_bound
. -
value_at_cutoffs
- Valeur aux seuils (par exemple précision@K, rappel@K). Possède desvalues
de propriété , chacune ayant des propriétéscutoff
etvalue
. -
confusion_matrix_at_thresholds
- Matrice de confusion aux seuils. Possède desmatrices
de propriétés , chacune ayant des propriétés pour les valeurs de matrice dethreshold
,precision
, derecall
et de confusion telles quefalse_negatives
. -
array_value
- Pour les métriques qui renvoient un tableau de valeurs.
Clés de tracé
Les PlotKeys sont similaires aux clés métriques sauf que pour des raisons historiques, toutes les valeurs des tracés sont stockées dans un seul proto, de sorte que la clé de tracé n'a pas de nom.
Valeurs de tracé
Tous les tracés pris en charge sont stockés dans un seul proto appelé PlotData .
Résultat de l'évaluation
Le retour d'une exécution d'évaluation est un tfma.EvalResult
. Cet enregistrement contient des slicing_metrics
qui encodent la clé de métrique sous la forme d'un dict à plusieurs niveaux où les niveaux correspondent respectivement au nom de la sortie, à l'ID de classe, au nom de la métrique et à la valeur de la métrique. Ceci est destiné à être utilisé pour l'affichage de l'interface utilisateur dans un ordinateur portable Jupiter. Si l'accès aux données sous-jacentes est nécessaire, le fichier de résultats des metrics
doit être utilisé à la place (voir metrics_for_slice.proto ).
Personnalisation
En plus des métriques personnalisées qui sont ajoutées dans le cadre d'un keras enregistré (ou EvalSavedModel hérité). Il existe deux façons de personnaliser les métriques dans TFMA après l'enregistrement : (1) en définissant une classe de métriques keras personnalisée et (2) en définissant une classe de métriques TFMA personnalisée soutenue par un combinateur de faisceaux.
Dans les deux cas, les métriques sont configurées en spécifiant le nom de la classe de métriques et du module associé. Par example:
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étriques Keras personnalisées
Pour créer une métrique keras personnalisée, les utilisateurs doivent étendre tf.keras.metrics.Metric
avec leur implémentation, puis s'assurer que le module de la métrique est disponible au moment de l'évaluation.
Notez que pour les métriques ajoutées après l'enregistrement du modèle, TFMA ne prend en charge que les métriques qui prennent l'étiquette (c'est-à-dire y_true), la prédiction (y_pred) et l'exemple de poids (sample_weight) comme paramètres de la méthode update_state
.
Exemple de métrique Keras
Voici un exemple de métrique Keras personnalisée :
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étriques TFMA personnalisées
Pour créer une métrique TFMA personnalisée, les utilisateurs doivent étendre tfma.metrics.Metric
avec leur implémentation, puis s'assurer que le module de la métrique est disponible au moment de l'évaluation.
Métrique
Une implémentation tfma.metrics.Metric
est composée d'un ensemble de kwargs qui définissent la configuration des métriques avec une fonction pour créer les calculs (éventuellement multiples) nécessaires pour calculer la valeur des métriques. Deux principaux types de calcul peuvent être utilisés : tfma.metrics.MetricComputation
et tfma.metrics.DerivedMetricComputation
, qui sont décrits dans les sections ci-dessous. La fonction qui crée ces calculs recevra les paramètres suivants en entrée :
-
eval_config: tfam.EvalConfig
- La configuration eval transmise à l'évaluateur (utile pour rechercher les paramètres de spécification du modèle tels que la clé de prédiction à utiliser, etc.).
-
model_names: List[Text]
- Liste des noms de modèles pour lesquels calculer les métriques (Aucun si modèle unique)
-
output_names: List[Text]
.- Liste des noms de sortie pour lesquels calculer les métriques (Aucun si modèle unique)
-
sub_keys: List[tfma.SubKey]
.- Liste des sous-clés (ID de classe, top K, etc.) pour calculer les métriques (ou Aucune)
-
aggregation_type: tfma.AggregationType
- Type d'agrégation en cas de calcul d'une métrique d'agrégation.
-
class_weights: Dict[int, float]
.- Pondérations de classe à utiliser si vous calculez une métrique d'agrégation.
-
query_key: Text
- Clé de requête utilisée lors du calcul d'une métrique basée sur la requête/le classement.
Si une métrique n'est pas associée à un ou plusieurs de ces paramètres, elle peut exclure ces paramètres de sa définition de signature.
Si une métrique est calculée de la même manière pour chaque modèle, sortie et sous-clé, l'utilitaire tfma.metrics.merge_per_key_computations
peut être utilisé pour effectuer les mêmes calculs pour chacune de ces entrées séparément.
MétriqueComputation
Un MetricComputation
est composé d'une combinaison de preprocessors
et d'un combiner
. Les preprocessors
sont une liste de preprocessor
, qui est un beam.DoFn
qui prend des extraits en entrée et produit l'état initial qui sera utilisé par le combinateur (voir architecture pour plus d'informations sur ce que sont les extraits). Tous les préprocesseurs seront exécutés séquentiellement dans l'ordre de la liste. Si les preprocessors
sont vides, le combinateur recevra StandardMetricInputs (les entrées de métrique standard contiennent des étiquettes, des prédictions et des example_weights). Le combiner
est un beam.CombineFn
qui prend un tuple de (clé de tranche, sortie du préprocesseur) comme entrée et produit un tuple de (clé_tranche, dict des résultats métriques) comme résultat.
Notez que le découpage se produit entre les preprocessors
et le combiner
.
Notez que si un calcul métrique veut utiliser à la fois les entrées métriques standard, mais l'augmenter avec quelques-unes des caractéristiques des extraits de features
, alors le FeaturePreprocessor spécial peut être utilisé qui fusionnera les caractéristiques demandées à partir de plusieurs combinateurs en un seul. valeur partagée StandardMetricsInputs qui est transmise à tous les combinateurs (les combinateurs sont chargés de lire les fonctionnalités qui les intéressent et d'ignorer le reste).
Exemple
Voici un exemple très simple de définition de métrique TFMA pour le calcul de 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
Un DerivedMetricComputation
est composé d'une fonction de résultat qui est utilisée pour calculer les valeurs de métrique en fonction de la sortie d'autres calculs de métrique. La fonction de résultat prend un dict de valeurs calculées en entrée et génère un dict de résultats de métriques supplémentaires.
Notez qu'il est acceptable (recommandé) d'inclure les calculs dont dépend un calcul dérivé dans la liste des calculs créés par une métrique. Cela évite d'avoir à pré-créer et à transmettre des calculs partagés entre plusieurs métriques. L'évaluateur dupliquera automatiquement les calculs qui ont la même définition afin qu'un seul calcul soit réellement exécuté.
Exemple
Les métriques TJUR fournissent un bon exemple de métriques dérivées.