Usare Azure Machine Learning con il pacchetto open source Fairlearn per valutare l'equità dei modelli di Machine Learning (anteprima)

Articolo
04/15/2024

Questa guida pratica illustra come usare il pacchetto Python open source Fairlearn con Azure Machine Learning per eseguire le attività seguenti:

Valutazione della congruità delle previsioni del modello. Per altre informazioni sull'equità nell'apprendimento automatico, vedere l'articolo relativo all'equità nell’apprendimento automatico.
Caricamento, visualizzazione e download di informazioni dettagliate sulla valutazione della congruità da e verso Azure Machine Learning Studio.
Vedere un dashboard di valutazione della congruità in Azure Machine Learning Studio per interagire con le informazioni dettagliate sulla congruità dei modelli.

Nota

La valutazione dell'equità non è un esercizio puramente tecnico. Questo pacchetto consente di valutare l'equità di un modello di Machine Learning, ma è possibile configurare e prendere decisioni relative alle prestazioni del modello. Anche se questo pacchetto consente di identificare le metriche quantitative per valutare l'equità, gli sviluppatori di modelli di Machine Learning devono anche eseguire un'analisi qualitativa per valutare l'equità dei propri modelli.

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio, pertanto non è consigliabile usarla per i carichi di lavoro in ambienti di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate.

Per altre informazioni, vedere le Condizioni supplementari per l'uso delle anteprime di Microsoft Azure.

Azure Machine Learning Fairness SDK

Azure Machine Learning Fairness SDK, azureml-contrib-fairness, integra il pacchetto Python open source, Fairlearn, all'interno di Azure Machine Learning. Per altre informazioni sull'integrazione di Fairlearn in Azure Machine Learning, vedere questi notebook di esempio. Per altre informazioni su Fairlearn, vedere la guida di esempio e i notebook di esempio.

Usare i comandi seguenti per installare i pacchetti azureml-contrib-fairness e fairlearn:

pip install azureml-contrib-fairness
pip install fairlearn==0.4.6

Anche le versioni successive di Fairlearn dovrebbero funzionare nel codice di esempio seguente.

Caricare informazioni dettagliate sull'equità per un singolo modello

Nell'esempio seguente viene illustrato come usare il pacchetto di equità. Le informazioni dettagliate sull'equità del modello verranno caricate in Azure Machine Learning e verrà visualizzato il dashboard di valutazione dell'equità in Azure Machine Learning Studio.

Eseguire il training di un modello di esempio in Jupyter Notebook.

Per il set di dati si usa il set di dati noto per il censimento degli adulti, recuperato da OpenML. Si immagini di avere un problema decisionale su un prestito con l'etichetta che indica se un individuo ha rimborsato un prestito precedente. Verrà eseguito il training di un modello per prevedere se persone non viste in precedenza restituiranno un prestito. Tale modello potrebbe essere usato per prendere decisioni su un prestito.

import copy
import numpy as np
import pandas as pd

from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import make_column_selector as selector
from sklearn.pipeline import Pipeline

from raiwidgets import FairnessDashboard

# Load the census dataset
data = fetch_openml(data_id=1590, as_frame=True)
X_raw = data.data
y = (data.target == ">50K") * 1

# (Optional) Separate the "sex" and "race" sensitive features out and drop them from the main data prior to training your model
X_raw = data.data
y = (data.target == ">50K") * 1
A = X_raw[["race", "sex"]]
X = X_raw.drop(labels=['sex', 'race'],axis = 1)

# Split the data in "train" and "test" sets
(X_train, X_test, y_train, y_test, A_train, A_test) = train_test_split(
    X_raw, y, A, test_size=0.3, random_state=12345, stratify=y
)

# Ensure indices are aligned between X, y and A,
# after all the slicing and splitting of DataFrames
# and Series
X_train = X_train.reset_index(drop=True)
X_test = X_test.reset_index(drop=True)
y_train = y_train.reset_index(drop=True)
y_test = y_test.reset_index(drop=True)
A_train = A_train.reset_index(drop=True)
A_test = A_test.reset_index(drop=True)

# Define a processing pipeline. This happens after the split to avoid data leakage
numeric_transformer = Pipeline(
    steps=[
        ("impute", SimpleImputer()),
        ("scaler", StandardScaler()),
    ]
)
categorical_transformer = Pipeline(
    [
        ("impute", SimpleImputer(strategy="most_frequent")),
        ("ohe", OneHotEncoder(handle_unknown="ignore")),
    ]
)
preprocessor = ColumnTransformer(
    transformers=[
        ("num", numeric_transformer, selector(dtype_exclude="category")),
        ("cat", categorical_transformer, selector(dtype_include="category")),
    ]
)

