Share via

Använda Azure Machine Learning med Fairlearn-paketet med öppen källkod för att bedöma rättvisan i ML-modeller (förhandsversion)

  • Artikel

GÄLLER FÖR:Python SDK azureml v1

I den här instruktionsguiden lär du dig att använda Fairlearn Python-paketet med öppen källkod med Azure Machine Learning för att utföra följande uppgifter:

  • Utvärdera rättvisan i dina modellförutsägelser. Mer information om rättvisa i maskininlärning finns i artikeln rättvisa i maskininlärning.
  • Ladda upp, lista och ladda ned insikter om rättvisebedömning till och från Azure Machine Learning-studio.
  • Se en instrumentpanel för rättvisebedömning i Azure Machine Learning-studio för att interagera med dina modellers rättviseinsikter.

Anteckning

Rättvisebedömning är inte en rent teknisk övning. Det här paketet kan hjälpa dig att bedöma rättvisan i en maskininlärningsmodell, men det är bara du som kan konfigurera och fatta beslut om hur modellen fungerar. Även om det här paketet hjälper till att identifiera kvantitativa mått för att bedöma rättvisa, måste utvecklare av maskininlärningsmodeller också utföra en kvalitativ analys för att utvärdera rättvisan i sina egna modeller.

Viktigt

Den här funktionen är för närvarande i allmänt tillgänglig förhandsversion. Den här förhandsversionen tillhandahålls utan serviceavtal och vi rekommenderar den inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade.

Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

Rättvise-SDK för Azure Machine Learning

Azure Machine Learning Fairness SDK, azureml-contrib-fairness, integrerar Python-paketet Fairlearn med öppen källkod i Azure Machine Learning. Mer information om Fairlearns integrering i Azure Machine Learning finns i de här exempelanteckningsböckerna. Mer information om Fairlearn finns i exempelguiden och exempelanteckningsböcker.

Använd följande kommandon för att installera paketen azureml-contrib-fairness och fairlearn :

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

Senare versioner av Fairlearn bör också fungera i följande exempelkod.

Ladda upp rättviseinsikter för en enskild modell

I följande exempel visas hur du använder rättvisepaketet. Vi laddar upp rättviseinsikter för modeller till Azure Machine Learning och ser instrumentpanelen för rättvisebedömning i Azure Machine Learning-studio.

  1. Träna en exempelmodell i Jupyter Notebook.

    För datauppsättningen använder vi den välkända datauppsättningen för vuxnas folkräkning, som vi hämtar från OpenML. Vi låtsas att vi har ett problem med lånebeslutet med etiketten som anger om en individ återbetalade ett tidigare lån. Vi kommer att träna en modell för att förutsäga om tidigare osynliga individer kommer att återbetala ett lån. En sådan modell kan användas för att fatta lånebeslut.

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

  2. Logga in på Azure Machine Learning och registrera din modell.

    Rättviseinstrumentpanelen kan integreras med registrerade eller oregistrerade modeller. Registrera din modell i Azure Machine Learning med följande steg:

    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)

  3. Förberäkna rättvisemått.

    Skapa en instrumentpanelsordlista metrics med Fairlearns paket. Metoden _create_group_metric_set har argument som liknar konstruktorn Instrumentpanel, förutom att de känsliga funktionerna skickas som en ordlista (för att säkerställa att namn är tillgängliga). Vi måste också ange typen av förutsägelse (binär klassificering i det här fallet) när vi anropar den här metoden.

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

  4. Ladda upp de förberäknade rättvisemåtten.

    azureml.contrib.fairness Importera nu paketet för att utföra uppladdningen:

    from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

    Skapa ett experiment, sedan en Kör och ladda upp instrumentpanelen till den:

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

  5. Kontrollera rättviseinstrumentpanelen från Azure Machine Learning-studio

    Om du slutför föregående steg (ladda upp genererade rättviseinsikter till Azure Machine Learning) kan du visa rättviseinstrumentpanelen i Azure Machine Learning-studio. Den här instrumentpanelen är samma visualiseringsinstrumentpanel som finns i Fairlearn, så att du kan analysera skillnaderna mellan undergrupperna för din känsliga funktion (t.ex. man eller kvinna). Följ någon av dessa sökvägar för att komma åt instrumentpanelen för visualisering i Azure Machine Learning-studio:

    • Fönstret Jobb (förhandsversion)
    1. Välj Jobb i det vänstra fönstret för att se en lista över experiment som du har kört på Azure Machine Learning.
    2. Välj ett visst experiment för att visa alla körningar i experimentet.
    3. Välj en körning och sedan fliken Rättvisa på instrumentpanelen för förklaringsvisualisering.
    4. När du har landat på fliken Rättvisa klickar du på ett rättvise-ID från menyn till höger.
    5. Konfigurera din instrumentpanel genom att välja ditt känsliga attribut, prestandamått och rättvisemått för att landa på sidan för rättvisebedömning.
    6. Växla diagramtyp från en till en annan för att observera både allokeringsskador och tjänstkvalitetsskador .

    Allokering av rättviseinstrumentpanel

    Rättviseinstrumentpanelens tjänstkvalitet

    • Fönstret Modeller
    1. Om du registrerade din ursprungliga modell genom att följa föregående steg kan du välja Modeller i den vänstra rutan för att visa den.
    2. Välj en modell och sedan fliken Rättvisa för att visa instrumentpanelen för förklaringsvisualisering.

    Mer information om visualiseringsinstrumentpanelen och vad den innehåller finns i Fairlearns användarhandbok.

Ladda upp rättviseinsikter för flera modeller

Om du vill jämföra flera modeller och se hur deras rättvisebedömningar skiljer sig åt kan du skicka mer än en modell till visualiseringsinstrumentpanelen och jämföra deras avvägningar mellan prestanda och rättvisa.

  1. Träna dina modeller:

    Nu skapar vi en andra klassificerare, baserad på en beräknare för en supportvektormaskin, och laddar upp en ordlista för rättviseinstrumentpanelen med Fairlearns metrics paket. Vi förutsätter att den tidigare tränade modellen fortfarande är tillgänglig.

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

  2. Registrera dina modeller

    Registrera sedan båda modellerna i Azure Machine Learning. För enkelhetens skull lagrar du resultatet i en ordlista som mappar den id registrerade modellen (en sträng i name:version format) till själva förutsägelsen:

    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

  3. Läs in rättviseinstrumentpanelen lokalt

    Innan du laddar upp rättviseinsikterna till Azure Machine Learning kan du undersöka dessa förutsägelser i en lokalt anropad rättviseinstrumentpanel.

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

  4. Förberäkna rättvisemått.

    Skapa en instrumentpanelsordlista metrics med Fairlearns paket.

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

  5. Ladda upp de förberäknade rättvisemåtten.

    azureml.contrib.fairness Importera nu paketet för att utföra uppladdningen:

    from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

    Skapa ett experiment, sedan en Kör och ladda upp instrumentpanelen till den:

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

    Precis som i föregående avsnitt kan du följa en av de sökvägar som beskrivs ovan (via experiment eller modeller) i Azure Machine Learning-studio för att få åtkomst till instrumentpanelen för visualisering och jämföra de två modellerna när det gäller rättvisa och prestanda.

Ladda upp oreglerade och minimerade rättviseinsikter

Du kan använda Fairlearns riskreduceringsalgoritmer, jämföra deras genererade minimerade modeller med den ursprungliga ej erade modellen och navigera i kompromisserna mellan prestanda och rättvisa mellan jämförda modeller.

Om du vill se ett exempel som visar användningen av åtgärdsalgoritmen för rutnätssökning (som skapar en samling minimerade modeller med olika rättvise- och prestandavägningar) kan du titta på den här exempelanteckningsboken.

Genom att ladda upp flera modellers rättviseinsikter i en enda körning kan du jämföra modeller med avseende på rättvisa och prestanda. Du kan klicka på någon av modellerna som visas i modelljämförelsediagrammet för att se detaljerade rättviseinsikter för den aktuella modellen.

Instrumentpanel för modelljämförelse

Nästa steg

Läs mer om rättvisa för modeller

Kolla in Azure Machine Learning Fairness-exempelanteckningsböcker