Análise de modelo do TensorFlow

Nota: Você pode executar este exemplo agora em um caderno Jupyter de estilo, sem configuração necessária! Basta clicar em "Executar no Google Colab"

Um exemplo de um componente-chave do TensorFlow Extended (TFX)

TensorFlow Modelo de Análise (TFMA) é uma biblioteca para a realização de avaliação do modelo em diferentes fatias de dados. TFMA executa seus cálculos de uma forma distribuída ao longo de grandes quantidades de dados utilizando Apache feixe .

Este exemplo de bloco de notas colab ilustra como o TFMA pode ser usado para investigar e visualizar o desempenho de um modelo em relação às características do conjunto de dados. Usaremos um modelo que treinamos anteriormente e agora você pode brincar com os resultados! O modelo que treinou foi para o Chicago Taxi Exemplo , que usa o táxi Viagens conjunto de dados liberado pela cidade de Chicago. Explorar o conjunto de dados completo no UI BigQuery .

Como modelador e desenvolvedor, pense em como esses dados são usados ​​e os benefícios e danos potenciais que as previsões de um modelo podem causar. Um modelo como esse poderia reforçar os preconceitos e disparidades sociais. Um recurso é relevante para o problema que você deseja resolver ou apresentará viés? Para mais informações, leia sobre ML justiça .

Nota: A fim de compreender TFMA e como ele funciona com Apache Beam, você precisa saber um pouco sobre si Apache Beam. O Guia de Programação do feixe é um ótimo lugar para começar.

As colunas do conjunto de dados são:

pickup_community_area	tarifa	trip_start_month
trip_start_hour	trip_start_day	trip_start_timestamp
pickup_latitude	pickup_longitude	dropoff_latitude
dropoff_longitude	trip_miles	pickup_census_tract
dropoff_census_tract	tipo de pagamento	companhia
trip_segundos	dropoff_community_area	pontas

Instale extensões Jupyter

Nota: Se você estiver executando em um caderno Jupyter local, em seguida, essas extensões Jupyter deve ser instalado no ambiente antes de executar Jupyter.

jupyter nbextension enable --py widgetsnbextension --sys-prefix 
jupyter nbextension install --py --symlink tensorflow_model_analysis --sys-prefix 
jupyter nbextension enable --py tensorflow_model_analysis --sys-prefix 

Instale o TensorFlow Model Analysis (TFMA)

Isso irá puxar todas as dependências e levará um minuto.

# Upgrade pip to the latest, and install TFMA.
pip install -U pip
pip install tensorflow-model-analysis

Agora você deve reiniciar o tempo de execução antes de executar as células abaixo.

# This setup was tested with TF 2.5 and TFMA 0.31 (using colab), but it should
# also work with the latest release.
import sys

# Confirm that we're using Python 3
assert sys.version_info.major==3, 'This notebook must be run using Python 3.'

import tensorflow as tf
print('TF version: {}'.format(tf.__version__))
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))

TF version: 2.4.4
Beam version: 2.34.0
TFMA version: 0.29.0

Nota: A saída acima deve estar livre de erros antes de prosseguir. Execute novamente a instalação se você ainda estiver vendo erros. Além disso, certifique-se de reiniciar o runtime / kernel antes de passar para a próxima etapa. **

Carregue os arquivos

Faremos o download de um arquivo tar que contém tudo o que precisamos. Isso inclui:

• Conjuntos de dados de treinamento e avaliação
• Esquema de dados
• Treinando e servindo modelos salvos (keras e estimador) e modelos salvos de avaliação (estimador).

# Download the tar file from GCP and extract it
import io, os, tempfile
TAR_NAME = 'saved_models-2.2'
BASE_DIR = tempfile.mkdtemp()
DATA_DIR = os.path.join(BASE_DIR, TAR_NAME, 'data')
MODELS_DIR = os.path.join(BASE_DIR, TAR_NAME, 'models')
SCHEMA = os.path.join(BASE_DIR, TAR_NAME, 'schema.pbtxt')
OUTPUT_DIR = os.path.join(BASE_DIR, 'output')

