Usar o Azure Machine Learning com o pacote de código aberto Fairlearn para avaliar a equidade dos modelos de ML (visualização)

APLICA-SE A: Python SDK azureml v1

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

• Avalie a equidade das previsões do seu modelo. Para saber mais sobre equidade no aprendizado de máquina, consulte o artigo equidade no aprendizado de máquina.
• Carregue, liste e transfira informações de avaliação de equidade de/para o estúdio Azure Machine Learning.
• Veja um painel de avaliação de equidade no estúdio de Aprendizado de Máquina do Azure para interagir com as perceções de equidade do(s) seu(s) modelo(s).

Nota

A avaliação da equidade não é um exercício puramente técnico. Este pacote pode ajudá-lo a avaliar a equidade de um modelo de aprendizado de máquina, mas somente você pode configurar e tomar decisões sobre o desempenho do modelo. Embora este pacote ajude a identificar métricas quantitativas para avaliar a equidade, os desenvolvedores de modelos de aprendizado de máquina também devem realizar uma análise qualitativa para avaliar a equidade de seus próprios modelos.

Importante

Esta funcionalidade está atualmente em pré-visualização pública. Esta versão de pré-visualização é fornecida sem um contrato de nível de serviço e não a recomendamos para cargas de trabalho de produção. Algumas funcionalidades poderão não ser suportadas ou poderão ter capacidades limitadas.

Para obter mais informações, veja Termos Suplementares de Utilização para Pré-visualizações do Microsoft Azure.

SDK de equidade do Azure Machine Learning

O SDK do Azure Machine Learning Fairness, azureml-contrib-fairness, integra o pacote Python de código aberto, Fairlearn, no Azure Machine Learning. Para saber mais sobre a integração do Fairlearn no Azure Machine Learning, confira estes blocos de anotações de exemplo. Para obter mais informações sobre o Fairlearn, consulte o guia de exemplo e os blocos de anotações de exemplo.

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

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

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

Carregue informações de equidade para um único modelo

O exemplo a seguir mostra como usar o pacote de equidade. Carregaremos informações de equidade de modelo no Azure Machine Learning e veremos o painel de avaliação de equidade no estúdio do Azure Machine Learning.

1. Treine um modelo de amostra no Jupyter Notebook.

   Para o conjunto de dados, usamos o conhecido conjunto de dados do censo adulto, que buscamos no OpenML. Fingimos que temos um problema de decisão de empréstimo com o rótulo que indica se um indivíduo pagou um empréstimo anterior. Vamos treinar um modelo para prever se indivíduos inéditos pagarão um empréstimo. Tal modelo pode ser usado na tomada de 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 equidade pode integrar-se com modelos registados ou não registados. Registe o seu modelo no Azure Machine Learning com os seguintes 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é-compute métricas de equidade.

   Crie um dicionário de painel usando o metrics pacote do Fairlearn. O _create_group_metric_set método tem argumentos semelhantes ao construtor Dashboard, 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 equidade pré-calculadas.

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

   from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id
   

   Crie um experimento, depois um Executar e carregue o painel para ele:

   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 equidade do estúdio de Aprendizado de Máquina do Azure

   Se você concluir as etapas anteriores (carregando informações de equidade geradas no Azure Machine Learning), poderá exibir o painel de equidade no estúdio do Azure Machine Learning. Este painel é o mesmo painel de visualização fornecido no Fairlearn, permitindo que você analise as disparidades entre os subgrupos do seu recurso sensível (por exemplo, masculino versus feminino). Siga um destes caminhos para acessar o painel de visualização no estúdio do Azure Machine Learning:

   • Painel Trabalhos (Pré-visualização)
   1. Selecione Trabalhos no painel esquerdo para ver uma lista de experiências que executou no Azure Machine Learning.
   2. Selecione um experimento específico para exibir todas as execuções desse experimento.
   3. Selecione uma execução e, em seguida, a guia Equidade para o painel de visualização de explicação.
   4. Depois de chegar à guia Justiça , clique em um ID de equidade no menu à direita.
   5. Configure seu painel selecionando seu atributo sensível, métrica de desempenho e métrica de equidade de interesse para chegar à página de avaliação de equidade.
   6. Mude o tipo de gráfico de um para outro para observar os danos de alocação e os danos à qualidade do serviço .

   

   

   • Painel Modelos
   1. Se você registrou seu modelo original seguindo as etapas anteriores, poderá selecionar Modelos no painel esquerdo para visualizá-lo.
   2. Selecione um modelo e, em seguida, a guia Equidade para exibir o painel de visualização de 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.

Carregue informações de equidade para vários modelos

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

1. Treine os seus modelos:

   Agora criamos um segundo classificador, com base em um estimador de máquina vetorial de suporte, e carregamos um dicionário de painel de equidade usando o metrics pacote do Fairlearn. Assumimos que o modelo previamente treinado ainda está 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. Registe os seus modelos

   Em seguida, registre ambos os modelos no Azure Machine Learning. Por conveniência, armazene os resultados em um dicionário, que mapeia o id modelo registrado (uma cadeia de caracteres em name:version formato) 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 Fairness localmente

   Antes de carregar as informações de equidade no Azure Machine Learning, você pode examinar essas previsões em um painel de equidade 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é-compute métricas de equidade.

   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 equidade pré-calculadas.

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

   from azureml.contrib.fairness import upload_dashboard_dictionary, download_dashboard_by_upload_id
   

   Crie um experimento, depois um Executar e carregue o painel para ele:

   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 de Aprendizado de Máquina do Azure para acessar o painel de visualização e comparar os dois modelos em termos de equidade e desempenho.

Carregue informações de equidade não mitigadas e mitigadas

Você pode usar os algoritmos de mitigação do Fairlearn, comparar o(s) modelo(s) mitigado(s) gerado(s) com o modelo não mitigado original e navegar pelas compensações de desempenho/equidade entre os modelos comparados.

Para ver um exemplo que demonstra o uso do algoritmo de mitigação da Pesquisa em Grade (que cria uma coleção de modelos mitigados com diferentes compensações de equidade e desempenho), confira este bloco de anotações de exemplo.

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

Próximos passos

Saiba mais sobre equidade de modelos

Confira os blocos de anotações de exemplo do Azure Machine Learning Fairness