Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Perguntas mais frequentes sobre a análise do modelo do Tensorflow

Em geral

Um EvalSavedModel ainda é necessário?

Anteriormente TFMA exigia que todas as métricas a serem armazenados dentro de um gráfico tensorflow usando um especial EvalSavedModel . Agora, as métricas podem ser computadas fora do gráfico TF usando beam.CombineFn implementações.

Algumas das principais diferenças são:

  • Um EvalSavedModel requer uma exportação especial do treinador enquanto que um modelo que serve podem ser utilizados sem quaisquer alterações necessárias ao código de treinamento.
  • Quando um EvalSavedModel é usado, nenhum métricas adicionadas em tempo de treinamento estão automaticamente disponíveis no momento da avaliação. Sem um EvalSavedModel essas métricas deve ser re-adicionado.
    • A exceção a esta regra é se um modelo keras for usado, as métricas também podem ser adicionadas automaticamente porque keras salva as informações métricas ao lado do modelo salvo.

O TFMA pode trabalhar tanto com métricas no gráfico quanto com métricas externas?

TFMA permite que uma abordagem híbrida seja usada onde algumas métricas podem ser calculadas no gráfico, enquanto outras podem ser calculadas externamente. Se você atualmente tem um EvalSavedModel então você pode continuar a usá-lo.

Existem dois casos:

  1. Use TFMA EvalSavedModel tanto para extração de características e computações métricas, mas também adicionar métricas baseadas em combinador adicionais. Neste caso, você teria todas as métricas em-graph do EvalSavedModel juntamente com quaisquer métricas adicionais do baseada combinador que pode não ter sido previamente suportados.
  2. Use TFMA EvalSavedModel para recurso de extração / previsão, mas de uso métricas baseadas em combinador para todas as métricas cálculos. Este modo é útil se houver transformações característica presente na EvalSavedModel que você gostaria de usar para cortar, mas preferem realizar todos os cálculos métricas fora do gráfico.

Configurar

Quais tipos de modelo são suportados?

TFMA suportes Keras modelos, modelos baseados em APIs de assinatura TF2 genéricos, como modelos baseados bem TF estimador (embora dependendo do caso de uso do estimador de modelos baseados pode exigir uma EvalSavedModel a ser utilizado).

Veja get_started guia para a lista completa de tipos de modelos suportados e quaisquer restrições.

Como configuro o TFMA para funcionar com um modelo baseado em keras nativo?

A seguir está um exemplo de configuração para um modelo keras com base nas seguintes suposições:

  • Modelo salvo é para servir e usa o nome de assinatura serving_default (isso pode ser alterado usando model_specs[0].signature_name ).
  • Construído em métricas de model.compile(...) devem ser avaliadas (este pode ser desativado via options.include_default_metric dentro do tfma.EvalConfig ).
from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    label_key: "<label-key>"
    example_weight_key: "<example-weight-key>"
  }
  metrics_specs {
    # Add metrics here. For example:
    #  metrics { class_name: "ConfusionMatrixPlot" }
    #  metrics { class_name: "CalibrationPlot" }
  }
  slicing_specs {}
""", tfma.EvalConfig())

Veja métricas para mais informações sobre outros tipos de métricas que podem ser configurados.

Como eu configuro o TFMA para funcionar com um modelo genérico baseado em assinaturas TF2?

A seguir está um exemplo de configuração para um modelo TF2 genérico. Abaixo, signature_name é o nome da assinatura específica que deve ser usado para avaliação.

from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    signature_name: "<signature-name>"
    label_key: "<label-key>"
    example_weight_key: "<example-weight-key>"
  }
  metrics_specs {
    # Add metrics here. For example:
    #  metrics { class_name: "BinaryCrossentropy" }
    #  metrics { class_name: "ConfusionMatrixPlot" }
    #  metrics { class_name: "CalibrationPlot" }
  }
  slicing_specs {}
""", tfma.EvalConfig())

