Gerar insights da IA responsável com o YAML e o Python

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Você pode gerar um painel de IA Responsável e um scorecard por meio de um trabalho de pipeline usando componentes de IA Responsável. Há seis componentes principais para criar painéis de IA responsável, juntamente com alguns componentes auxiliares. Veja abaixo o grafo de um experimento de exemplo:

Componentes da IA Responsável

Os principais componentes para construir o painel de IA Responsável no Azure Machine Learning são:

• RAI Insights dashboard constructor
• Os componentes da ferramenta:
  • Add Explanation to RAI Insights dashboard
  • Add Causal to RAI Insights dashboard
  • Add Counterfactuals to RAI Insights dashboard
  • Add Error Analysis to RAI Insights dashboard
  • Gather RAI Insights dashboard
  • Gather RAI Insights score card

Os componentes RAI Insights dashboard constructor e Gather RAI Insights dashboard são sempre necessários, além de pelo menos um dos componentes da ferramenta. No entanto, não é necessário usar todas as ferramentas em todos os painéis de IA Responsável.

Veja nas seções abaixo as especificações dos componentes de IA Responsável e os exemplos de snippets de código em YAML e Python.

Limitações

O conjunto atual de componentes tem várias limitações de uso:

• Todos os modelos devem ser registrados no Azure Machine Learning no formato MLflow com uma variante sklearn (scikit-learn).
• Os modelos precisam ser carregáveis no ambiente do componente.
• Os modelos precisam ser selecionáveis.
• Os modelos precisam ser fornecidos aos componentes de IA Responsável usando o componente Fetch Registered Model que fornecemos.
• As entradas do conjunto de dados precisam estar no formato mltable.
• Um modelo deve ser fornecido mesmo que apenas uma análise de causa dos dados seja executada. Use os estimadores DummyClassifier e DummyRegressor do Scikit-learn para essa finalidade.

Construtor de painel do RAI Insights

Esse componente tem três portas de entrada:

• O modelo de machine learning
• O conjunto de dados de treinamento
• O conjunto de dados de teste

Para gerar insights de depuração do modelo com componentes como análise de erros e Explicações de modelo, use o conjunto de dados de treinamento e de teste usado ao treinar o modelo. Para componentes como análise de causa, que não exigem um modelo, use o conjunto de dados de treinamento para treinar o modelo de causa para gerar os insights de causa. Use o conjunto de dados de teste para preencher as visualizações do painel de IA Responsável.

A maneira mais fácil de fornecer o modelo é registrar o modelo de entrada e referenciar o mesmo modelo na porta de entrada do modelo do componente RAI Insight Constructor, que discutiremos mais adiante neste artigo.

Os dois conjuntos de dados devem estar no formato mltable. Os conjuntos de dados de treinamento e de teste fornecidos não precisam ser os mesmos conjuntos de dados usados no treinamento do modelo, mas podem ser os mesmos. Por padrão e por motivos de desempenho, o conjunto de dados de teste é restrito a 5.000 mil linhas da interface do usuário de visualização.

O componente construtor também aceita os seguintes parâmetros:

¹ As listas devem ser fornecidas como uma única cadeia de caracteres codificada em JSON para as entradas categorical_column_names, classes e feature_metadata.

O componente construtor tem uma única saída chamada rai_insights_dashboard. Esse é um painel vazio em que operam os componentes individuais da ferramenta. Todos os resultados são montados pelo componente Gather RAI Insights dashboard no final.

 create_rai_job: 

    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_insight_constructor/versions/<get current version>
    inputs: 
      title: From YAML snippet 
      task_type: regression
      type: mlflow_model
      path: azureml:<registered_model_name>:<registered model version> 
      train_dataset: ${{parent.inputs.my_training_data}} 
      test_dataset: ${{parent.inputs.my_test_data}} 
      target_column_name: ${{parent.inputs.target_column_name}} 
      categorical_column_names: '["location", "style", "job title", "OS", "Employer", "IDE", "Programming language"]' 

# First load the component:

        rai_constructor_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_insight_constructor", label="latest")

#Then inside the pipeline:

            construct_job = rai_constructor_component( 
                title="From Python", 
                task_type="classification", 
                model_input= model_input= Input(type=AssetTypes.MLFLOW_MODEL, path="<azureml:model_name:model_id>"),
                train_dataset=train_data, 
                test_dataset=test_data, 
                target_column_name=target_column_name, 
                categorical_column_names='["location", "style", "job title", "OS", "Employer", "IDE", "Programming language"]', 
                maximum_rows_for_test_dataset=5000, 
                classes="[]", 
            ) 

Painel Adicionar Causa ao RAI Insights

Esse componente executa uma análise de causa nos conjuntos de dados fornecidos. Ele tem apenas uma porta de entrada, que aceita a saída do RAI Insights dashboard constructor. Ele também aceita os seguintes parâmetros:

² Para os parâmetros list: vários dos parâmetros aceitam listas de outros tipos (cadeias de caracteres, números e até mesmo outras listas). Para passá-los para o componente, primeiro eles devem ser codificados em JSON em uma única cadeia de caracteres.

Esse componente tem uma só porta de saída, que pode ser conectada a uma das portas de entrada de insight_[n] do componente Gather RAI Insights Dashboard.

  causal_01: 
    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_causal/versions/<version>
    inputs: 
      rai_insights_dashboard: ${{parent.jobs.create_rai_job.outputs.rai_insights_dashboard}} 
      treatment_features: `["Number of GitHub repos contributed to", "YOE"]' 

#First load the component: 

        rai_causal_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_causal", label="latest")

#Use it inside a pipeline definition: 
            causal_job = rai_causal_component( 
                rai_insights_dashboard=construct_job.outputs.rai_insights_dashboard, 
                treatment_features='`["Number of GitHub repos contributed to", "YOE"]', 
            ) 

Painel Adicionar Contrafactuais ao RAI Insights

Esse componente gera pontos contrafactuais para o conjunto de dados de teste fornecido. Ele tem uma única porta de entrada, que aceita a saída do construtor de porta do RAI Insights. Ele também aceita os seguintes parâmetros:

³ Para os parâmetros não escalares: os parâmetros que são listas ou dicionários devem ser passados como cadeias de caracteres individuais codificadas em JSON.

Esse componente tem uma só porta de saída, que pode ser conectada a uma das portas de entrada de insight_[n] do componente Gather RAI Insights dashboard.

 counterfactual_01: 
    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_counterfactual/versions/<version>
    inputs: 
      rai_insights_dashboard: ${{parent.jobs.create_rai_job.outputs.rai_insights_dashboard}} 
      total_CFs: 10 
      desired_range: "[5, 10]" 

#First load the component: 
        rai_counterfactual_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_counterfactual", label="latest")

#Use it in a pipeline function: 
            counterfactual_job = rai_counterfactual_component( 
                rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard, 
                total_cfs=10, 
                desired_range="[5, 10]", 
            ) 

Painel Adicionar Análise de Erros ao RAI Insights

Esse componente gera uma análise de erro para o modelo. Ele tem apenas uma porta de entrada, que aceita a saída do RAI Insights Dashboard Constructor. Ele também aceita os seguintes parâmetros:

Esse componente tem uma só porta de saída, que pode ser conectada a uma das portas de entrada de insight_[n] do componente Gather RAI Insights Dashboard.

  error_analysis_01: 
    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_erroranalysis/versions/<version>
    inputs: 
      rai_insights_dashboard: ${{parent.jobs.create_rai_job.outputs.rai_insights_dashboard}} 
      filter_features: `["style", "Employer"]' 

#First load the component: 
        rai_erroranalysis_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_erroranalysis", label="latest")

#Use inside a pipeline: 
            erroranalysis_job = rai_erroranalysis_component( 
                rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard, 
                filter_features='["style", "Employer"]', 
            ) 

Painel Adicionar Explicação ao RAI Insights

Esse componente gera uma explicação para o modelo. Ele tem apenas uma porta de entrada, que aceita a saída do RAI Insights Dashboard Constructor. Ele aceita uma única cadeia de caracteres de comentário opcional como parâmetro.

Esse componente tem uma única porta de saída, que pode ser conectada a uma das portas de entrada insight_[n] do componente do painel Coletar RAI Insightss.

  explain_01: 
    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_explanation/versions/<version>
    inputs: 
      comment: My comment 
      rai_insights_dashboard: ${{parent.jobs.create_rai_job.outputs.rai_insights_dashboard}} 

#First load the component: 
        rai_explanation_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_explanation", label="latest"

#Use inside a pipeline: 
            explain_job = rai_explanation_component( 
                comment="My comment", 
                rai_insights_dashboard=create_rai_job.outputs.rai_insights_dashboard, 
            ) 

Painel Coletar RAI Insights

Esse componente monta os insights gerados em um único painel de IA Responsável. Ele tem cinco portas de entrada:

• A porta constructor que deve ser conectada ao componente do construtor de painel do RAI Insights.
• Quatro portas insight_[n] que podem ser conectadas à saída dos componentes da ferramenta. Pelo menos uma dessas portas deve estar conectada.

Existem duas portas de saída:

• A porta dashboard contém o objeto RAIInsights concluído.
• A porta ux_json contém os dados necessários para exibir um painel mínimo.

  gather_01: 
    type: command 
    component: azureml://registries/azureml/components/microsoft_azureml_rai_tabular_insight_gather/versions/<version>
    inputs: 
      constructor: ${{parent.jobs.create_rai_job.outputs.rai_insights_dashboard}} 
      insight_1: ${{parent.jobs.causal_01.outputs.causal}} 
      insight_2: ${{parent.jobs.counterfactual_01.outputs.counterfactual}} 
      insight_3: ${{parent.jobs.error_analysis_01.outputs.error_analysis}} 
      insight_4: ${{parent.jobs.explain_01.outputs.explanation}} 

#First load the component: 
        rai_gather_component = ml_client_registry.components.get(name="microsoft_azureml_rai_tabular_insight_gather", label="latest")
#Use in a pipeline: 
            rai_gather_job = rai_gather_component( 
                constructor=create_rai_job.outputs.rai_insights_dashboard, 
                insight_1=explain_job.outputs.explanation, 
                insight_2=causal_job.outputs.causal, 
                insight_3=counterfactual_job.outputs.counterfactual, 
                insight_4=erroranalysis_job.outputs.error_analysis, 
            ) 

Como gerar um scorecard de IA Responsável (versão prévia)

A fase de configuração exige que você use sua experiência com domínios nesse problema para definir os valores de destino desejados nas métricas de desempenho e imparcialidade do modelo.

Assim como os outros componentes do painel de IA Responsável configurados no pipeline do YAML, você pode adicionar um componente para gerar o scorecard no pipeline do YAML:

scorecard_01: 

   type: command 
   component: azureml:rai_score_card@latest 
   inputs: 
     dashboard: ${{parent.jobs.gather_01.outputs.dashboard}} 
     pdf_generation_config: 
       type: uri_file 
       path: ./pdf_gen.json 
       mode: download 

     predefined_cohorts_json: 
       type: uri_file 
       path: ./cohorts.json 
       mode: download 

Em que pdf_gen.json é o arquivo JSON de configuração de geração de scorecard, e predifined_cohorts_json é a ID do arquivo JSON de definição de coorte predefinido.

Esse é um arquivo JSON de exemplo para definição de coortes e configuração de geração de scorecard:

Definição de coortes:

[ 
  { 
    "name": "High Yoe", 
    "cohort_filter_list": [ 
      { 
        "method": "greater", 
        "arg": [ 
          5 
        ], 
        "column": "YOE" 
      } 
    ] 
  }, 
  { 
    "name": "Low Yoe", 
    "cohort_filter_list": [ 
      { 
        "method": "less", 
        "arg": [ 
          6.5 
        ], 
        "column": "YOE" 
      } 
    ] 
  } 
] 

Esse é um arquivo de configuração de geração de scorecard como um exemplo de regressão:

{ 
  "Model": { 
    "ModelName": "GPT-2 Access", 
    "ModelType": "Regression", 
    "ModelSummary": "This is a regression model to analyze how likely a programmer is given access to GPT-2" 
  }, 
  "Metrics": { 
    "mean_absolute_error": { 
      "threshold": "<=20" 
    }, 
    "mean_squared_error": {} 
  }, 
  "FeatureImportance": { 
    "top_n": 6 
  }, 
  "DataExplorer": { 
    "features": [ 
      "YOE", 
      "age" 
    ] 
  }, 
  "Fairness": {
    "metric": ["mean_squared_error"],
    "sensitive_features": ["YOUR SENSITIVE ATTRIBUTE"],
    "fairness_evaluation_kind": "difference OR ratio"
  },
  "Cohorts": [ 
    "High Yoe", 
    "Low Yoe" 
  ]  
} 

Esse é um arquivo de configuração de geração de scorecard como um exemplo de classificação:

{
  "Model": {
    "ModelName": "Housing Price Range Prediction",
    "ModelType": "Classification",
    "ModelSummary": "This model is a classifier that predicts whether the house will sell for more than the median price."
  },
  "Metrics" :{
    "accuracy_score": {
        "threshold": ">=0.85"
    },
  }
  "FeatureImportance": { 
    "top_n": 6 
  }, 
  "DataExplorer": { 
    "features": [ 
      "YearBuilt", 
      "OverallQual", 
      "GarageCars"
    ] 
  },
  "Fairness": {
    "metric": ["accuracy_score", "selection_rate"],
    "sensitive_features": ["YOUR SENSITIVE ATTRIBUTE"],
    "fairness_evaluation_kind": "difference OR ratio"
  }
}

Definição de entradas do componente do scorecard de IA responsável

Esta seção lista e define os parâmetros necessários para configurar o componente do scorecard de IA responsável.

Modelar

Métricas

Limite: o limite desejado para a métrica selecionada. Os tokens matemáticos permitidos são >, <, >=, e <=m, seguidos por um número real. Por exemplo, >= 0,75 significa que o destino da métrica selecionada é maior ou igual a 0,75.

Importância do recurso

top_n: o número de recursos a serem exibidos com um máximo de 10. Inteiros positivos de até 10 são permitidos.

Imparcialidade

É possível selecionar entre as seguintes métricas, emparelhadas com o fairness_evaluation_kind, para configurar seu componente de avaliação de imparcialidade do scorecard:

Restrições de entrada

Quais formatos e sabores variantes de modelo são compatíveis?

O modelo deve estar no diretório MLFlow com uma variante sklearn disponível. Além disso, o modelo deve ser carregado no ambiente usado pelos componentes de IA Responsável.

Quais formatos de dados são compatíveis?

Os conjuntos de dados fornecidos devem ser mltable com os dados de tabela.

Próximas etapas

• Depois de gerar o painel de IA Responsável, veja como acessá-lo e usá-lo no Estúdio do Azure Machine Learning.
• Resuma e compartilhe seus insights de IA Responsável com o Scorecard de IA Responsável exportado em PDF.
• Saiba mais sobre os conceitos e as técnicas por trás do painel de IA Responsável.
• Saiba mais sobre como coletar dados com responsabilidade.
• Veja Notebooks YAML e Python de exemplo para gerar o painel de IA Responsável com o YAML ou o Python.
• Saiba mais sobre como usar o painel de IA Responsável e o Scorecard para depurar dados e modelos e informar melhor a tomada de decisão nesta postagem no blog da comunidade técnica.
• Veja como o painel de IA Responsável e o scorecard foram usados pelo NHS (Serviço Nacional de Saúde do Reino Unido) em uma história real de cliente.
• Explore os recursos do painel de IA Responsável nesta demonstração interativa da Web do AI Lab.