Métriques et tracés d'analyse de modèle Tensorflow

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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és value , lower_bound et upper_bound .
  • value_at_cutoffs - Valeur aux seuils (par exemple précision@K, rappel@K). Possède des values de propriété , chacune ayant des propriétés cutoff et value .
  • confusion_matrix_at_thresholds - Matrice de confusion aux seuils. Possède des matrices de propriétés , chacune ayant des propriétés pour les valeurs de matrice de threshold , precision , de recall et de confusion telles que false_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.