O Dia da Comunidade de ML é dia 9 de novembro! Junte-nos para atualização de TensorFlow, JAX, e mais Saiba mais

Indicadores de justiça

O Fairness Indicators é projetado 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. A ferramenta é usada ativamente internamente por muitos de nossos produtos e agora está disponível em versão BETA para tentar em seus próprios casos de uso.

Painel do Indicador de Equidade

O que são indicadores de justiça?

Fairness Indicators é uma biblioteca que permite fácil cálculo 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 modelos e conjuntos de dados de grande escala. No Google, é importante para nós ter ferramentas que possam funcionar em sistemas de bilhões de usuários. Os indicadores de imparcialidade permitirão que você avalie qualquer tamanho de caso de uso.

Em particular, os Indicadores de Equidade incluem a capacidade de:

  • Avalie a distribuição de 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 em fatias individuais para explorar as causas 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 questões de justiça ao longo do tempo.

O download do pacote pip inclui:

Usando indicadores de imparcialidade com modelos do Tensorflow

Dados

Para executar indicadores de imparcialidade com TFMA, certifique-se de que o conjunto de dados de avaliação esteja rotulado para os recursos que você gostaria de dividir. Se você não tiver os recursos de fatia exatos para suas preocupações de justiça, você pode tentar encontrar um conjunto de avaliação que os tenha, ou considerar recursos de proxy dentro de seu conjunto de recursos que podem destacar disparidades de resultados. Para obter orientação adicional, consulte aqui .

Modelo

Você pode usar a classe Tensorflow Estimator para construir seu modelo. O suporte para os modelos Keras chegará em breve ao TFMA. Se você gostaria de executar TFMA em um modelo Keras, consulte a seção “TFMA Agnóstico de Modelo” abaixo.

Depois que seu Estimador for treinado, 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 que você gostaria de avaliar:

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

Se quiser avaliar fatias intersetoriais (por exemplo, cor e altura do pelo), você pode definir o seguinte:

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

Calcular métricas de imparcialidade

Adicione um retorno de chamada de Fairness Indicators à lista 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 dos intervalos de confiança. Os intervalos de confiança são calculados usando bootstrap de Poisson e requerem recomputação em 20 amostras.

compute_confidence_intervals = True

Execute o pipeline de avaliação 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)

Renderizar indicadores de justiça

from tensorflow_model_analysis.addons.fairness.view import widget_view

widget_view.render_fairness_indicator(eval_result=eval_result)

Indicadores de justiça

Dicas para usar indicadores de justiça:

  • Selecione as métricas a serem exibidas marcando as caixas do 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. 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 "Diferença da linha de base", 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 Equidade para Vários Modelos

Os 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 que mapeia 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 justiça - comparação de modelos

A comparação de modelos pode ser usada junto 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 justiça.

Usando indicadores de imparcialidade com modelos não TensorFlow

Para melhor atender aos clientes que possuem diferentes modelos e fluxos de trabalho, desenvolvemos uma biblioteca de avaliação que é agnóstica ao 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 do Apache Beam para Python, você pode criar um binário de avaliação TFMA independente e, em seguida, executá-lo para analisar seu modelo.

Dados

Esta etapa fornece o conjunto de dados no qual deseja que as avaliações sejam executadas. Deve estar no formato tf.Example proto 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ê pode criar uma configuração de avaliação agnóstica de modelo e um extrator para analisar e fornecer os dados de que o TFMA precisa para calcular as métricas. A especificação ModelAgnosticConfig define os recursos, previsões e rótulos a serem usados ​​a partir dos exemplos de entrada.

Para isso, crie um mapa de recursos com chaves que representam todos os recursos, incluindo rótulos e chaves de predição e valores que representam 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 modelo

O extrator é usado para extrair os recursos, rótulos e previsões da entrada usando configuração agnóstica de modelo. E se você deseja fatiar seus dados, você também precisa definir aespecificação da chave de fatia , contendo informações sobre as colunas que deseja fatiar.

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 callbacks de métricas, como os definidos 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 leva em 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 um dos ExtractEvaluate ou ExtractEvaluateAndWriteResults funções fornecidas pelo 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)

Finalmente, 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 Fairness Indicators contém vários exemplos: