Le composant de pipeline TFX de l'évaluateur

Le composant de pipeline Evaluator TFX effectue une analyse approfondie des résultats de formation de vos modèles, pour vous aider à comprendre les performances de votre modèle sur des sous-ensembles de vos données. L'évaluateur vous aide également à valider vos modèles exportés, en s'assurant qu'ils sont "suffisamment bons" pour être mis en production.

Lorsque la validation est activée, l'évaluateur compare les nouveaux modèles à une ligne de base (telle que le modèle actuellement utilisé) pour déterminer s'ils sont "suffisamment bons" par rapport à la ligne de base. Pour ce faire, il évalue les deux modèles sur un ensemble de données d'évaluation et calcule leurs performances sur des métriques (par exemple, AUC, perte). Si les métriques du nouveau modèle répondent aux critères spécifiés par le développeur par rapport au modèle de base (par exemple, l'AUC n'est pas inférieure), le modèle est "béni" (marqué comme bon), indiquant au Pusher qu'il est correct de pousser le modèle en production.

• Consomme :
  • Une séparation d'évaluation de ExampleGen
  • Un modèle formé de Trainer
  • Un modèle préalablement béni (si validation à effectuer)
• Émet :
  • Résultats de l'analyse vers les métadonnées ML
  • Résultats de la validation des métadonnées ML (si validation à effectuer)

Analyse de l'évaluateur et du modèle TensorFlow

Evaluator exploite la bibliothèque TensorFlow Model Analysis pour effectuer l'analyse, qui à son tour utilise Apache Beam pour un traitement évolutif.

Utilisation du composant Evaluateur

Un composant de pipeline Evaluator est généralement très facile à déployer et nécessite peu de personnalisation, car la majeure partie du travail est effectuée par le composant Evaluator TFX.

Pour configurer l'évaluateur, les informations suivantes sont nécessaires :

• Métriques à configurer (obligatoire uniquement si des métriques supplémentaires sont ajoutées en dehors de celles enregistrées avec le modèle). Consultez Métriques d' analyse du modèle Tensorflow pour plus d'informations.
• Tranches à configurer (si aucune tranche n'est donnée alors une tranche "globale" sera ajoutée par défaut). Voir Configuration de l'analyse du modèle Tensorflow pour plus d'informations.

Si la validation doit être incluse, les informations supplémentaires suivantes sont nécessaires :

• À quel modèle comparer (dernier bienheureux, etc.).
• Validations du modèle (seuils) à vérifier. Consultez Validations du modèle d'analyse du modèle Tensorflow pour plus d'informations.

Lorsqu'elle est activée, la validation sera effectuée par rapport à toutes les métriques et tranches qui ont été définies.

Le code typique ressemble à ceci :

import tensorflow_model_analysis as tfma
...

# For TFMA evaluation

eval_config = tfma.EvalConfig(
    model_specs=[
        # This assumes a serving model with signature 'serving_default'. If
        # using estimator based EvalSavedModel, add signature_name='eval' and
        # remove the label_key. Note, if using a TFLite model, then you must set
        # model_type='tf_lite'.
        tfma.ModelSpec(label_key='<label_key>')
    ],
    metrics_specs=[
        tfma.MetricsSpec(
            # The metrics added here are in addition to those saved with the
            # model (assuming either a keras model or EvalSavedModel is used).
            # Any metrics added into the saved model (for example using
            # model.compile(..., metrics=[...]), etc) will be computed
            # automatically.
            metrics=[
                tfma.MetricConfig(class_name='ExampleCount'),
                tfma.MetricConfig(
                    class_name='BinaryAccuracy',
                    threshold=tfma.MetricThreshold(
                        value_threshold=tfma.GenericValueThreshold(
                            lower_bound={'value': 0.5}),
                        change_threshold=tfma.GenericChangeThreshold(
                            direction=tfma.MetricDirection.HIGHER_IS_BETTER,
                            absolute={'value': -1e-10})))
            ]
        )
    ],
    slicing_specs=[
        # An empty slice spec means the overall slice, i.e. the whole dataset.
        tfma.SlicingSpec(),
        # Data can be sliced along a feature column. In this case, data is
        # sliced along feature column trip_start_hour.
        tfma.SlicingSpec(feature_keys=['trip_start_hour'])
    ])

# The following component is experimental and may change in the future. This is
# required to specify the latest blessed model will be used as the baseline.
model_resolver = Resolver(
      strategy_class=dsl.experimental.LatestBlessedModelStrategy,
      model=Channel(type=Model),
      model_blessing=Channel(type=ModelBlessing)
).with_id('latest_blessed_model_resolver')

model_analyzer = Evaluator(
      examples=examples_gen.outputs['examples'],
      model=trainer.outputs['model'],
      baseline_model=model_resolver.outputs['model'],
      # Change threshold will be ignored if there is no baseline (first run).
      eval_config=eval_config)

L'évaluateur produit un EvalResult (et éventuellement un ValidationResult si la validation a été utilisée) qui peut être chargé à l'aide de TFMA . Voici un exemple de chargement des résultats dans un notebook Jupyter :

import tensorflow_model_analysis as tfma

output_path = evaluator.outputs['evaluation'].get()[0].uri

# Load the evaluation results.
eval_result = tfma.load_eval_result(output_path)

# Visualize the metrics and plots using tfma.view.render_slicing_metrics,
# tfma.view.render_plot, etc.
tfma.view.render_slicing_metrics(tfma_result)
...

# Load the validation results
validation_result = tfma.load_validation_result(output_path)
if not validation_result.validation_ok:
  ...

Plus de détails sont disponibles dans la référence de l'API Evaluator .