Veja métricas para mais informações sobre outros tipos de métricas que podem ser configurados.

Como eu configuro o TFMA para funcionar com um modelo baseado em estimador?

Neste caso, existem três opções.

Opção 1: usar modelo de veiculação

Se esta opção for usada, quaisquer métricas adicionadas durante o treinamento NÃO serão incluídas na avaliação.

O seguinte é um exemplo config-assumindo serving_default é o nome assinatura utilizada:

from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    label_key: "<label-key>"
    example_weight_key: "<example-weight-key>"
  }
  metrics_specs {
    # Add metrics here.
  }
  slicing_specs {}
""", tfma.EvalConfig())

Veja métricas para mais informações sobre outros tipos de métricas que podem ser configurados.

Opção 2: usar EvalSavedModel junto com métricas adicionais baseadas em combinador

Neste caso, use EvalSavedModel tanto para recurso de extração / previsão e avaliação e também adicionar métricas baseadas combinador adicional.

A seguir está um exemplo de configuração:

from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    signature_name: "eval"
  }
  metrics_specs {
    # Add metrics here.
  }
  slicing_specs {}
""", tfma.EvalConfig())

Veja métricas para mais informações sobre outros tipos de métricas que podem ser configurados e EvalSavedModel para mais informações sobre como configurar o EvalSavedModel.

Opção 3: usar o modelo EvalSavedModel apenas para extração de recurso / previsão

Semelhante a opção (2), mas usar apenas EvalSavedModel para extracção de características / previsão. Essa opção é útil se apenas métricas externas forem desejadas, mas houver transformações de recursos que você gostaria de dividir. Semelhante à opção (1), quaisquer métricas adicionadas durante o treinamento NÃO serão incluídas na avaliação.

Neste caso, a configuração é o mesmo que acima apenas include_default_metrics está desativado.

from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    signature_name: "eval"
  }
  metrics_specs {
    # Add metrics here.
  }
  slicing_specs {}
  options {
    include_default_metrics { value: false }
  }
""", tfma.EvalConfig())

Veja métricas para mais informações sobre outros tipos de métricas que podem ser configurados e EvalSavedModel para mais informações sobre como configurar o EvalSavedModel.

Como configuro o TFMA para funcionar com um modelo baseado em modelo para estimador keras?

O keras model_to_estimator configuração é semelhante ao confiugration estimador. No entanto, existem algumas diferenças específicas de como funciona o modelo para o estimador. Em particular, o model-to-esimtator retorna suas saídas na forma de um dicionário onde a chave dict é o nome da última camada de saída no modelo keras associado (se nenhum nome for fornecido, keras irá escolher um nome padrão para você tal como dense_1 ou output_1 ). Do ponto de vista do TFMA, esse comportamento é semelhante ao que seria a saída de um modelo de múltiplas saídas, embora o modelo para o estimador possa ser apenas para um único modelo. Para compensar essa diferença, uma etapa adicional é necessária para configurar o nome de saída. No entanto, as mesmas três opções se aplicam como estimador.

A seguir está um exemplo das mudanças necessárias para uma configuração baseada no estimador:

from google.protobuf import text_format

config = text_format.Parse("""
  ... as for estimator ...
  metrics_specs {
    output_names: ["<keras-output-layer>"]
    # Add metrics here.
  }
  ... as for estimator ...
""", tfma.EvalConfig())

Como configuro o TFMA para funcionar com previsões pré-calculadas (ou seja, agnósticas de modelo)? ( TFRecord e tf.Example )

Para configurar TFMA ao trabalho com as previsões pré-calculados, o padrão tfma.PredictExtractor deve ser desativado eo tfma.InputExtractor deve ser configurado para analisar as previsões, juntamente com as outras características de entrada. Isto é realizado configurando uma tfma.ModelSpec com o nome da chave de função utilizada para as previsões a par dos rótulos e pesos.

A seguir está um exemplo de configuração:

from google.protobuf import text_format

config = text_format.Parse("""
  model_specs {
    prediction_key: "<prediction-key>"
    label_key: "<label-key>"
    example_weight_key: "<example-weight-key>"
  }
  metrics_specs {
    # Add metrics here.
  }
  slicing_specs {}
""", tfma.EvalConfig())

Veja métricas para obter mais informações sobre métricas que podem ser configurados.

Note-se que apesar de um tfma.ModelSpec está sendo configurado um modelo não está efectivamente a ser utilizado (ou seja, não há nenhum tfma.EvalSharedModel ). A chamada para executar a análise do modelo pode ser a seguinte:

eval_result = tfma.run_model_analysis(
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location="/path/to/file/containing/tfrecords",
    output_path="/path/for/metrics_for_slice_proto")

Como configuro o TFMA para funcionar com previsões pré-calculadas (ou seja, agnósticas de modelo)? ( pd.DataFrame )

Para os pequenos conjuntos de dados que podem caber na memória, uma alternativa para um TFRecord é um pandas.DataFrame s. TFMA pode operar em pandas.DataFrame s usando o tfma.analyze_raw_data API. Para uma explicação sobre tfma.MetricsSpec e tfma.SlicingSpec , ver a configuração do guia. Veja métricas para obter mais informações sobre métricas que podem ser configurados.

A seguir está um exemplo de configuração:

# Run in a Jupyter Notebook.

df_data = ...  # your pd.DataFrame

eval_config = text_format.Parse("""
  model_specs {
    label_key: 'label'
    prediction_key: 'prediction'
  }
  metrics_specs {
    metrics { class_name: "AUC" }
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  slicing_specs {}
  slicing_specs {
    feature_keys: 'language'
  }
""", config.EvalConfig())

eval_result = tfma.analyze_raw_data(df_data, eval_config)

tfma.view.render_slicing_metrics(eval_result)

Métricas

Quais tipos de métricas são compatíveis?

TFMA oferece suporte a uma ampla variedade de métricas, incluindo:

Há suporte para métricas de modelos de múltiplas saídas?

sim. Veja métricas guia para obter mais detalhes.

As métricas de vários modelos são suportadas?

sim. Veja métricas guia para obter mais detalhes.

As configurações de métrica (nome, etc) podem ser personalizadas?

sim. Definições de métricas pode ser personalizado (por exemplo, limites específicos de ajuste, etc.) através da adição config configurações para a configuração de métrica. Veja métricas guia tem mais detalhes.

Há suporte para métricas personalizadas?

sim. Ou escrevendo um costume tf.keras.metrics.Metric implementação ou escrevendo um costume beam.CombineFn implementação. O métricas guia tem mais detalhes.

Quais tipos de métricas não são compatíveis?

Enquanto sua métrica pode ser calculada usando uma beam.CombineFn , não há restrições sobre os tipos de métricas que podem ser calculadas com base em tfma.metrics.Metric . Se estiver trabalhando com uma métrica derivada de tf.keras.metrics.Metric em seguida, os seguintes critérios devem ser atendidos:

  • Deve ser possível calcular estatísticas suficientes para a métrica em cada exemplo de forma independente e, em seguida, combinar essas estatísticas suficientes adicionando-as em todos os exemplos e determinar o valor da métrica apenas a partir dessas estatísticas suficientes.
  • Por exemplo, para precisão, as estatísticas suficientes são "total correto" e "exemplos totais". É possível calcular esses dois números para exemplos individuais e soma-los para um grupo de exemplos para obter os valores corretos para esses exemplos. A precisão final pode ser calculada usando "exemplos corretos / totais totais".

Complementos

Posso usar o TFMA para avaliar justiça ou preconceito em meu modelo?

TFMA inclui um FairnessIndicators add-on que fornece métricas pós-exportação para avaliar os efeitos de viés não intencional em modelos de classificação.

Costumização

E se eu precisar de mais personalização?

TFMA é muito flexibile e permite personalizar quase todas as partes do gasoduto usando personalizados Extractors , Evaluators , e / ou Writers . Estes abstrations são discusssed em mais detalhe na arquitetura documento.

Solução de problemas, depuração e obtenção de ajuda

Por que as métricas MultiClassConfusionMatrix não correspondem às métricas binarizadas do ConfusionMatrix

Na verdade, são cálculos diferentes. A binarização realiza uma comparação para cada ID de classe de forma independente (ou seja, a previsão para cada classe é comparada separadamente com os limites fornecidos). Nesse caso, é possível que duas ou mais classes todas indiquem que corresponderam à previsão porque seu valor previsto era maior do que o limite (isso será ainda mais aparente em limites mais baixos). No caso da matriz de confusão multiclasse, ainda há apenas um valor predito verdadeiro e ele corresponde ao valor real ou não. O limite é usado apenas para forçar uma predição a não corresponder a nenhuma classe se for menor que o limite. Quanto mais alto o limite, mais difícil será a correspondência da previsão de uma classe binarizada. Da mesma forma, quanto mais baixo o limite, mais fácil é para as previsões de uma classe binarizada corresponderem. Isso significa que em limiares> 0,5 os valores binarizados e os valores da matriz multiclasse estarão mais alinhados e em limiares <0,5 eles estarão mais distantes.

Por exemplo, digamos que temos 10 classes em que a classe 2 foi prevista com uma probabilidade de 0,8, mas a classe real era a classe 1, que tinha uma probabilidade de 0,15. Se você binarizar na classe 1 e usar um limite de 0,1, a classe 1 será considerada correta (0,15> 0,1), então será contada como um TP. No entanto, para o caso multiclasse, a classe 2 será considerada correta (0,8> 0.1) e como a classe 1 era real, isso contará como um FN. Como em limiares mais baixos, mais valores serão considerados positivos, em geral haverá contagens de TP e FP mais altas para a matriz de confusão binarizada do que para a matriz de confusão multiclasse e, de forma semelhante, TN e FN mais baixos.

A seguir está um exemplo de diferenças observadas entre MultiClassConfusionMatrixAtThresholds e as contagens correspondentes da binarização de uma das classes.

MultiClassConfusionMatrixAtThresholds vs Binarized

Por que minhas métricas de precisão @ 1 e recall @ 1 têm o mesmo valor?

Em um valor máximo de k de 1, a precisão e a recuperação são a mesma coisa. A precisão é igual a TP / (TP + FP) e recordação é igual a TP / (TP + FN) . A previsão superior é sempre positiva e corresponderá ou não ao rótulo. Em outras palavras, com N exemplos, TP + FP = N . No entanto, se o marcador não coincide com a previsão de topo, então esta também implica uma previsão não superior k foi combinado e com set top k para 1, todas as previsões não superior 1 será 0. Isto implica FN deve ser (N - TP) ou N = TP + FN . O resultado final é precision@1 = TP / N = recall@1 . Observe que isso só se aplica quando há um único rótulo por exemplo, não para vários rótulos.

Por que minhas métricas mean_label e mean_prediction são sempre 0,5?

Provavelmente, isso é causado porque as métricas são configuradas para um problema de classificação binária, mas o modelo está gerando probabilidades para ambas as classes, em vez de apenas uma. Isso é comum quando API classificação de tensorflow é usado. A solução é escolher a classe na qual deseja que as previsões se baseiem e, em seguida, binarizar nessa classe. Por exemplo:

eval_config = text_format.Parse("""
  ...
  metrics_specs {
    binarize { class_ids: { values: [0] } }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    ...
  }
  ...
""", config.EvalConfig())

Como interpretar o MultiLabelConfusionMatrixPlot?

Dado um rótulo específico, o MultiLabelConfusionMatrixPlot (e associado MultiLabelConfusionMatrix ) pode ser usado para comparar os resultados de outras etiquetas e as suas previsões quando o rótulo escolhido era realmente verdade. Por exemplo, vamos dizer que temos três classes bird , plane , e superman e estamos classificando imagens para indicar se eles contêm um ou mais de qualquer uma destas classes. O MultiLabelConfusionMatrix irá calcular o produto cartesiano de cada classe real contra a outra classe (chamado a classe do previsto). Note-se que enquanto o emparelhamento é (actual, predicted) , o predicted classe não implica necessariamente uma previsão positiva, que representa apenas a coluna previsto no real vs matriz previsto. Por exemplo, digamos que calculamos as seguintes matrizes:

   (bird, bird)         ->    { tp: 6, fp: 0, fn: 2, tn: 0}
   (bird, plane)        ->    { tp: 2, fp: 2, fn: 2, tn: 2}
   (bird, superman)     ->    { tp: 1, fp: 1, fn: 4, tn: 2}
   (plane, bird)        ->    { tp: 3, fp: 1, fn: 1, tn: 3}
   (plane, plane)       ->    { tp: 4, fp: 0, fn: 4, tn: 0}
   (plane, superman)    ->    { tp: 1, fp: 3, fn: 3, tn: 1}
   (superman, bird)     ->    { tp: 3, fp: 2, fn: 2, tn: 2}
   (superman, plane)    ->    { tp: 2, fp: 3, fn: 2, tn: 2}
   (superman, superman) ->    { tp: 4, fp: 0, fn: 5, tn: 0}

   num_examples: 20

O MultiLabelConfusionMatrixPlot tem três maneiras de exibir esses dados. Em todos os casos, a forma de ler a tabela é linha por linha da perspectiva da classe real.

1) Contagem total de previsão

Neste caso, para uma determinada linha (ou seja, classe real) quais foram os TP + FP contagens para as outras classes. Para as contagens acima, nossa exibição seria a seguinte:

Pássaro previsto Plano previsto Super-homem predito
Pássaro real 6 4 2
Plano real 4 4 4
Super-homem real 5 5 4

Quando as imagens realmente continha um bird que previu corretamente 6 deles. Ao mesmo tempo que também previu plane (seja correctamente ou incorrectamente) 4 vezes e superman (seja correctamente ou incorrectamente) 2 vezes.

2) Contagem de previsão incorreta

Neste caso, para uma determinada linha (ou seja, classe real) quais foram os FP contagens para as outras classes. Para as contagens acima, nossa exibição seria a seguinte:

Pássaro previsto Plano previsto Super-homem predito
Pássaro real 0 2 1
Plano real 1 0 3
Super-homem real 2 3 0

Quando as imagens realmente continha um bird que incorretamente previu plane 2 vezes e superman 1 vezes.

3) Contagem falsa negativa

Neste caso, para uma determinada linha (ou seja, classe real) quais foram as FN contagens para as outras classes. Para as contagens acima, nossa exibição seria a seguinte:

Pássaro previsto Plano previsto Super-homem predito
Pássaro real 2 2 4
Plano real 1 4 3
Super-homem real 2 2 5

Quando as imagens realmente continha um bird que não conseguiram prever que 2 vezes. Ao mesmo tempo, não conseguimos prever plane 2 vezes e superman 4 vezes.

Por que recebo um erro sobre a chave de previsão não encontrada?

Alguns modelos produzem suas previsões na forma de um dicionário. Por exemplo, um estimador de TF para o problema de classificação binária gera um dicionário contendo probabilities , class_ids , etc. Na maioria dos casos TFMA tem padrões para encontrar nomes de chave commomly utilizadas, tais como predictions , probabilities , etc. No entanto, se o seu modelo é muito personalizado for chaves de saída com nomes não conhecidos pelo TFMA. Em teses casos, uma prediciton_key configuração deve ser adicionada ao tfma.ModelSpec para identificar o nome da chave, a saída é armazenada sob.