Esta página foi traduzida pela API Cloud Translation.
Switch to English

Pandas trama de dados para a Justiça Indicadores Estudo de Caso

Nesta atividade, você aprenderá como usar Fairness Indicadores com um Pandas trama de dados.

Visão Geral do Caso de Estudo

Neste estudo de caso, vamos aplicar TensorFlow Modelo de Análise e Equidade Indicadores para avaliar os dados armazenados como um Pandas trama de dados, onde cada linha contém rótulos verdade terrestre, várias características, e uma previsão do modelo. Vamos mostrar como esse fluxo de trabalho pode ser usado para detectar as preocupações de equidade potenciais, independentemente da estrutura usada para construir e treinar o modelo. Como neste estudo de caso, podemos analisar os resultados de qualquer quadro de aprendizagem de máquina (por exemplo TensorFlow, JAX, etc) uma vez que eles são convertidos para um Pandas trama de dados.

Para este exercício, vamos alavancar o modelo de profunda Neural Network (DNN) que foi desenvolvido nos Restrições forma para Ética com Tensorflow Malha estudo de caso utilizando a Faculdade de Direito de Admissão conjunto de dados da Law School Admissions Conselho (CTAS). Este classificador tentativas de prever se ou não um estudante vai passar o bar, com base em sua Faculdade de Direito Admission Test (ÚLTIMA) pontuação e de graduação GPA. Este classificador tentativas de prever se ou não um estudante vai passar o bar, com base em sua pontuação LSAT e de graduação GPA.

CTAS Dataset

O conjunto de dados utilizado dentro deste estudo de caso foi originalmente recolhida para um estudo chamado " CTAS Nacional Longitudinal Bar Passage Study. CTAS Research Report Series "por Linda Wightman em 1998. O conjunto de dados está hospedado aqui .

  • dnn_bar_pass_prediction: A predição do modelo LAST DNN.
  • Sexo: Sexo do aluno.
  • lsat: ÚLTIMA pontuação recebida pelo aluno.
  • pass_bar: Etiqueta verdade chão indicando se ou não o aluno eventualmente, passou a barra.
  • corrida: Corrida do aluno.
  • ugpa: A graduação GPA do aluno.
 !pip install -q -U \
  tensorflow-model-analysis==0.22.2 \
  tensorflow-data-validation==0.22.1 \
  tfx-bsl==0.22.1 \
  pyarrow==0.16.0

 
ERROR: tensorflow-serving-api 2.2.0 has requirement tensorflow~=2.2.0, but you'll have tensorflow 2.3.0 which is incompatible.
ERROR: tensorflow-transform 0.22.0 has requirement tensorflow!=2.0.*,<2.3,>=1.15, but you'll have tensorflow 2.3.0 which is incompatible.
WARNING: You are using pip version 20.1.1; however, version 20.2 is available.
You should consider upgrading via the '/tmpfs/src/tf_docs_env/bin/python -m pip install --upgrade pip' command.

Importando pacotes necessários:

 import os
import tempfile
import pandas as pd
import six.moves.urllib as urllib

import tensorflow_model_analysis as tfma
from google.protobuf import text_format

 

Baixar os dados e explorar o conjunto de dados inicial.

 # Download the LSAT dataset and setup the required filepaths.
_DATA_ROOT = tempfile.mkdtemp(prefix='lsat-data')
_DATA_PATH = 'https://storage.googleapis.com/lawschool_dataset/bar_pass_prediction.csv'
_DATA_FILEPATH = os.path.join(_DATA_ROOT, 'bar_pass_prediction.csv')

data = urllib.request.urlopen(_DATA_PATH)

_LSAT_DF = pd.read_csv(data)

# To simpliy the case study, we will only use the columns that will be used for
# our model.
_COLUMN_NAMES = [
  'dnn_bar_pass_prediction',
  'gender',
  'lsat',
  'pass_bar',
  'race1',
  'ugpa',
]

_LSAT_DF.dropna()
_LSAT_DF['gender'] = _LSAT_DF['gender'].astype(str)
_LSAT_DF['race1'] = _LSAT_DF['race1'].astype(str)
_LSAT_DF = _LSAT_DF[_COLUMN_NAMES]

_LSAT_DF.head()
 

Configurar Indicadores de Equidade.

Existem vários parâmetros que você precisa levar em conta ao usar Fairness Indicadores com uma trama de dados

  • Sua trama de dados de entrada deve conter uma coluna de previsão e coluna rótulo do seu modelo. Por padrão Fairness Indicadores irá procurar por uma coluna de previsão chamado de prediction e uma chamada coluna rótulo label dentro de sua trama de dados.

    • Se um desses valores não são encontrados um KeyError será gerado.
  • Além de uma trama de dados, você também precisará incluir uma eval_config que deve incluir as métricas para calcular, fatias para calcular as métricas, e os nomes das colunas por exemplo, rótulos e previsões.

    • metrics_specs irá definir as métricas de calcular. Os FairnessIndicators métricas serão necessários para tornar as métricas de equidade e você pode ver uma lista de métricas opcionais adicionais aqui .

    • slicing_specs é um parâmetro de corte opcional para especificar o recurso que você está interessado em investigar. Dentro deste estudo race1 caso é usado, mas você também pode definir esse valor para outro recurso (por exemplo gênero no contexto desta trama de dados). Se slicing_specs não é fornecido todos os recursos serão incluídos.

    • Se a sua trama de dados inclui uma coluna de etiqueta ou previsão de que é diferente do padrão prediction ou label , você pode configurar o label_key e prediction_key para um novo valor.

  • Se output_path não for especificado um diretório temporário será criado.

 # Specify Fairness Indicators in eval_config.