# Put an estimator onto the end of the pipeline
lr_predictor = Pipeline(
    steps=[
        ("preprocessor", copy.deepcopy(preprocessor)),
        (
            "classifier",
            LogisticRegression(solver="liblinear", fit_intercept=True),
        ),
    ]
)

# Train the model on the test data
lr_predictor.fit(X_train, y_train)

# (Optional) View this model in the fairness dashboard, and see the disparities which appear:
from raiwidgets import FairnessDashboard
FairnessDashboard(sensitive_features=A_test,
                  y_true=y_test,
                  y_pred={"lr_model": lr_predictor.predict(X_test)})

Accedere ad Azure Machine Learning e registrare il modello.

Il dashboard di equità può essere integrato con modelli registrati o non registrati. Registrare il modello in Azure Machine Learning seguendo questa procedura:

from azureml.core import Workspace, Experiment, Model
import joblib
import os

ws = Workspace.from_config()
ws.get_details()

os.makedirs('models', exist_ok=True)

# Function to register models into Azure Machine Learning
def register_model(name, model):
    print("Registering ", name)
    model_path = "models/{0}.pkl".format(name)
    joblib.dump(value=model, filename=model_path)
    registered_model = Model.register(model_path=model_path,
                                    model_name=name,
                                    workspace=ws)
    print("Registered ", registered_model.id)
    return registered_model.id

# Call the register_model function 
lr_reg_id = register_model("fairness_logistic_regression", lr_predictor)

Precalcolo di metriche di equità.

Creare un dizionario dashboard usando il pacchetto metrics di Fairlearn. Il metodo _create_group_metric_set ha argomenti simili al costruttore Dashboard, ad eccezione del fatto che le funzionalità sensibili vengono passate come dizionario (per assicurarsi che i nomi siano disponibili). È inoltre necessario specificare il tipo di stima (classificazione binaria in questo caso) quando si chiama questo metodo.

#  Create a dictionary of model(s) you want to assess for fairness 
sf = { 'Race': A_test.race, 'Sex': A_test.sex}
ys_pred = { lr_reg_id:lr_predictor.predict(X_test) }
from fairlearn.metrics._group_metric_set import _create_group_metric_set

dash_dict = _create_group_metric_set(y_true=y_test,
                                    predictions=ys_pred,
                                    sensitive_features=sf,
                                    prediction_type='binary_classification')

Caricare le metriche di equità pre-calcolate.

Importare ora il pacchetto azureml.contrib.fairness per eseguire il caricamento:

from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

Creare un esperimento, quindi eseguire e caricarvi il dashboard:

exp = Experiment(ws, "Test_Fairness_Census_Demo")
print(exp)

run = exp.start_logging()

# Upload the dashboard to Azure Machine Learning
try:
    dashboard_title = "Fairness insights of Logistic Regression Classifier"
    # Set validate_model_ids parameter of upload_dashboard_dictionary to False if you have not registered your model(s)
    upload_id = upload_dashboard_dictionary(run,
                                            dash_dict,
                                            dashboard_name=dashboard_title)
    print("\nUploaded to id: {0}\n".format(upload_id))

    # To test the dashboard, you can download it back and ensure it contains the right information
    downloaded_dict = download_dashboard_by_upload_id(run, upload_id)
finally:
    run.complete()

Controllare il dashboard di equità da Azure Machine Learning Studio

