Rejoignez-nous au DevFest pour l'Ukraine les 14 et 15 juin En ligne Inscrivez-vous maintenant

Indicateurs d'équité

Les indicateurs d'équité sont conçus pour aider les équipes à évaluer et à améliorer les modèles de problèmes d'équité en partenariat avec la boîte à outils plus large Tensorflow. L'outil est actuellement activement utilisé en interne par bon nombre de nos produits et est désormais disponible en version bêta pour l'essayer dans vos propres cas d'utilisation.

Tableau de bord des indicateurs d'équité

Qu'est-ce que les indicateurs d'équité ?

Fairness Indicators est une bibliothèque qui permet de calculer facilement des métriques d'équité communément identifiées pour les classificateurs binaires et multiclasses. De nombreux outils existants pour évaluer les problèmes d'équité ne fonctionnent pas bien sur des ensembles de données et des modèles à grande échelle. Chez Google, il est important pour nous de disposer d'outils capables de fonctionner sur des systèmes d'un milliard d'utilisateurs. Les indicateurs d'équité vous permettront d'évaluer toutes les tailles de cas d'utilisation.

En particulier, les indicateurs d'équité incluent la capacité de :

  • Évaluer la distribution des ensembles de données
  • Évaluer les performances du modèle, réparties sur des groupes d'utilisateurs définis
    • Ayez confiance en vos résultats avec des intervalles de confiance et des évaluations à plusieurs seuils
  • Plongez en profondeur dans les tranches individuelles pour explorer les causes profondes et les opportunités d'amélioration

Cette étude de cas , avec des vidéos et des exercices de programmation, montre comment les indicateurs d' équité peut être utilisé sur un de vos propres produits afin d' évaluer les préoccupations d'équité dans le temps.

Le téléchargement du package pip comprend :

Utiliser des indicateurs d'équité avec les modèles Tensorflow

Données

Pour exécuter des indicateurs d'équité avec TFMA, assurez-vous que l'ensemble de données d'évaluation est étiqueté pour les fonctionnalités que vous souhaitez trancher. Si vous ne disposez pas des fonctionnalités de tranche exactes pour vos problèmes d'équité, vous pouvez essayer de trouver un ensemble d'évaluation qui le fait, ou envisager des fonctionnalités de proxy au sein de votre ensemble de fonctionnalités qui peuvent mettre en évidence les disparités de résultats. Pour obtenir des conseils, voir ici .

Modèle

Vous pouvez utiliser la classe Tensorflow Estimator pour créer votre modèle. La prise en charge des modèles Keras sera bientôt disponible sur TFMA. Si vous souhaitez exécuter TFMA sur un modèle Keras, veuillez consulter la section « TFMA indépendante du modèle » ci-dessous.

Une fois votre estimateur formé, vous devrez exporter un modèle enregistré à des fins d'évaluation. Pour en savoir plus, consultez le guide de TFMA .

Configuration des tranches

Ensuite, définissez les tranches sur lesquelles vous souhaitez évaluer :

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur color’])
]

Si vous souhaitez évaluer les tranches intersectionnelles (par exemple, la couleur et la hauteur de la fourrure), vous pouvez définir les éléments suivants :

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur_color’, ‘height’])
]`

Calculer les métriques d'équité

Ajouter un rappel Indicateurs d' équité pour les metrics_callback liste. Dans le rappel, vous pouvez définir une liste de seuils auxquels le modèle sera évalué.

from tensorflow_model_analysis.addons.fairness.post_export_metrics import fairness_indicators

# Build the fairness metrics. Besides the thresholds, you also can config the example_weight_key, labels_key here. For more details, please check the api.
metrics_callbacks = \
    [tfma.post_export_metrics.fairness_indicators(thresholds=[0.1, 0.3,
     0.5, 0.7, 0.9])]

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=tfma_export_dir,
    add_metrics_callbacks=metrics_callbacks)

Avant d'exécuter la configuration, déterminez si vous souhaitez ou non activer le calcul des intervalles de confiance. Les intervalles de confiance sont calculés à l'aide de l'amorçage de Poisson et nécessitent un recalcul sur 20 échantillons.

compute_confidence_intervals = True

Exécutez le pipeline d'évaluation TFMA :

validate_dataset = tf.data.TFRecordDataset(filenames=[validate_tf_file])

# Run the fairness evaluation.
with beam.Pipeline() as pipeline:
  _ = (
      pipeline
      | beam.Create([v.numpy() for v in validate_dataset])
      | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
                 eval_shared_model=eval_shared_model,
                 slice_spec=slice_spec,
                 compute_confidence_intervals=compute_confidence_intervals,
                 output_path=tfma_eval_result_path)
  )
eval_result = tfma.load_eval_result(output_path=tfma_eval_result_path)

Indicateurs d'équité de rendu

from tensorflow_model_analysis.addons.fairness.view import widget_view

widget_view.render_fairness_indicator(eval_result=eval_result)

Indicateurs d'équité

Conseils pour l'utilisation des indicateurs d'équité :

  • Sélectionnez les paramètres à afficher en cochant les cases sur le côté gauche. Des graphiques individuels pour chacune des métriques apparaîtront dans le widget, dans l'ordre.
  • Changer la tranche de base, la première barre sur le graphique, à l' aide du sélecteur déroulant. Les deltas seront calculés avec cette valeur de référence.
  • Sélectionnez seuils à l' aide du sélecteur de menu déroulant. Vous pouvez afficher plusieurs seuils sur le même graphique. Les seuils sélectionnés seront en gras et vous pouvez cliquer sur un seuil en gras pour le désélectionner.
  • Passez la souris sur une barre pour voir paramètres pour cette tranche.
  • Identifier les disparités avec la ligne de base à l' aide de la colonne « Diff w. De base », qui identifie la différence en pourcentage entre la tranche en cours et la ligne de base.
  • Explorez les points de données d'une tranche en profondeur à l' aide du What-If outil . Voir ici pour un exemple.

Indicateurs d'équité de rendu pour plusieurs modèles

Les indicateurs d'équité peuvent également être utilisés pour comparer les modèles. Au lieu de transmettre un seul eval_result, transmettez un objet multi_eval_results, qui est un dictionnaire mappant deux noms de modèle aux objets eval_result.

from tensorflow_model_analysis.addons.fairness.view import widget_view

eval_result1 = tfma.load_eval_result(...)
eval_result2 = tfma.load_eval_result(...)
multi_eval_results = {"MyFirstModel": eval_result1, "MySecondModel": eval_result2}

widget_view.render_fairness_indicator(multi_eval_results=multi_eval_results)

Indicateurs d'équité - Comparaison de modèles

La comparaison de modèles peut être utilisée parallèlement à la comparaison de seuils. Par exemple, vous pouvez comparer deux modèles à deux ensembles de seuils pour trouver la combinaison optimale pour vos mesures d'équité.

Utiliser des indicateurs d'équité avec des modèles non TensorFlow

Pour mieux prendre en charge les clients qui ont des modèles et des flux de travail différents, nous avons développé une bibliothèque d'évaluation qui est indépendante du modèle évalué.

Quiconque souhaite évaluer son système d'apprentissage automatique peut l'utiliser, en particulier si vous avez des modèles non basés sur TensorFlow. À l'aide du SDK Apache Beam Python, vous pouvez créer un binaire d'évaluation TFMA autonome, puis l'exécuter pour analyser votre modèle.

Données

Cette étape consiste à fournir l'ensemble de données sur lequel vous souhaitez que les évaluations s'exécutent. Il devrait être dans tf.Example format proto ayant des étiquettes, des prévisions et d' autres caractéristiques que vous pourriez vouloir trancher sur.

tf.Example {
    features {
        feature {
          key: "fur_color" value { bytes_list { value: "gray" } }
        }
        feature {
          key: "height" value { bytes_list { value: "tall" } }
        }
        feature {
          key: "prediction" value { float_list { value: 0.9 } }
        }
        feature {
          key: "label" value { float_list { value: 1.0 } }
        }
    }
}

Modèle

Au lieu de spécifier un modèle, vous créez une configuration d'évaluation et un extracteur indépendants du modèle pour analyser et fournir les données dont TFMA a besoin pour calculer les métriques. ModelAgnosticConfig spécification définit les caractéristiques, les prédictions et les étiquettes à utiliser dans les exemples d'entrée.

Pour cela, créez une carte des caractéristiques avec des clés représentant toutes les caractéristiques, y compris des clés d'étiquette et de prédiction et des valeurs représentant le type de données de l'entité.

feature_map[label_key] = tf.FixedLenFeature([], tf.float32, default_value=[0])

Créez une configuration indépendante du modèle à l'aide de clés d'étiquette, de clés de prédiction et de la carte des caractéristiques.

model_agnostic_config = model_agnostic_predict.ModelAgnosticConfig(
    label_keys=list(ground_truth_labels),
    prediction_keys=list(predition_labels),
    feature_spec=feature_map)

Configurer l'extracteur agnostique de modèle

Extracteur est utilisé pour extraire les caractéristiques, les étiquettes et les prédictions de l'entrée à l' aide de config agnostique de modèle. Et si vous voulez couper vos données, vous devez également définir la spécification clé de tranche , contenant des informations sur les colonnes que vous souhaitez tranche sur.

model_agnostic_extractors = [
    model_agnostic_extractor.ModelAgnosticExtractor(
        model_agnostic_config=model_agnostic_config, desired_batch_size=3),
    slice_key_extractor.SliceKeyExtractor([
        slicer.SingleSliceSpec(),
        slicer.SingleSliceSpec(columns=[‘height’]),
    ])
]

Calculer les métriques d'équité

Dans le cadre de EvalSharedModel , vous pouvez fournir tous les paramètres sur lesquels vous voulez que votre modèle à évaluer. Les statistiques sont fournies sous la forme de paramètres callbacks comme celles définies dans post_export_metrics ou fairness_indicators .

metrics_callbacks.append(
    post_export_metrics.fairness_indicators(
        thresholds=[0.5, 0.9],
        target_prediction_keys=[prediction_key],
        labels_key=label_key))

Il faut aussi dans un construct_fn qui est utilisé pour créer un graphique de tensorflow pour effectuer l'évaluation.

eval_shared_model = types.EvalSharedModel(
    add_metrics_callbacks=metrics_callbacks,
    construct_fn=model_agnostic_evaluate_graph.make_construct_fn(
        add_metrics_callbacks=metrics_callbacks,
        fpl_feed_config=model_agnostic_extractor
        .ModelAgnosticGetFPLFeedConfig(model_agnostic_config)))

Une fois que tout est mis en place, utilisez une des ExtractEvaluate ou ExtractEvaluateAndWriteResults fonctions fournies par model_eval_lib pour évaluer le modèle.

_ = (
    examples |
    'ExtractEvaluateAndWriteResults' >>
        model_eval_lib.ExtractEvaluateAndWriteResults(
        eval_shared_model=eval_shared_model,
        output_path=output_path,
        extractors=model_agnostic_extractors))

eval_result = tensorflow_model_analysis.load_eval_result(output_path=tfma_eval_result_path)

Enfin, effectuez le rendu des indicateurs d'équité en suivant les instructions de la section « Rendu des indicateurs d'équité » ci-dessus.

Plus d'exemples

Le répertoire des exemples indicateurs d' équité contient plusieurs exemples: