Salva la data! Google I / O ritorna dal 18 al 20 maggio Registrati ora
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Case study sulla riparazione del modello

In questo taccuino formeremo un classificatore di testo per identificare il contenuto scritto che potrebbe essere considerato tossico o dannoso e applicheremo MinDiff per porre rimedio ad alcuni problemi di equità. Nel nostro flusso di lavoro, dovremo:

  1. Valuta le prestazioni del nostro modello di base sul testo contenente riferimenti a gruppi sensibili.
  2. Migliora le prestazioni su tutti i gruppi con prestazioni insufficienti allenandoti con MinDiff.
  3. Valuta le prestazioni del nuovo modello sulla metrica scelta.

Il nostro scopo è dimostrare l'utilizzo della tecnica MinDiff con un flusso di lavoro minimo, non delineare un approccio di principio all'equità nell'apprendimento automatico. Pertanto, la nostra valutazione si concentrerà solo su una categoria sensibile e una singola metrica. Inoltre, non affrontiamo potenziali carenze nel set di dati, né ottimizziamo le nostre configurazioni. In un contesto di produzione, dovresti avvicinarti a ciascuno di questi con rigore. Per ulteriori informazioni sulla valutazione dell'equità, consultare questa guida .

Impostare

Iniziamo installando gli indicatori di equità e la correzione del modello TensorFlow.

Installa

Importare tutti i componenti necessari, inclusi MinDiff e Indicatori di equità per la valutazione.

Importazioni

Usiamo una funzione di utilità per scaricare i dati preelaborati e preparare le etichette in modo che corrispondano alla forma di output del modello. La funzione scarica anche i dati come TFRecords per rendere più rapida la valutazione successiva. In alternativa, puoi convertire Pandas DataFrame in TFRecords con qualsiasi funzione di conversione di utilità disponibile.

# We use a helper utility to preprocessed data for convenience and speed.
data_train, data_validate, validate_tfrecord_file, labels_train, labels_validate = min_diff_keras_utils.download_and_process_civil_comments_data()
Downloading data from https://storage.googleapis.com/civil_comments_dataset/train_df_processed.csv
345702400/345699197 [==============================] - 12s 0us/step
Downloading data from https://storage.googleapis.com/civil_comments_dataset/validate_df_processed.csv
229974016/229970098 [==============================] - 8s 0us/step
Downloading data from https://storage.googleapis.com/civil_comments_dataset/validate_tf_processed.tfrecord
324943872/324941336 [==============================] - 11s 0us/step

Definiamo alcune costanti utili. Addestreremo il modello sulla funzione 'comment_text' , con la nostra etichetta target come 'toxicity' . Si noti che la dimensione del batch qui viene scelta arbitrariamente, ma in un'impostazione di produzione sarebbe necessario regolarla per ottenere le migliori prestazioni.

TEXT_FEATURE = 'comment_text'
LABEL = 'toxicity'
BATCH_SIZE = 512

Imposta semi casuali. (Notare che questo non stabilizza completamente i risultati.)

Semi

Definisci e addestra il modello di base

Per ridurre il tempo di esecuzione, utilizziamo un modello pre-addestrato per impostazione predefinita. È un semplice modello sequenziale di Keras con un incorporamento iniziale e strati di convoluzione, che forniscono una previsione di tossicità. Se preferisci, puoi modificarlo e allenarti da zero utilizzando la nostra funzione di utilità per creare il modello. (Tieni presente che poiché il tuo ambiente è probabilmente diverso dal nostro, dovrai personalizzare le soglie di ottimizzazione e valutazione.)

use_pretrained_model = True

if use_pretrained_model:
  URL = 'https://storage.googleapis.com/civil_comments_model/baseline_model.zip'
  BASE_PATH = tempfile.mkdtemp()
  ZIP_PATH = os.path.join(BASE_PATH, 'baseline_model.zip')
  MODEL_PATH = os.path.join(BASE_PATH, 'tmp/baseline_model')

  r = requests.get(URL, allow_redirects=True)
  open(ZIP_PATH, 'wb').write(r.content)

  with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:
    zip_ref.extractall(BASE_PATH)
  baseline_model = tf.keras.models.load_model(
      MODEL_PATH, custom_objects={'KerasLayer' : hub.KerasLayer})
else:
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  loss = tf.keras.losses.BinaryCrossentropy()

  baseline_model = min_diff_keras_utils.create_keras_sequential_model()

  baseline_model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

  baseline_model.fit(x=data_train[TEXT_FEATURE],
                     y=labels_train,
                     batch_size=BATCH_SIZE,
                     epochs=20)

Salviamo il modello per valutarlo utilizzando gli indicatori di equità .

base_dir = tempfile.mkdtemp(prefix='saved_models')
baseline_model_location = os.path.join(base_dir, 'model_export_baseline')
baseline_model.save(baseline_model_location, save_format='tf')
INFO:tensorflow:Assets written to: /tmp/saved_modelsowlqmp2b/model_export_baseline/assets
INFO:tensorflow:Assets written to: /tmp/saved_modelsowlqmp2b/model_export_baseline/assets

Successivamente eseguiamo gli indicatori di equità. Come promemoria, eseguiremo solo una valutazione parziale per i commenti che fanno riferimento a una categoria, i gruppi religiosi . In un ambiente di produzione, consigliamo di adottare un approccio ponderato per determinare quali categorie e metriche valutare.

Per calcolare le prestazioni del modello, la funzione di utilità effettua alcune scelte convenienti per metriche, sezioni e soglie di classificazione.

# We use a helper utility to hide the evaluation logic for readability.
base_dir = tempfile.mkdtemp(prefix='eval')
eval_dir = os.path.join(base_dir, 'tfma_eval_result')
eval_result = fi_util.get_eval_results(
    baseline_model_location, eval_dir, validate_tfrecord_file)
