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

Primeiros passos com a análise de modelo do TensorFlow

Visão geral

TensorFlow Model Analysis (TFMA) é uma biblioteca para realizar avaliação de modelo.

  • Para : engenheiros de aprendizado de máquina ou cientistas de dados
  • quem : deseja analisar e compreender seus modelos do TensorFlow
  • é : uma biblioteca autônoma ou componente de um pipeline TFX
  • que : avalia modelos em grandes quantidades de dados de forma distribuída nas mesmas métricas definidas no treinamento. Essas métricas são comparadas em fatias de dados e visualizadas em notebooks Jupyter ou Colab.
  • ao contrário : algumas ferramentas de introspecção de modelo como tensorboard que oferecem introspecção de modelo

TFMA executa seus cálculos de maneira distribuída em grandes quantidades de dados usando o Apache Beam . As seções a seguir descrevem como configurar um pipeline de avaliação TFMA básico. Veja a arquitetura mais detalhes sobre a implementação subjacente.

Se você quer apenas começar, dê uma olhada em nosso caderno colab .

Esta página também pode ser visualizada em tensorflow.org .

Tipos de modelos suportados

TFMA é projetado para suportar modelos baseados em tensorflow, mas pode ser facilmente estendido para suportar outras estruturas também. Historicamente, o TFMA exigia que um EvalSavedModel fosse criado para usar o TFMA, mas a versão mais recente do TFMA oferece suporte a vários tipos de modelos, dependendo das necessidades do usuário. A configuração de um EvalSavedModel só deve ser necessária se um modelo baseado em tf.estimator for usado e as métricas de tempo de treinamento personalizadas forem necessárias.

Observe que, como o TFMA agora é executado com base no modelo de serviço, o TFMA não avaliará mais automaticamente as métricas adicionadas no momento do treinamento. A exceção neste caso é se um modelo keras for usado, já que keras salva as métricas usadas junto com o modelo salvo. No entanto, se este for um requisito rígido, o TFMA mais recente é compatível com versões anteriores, de modo que um EvalSavedModel ainda pode ser executado em um pipeline TFMA.

A tabela a seguir resume os modelos suportados por padrão:

Tipo de modelo Métricas de tempo de treinamento Métricas pós-treinamento
TF2 (keras) Y * Y
TF2 (genérico) N / D Y
EvalSavedModel (estimador) Y Y
Nenhum (pd.DataFrame, etc) N / D Y
  • A métrica de tempo de treinamento refere-se a métricas definidas no tempo de treinamento e salvas com o modelo (TFMA EvalSavedModel ou modelo salvo keras). As métricas pós-treinamento referem-se às métricas adicionadas via tfma.MetricConfig .
  • Modelos TF2 genéricos são modelos personalizados que exportam assinaturas que podem ser usadas para inferência e não são baseados em keras ou estimador.

Consulte o FAQ para obter mais informações sobre como instalar e configurar esses diferentes tipos de modelo.

Configurar

Antes de executar uma avaliação, uma pequena configuração é necessária. Primeiro, um objeto tfma.EvalConfig deve ser definido para fornecer especificações para o modelo, métricas e fatias que serão avaliadas. Em segundo lugar, tfma.EvalSharedModel necessário tfma.EvalSharedModel um tfma.EvalSharedModel que aponte para o modelo (ou modelos) real a ser usado durante a avaliação. Depois de definidos, a avaliação é realizada chamando tfma.run_model_analysis com um conjunto de dados apropriado. Para obter mais detalhes, consulte o guia de configuração .

Se estiver executando em um pipeline TFX, consulte o guia TFX para saber como configurar o TFMA para ser executado como um componente TFX Evaluator .

Exemplos

Avaliação de modelo único

O seguinte usa tfma.run_model_analysis para realizar a avaliação em um modelo de serviço. Para obter uma explicação das diferentes configurações necessárias, consulte o guia de configuração .

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

eval_result = tfma.run_model_analysis(
    eval_shared_model=eval_shared_model,
    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/output')

tfma.view.render_slicing_metrics(eval_result)

Para avaliação distribuída, construa um pipeline do Apache Beam usando um executor distribuído. No pipeline, use o tfma.ExtractEvaluateAndWriteResults para avaliação e para escrever os resultados. Os resultados podem ser carregados para visualização usando tfma.load_eval_result .

Por exemplo:

# To run the pipeline.
from google.protobuf import text_format
from tfx_bsl.tfxio import tf_example_record

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics { class_name: "AUC" }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path='/path/to/saved/model', eval_config=eval_config)

output_path = '/path/for/output'

tfx_io = tf_example_record.TFExampleRecord(
    file_pattern=data_location, raw_record_column_name=tfma.ARROW_INPUT_COLUMN)

with beam.Pipeline(runner=...) as p:
  _ = (p
       # You can change the source as appropriate, e.g. read from BigQuery.
       # This assumes your data is a TFRecords file containing records in the
       # tf.train.Example format. If using EvalSavedModel then use the following
       # instead: 'ReadData' >> beam.io.ReadFromTFRecord(file_pattern=...)
       | 'ReadData' >> tfx_io.BeamSource()
       | 'ExtractEvaluateAndWriteResults' >>
       tfma.ExtractEvaluateAndWriteResults(
            eval_shared_model=eval_shared_model,
            eval_config=eval_config,
            output_path=output_path))

# To load and visualize results.
# Note that this code should be run in a Jupyter Notebook.
result = tfma.load_eval_result(output_path)
tfma.view.render_slicing_metrics(result)

Validação do modelo

Para realizar a validação do modelo em relação a uma candidatura e linha de base, atualize a configuração para incluir uma configuração de limite e passe dois modelos para tfma.run_model_analysis .

Por exemplo:

# Run in a Jupyter Notebook.
from google.protobuf import text_format

eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # This assumes a serving model with a "serving_default" signature.
    label_key: "label"
    example_weight_key: "weight"
  }
  ## Post export metric information
  metrics_specs {
    # This adds AUC and as a post training metric. If the model has built in
    # training metrics which also contains AUC, this metric will replace it.
    metrics {
      class_name: "AUC"
      threshold {
        value_threshold {
          lower_bound { value: 0.9 }
        }
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    # ... other post training metrics ...

    # Plots are also configured here...
    metrics { class_name: "ConfusionMatrixPlot" }
  }
  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["age"]
  }
""", tfma.EvalConfig())

eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path='/path/to/saved/candiate/model',
      eval_config=eval_config),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path='/path/to/saved/baseline/model',
      eval_config=eval_config),
]

output_path = '/path/for/output'

eval_result = tfma.run_model_analysis(
    eval_shared_models,
    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=output_path)

tfma.view.render_slicing_metrics(eval_result)
tfma.load_validation_result(output_path)

Visualização

Os resultados da avaliação TFMA podem ser visualizados em um notebook Jupyter usando os componentes front-end incluídos no TFMA. Por exemplo:

TFMA Slicing Metrics Browser .

Mais Informações