eval_config = text_format.Parse("""
  model_specs {
    prediction_key: 'dnn_bar_pass_prediction',
    label_key: 'pass_bar'
  }
  metrics_specs {
    metrics {class_name: "AUC"}
    metrics {
      class_name: "FairnessIndicators"
      config: '{"thresholds": [0.50, 0.90]}'
    }
  }
  slicing_specs {
    feature_keys: 'race1'
  }
  slicing_specs {}
  """, tfma.EvalConfig())

# Run TensorFlow Model Analysis.
eval_result = tfma.analyze_raw_data(
  data=_LSAT_DF,
  eval_config=eval_config,
  output_path=_DATA_ROOT)
 
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.

Warning:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:68: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:68: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`

Explorar desempenho do modelo com justiça indicadores.

Depois de executar Fairness indicadores, podemos visualizar métricas diferentes que foram selecionados para analisar o nosso desempenho modelos. Dentro deste estudo de caso nós incluímos Fairness Indicadores e arbitrariamente escolhidos AUC.

Quando começamos a olhar para a AUC total para cada fatia de corrida, podemos ver uma ligeira discrepância no desempenho do modelo, mas nada que é, sem dúvida, alarmante.

  • Asian: 0,58
  • Preto: 0,58
  • Hispânica: 0,58
  • Outros: 0,64
  • Branco: 0,6

No entanto, quando olhamos para a falsa taxas negativas dividido por raça, nosso modelo novamente incorretamente prevê a probabilidade de um usuário passar o bar em taxas diferentes e, desta vez, fá-lo por um lote.

  • Asian: 0,01
  • Preto: 0,05
  • Hispânico: 0,02
  • Outros: 0,01
  • Branco: 0,01

Mais notavelmente a diferença entre estudantes negros e brancos é de cerca de 380%, o que significa que o nosso modelo é quase 4x mais propensos a incorretamente prever que um aluno negro não vai passar no bar, que um estudante whilte. Se tivéssemos de continuar com esse esforço, um praticante pode usar estes resultados como um sinal de que eles deveriam gastar mais tempo garantindo que o seu modelo funciona bem para as pessoas de todas as origens.

 # Render Fairness Indicators.
tfma.addons.fairness.view.widget_view.render_fairness_indicator(eval_result)
 
FairnessIndicatorViewer(slicingMetrics=[{'sliceValue': 'white', 'slice': 'race1:white', 'metrics': {'fairness_…

Conclusão

Dentro deste estudo de caso, importado um conjunto de dados em um Pandas trama de dados que, em seguida, analisados ​​com justiça indicadores. Compreender os resultados de seu modelo e dados subjacentes é um passo importante no sentido de garantir o seu modelo não reflete viés prejudicial. No contexto deste estudo de caso que examinou o conjunto de dados CTAS e como previsões de esses dados podem ser afetados por uma raça alunos. O conceito de “o que é injusto e que é justo foram introduzidas em várias disciplinas para bem mais de 50 anos, incluindo na educação, contratação e de aprendizado de máquina.” Indicador Fairness 1 é uma ferramenta para preocupações de equidade ajudar a mitigar em sua máquina modelo de aprendizagem.

Para mais informações sobre o uso Fairness Indicadores e recursos para aprender mais sobre as preocupações de equidade ver aqui .


  1. Hutchinson, B., Mitchell, M. (2018). 50 Anos de Test (Un) justiça: Lições para Machine Learning. https://arxiv.org/abs/1811.10104

Apêndice

Abaixo estão algumas funções para ajudar a converter modelos ML para Pandas trama de dados.

 # TensorFlow Estimator to Pandas DataFrame:

# _X_VALUE =  # X value of binary estimator.
# _Y_VALUE =  # Y value of binary estimator.
# _GROUND_TRUTH_LABEL =  # Ground truth value of binary estimator.

def _get_predicted_probabilities(estimator, input_df, get_input_fn):
  predictions = estimator.predict(
      input_fn=get_input_fn(input_df=input_df, num_epochs=1))
  return [prediction['probabilities'][1] for prediction in predictions]

def _get_input_fn_law(input_df, num_epochs, batch_size=None):
  return tf.compat.v1.estimator.inputs.pandas_input_fn(
      x=input_df[[_X_VALUE, _Y_VALUE]],
      y=input_df[_GROUND_TRUTH_LABEL],
      num_epochs=num_epochs,
      batch_size=batch_size or len(input_df),
      shuffle=False)

def estimator_to_dataframe(estimator, input_df, num_keypoints=20):
  x = np.linspace(min(input_df[_X_VALUE]), max(input_df[_X_VALUE]), num_keypoints)
  y = np.linspace(min(input_df[_Y_VALUE]), max(input_df[_Y_VALUE]), num_keypoints)

  x_grid, y_grid = np.meshgrid(x, y)

  positions = np.vstack([x_grid.ravel(), y_grid.ravel()])
  plot_df = pd.DataFrame(positions.T, columns=[_X_VALUE, _Y_VALUE])
  plot_df[_GROUND_TRUTH_LABEL] = np.ones(len(plot_df))
  predictions = _get_predicted_probabilities(
      estimator=estimator, input_df=plot_df, get_input_fn=_get_input_fn_law)
  return pd.DataFrame(
      data=np.array(np.reshape(predictions, x_grid.shape)).flatten())
 
Ver TensorFlow.org