WARNING:absl:Tensorflow version (2.4.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:tensorflow:5 out of the last 5 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4de0d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:5 out of the last 5 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4de0d0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:6 out of the last 6 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4de598> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:6 out of the last 6 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4de598> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Rendering dei risultati della valutazione

widget_view.render_fairness_indicator(eval_result)
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Overall', 'slice': 'Overall', 'metrics': {'accuracy': …

Diamo un'occhiata ai risultati della valutazione. Prova a selezionare il tasso metrico di falsi positivi (FPR) con soglia 0,450. Possiamo vedere che il modello non funziona bene per alcuni gruppi religiosi come per altri, mostrando un FPR molto più alto. Notare gli ampi intervalli di confidenza su alcuni gruppi perché hanno pochi esempi. Ciò rende difficile affermare con certezza che esiste una differenza significativa nelle prestazioni per queste sezioni. Potremmo voler raccogliere più esempi per affrontare questo problema. Possiamo, tuttavia, tentare di applicare MinDiff per i due gruppi che, siamo certi, stanno sottoperformando.

Abbiamo scelto di concentrarci su FPR, perché un FPR più elevato significa che i commenti che fanno riferimento a questi gruppi di identità hanno maggiori probabilità di essere contrassegnati in modo errato come tossici rispetto ad altri commenti. Ciò potrebbe portare a risultati ingiusti per gli utenti che si impegnano nel dialogo sulla religione, ma si noti che le disparità in altri parametri possono portare ad altri tipi di danno.

Definire e addestrare il modello MinDiff

Ora proveremo a migliorare l'FPR per i gruppi religiosi con prestazioni insufficienti. Tenteremo di farlo utilizzando MinDiff , una tecnica di correzione che cerca di bilanciare i tassi di errore tra le porzioni di dati penalizzando le disparità nelle prestazioni durante l'addestramento. Quando applichiamo MinDiff, le prestazioni del modello potrebbero peggiorare leggermente su altre sezioni. Pertanto, i nostri obiettivi con MinDiff saranno:

  • Prestazioni migliorate per i gruppi con prestazioni inferiori
  • Riduzione limitata per altri gruppi e prestazioni complessive

Prepara i tuoi dati

Per utilizzare MinDiff, creiamo due ulteriori suddivisioni dei dati:

  • Una divisione per esempi non tossici che fanno riferimento a gruppi di minoranza: nel nostro caso, questo includerà commenti con riferimenti ai nostri termini di identità poco performanti. Non includiamo alcuni dei gruppi perché ci sono troppo pochi esempi, portando a una maggiore incertezza con ampi intervalli di intervallo di confidenza.
  • Una divisione per esempi non tossici che fanno riferimento al gruppo di maggioranza.

È importante avere un numero sufficiente di esempi appartenenti alle classi con prestazioni insufficienti. In base all'architettura del modello, alla distribuzione dei dati e alla configurazione MinDiff, la quantità di dati necessaria può variare in modo significativo. Nelle applicazioni precedenti, abbiamo visto MinDiff funzionare bene con 5.000 esempi in ciascuna suddivisione dei dati.

Nel nostro caso, i gruppi nelle scissioni di minoranza hanno quantità di esempio di 9.688 e 3.906. Notare gli squilibri di classe nel set di dati; in pratica, questo potrebbe essere motivo di preoccupazione, ma non cercheremo di affrontarli in questo taccuino poiché la nostra intenzione è solo di dimostrare MinDiff.

Selezioniamo solo esempi negativi per questi gruppi, in modo che MinDiff possa ottimizzare per ottenere questi esempi correttamente. Può sembrare controintuitivo ritagliarsi una serie di esempi negativi di verità di base se siamo principalmente interessati alle disparità nel tasso di falsi positivi , ma ricorda che una previsione di falsi positivi è un esempio di verità negativo di base che è erroneamente classificato come positivo, che è il problema che stai cercando di affrontare.

Crea DataFrame MinDiff

# Create masks for the sensitive and nonsensitive groups
minority_mask = data_train.religion.apply(
    lambda x: any(religion in x for religion in ('jewish', 'muslim')))
majority_mask = data_train.religion.apply(lambda x: x == "['christian']")

# Select nontoxic examples, so MinDiff will be able to reduce sensitive FP rate.
true_negative_mask = data_train['toxicity'] == 0

data_train_main = copy.copy(data_train)
data_train_sensitive = data_train[minority_mask & true_negative_mask]
data_train_nonsensitive = data_train[majority_mask & true_negative_mask]

Dobbiamo anche convertire i nostri DataFrame Pandas in set di dati Tensorflow per l'input MinDiff. Si noti che, a differenza dell'API del modello Keras per Pandas DataFrame, l'utilizzo di set di dati significa che dobbiamo fornire le caratteristiche di input e le etichette del modello insieme in un set di dati. Qui forniamo 'comment_text' come funzione di input e rimodelliamo l'etichetta in modo che corrisponda all'output previsto del modello.

In questa fase eseguiamo anche il batch del set di dati, poiché MinDiff richiede set di dati in batch. Si noti che ottimizziamo la selezione della dimensione del batch nello stesso modo in cui è ottimizzata per il modello di base, tenendo conto della velocità di addestramento e delle considerazioni sull'hardware mentre bilanciamo con le prestazioni del modello. Qui abbiamo scelto la stessa dimensione del batch per tutti e tre i set di dati, ma questo non è un requisito, sebbene sia buona pratica che le due dimensioni del batch MinDiff siano equivalenti.

Crea set di dati MinDiff

# Convert the pandas DataFrames to Datasets.
dataset_train_main = tf.data.Dataset.from_tensor_slices(
    (data_train_main['comment_text'].values, 
     data_train_main.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)
dataset_train_sensitive = tf.data.Dataset.from_tensor_slices(
    (data_train_sensitive['comment_text'].values, 
     data_train_sensitive.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)
dataset_train_nonsensitive = tf.data.Dataset.from_tensor_slices(
    (data_train_nonsensitive['comment_text'].values, 
     data_train_nonsensitive.pop(LABEL).values.reshape(-1,1) * 1.0)).batch(BATCH_SIZE)

Addestra e valuta il modello

Per allenarsi con MinDiff, semplicemente prendere il modello originale e avvolgerlo in un MinDiffModel con una corrispondente loss e loss_weight . Usiamo 1.5 come loss_weight predefinito, ma questo è un parametro che deve essere regolato per il tuo caso d'uso, poiché dipende dal modello e dai requisiti del prodotto. Puoi provare a modificare il valore per vedere come influisce sul modello, notando che aumentarlo spinge le prestazioni dei gruppi di minoranza e maggioranza più vicini, ma può comportare compromessi più pronunciati.

Quindi compiliamo il modello normalmente (utilizzando la normale perdita non MinDiff) e lo adattiamo all'addestramento.

Train MinDiffModel

use_pretrained_model = True

base_dir = tempfile.mkdtemp(prefix='saved_models')
min_diff_model_location = os.path.join(base_dir, 'model_export_min_diff')

if use_pretrained_model:
  BASE_MIN_DIFF_PATH = tempfile.mkdtemp()
  MIN_DIFF_URL = 'https://storage.googleapis.com/civil_comments_model/min_diff_model.zip'
  ZIP_PATH = os.path.join(BASE_PATH, 'min_diff_model.zip')
  MIN_DIFF_MODEL_PATH = os.path.join(BASE_MIN_DIFF_PATH, 'tmp/min_diff_model')
  DIRPATH = '/tmp/min_diff_model'

  r = requests.get(MIN_DIFF_URL, allow_redirects=True)
  open(ZIP_PATH, 'wb').write(r.content)

  with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:
    zip_ref.extractall(BASE_MIN_DIFF_PATH)
  min_diff_model = tf.keras.models.load_model(
      MIN_DIFF_MODEL_PATH, custom_objects={'KerasLayer' : hub.KerasLayer})

  min_diff_model.save(min_diff_model_location, save_format='tf')

else:
  min_diff_weight = 1.5

  # Create the dataset that will be passed to the MinDiffModel during training.
  dataset = md.keras.utils.input_utils.pack_min_diff_data(
      dataset_train_main, dataset_train_sensitive, dataset_train_nonsensitive)

  # Create the original model.
  original_model = min_diff_keras_utils.create_keras_sequential_model()

  # Wrap the original model in a MinDiffModel, passing in one of the MinDiff
  # losses and using the set loss_weight.
  min_diff_loss = md.losses.MMDLoss()
  min_diff_model = md.keras.MinDiffModel(original_model,
                                         min_diff_loss,
                                         min_diff_weight)

  # Compile the model normally after wrapping the original model.  Note that
  # this means we use the baseline's model's loss here.
  optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
  loss = tf.keras.losses.BinaryCrossentropy()
  min_diff_model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])

  min_diff_model.fit(dataset, epochs=20)

  min_diff_model.save_original_model(min_diff_model_location, save_format='tf')
WARNING:tensorflow:7 out of the last 7 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e287e07b8> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:7 out of the last 7 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e287e07b8> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:8 out of the last 8 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e2871b048> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:8 out of the last 8 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e2871b048> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:9 out of the last 9 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e2871bd08> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:9 out of the last 9 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6e2871bd08> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:10 out of the last 10 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f4e32378> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:10 out of the last 10 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f4e32378> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
INFO:tensorflow:Assets written to: /tmp/saved_modelst7yg_ghr/model_export_min_diff/assets
INFO:tensorflow:Assets written to: /tmp/saved_modelst7yg_ghr/model_export_min_diff/assets

Successivamente valutiamo i risultati.

min_diff_eval_subdir = os.path.join(base_dir, 'tfma_eval_result')
min_diff_eval_result = fi_util.get_eval_results(
    min_diff_model_location,
    min_diff_eval_subdir,
    validate_tfrecord_file,
    slice_selection='religion')
WARNING:absl:Tensorflow version (2.4.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f545b840> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f545b840> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f5443378> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f69f5443378> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4dea60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.
WARNING:tensorflow:11 out of the last 11 calls to <function recreate_function.<locals>.restored_function_body at 0x7f6eac4dea60> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

Per assicurarci di valutare correttamente un nuovo modello, dobbiamo selezionare una soglia nello stesso modo in cui faremmo il modello di base. In un contesto di produzione, ciò significherebbe garantire che le metriche di valutazione soddisfino gli standard di lancio. Nel nostro caso, sceglieremo la soglia che si traduce in un FPR complessivo simile al modello di base. Questa soglia potrebbe essere diversa da quella selezionata per il modello di riferimento. Prova a selezionare il tasso di falsi positivi con soglia 0.400. (Si noti che i sottogruppi con esempi di quantità molto bassa hanno intervalli di intervallo di confidenza molto ampi e non hanno risultati prevedibili.)

widget_view.render_fairness_indicator(min_diff_eval_result)
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'Overall', 'slice': 'Overall', 'metrics': {'accuracy': …

Esaminando questi risultati, potresti notare che gli FPR per i nostri gruppi target sono migliorati. Il divario tra il nostro gruppo con le prestazioni più basse e il gruppo di maggioranza è migliorato da 0,024 a 0,006. Dati i miglioramenti che abbiamo osservato e la continua performance positiva per il gruppo di maggioranza, abbiamo soddisfatto entrambi i nostri obiettivi. A seconda del prodotto, potrebbero essere necessari ulteriori miglioramenti, ma questo approccio ha consentito al nostro modello di avvicinarsi di un passo alle prestazioni in modo equo per tutti gli utenti.