Treten Sie der SIG TFX-Addons-Community bei und helfen Sie, TFX noch besser zu machen!

Fairness-Indikatoren

Fairness Indicators soll Teams bei der Bewertung und Verbesserung von Modellen für Fairness-Bedenken in Zusammenarbeit mit dem breiteren Tensorflow-Toolkit unterstützen. Das Tool wird derzeit von vielen unserer Produkte intern aktiv verwendet und ist jetzt in BETA verfügbar, um Ihre eigenen Anwendungsfälle zu testen.

Fairness Indicator Dashboard

Was sind Fairness-Indikatoren?

Fairness Indicators ist eine Bibliothek, die die einfache Berechnung häufig identifizierter Fairness-Metriken für Binär- und Mehrklassenklassifizierer ermöglicht. Viele vorhandene Tools zur Bewertung von Fairnessproblemen funktionieren bei großen Datensätzen und Modellen nicht gut. Bei Google ist es wichtig, dass wir über Tools verfügen, die auf Systemen mit Milliarden Nutzern funktionieren. Mit Fairness Indicators können Sie eine Bewertung für jede Anwendungsfallgröße vornehmen.

Fairness Indicators umfasst insbesondere die Fähigkeit:

  • Bewerten Sie die Verteilung von Datensätzen
  • Bewerten Sie die Modellleistung, die auf definierte Benutzergruppen verteilt ist
    • Vertrauen Sie auf Ihre Ergebnisse mit Konfidenzintervallen und Auswertungen bei mehreren Schwellenwerten
  • Tauchen Sie tief in einzelne Scheiben ein, um die Ursachen und Verbesserungsmöglichkeiten zu erkunden

Diese Fallstudie mit Videos und Programmierübungen zeigt, wie Fairness Indicators für eines Ihrer eigenen Produkte verwendet werden können, um Fairness-Bedenken im Laufe der Zeit zu bewerten.

Der Download des Pip-Pakets beinhaltet:

Verwenden von Fairness-Indikatoren mit Tensorflow-Modellen

Daten

Stellen Sie zum Ausführen von Fairness Indicators mit TFMA sicher, dass der Bewertungsdatensatz für die Funktionen gekennzeichnet ist, nach denen Sie schneiden möchten. Wenn Sie nicht über die genauen Slice-Funktionen für Ihre Fairness-Bedenken verfügen, können Sie versuchen, einen Bewertungssatz zu finden, der dies tut, oder Proxy-Funktionen in Ihrem Funktionssatz berücksichtigen, die möglicherweise zu Ergebnisunterschieden führen. Weitere Hinweise finden Sie hier .

Modell

Sie können die Tensorflow Estimator-Klasse verwenden, um Ihr Modell zu erstellen. Die Unterstützung für Keras-Modelle wird in Kürze von TFMA angeboten. Wenn Sie TFMA auf einem Keras-Modell ausführen möchten, lesen Sie bitte den folgenden Abschnitt „Modellunabhängiges TFMA“.

Nachdem Ihr Schätzer geschult wurde, müssen Sie ein gespeichertes Modell zu Bewertungszwecken exportieren. Weitere Informationen finden Sie im TFMA-Handbuch .

Slices konfigurieren

Definieren Sie als Nächstes die Slices, für die Sie eine Bewertung vornehmen möchten:

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

Wenn Sie Schnittschnitte auswerten möchten (z. B. Fellfarbe und -höhe), können Sie Folgendes einstellen:

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

Fairness-Metriken berechnen

Fügen Sie der metrics_callback Liste einen Fairness Indicators-Rückruf metrics_callback . Im Rückruf können Sie eine Liste von Schwellenwerten definieren, bei denen das Modell ausgewertet wird.

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)

Stellen Sie vor dem Ausführen der Konfiguration fest, ob Sie die Berechnung von Konfidenzintervallen aktivieren möchten oder nicht. Konfidenzintervalle werden mithilfe von Poisson-Bootstrapping berechnet und erfordern eine Neuberechnung über 20 Stichproben.

compute_confidence_intervals = True

Führen Sie die TFMA-Evaluierungspipeline aus:

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)

Render-Fairness-Indikatoren

from tensorflow_model_analysis.addons.fairness.view import widget_view

widget_view.render_fairness_indicator(eval_result=eval_result)

Fairness-Indikatoren

Tipps zur Verwendung von Fairness Indicators:

  • Wählen Sie die anzuzeigenden Metriken aus, indem Sie die Kontrollkästchen auf der linken Seite aktivieren. Einzelne Diagramme für jede der Metriken werden der Reihe nach im Widget angezeigt.
  • Ändern Sie den Grundlinien-Slice , den ersten Balken im Diagramm, mithilfe der Dropdown-Auswahl. Deltas werden mit diesem Basiswert berechnet.
  • Wählen Sie Schwellenwerte mit der Dropdown-Auswahl. Sie können mehrere Schwellenwerte in demselben Diagramm anzeigen. Ausgewählte Schwellenwerte werden fett gedruckt, und Sie können auf einen fettgedruckten Schwellenwert klicken, um die Auswahl aufzuheben.
  • Bewegen Sie den Mauszeiger über eine Leiste , um die Metriken für dieses Slice anzuzeigen.
  • Identifizieren Sie Unterschiede zur Basislinie mithilfe der Spalte "Diff w. Baseline", in der die prozentuale Differenz zwischen dem aktuellen Slice und der Baseline angegeben ist.
  • Untersuchen Sie die Datenpunkte eines Slice mit dem Was-wäre-wenn-Werkzeug in der Tiefe . Siehe hier für ein Beispiel.

Rendern von Fairness-Indikatoren für mehrere Modelle

Fairness Indicators können auch zum Vergleichen von Modellen verwendet werden. Anstatt ein einzelnes eval_result zu übergeben, übergeben Sie ein multi_eval_results-Objekt, bei dem es sich um ein Wörterbuch handelt, das zwei Modellnamen eval_result-Objekten zuordnet.

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)

Fairness Indicators - Modellvergleich

Der Modellvergleich kann neben dem Schwellenwertvergleich verwendet werden. Sie können beispielsweise zwei Modelle mit zwei Schwellenwerten vergleichen, um die optimale Kombination für Ihre Fairness-Metriken zu finden.

Verwenden von Fairness-Indikatoren mit Nicht-TensorFlow-Modellen

Um Kunden mit unterschiedlichen Modellen und Workflows besser zu unterstützen, haben wir eine Evaluierungsbibliothek entwickelt, die für das zu evaluierende Modell unabhängig ist.

Jeder, der sein maschinelles Lernsystem evaluieren möchte, kann dies verwenden, insbesondere wenn Sie nicht auf TensorFlow basierende Modelle haben. Mit dem Apache Beam Python SDK können Sie eine eigenständige TFMA-Evaluierungsbinärdatei erstellen und diese dann ausführen, um Ihr Modell zu analysieren.

Daten

In diesem Schritt wird das Dataset bereitgestellt, auf dem die Auswertungen ausgeführt werden sollen. Es sollte im tf.Beispiel- Proto-Format mit Beschriftungen, Vorhersagen und anderen Funktionen vorliegen, auf die Sie möglicherweise schneiden möchten.

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 } }
        }
    }
}

Modell

Anstatt ein Modell anzugeben, erstellen Sie eine modellunabhängige Evaluierungskonfiguration und einen Extraktor, um die Daten zu analysieren und bereitzustellen, die TFMA zur Berechnung von Metriken benötigt. Die ModelAgnosticConfig- Spezifikation definiert die Features, Vorhersagen und Beschriftungen, die aus den Eingabebeispielen verwendet werden sollen.

Erstellen Sie dazu eine Feature-Map mit Schlüsseln, die alle Features darstellen, einschließlich Beschriftungs- und Vorhersageschlüsseln sowie Werten, die den Datentyp des Features darstellen.

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

Erstellen Sie eine modellunabhängige Konfiguration mit Beschriftungsschlüsseln, Vorhersageschlüsseln und der Feature-Map.

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

Richten Sie Model Agnostic Extractor ein

Extractor wird verwendet, um die Features, Beschriftungen und Vorhersagen mithilfe der modellunabhängigen Konfiguration aus der Eingabe zu extrahieren. Wenn Sie Ihre Daten aufteilen möchten, müssen Sie auch dieSlice-Schlüsselspezifikation definieren, die Informationen zu den Spalten enthält, in die Sie aufteilen möchten.

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’]),
    ])
]

Fairness-Metriken berechnen

Als Teil von EvalSharedModel können Sie alle Metriken bereitstellen, anhand derer Ihr Modell ausgewertet werden soll. Metriken werden in Form von Metrik-Rückrufen bereitgestellt, wie sie in post_export_metrics oder fairness_indicators definiert sind .

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

Es wird auch ein construct_fn verwendet, mit dem ein Tensorflow-Diagramm zur Durchführung der Auswertung erstellt wird.

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)))

Wenn alles eingerichtet ist, verwenden Sie eine der von ExtractEvaluate ExtractEvaluateAndWriteResults Funktionen ExtractEvaluate oder ExtractEvaluateAndWriteResults , um das Modell auszuwerten.

_ = (
    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)

Rendern Sie abschließend Fairness Indicators anhand der Anweisungen im obigen Abschnitt "Render Fairness Indicators".

Mehr Beispiele

Das Beispielverzeichnis für Fairness Indicators enthält mehrere Beispiele: