Indicadores de imparcialidade

O Fairness Indicators foi desenvolvido para apoiar as equipes na avaliação e melhoria de modelos para questões de justiça em parceria com o kit de ferramentas Tensorflow mais amplo. Atualmente, a ferramenta é usada ativamente internamente por muitos de nossos produtos e agora está disponível em BETA para testar seus próprios casos de uso.

Painel de indicadores de imparcialidade

O que são indicadores de imparcialidade?

Fairness Indicators é uma biblioteca que permite o cálculo fácil de métricas de imparcialidade comumente identificadas para classificadores binários e multiclasse. Muitas ferramentas existentes para avaliar questões de justiça não funcionam bem em conjuntos de dados e modelos de grande escala. No Google, é importante termos ferramentas que possam funcionar em sistemas de bilhões de usuários. Os indicadores de imparcialidade permitirão que você avalie em qualquer tamanho de caso de uso.

Em particular, os Indicadores de Justiça incluem a capacidade de:

  • Avalie a distribuição dos conjuntos de dados
  • Avalie o desempenho do modelo, dividido em grupos definidos de usuários
    • Sinta-se confiante sobre seus resultados com intervalos de confiança e avaliações em vários limites
  • Mergulhe profundamente em fatias individuais para explorar as causas-raiz e oportunidades de melhoria

Este estudo de caso , completo com vídeos e exercícios de programação, demonstra como os indicadores de justiça podem ser usados ​​em um de seus próprios produtos para avaliar as preocupações de justiça ao longo do tempo.

O download do pacote pip inclui:

Como usar indicadores de imparcialidade com modelos do Tensorflow

Dados

Para executar indicadores de imparcialidade com o TFMA, certifique-se de que o conjunto de dados de avaliação esteja rotulado para os recursos pelos quais você gostaria de dividir. Se você não tiver os recursos de fatia exatos para suas preocupações de justiça, tente encontrar um conjunto de avaliação que tenha ou considere os recursos de proxy em seu conjunto de recursos que possam destacar as disparidades de resultados. Para obter orientações adicionais, consulte aqui .

Modelo

Você pode usar a classe Tensorflow Estimator para criar seu modelo. O suporte para modelos Keras chegará em breve ao TFMA. Se você deseja executar o TFMA em um modelo Keras, consulte a seção “Model-Agnostic TFMA” abaixo.

Após o treinamento do seu Estimador, você precisará exportar um modelo salvo para fins de avaliação. Para saber mais, consulte o guia TFMA .

Configurando Fatias

Em seguida, defina as fatias nas quais você gostaria de avaliar:

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur color’])
]

Se você deseja avaliar fatias interseccionais (por exemplo, cor e altura da pele), pode definir o seguinte:

slice_spec = [
  tfma.slicer.SingleSliceSpec(columns=[‘fur_color’, ‘height’])
]`

Calcular Métricas de Imparcialidade

Adicione um retorno de chamada de indicadores de imparcialidade à lista de metrics_callback . No retorno de chamada, você pode definir uma lista de limites nos quais o modelo será avaliado.

from tensorflow_model_analysis.addons.fairness.post_export_metrics import fairness_indicators

# Build the fairness metrics. Besides the thresholds, you also can config the example_weight_key, labels_key here. For more details, please check the api.
metrics_callbacks = \
    [tfma.post_export_metrics.fairness_indicators(thresholds=[0.1, 0.3,
     0.5, 0.7, 0.9])]

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=tfma_export_dir,
    add_metrics_callbacks=metrics_callbacks)

Antes de executar a configuração, determine se deseja ou não habilitar o cálculo de intervalos de confiança. Os intervalos de confiança são calculados usando bootstrapping de Poisson e requerem recálculo em 20 amostras.

compute_confidence_intervals = True

Execute o pipeline de avaliação do TFMA:

validate_dataset = tf.data.TFRecordDataset(filenames=[validate_tf_file])

# Run the fairness evaluation.
with beam.Pipeline() as pipeline:
  _ = (
      pipeline
      | beam.Create([v.numpy() for v in validate_dataset])
      | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
                 eval_shared_model=eval_shared_model,
                 slice_spec=slice_spec,
                 compute_confidence_intervals=compute_confidence_intervals,
                 output_path=tfma_eval_result_path)
  )
eval_result = tfma.load_eval_result(output_path=tfma_eval_result_path)

Indicadores de equidade de renderização

from tensorflow_model_analysis.addons.fairness.view import widget_view

widget_view.render_fairness_indicator(eval_result=eval_result)

Indicadores de imparcialidade

Dicas para usar indicadores de imparcialidade:

  • Selecione as métricas a serem exibidas marcando as caixas no lado esquerdo. Gráficos individuais para cada uma das métricas aparecerão no widget, em ordem.
  • Altere a fatia da linha de base , a primeira barra do gráfico, usando o seletor suspenso. Os deltas serão calculados com este valor de linha de base.
  • Selecione os limites usando o seletor suspenso. Você pode visualizar vários limites no mesmo gráfico. Os limites selecionados ficarão em negrito e você pode clicar em um limite em negrito para desmarcá-lo.
  • Passe o mouse sobre uma barra para ver as métricas dessa fatia.
  • Identifique as disparidades com a linha de base usando a coluna "Diff w. baseline", que identifica a diferença percentual entre a fatia atual e a linha de base.
  • Explore os pontos de dados de uma fatia em profundidade usando a ferramenta What-If . Veja aqui um exemplo.

Renderizando indicadores de imparcialidade para vários modelos

Indicadores de imparcialidade também podem ser usados ​​para comparar modelos. Em vez de passar um único eval_result, passe um objeto multi_eval_results, que é um dicionário mapeando dois nomes de modelo para objetos eval_result.

from tensorflow_model_analysis.addons.fairness.view import widget_view

eval_result1 = tfma.load_eval_result(...)
eval_result2 = tfma.load_eval_result(...)
multi_eval_results = {"MyFirstModel": eval_result1, "MySecondModel": eval_result2}

widget_view.render_fairness_indicator(multi_eval_results=multi_eval_results)

Indicadores de imparcialidade - Comparação de modelos

A comparação de modelos pode ser usada juntamente com a comparação de limites. Por exemplo, você pode comparar dois modelos em dois conjuntos de limites para encontrar a combinação ideal para suas métricas de imparcialidade.

Como usar indicadores de imparcialidade com modelos não TensorFlow

Para melhor atender clientes que possuem modelos e fluxos de trabalho diferentes, desenvolvemos uma biblioteca de avaliação independente do modelo que está sendo avaliado.

Qualquer pessoa que queira avaliar seu sistema de aprendizado de máquina pode usar isso, especialmente se você tiver modelos não baseados no TensorFlow. Usando o SDK Python do Apache Beam, você pode criar um binário de avaliação TFMA autônomo e executá-lo para analisar seu modelo.

Dados

Esta etapa é fornecer o conjunto de dados no qual você deseja que as avaliações sejam executadas. Ele deve estar no formato proto tf.Example com rótulos, previsões e outros recursos que você pode querer dividir.

tf.Example {
    features {
        feature {
          key: "fur_color" value { bytes_list { value: "gray" } }
        }
        feature {
          key: "height" value { bytes_list { value: "tall" } }
        }
        feature {
          key: "prediction" value { float_list { value: 0.9 } }
        }
        feature {
          key: "label" value { float_list { value: 1.0 } }
        }
    }
}

Modelo

Em vez de especificar um modelo, você cria uma configuração de avaliação agnóstica de modelo e um extrator para analisar e fornecer os dados que o TFMA precisa para calcular as métricas. A especificação ModelAgnosticConfig define os recursos, previsões e rótulos a serem usados ​​nos exemplos de entrada.

Para isso, crie um mapa de feição com chaves representando todos os recursos, incluindo chaves de rótulo e previsão e valores representando o tipo de dados do recurso.

feature_map[label_key] = tf.FixedLenFeature([], tf.float32, default_value=[0])

Crie uma configuração agnóstica de modelo usando chaves de rótulo, chaves de previsão e o mapa de recursos.

model_agnostic_config = model_agnostic_predict.ModelAgnosticConfig(
    label_keys=list(ground_truth_labels),
    prediction_keys=list(predition_labels),
    feature_spec=feature_map)

Configurar o extrator agnóstico de modelo

O Extractor é usado para extrair os recursos, rótulos e previsões da entrada usando a configuração agnóstica do modelo. E se você quiser dividir seus dados, também precisará definir a especificação da chave de fatia , contendo informações sobre as colunas nas quais deseja dividir.

model_agnostic_extractors = [
    model_agnostic_extractor.ModelAgnosticExtractor(
        model_agnostic_config=model_agnostic_config, desired_batch_size=3),
    slice_key_extractor.SliceKeyExtractor([
        slicer.SingleSliceSpec(),
        slicer.SingleSliceSpec(columns=[‘height’]),
    ])
]

Calcular Métricas de Imparcialidade

Como parte do EvalSharedModel , você pode fornecer todas as métricas nas quais deseja que seu modelo seja avaliado. As métricas são fornecidas na forma de retornos de chamada de métricas como as definidas em post_export_metrics ou fairness_indicators .

metrics_callbacks.append(
    post_export_metrics.fairness_indicators(
        thresholds=[0.5, 0.9],
        target_prediction_keys=[prediction_key],
        labels_key=label_key))

Ele também recebe um construct_fn que é usado para criar um gráfico tensorflow para realizar a avaliação.

eval_shared_model = types.EvalSharedModel(
    add_metrics_callbacks=metrics_callbacks,
    construct_fn=model_agnostic_evaluate_graph.make_construct_fn(
        add_metrics_callbacks=metrics_callbacks,
        fpl_feed_config=model_agnostic_extractor
        .ModelAgnosticGetFPLFeedConfig(model_agnostic_config)))

Depois que tudo estiver configurado, use uma das funções ExtractEvaluate ou ExtractEvaluateAndWriteResults fornecidas por model_eval_lib para avaliar o modelo.

_ = (
    examples |
    'ExtractEvaluateAndWriteResults' >>
        model_eval_lib.ExtractEvaluateAndWriteResults(
        eval_shared_model=eval_shared_model,
        output_path=output_path,
        extractors=model_agnostic_extractors))

eval_result = tensorflow_model_analysis.load_eval_result(output_path=tfma_eval_result_path)

Por fim, renderize os indicadores de imparcialidade usando as instruções da seção "Renderizar indicadores de imparcialidade" acima.

Mais exemplos

O diretório de exemplos de indicadores de imparcialidade contém vários exemplos: