Compartilhar via

Use Azure Machine Learning com o pacote de código-fonte aberto Fairlearn para avaliar a imparcialidade dos modelos de ML (versão prévia)

  • Artigo

APLICA-SE A: SDK do Python azureml v1

Neste guia de instruções, você aprenderá a usar o pacote Python de software livre Fairlearn com Azure Machine Learning para executar as seguintes tarefas:

  • Avaliar a imparcialidade de suas previsões de modelo. Para saber mais sobre a imparcialidade no aprendizado de máquina, confira o artigo Imparcialidade no machine learning.
  • Carregar, listar e baixar insights de avaliação de imparcialidade de/para Estúdio do Azure Machine Learning.
  • Consulte um painel de avaliação de imparcialidade no Estúdio do Azure Machine Learning para interagir com os insights de imparcialidade dos seus modelos.

Observação

Uma avaliação de imparcialidade não é um exercício puramente técnico. Esse pacote pode ajudá-lo a avaliar a imparcialidade de um modelo de machine learning, mas somente você pode configurar e tomar decisões sobre o desempenho do modelo. Embora esse pacote ajude a identificar métricas quantitativas para avaliar a imparcialidade, os desenvolvedores de modelos de machine learning também devem executar uma análise qualitativa para avaliar a imparcialidade de seus próprios modelos.

Importante

Esse recurso está atualmente em visualização pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não é recomendada para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos.

Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Imparcialidade do SDK do Azure Machine Learning

A imparcialidade do SDK do Azure Machine Learning Fairness azureml-contrib-fairness integra o pacote do Python de software livre, Fairlearn, dentro do Azure Machine Learning. Para saber mais sobre a integração do Fairlearn com Azure Machine Learning, confira estes notebooks de exemplo. Para mais informações sobre o Fairlearn, consulte o guia de exemplo e os notebooks de exemplo.

Use os comandos a seguir para instalar os pacotes azureml-contrib-fairness e fairlearn:

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

As versões posteriores do Fairlearn também devem funcionar no código de exemplo a seguir.

Carregar insights de imparcialidade para um único modelo

O exemplo a seguir mostra como usar o pacote de imparcialidade. Carregaremos insights de imparcialidade de modelo Azure Machine Learning e veremos o painel de avaliação de imparcialidade no Estúdio do Azure Machine Learning.

  1. Treine um modelo de exemplo em um Jupyter Notebook local.

    Para o conjuntos de dados, usamos o conhecido conjuntos de dados de censo para adulto, que buscamos no OpenML. Vamos fingir que temos um problema de decisão de empréstimo com o rótulo indicando se um indivíduo pagou um empréstimo anterior. Treinaremos um modelo para prever se indivíduos anteriormente não vistos vão pagar um empréstimo. Esse modelo pode ser usado para tomar decisões de empréstimo.

    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. Faça logon no Azure Machine Learning e registre seu modelo.

    O painel de imparcialidade pode ser integrado a modelos registrados ou não registrados. Registre o seu modelo no Azure Machine Learning seguindo estes passos:

    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. Pré-calcule as métricas de imparcialidade.

    Crie um dicionário de painel usando o metrics pacote do Fairlearn. O _create_group_metric_set método tem argumentos semelhantes ao construtor do painel, exceto que os recursos confidenciais são passados como um dicionário (para garantir que os nomes estejam disponíveis). Também devemos especificar o tipo de previsão (classificação binária, neste caso) ao chamar esse método.

    #  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. Carregue as métricas de integridade em computação.

    Agora, importe azureml.contrib.fairness o pacote para executar o upload:

    from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

    Crie um experimento, execute uma execução e carregue o painel nele:

    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. Verifique o painel de imparcialidade do Estúdio do Azure Machine Learning

    Se você concluir as etapas anteriores (carregando informações de imparcialidade geradas para Azure Machine Learning), poderá exibir o painel de imparcialidade no Estúdio do Azure Machine Learning. Esse painel é o mesmo painel de visualização fornecido no Fairlearn, permitindo que você analise as diferenças entre os subgrupos de seus recursos confidenciais (por exemplo, masculino vs. fêmea). Siga um destes caminhos para acessar o painel de explicações no Estúdio do Azure Machine Learning:

    • Painel Trabalhos (Versão prévia)
    1. Escolher Trabalhos no painel esquerdo para ver uma lista de experimentos que você executou no Azure Machine Learning.
    2. Escolher um experimento específico para exibir todas as execuções nesse experimento.
    3. Escolher uma execução e, em seguida, a guia Imparcialidade para o painel de visualização da explicação.
    4. Após o pouso na guia Imparcialidade, clique em uma ID de imparcialidade no menu à direita.
    5. Configure seu painel selecionando seu atributo confidencial, a métrica de desempenho e a métrica de imparcialidade de interesse para chegar à página de avaliação de imparcialidade.
    6. Alterne o tipo de gráfico de um para outro para observar os danos de alocação e a qualidade dos danos de serviço.

    Alocação do painel de imparcialidade

    Qualidade de serviço do Painel de Imparcialidade

    • Painel de modelos
    1. Se você registrou seu modelo original seguindo as etapas anteriores, poderá selecionar Modelos no painel esquerdo para exibi-lo.
    2. Escolha um modelo e, em seguida, a guia Imparcialidade para exibir o painel de visualização da explicação.

    Para saber mais sobre o painel de visualização e o que ele contém, confira o guia do usuário do Fairlearn.