Se si completano i passaggi precedenti (caricamento di informazioni dettagliate sull'equità generate in Azure Machine Learning), è possibile visualizzare il dashboard di equità in Azure Machine Learning Studio. Questo dashboard è lo stesso dashboard di visualizzazione fornito in Fairlearn, che consente di analizzare le disparità tra i sottogruppi delle funzionalità sensibili (ad esempio, maschile e femminile). Seguire uno di questi percorsi per accedere al dashboard di visualizzazione in Azure Machine Learning Studio:
- Riquadro Processi (anteprima)
1. Selezionare Processi nel riquadro sinistro per visualizzare un elenco di esperimenti eseguiti in Azure Machine Learning.
2. Selezionare un esperimento specifico per visualizzare tutte le esecuzioni nell'esperimento.
3. Selezionare un'esecuzione e quindi la scheda equità nel dashboard di visualizzazione della spiegazione.
4. Una volta atterrati nella scheda Equità, fare clic su un ID di equità dal menu a destra.
5. Configurare il dashboard selezionando l'attributo sensibile, la metrica delle prestazioni e la metrica di equità di interesse per raggiungere la pagina di valutazione dell'equità.
6. Cambiare il tipo di grafico da uno a un altro per osservare sia danni all'allocazione che alla qualità del servizio.
- Riquadro Modelli
1. Se il modello originale è stato registrato seguendo i passaggi precedenti, è possibile selezionare Modelli nel riquadro sinistro per visualizzarlo.
2. Selezionare un modello e quindi la scheda Equità per visualizzare il dashboard di visualizzazione della spiegazione.
Per altre informazioni sul dashboard di visualizzazione e su ciò che contiene, vedere la guida dell'utente di Fairlearn.

Caricare informazioni dettagliate sull'equità per più modelli

Per confrontare più modelli e vedere in che modo le valutazioni di equità differiscono, è possibile passare più di un modello al dashboard di visualizzazione e confrontare i compromessi di equità delle prestazioni.

Eseguire il training dei modelli:

A questo punto viene creato un secondo classificatore basato su uno strumento di stima della macchina a vettori di supporto e si carica un dizionario dashboard di equità usando il pacchetto di Fairlearn metrics. Si presuppone che il modello sottoposto a training in precedenza sia ancora disponibile.
```
# Put an SVM predictor onto the preprocessing pipeline
from sklearn import svm
svm_predictor = Pipeline(
    steps=[
        ("preprocessor", copy.deepcopy(preprocessor)),
        (
            "classifier",
            svm.SVC(),
        ),
    ]
)

# Train your second classification model
svm_predictor.fit(X_train, y_train)
```
Registrare i modelli

Registrare quindi entrambi i modelli in Azure Machine Learning. Per praticità, archiviare i risultati in un dizionario, che esegue il mapping di id del modello registrato (una stringa in formato name:version) al predictor stesso:
```
model_dict = {}

lr_reg_id = register_model("fairness_logistic_regression", lr_predictor)
model_dict[lr_reg_id] = lr_predictor

svm_reg_id = register_model("fairness_svm", svm_predictor)
model_dict[svm_reg_id] = svm_predictor
```

Caricare il dashboard equità in locale

Prima di caricare le informazioni dettagliate sull'equità in Azure Machine Learning, è possibile esaminare queste stime in un dashboard di equità richiamato localmente.

#  Generate models' predictions and load the fairness dashboard locally 
ys_pred = {}
for n, p in model_dict.items():
    ys_pred[n] = p.predict(X_test)

from raiwidgets import FairnessDashboard

FairnessDashboard(sensitive_features=A_test,
                  y_true=y_test.tolist(),
                  y_pred=ys_pred)

Precalcolo di metriche di equità.

Creare un dizionario dashboard usando il pacchetto metrics di Fairlearn.

sf = { 'Race': A_test.race, 'Sex': A_test.sex }

from fairlearn.metrics._group_metric_set import _create_group_metric_set

dash_dict = _create_group_metric_set(y_true=Y_test,
                                    predictions=ys_pred,
                                    sensitive_features=sf,
                                    prediction_type='binary_classification')

Caricare le metriche di equità pre-calcolate.

Importare ora il pacchetto azureml.contrib.fairness per eseguire il caricamento:

from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

Creare un esperimento, quindi eseguire e caricarvi il dashboard:

exp = Experiment(ws, "Compare_Two_Models_Fairness_Census_Demo")
print(exp)

run = exp.start_logging()

# Upload the dashboard to Azure Machine Learning
try:
    dashboard_title = "Fairness Assessment of Logistic Regression and SVM Classifiers"
    # Set validate_model_ids parameter of upload_dashboard_dictionary to False if you have not registered your model(s)
    upload_id = upload_dashboard_dictionary(run,
                                            dash_dict,
                                            dashboard_name=dashboard_title)
    print("\nUploaded to id: {0}\n".format(upload_id))

    # To test the dashboard, you can download it back and ensure it contains the right information
    downloaded_dict = download_dashboard_by_upload_id(run, upload_id)
finally:
    run.complete()

Analogamente alla sezione precedente, è possibile seguire uno dei percorsi descritti in precedenza (tramite Esperimenti o Modelli) in Azure Machine Learning Studio per accedere al dashboard di visualizzazione e confrontare i due modelli in termini di equità e prestazioni.

Caricare informazioni dettagliate sull'equità non autorizzate e attenuate

È possibile usare gli algoritmi di mitigazione di Fairlearn, confrontare i modelli mitigati generati con il modello originale non simulato e spostarsi tra i compromessi di prestazioni/equità tra i modelli confrontati.

Per un esempio che illustra l'uso dell'algoritmo di mitigazione di Ricerca griglia (che crea una raccolta di modelli mitigati con compromessi di equità e prestazioni diversi), vedere questo notebook di esempio.

Il caricamento di più dati analitici sull'equità dei modelli in un'unica esecuzione consente di confrontare i modelli in relazione all'equità e alle prestazioni. È possibile fare clic su uno dei modelli visualizzati nel grafico di confronto dei modelli per visualizzare le informazioni dettagliate sull'equità del modello specifico.

Passaggi successivi

Altre informazioni sull'equità del modello

Vedere i notebook di esempio di equità di Azure Machine Learning

Share via