!curl -O https://storage.googleapis.com/artifacts.tfx-oss-public.appspot.com/datasets/{TAR_NAME}.tar
!tar xf {TAR_NAME}.tar
!mv {TAR_NAME} {BASE_DIR}
!rm {TAR_NAME}.tar

print("Here's what we downloaded:")
!ls -R {BASE_DIR}

% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 6800k  100 6800k    0     0  28.2M      0 --:--:-- --:--:-- --:--:-- 28.2M
Here's what we downloaded:
/tmp/tmp_at9q62d:
saved_models-2.2

/tmp/tmp_at9q62d/saved_models-2.2:
data  models  schema.pbtxt

/tmp/tmp_at9q62d/saved_models-2.2/data:
eval  train

/tmp/tmp_at9q62d/saved_models-2.2/data/eval:
data.csv

/tmp/tmp_at9q62d/saved_models-2.2/data/train:
data.csv

/tmp/tmp_at9q62d/saved_models-2.2/models:
estimator  keras

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator:
eval_model_dir  serving_model_dir

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir:
1591221811

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811:
saved_model.pb  tmp.pbtxt  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir:
checkpoint
eval_chicago-taxi-eval
events.out.tfevents.1591221780.my-pipeline-b57vp-237544850
export
graph.pbtxt
model.ckpt-100.data-00000-of-00001
model.ckpt-100.index
model.ckpt-100.meta

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export:
chicago-taxi

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi:
1591221801

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/estimator/serving_model_dir/export/chicago-taxi/1591221801/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras:
0  1  2

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/0:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/0/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/1:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/1/variables:
variables.data-00000-of-00001  variables.index

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/2:
saved_model.pb  variables

/tmp/tmp_at9q62d/saved_models-2.2/models/keras/2/variables:
variables.data-00000-of-00001  variables.index

Analise o esquema

Entre as coisas que baixado foi um esquema para os nossos dados que foram criados por TensorFlow validação de dados . Vamos analisar isso agora para que possamos usá-lo com TFMA.

import tensorflow as tf
from google.protobuf import text_format
from tensorflow.python.lib.io import file_io
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow.core.example import example_pb2

schema = schema_pb2.Schema()
contents = file_io.read_file_to_string(SCHEMA)
schema = text_format.Parse(contents, schema)

Use o esquema para criar TFRecords

Precisamos dar acesso TFMA ao nosso conjunto de dados, então vamos criar um arquivo TFRecords. Podemos usar nosso esquema para criá-lo, pois ele nos fornece o tipo correto para cada recurso.

import csv

datafile = os.path.join(DATA_DIR, 'eval', 'data.csv')
reader = csv.DictReader(open(datafile, 'r'))
examples = []
for line in reader:
  example = example_pb2.Example()
  for feature in schema.feature:
    key = feature.name
    if feature.type == schema_pb2.FLOAT:
      example.features.feature[key].float_list.value[:] = (
          [float(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.INT:
      example.features.feature[key].int64_list.value[:] = (
          [int(line[key])] if len(line[key]) > 0 else [])
    elif feature.type == schema_pb2.BYTES:
      example.features.feature[key].bytes_list.value[:] = (
          [line[key].encode('utf8')] if len(line[key]) > 0 else [])
  # Add a new column 'big_tipper' that indicates if tips was > 20% of the fare. 
  # TODO(b/157064428): Remove after label transformation is supported for Keras.
  big_tipper = float(line['tips']) > float(line['fare']) * 0.2
  example.features.feature['big_tipper'].float_list.value[:] = [big_tipper]
  examples.append(example)

tfrecord_file = os.path.join(BASE_DIR, 'train_data.rio')
with tf.io.TFRecordWriter(tfrecord_file) as writer:
  for example in examples:
    writer.write(example.SerializeToString())

!ls {tfrecord_file}

/tmp/tmp_at9q62d/train_data.rio

Configurar e executar o TFMA

TFMA suporta vários tipos de modelos diferentes, incluindo modelos TF keras, modelos baseados em APIs de assinatura TF2 genéricas, bem como modelos baseados em estimadores TF. O get_started guia tem a lista completa de tipos de modelos suportados e quaisquer restrições. Para este exemplo, vamos mostrar como configurar um keras modelo baseado, bem como um modelo baseado estimador que foi salvo como um EvalSavedModel . Veja o FAQ para exemplos de outras configurações.

TFMA fornece suporte para calcular métricas que foram usadas no momento do treinamento (ou seja, métricas integradas), bem como métricas definidas depois que o modelo foi salvo como parte das configurações do TFMA. Para o nosso keras configuração vamos demonstrar a adição de nossas métricas e gráficos manualmente como parte de nossa configuração (consulte a métricas guia para obter informações sobre as métricas e gráficos que são suportadas). Para a configuração do estimador, usaremos as métricas integradas que foram salvas com o modelo. Nossas configurações também incluem uma série de especificações de fatiamento que são discutidas em mais detalhes nas seções a seguir.

Depois de criar um tfma.EvalConfig e tfma.EvalSharedModel podemos então executar TFMA usando tfma.run_model_analysis . Isto irá criar uma tfma.EvalResult que podemos usar mais tarde para a prestação de nossas métricas e gráficos.

Keras

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
keras_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # For keras (and serving models) we need to add a `label_key`.
    label_key: "big_tipper"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our keras model.
keras_model_path = os.path.join(MODELS_DIR, 'keras', '2')
keras_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=keras_model_path,
    eval_config=keras_eval_config)

keras_output_path = os.path.join(OUTPUT_DIR, 'keras')

# Run TFMA
keras_eval_result = tfma.run_model_analysis(
    eval_shared_model=keras_eval_shared_model,
    eval_config=keras_eval_config,
    data_location=tfrecord_file,
    output_path=keras_output_path)

2021-12-04 10:18:15.463173: W tensorflow/stream_executor/platform/default/dso_loader.cc:60] Could not load dynamic library 'libcusolver.so.10'; dlerror: libcusolver.so.10: cannot open shared object file: No such file or directory
2021-12-04 10:18:15.464249: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1757] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
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:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
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.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: 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.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: 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)`

Estimador

import tensorflow_model_analysis as tfma

# Setup tfma.EvalConfig settings
estimator_eval_config = text_format.Parse("""
  ## Model information
  model_specs {
    # To use EvalSavedModel set `signature_name` to "eval".
    signature_name: "eval"
  }

  ## Post training metric information. These will be merged with any built-in
  ## metrics from training.
  metrics_specs {
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_values: {
      key: "trip_start_month"
      value: "1"
    }
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create a tfma.EvalSharedModel that points at our eval saved model.
estimator_base_model_path = os.path.join(
    MODELS_DIR, 'estimator', 'eval_model_dir')
estimator_model_path = os.path.join(
    estimator_base_model_path, os.listdir(estimator_base_model_path)[0])
estimator_eval_shared_model = tfma.default_eval_shared_model(
    eval_saved_model_path=estimator_model_path,
    eval_config=estimator_eval_config)

estimator_output_path = os.path.join(OUTPUT_DIR, 'estimator')

# Run TFMA
estimator_eval_result = tfma.run_model_analysis(
    eval_shared_model=estimator_eval_shared_model,
    eval_config=estimator_eval_config,
    data_location=tfrecord_file,
    output_path=estimator_output_path)

WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/load.py:169: load (from tensorflow.python.saved_model.loader_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.loader.load or tf.compat.v1.saved_model.load. There will be a new function for importing SavedModels in Tensorflow 2.0.
INFO:tensorflow:Restoring parameters from /tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
INFO:tensorflow:Restoring parameters from /tmp/tmp_at9q62d/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/eval_saved_model/graph_ref.py:189: get_tensor_from_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.
Instructions for updating:
This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.get_tensor_from_tensor_info or tf.compat.v1.saved_model.get_tensor_from_tensor_info.

Visualizando métricas e gráficos

Agora que executamos a avaliação, vamos dar uma olhada em nossas visualizações usando TFMA. Para os exemplos a seguir, visualizaremos os resultados da execução da avaliação no modelo keras. Para visualizar o estimador baseado atualização modelo do eval_result ao ponto em nosso estimator_eval_result variável.

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Rendering Metrics

Para visualizar métricas você usa tfma.view.render_slicing_metrics

Por padrão, os pontos de vista irá exibir o Overall fatia. Para ver uma fatia especial que você pode usar o nome da coluna (por definição slicing_column ) ou fornecer um tfma.SlicingSpec .

A visualização de métricas suporta as seguintes interações:

• Clique e arraste para deslocar
• Role para zoom
• Clique com o botão direito para reiniciar a vista
• Passe o mouse sobre o ponto de dados desejado para ver mais detalhes.
• Selecione entre quatro tipos diferentes de visualizações usando as seleções na parte inferior.

Por exemplo, nós estaremos definindo slicing_column de olhar para o trip_start_hour característica dos nossos anteriores slicing_specs .

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_hour')

SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_hour:2', …

Visão geral das fatias

A visualização padrão é a Visão Slices quando o número de fatias é pequena. Mostra os valores das métricas para cada fatia. Uma vez que você selecionou trip_start_hour acima, ele está nos mostrando métricas como precisão e AUC para cada hora, o que nos permite olhar para problemas que são específicos para algumas horas e não outros.

Na visualização acima:

• Tentar classificar a coluna característica, que é o nosso trip_start_hours apresentam, clicando no cabeçalho da coluna
• Tente classificar por precisão, e aviso que a precisão para algumas das horas com exemplos é 0, o que pode indicar um problema

O gráfico também nos permite selecionar e exibir diferentes métricas em nossas fatias.

• Tente selecionar métricas diferentes no menu "Mostrar"
• Tente selecionar recordação no menu "Show", e observe que o recall para algumas das horas com exemplos é 0, o que pode indicar um problema

Também é possível definir um limite para filtrar fatias com menor número de exemplos, ou "pesos". Você pode digitar um número mínimo de exemplos ou usar o controle deslizante.

Histograma de métricas

Este ponto de vista também suporta uma Metrics Histograma como uma visualização alternativa, que é também o modo de exibição padrão quando o número de fatias é grande. Os resultados serão divididos em baldes e o número de fatias / pesos totais / ambos podem ser visualizados. As colunas podem ser classificadas clicando no cabeçalho da coluna. Fatias com pesos pequenos podem ser filtradas definindo o limite. Filtragem adicional pode ser aplicada arrastando a faixa cinza. Para redefinir o intervalo, clique duas vezes na banda. A filtragem também pode ser usada para remover outliers na visualização e nas tabelas de métricas. Clique no ícone de engrenagem para alternar para uma escala logarítmica em vez de uma escala linear.

• Tente selecionar "Histograma de métricas" no menu Visualização

Mais fatias

Nosso inicial tfma.EvalConfig criou toda uma lista de slicing_specs , que podemos visualizar pela informação fatia atualização passado para tfma.view.render_slicing_metrics . Aqui nós vamos selecionar o trip_start_day fatia (dias da semana). Tente alterar o trip_start_day para trip_start_month e renderização de novo para examinar fatias diferentes.

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_day')

SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day:3', '…

TFMA também suporta a criação de cruzamentos de recursos para analisar combinações de recursos. Nossos configurações originais criou uma cruz trip_start_hour e trip_start_day :

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_hour', 'trip_start_day']))

SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Cruzar as duas colunas cria muitas combinações! Vamos estreitar nossa cruz para procurar somente em viagens que começam ao meio-dia. Então vamos selecionar binary_accuracy da visualização:

tfma.view.render_slicing_metrics(
    eval_result,
    slicing_spec=tfma.SlicingSpec(
        feature_keys=['trip_start_day'], feature_values={'trip_start_hour': '12'}))

SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day_X_tri…

Renderizando Plots

Quaisquer parcelas que foram adicionados ao tfma.EvalConfig como formação pós metric_specs podem ser exibidos usando tfma.view.render_plot .

Tal como acontece com as métricas, os gráficos podem ser visualizados por fatia. Ao contrário de métricas, apenas lotes para um valor fatia particular pode ser exibida para o tfma.SlicingSpec deve ser utilizado e deve especificar um nome de recurso fatia e valor. Se nenhuma fatia é fornecido então as parcelas para a Overall fatia é usado.

No exemplo abaixo, estamos exibindo os CalibrationPlot e ConfusionMatrixPlot parcelas que foram computados para o trip_start_hour:1 fatia.

tfma.view.render_plot(
    eval_result,
    tfma.SlicingSpec(feature_values={'trip_start_hour': '1'}))

PlotViewer(config={'sliceName': 'trip_start_hour:1', 'metricKeys': {'calibrationPlot': {'metricName': 'calibra…

Acompanhamento do desempenho do modelo ao longo do tempo

Seu conjunto de dados de treinamento será usado para treinar seu modelo e, com sorte, será representativo de seu conjunto de dados de teste e dos dados que serão enviados para seu modelo em produção. No entanto, embora os dados nas solicitações de inferência possam permanecer iguais aos seus dados de treinamento, em muitos casos eles começarão a mudar o suficiente para que o desempenho do seu modelo mude.

Isso significa que você precisa monitorar e medir o desempenho do seu modelo continuamente, para que possa estar ciente e reagir às mudanças. Vamos dar uma olhada em como o TFMA pode ajudar.

Deixou-nos carga 3 corridas diferentes modelos e uso TFMA para ver como eles se comparam com render_time_series .

# Note this re-uses the EvalConfig from the keras setup.

# Run eval on each saved model
output_paths = []
for i in range(3):
  # Create a tfma.EvalSharedModel that points at our saved model.
  eval_shared_model = tfma.default_eval_shared_model(
      eval_saved_model_path=os.path.join(MODELS_DIR, 'keras', str(i)),
      eval_config=keras_eval_config)

  output_path = os.path.join(OUTPUT_DIR, 'time_series', str(i))
  output_paths.append(output_path)

  # Run TFMA
  tfma.run_model_analysis(eval_shared_model=eval_shared_model,
                          eval_config=keras_eval_config,
                          data_location=tfrecord_file,
                          output_path=output_path)

WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Primeiro, vamos imaginar que treinamos e implantamos nosso modelo ontem e agora queremos ver como ele está se saindo nos novos dados que chegam hoje. A visualização começará exibindo AUC. Na IU, você pode:

• Adicione outras métricas usando o menu "Adicionar série de métricas".
• Feche os gráficos indesejados clicando em x
• Passe o mouse sobre os pontos de dados (as extremidades dos segmentos de linha no gráfico) para obter mais detalhes

Nota: Nos quadros série métrica do eixo X é o nome do diretório do modelo do modelo de execução que você está examinando. Esses nomes em si não são significativos.

eval_results_from_disk = tfma.load_eval_results(output_paths[:2])

tfma.view.render_time_series(eval_results_from_disk)

TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Agora, vamos imaginar que outro dia se passou e queremos ver como está o desempenho dos novos dados que chegam hoje, em comparação com os dois dias anteriores:

eval_results_from_disk = tfma.load_eval_results(output_paths)

tfma.view.render_time_series(eval_results_from_disk)

TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Validação do modelo

O TFMA pode ser configurado para avaliar vários modelos ao mesmo tempo. Normalmente, isso é feito para comparar um novo modelo com uma linha de base (como o modelo atualmente em uso) para determinar quais são as diferenças de desempenho nas métricas (por exemplo, AUC, etc.) em relação à linha de base. Quando limiares são configurados, TFMA irá produzir um tfma.ValidationResult ficha que indica se o desempenho corresponde expecations.

Vamos reconfigurar nossa avaliação de keras para comparar dois modelos: um candidato e uma linha de base. Nós também irá validar o desempenho do candidato contra a linha de base, definindo um tmfa.MetricThreshold na métrica AUC.

# Setup tfma.EvalConfig setting
eval_config_with_thresholds = text_format.Parse("""
  ## Model information
  model_specs {
    name: "candidate"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
  }
  model_specs {
    name: "baseline"
    # For keras we need to add a `label_key`.
    label_key: "big_tipper"
    is_baseline: true
  }

  ## Post training metric information
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics {
      class_name: "AUC"
      threshold {
        # Ensure that AUC is always > 0.9
        value_threshold {
          lower_bound { value: 0.9 }
        }
        # Ensure that AUC does not drop by more than a small epsilon
        # e.g. (candidate - baseline) > -1e-10 or candidate > baseline - 1e-10
        change_threshold {
          direction: HIGHER_IS_BETTER
          absolute { value: -1e-10 }
        }
      }
    }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "Precision" }
    metrics { class_name: "Recall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "CalibrationPlot" }
    metrics { class_name: "ConfusionMatrixPlot" }
    # ... add additional metrics and plots ...
  }

  ## Slicing information
  slicing_specs {}  # overall slice
  slicing_specs {
    feature_keys: ["trip_start_hour"]
  }
  slicing_specs {
    feature_keys: ["trip_start_day"]
  }
  slicing_specs {
    feature_keys: ["trip_start_month"]
  }
  slicing_specs {
    feature_keys: ["trip_start_hour", "trip_start_day"]
  }
""", tfma.EvalConfig())

# Create tfma.EvalSharedModels that point at our keras models.
candidate_model_path = os.path.join(MODELS_DIR, 'keras', '2')
baseline_model_path = os.path.join(MODELS_DIR, 'keras', '1')
eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path=candidate_model_path,
      eval_config=eval_config_with_thresholds),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path=baseline_model_path,
      eval_config=eval_config_with_thresholds),
]

validation_output_path = os.path.join(OUTPUT_DIR, 'validation')

# Run TFMA
eval_result_with_validation = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config_with_thresholds,
    data_location=tfrecord_file,
    output_path=validation_output_path)

WARNING:absl:Tensorflow version (2.4.4) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Ao executar avaliações com um ou mais modelos em relação a uma linha de base, o TFMA adiciona automaticamente as métricas de diferenças para todas as métricas calculadas durante a avaliação. Estas métricas são nomeados após a métrica, mas com correspondente _diff anexado ao nome métrica.

Vamos dar uma olhada nas métricas produzidas por nossa execução:

tfma.view.render_time_series(eval_result_with_validation)

TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'binary_accuracy': {'doubleValu…

Agora vamos dar uma olhada na saída de nossas verificações de validação. Para visualizar os resultados de validação que usamos tfma.load_validator_result . Para nosso exemplo, a validação falha porque AUC está abaixo do limite.

validation_result = tfma.load_validation_result(validation_output_path)
print(validation_result.validation_ok)

False

Nota: Este site fornece aplicações utilizando dados que foram modificados para uso de sua fonte original, www.cityofchicago.org, o site oficial da cidade de Chicago. A cidade de Chicago não faz nenhuma reclamação quanto ao conteúdo, precisão, oportunidade ou integridade de qualquer um dos dados fornecidos neste site. Os dados fornecidos neste site estão sujeitos a alterações a qualquer momento. Entende-se que os dados fornecidos neste site estão sendo utilizados por sua própria conta e risco.