Carregar insights de imparcialidade para vários modelos

Para comparar vários modelos e ver como as avaliações de imparcialidade diferem, você pode passar mais de um modelo para o painel de visualização e comparar suas diferenças de imparcialidade de desempenho.

  1. Treinar seus modelos:

    Agora, criamos um segundo classificador, com base em um estimador do computador vetor de suporte, e carregamos um dicionário de dashboards de imparcialidade usando o pacote do metrics Fairlearn. Vamos supor que o modelo treinado anteriormente ainda esteja disponível.

    # 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. Registre seus modelos

    Em seguida, registre os dois modelos no Azure Machine Learning. Para sua conveniência, armazene os resultados em um dicionário, que mapeia o iddo modelo registrado (uma cadeia de caracteres no formatoname:version) para o próprio preditor:

    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. Carregue o painel de imparcialidade localmente

    Antes de carregar os insights de imparcialidade no Azure Machine Learning, você poderá examinar essas previsões em um painel de imparcialidade invocado 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)

  4. Pré-calcule as métricas de imparcialidade.

    Crie um dicionário de painel usando o metrics pacote do 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')

  5. Carregue as métricas de integridade em computação.

    Agora, importe azureml.contrib.fairness o pacote para executar o upload:

    from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id

    Crie um experimento, execute uma execução e carregue o painel nele:

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

    Semelhante à seção anterior, você pode seguir um dos caminhos descritos acima (por meio de Experimentos ou Modelos) no Estúdio do Azure Machine Learning para acessar o painel de visualização e comparar os dois modelos em termos de imparcialidade e desempenho.

Carregar insights de imparcialidade não mitigados e mitigados

Você pode usar algoritmos de mitigaçãodo Fairlearn, comparar seus modelos mitigados gerados com o modelo não mitigado original e navegar pelas compensações de desempenho/imparcialidade entre modelos comparados.

Para ver um exemplo que demonstra o uso do algoritmo de mitigação da pesquisa de grade (que cria uma coleção de modelos mitigados com diferentes interações de desempenho e imparcialidade), confira este notebook de exemplo.

Carregar insights de imparcialidade de vários modelos em uma única execução permite a comparação de modelos com relação à imparcialidade e ao desempenho. Você pode clicar em qualquer um dos modelos exibidos no gráfico de comparação de modelo para ver as informações de imparcialidade detalhadas do modelo específico.

Painel de imparcialidade de comparação de modelos

Próximas etapas

Saiba mais sobre a imparcialidade do modelo

Confira notebooks de exemplo de imparcialidade do Azure Machine Learning