Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Análisis del modelo de TensorFlow

Un ejemplo de un componente clave de TensorFlow Extended (TFX)

TensorFlow Model Analysis (TFMA) es una biblioteca para realizar la evaluación del modelo en diferentes segmentos de datos. TFMA realiza sus cálculos de manera distribuida sobre grandes cantidades de datos utilizando Apache Beam .

Este cuaderno de ejemplo de colab ilustra cómo se puede utilizar TFMA para investigar y visualizar el rendimiento de un modelo con respecto a las características del conjunto de datos. Usaremos un modelo que entrenamos anteriormente, ¡y ahora puedes jugar con los resultados! El modelo que entrenamos fue para el ejemplo de taxi de Chicago , que utiliza el conjunto de datos de viajes en taxi publicado por la ciudad de Chicago. Explore el conjunto de datos completo en la IU de BigQuery .

Como modelador y desarrollador, piense en cómo se utilizan estos datos y los posibles beneficios y daños que pueden causar las predicciones de un modelo. Un modelo como este podría reforzar los prejuicios y disparidades sociales. ¿Es una característica relevante para el problema que desea resolver o introducirá sesgos? Para obtener más información, lea acerca de la equidad del AA .

Las columnas del conjunto de datos son:

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 pago empresa
trip_seconds dropoff_community_area consejos

Instalar extensiones de 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 

Instalar TensorFlow Model Analysis (TFMA)

Esto atraerá todas las dependencias y tomará un minuto.

Tenga en cuenta que para asegurarse de que todas las dependencias estén instaladas correctamente, es posible que deba volver a ejecutar este paso de instalación varias veces antes de que no haya errores.

# This setup was tested with TF 2.3 and TFMA 0.24 (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.'

print('Installing TensorFlow')
import tensorflow as tf
print('TF version: {}'.format(tf.__version__))

print('Installing Tensorflow Model Analysis and Dependencies')
!pip install -q tensorflow_model_analysis
import apache_beam as beam
print('Beam version: {}'.format(beam.__version__))
import tensorflow_model_analysis as tfma
print('TFMA version: {}'.format(tfma.__version__))
Installing TensorFlow
TF version: 2.3.1
Installing Tensorflow Model Analysis and Dependencies
ERROR: After October 2020 you may experience errors when installing or updating packages. This is because pip will change the way that it resolves dependency conflicts.

We recommend you use --use-feature=2020-resolver to test your packages with the new resolver before it becomes the default.

google-api-python-client 1.12.3 requires httplib2<1dev,>=0.15.0, but you'll have httplib2 0.9.2 which is incompatible.
Beam version: 2.24.0
TFMA version: 0.24.3

Cargar los archivos

Descargaremos un archivo tar que tiene todo lo que necesitamos. Eso incluye:

  • Conjuntos de datos de capacitación y evaluación
  • Esquema de datos
  • Entrenamiento y servicio de modelos guardados (keras y estimador) y eval modelos guardados (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  25.4M      0 --:--:-- --:--:-- --:--:-- 25.3M
Here's what we downloaded:
/tmp/tmpj6t03cp6:
saved_models-2.2

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

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

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

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

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

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

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

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

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

/tmp/tmpj6t03cp6/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/tmpj6t03cp6/saved_models-2.2/models/estimator/serving_model_dir/eval_chicago-taxi-eval:
events.out.tfevents.1591221799.my-pipeline-b57vp-237544850

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

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

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

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

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

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

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

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

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

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

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

Analizar el esquema

Entre las cosas que descargamos estaba un esquema para nuestros datos que fue creado por TensorFlow Data Validation . Analicemos eso ahora para que podamos usarlo con 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)

Utilice el esquema para crear TFRecords

Necesitamos dar acceso a TFMA a nuestro conjunto de datos, así que creemos un archivo TFRecords. Podemos usar nuestro esquema para crearlo, ya que nos da el tipo correcto para cada característica.

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/tmpj6t03cp6/train_data.rio

Configurar y ejecutar TFMA

TFMA admite varios tipos de modelos diferentes, incluidos modelos TF keras, modelos basados ​​en API de firma TF2 genéricas, así como modelos basados ​​en estimadores TF. La guía get_started tiene la lista completa de tipos de modelos admitidos y las restricciones. Para este ejemplo, vamos a mostrar cómo configurar un modelo basado en Keras, así como un modelo basado en estimador que se guardó como un EvalSavedModel . Consulte las preguntas frecuentes para ver ejemplos de otras configuraciones.

TFMA proporciona soporte para calcular métricas que se utilizaron en el momento del entrenamiento (es decir, métricas integradas), así como métricas definidas después de que el modelo se guardó como parte de los ajustes de configuración de TFMA. Para nuestra configuración de keras, demostraremos cómo agregar nuestras métricas y gráficos manualmente como parte de nuestra configuración (consulte la guía de métricas para obtener información sobre las métricas y gráficos compatibles). Para la configuración del estimador usaremos las métricas integradas que se guardaron con el modelo. Nuestras configuraciones también incluyen una serie de especificaciones de corte que se analizan con más detalle en las siguientes secciones.

Después de crear un tfma.EvalConfig y tfma.EvalSharedModel , podemos ejecutar TFMA usando tfma.run_model_analysis . Esto creará un tfma.EvalResult que podremos usar más adelante para representar nuestras métricas y 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)
​​
WARNING:absl:Tensorflow version (2.3.1) 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: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.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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.6/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:70: 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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/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.6/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/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

INFO:tensorflow:Restoring parameters from /tmp/tmpj6t03cp6/saved_models-2.2/models/estimator/eval_model_dir/1591221811/variables/variables

Warning:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/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.6/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.

Visualización de métricas y gráficos

Ahora que hemos realizado la evaluación, echemos un vistazo a nuestras visualizaciones usando TFMA. Para los siguientes ejemplos, visualizaremos los resultados de ejecutar la evaluación en el modelo keras. Para ver el modelo basado en estimador, actualice eval_result para que apunte a nuestra variable estimator_eval_result .

eval_result = keras_eval_result
# eval_result = estimator_eval_result

Métricas de renderizado

Para ver las métricas, usa tfma.view.render_slicing_metrics

De forma predeterminada, las vistas mostrarán el sector Overall . Para ver un corte en particular, puede usar el nombre de la columna (configurando slicing_column ) o proporcionar un tfma.SlicingSpec .

La visualización de métricas admite las siguientes interacciones:

  • Haga clic y arrastre para desplazarse
  • Desplácese para hacer zoom
  • Haga clic derecho para restablecer la vista
  • Desplácese sobre el punto de datos deseado para ver más detalles.
  • Seleccione entre cuatro tipos diferentes de vistas usando las selecciones en la parte inferior.

Por ejemplo, configuraremos slicing_column para ver la característica trip_start_hour de nuestras 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', …

Resumen de rebanadas

La visualización predeterminada es Vista general de sectores cuando el número de sectores es pequeño. Muestra los valores de las métricas para cada segmento. Como hemos seleccionado trip_start_hour arriba, nos muestra métricas como la precisión y el AUC para cada hora, lo que nos permite buscar problemas que son específicos de algunas horas y no de otras.

En la visualización de arriba:

  • Intente ordenar la columna de funciones, que es nuestra función trip_start_hours , haciendo clic en el encabezado de la columna
  • Intente ordenar por precisión y observe que la precisión para algunas de las horas con ejemplos es 0, lo que puede indicar un problema

El gráfico también nos permite seleccionar y mostrar diferentes métricas en nuestros segmentos.

  • Prueba a seleccionar diferentes métricas en el menú "Mostrar".
  • Intente seleccionar la recuperación en el menú "Mostrar" y observe que la recuperación de algunas de las horas con ejemplos es 0, lo que puede indicar un problema.

También es posible establecer un umbral para filtrar porciones con un número menor de ejemplos o "pesos". Puede escribir un número mínimo de ejemplos o utilizar el control deslizante.

Histograma de métricas

Esta vista también admite un histograma de métricas como visualización alternativa, que también es la vista predeterminada cuando el número de sectores es grande. Los resultados se dividirán en cubos y se podrá visualizar el número de cortes / pesos totales / ambos. Las columnas se pueden ordenar haciendo clic en el encabezado de la columna. Las rebanadas con pesos pequeños se pueden filtrar estableciendo el umbral. Se puede aplicar más filtrado arrastrando la banda gris. Para restablecer el rango, haga doble clic en la banda. El filtrado también se puede utilizar para eliminar valores atípicos en la visualización y las tablas de métricas. Haga clic en el icono de engranaje para cambiar a una escala logarítmica en lugar de una escala lineal.

  • Prueba a seleccionar "Histograma de métricas" en el menú de visualización.

Más rebanadas

Nuestro tfma.EvalConfig inicial creó una lista completa de slicing_specs , que podemos visualizar actualizando la información de corte pasada a tfma.view.render_slicing_metrics . Aquí seleccionaremos el segmento trip_start_day (días de la semana). Intente cambiar trip_start_day a trip_start_month y trip_start_month nuevamente para examinar diferentes cortes.

tfma.view.render_slicing_metrics(eval_result, slicing_column='trip_start_day')
SlicingMetricsViewer(config={'weightedExamplesColumn': 'example_count'}, data=[{'slice': 'trip_start_day:3', '…

TFMA también admite la creación de cruces de características para analizar combinaciones de características. Nuestra configuración original creó una trip_start_hour y 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 las dos columnas crea muchas combinaciones! Reduzcamos nuestra cruz para ver solo los viajes que comienzan al mediodía . Luego, seleccionemos binary_accuracy de la visualización:

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…

Representación de gráficos

Cualquier parcelas que se agregaron a la tfma.EvalConfig como formación post metric_specs se pueden visualizar utilizando tfma.view.render_plot .

Al igual que con las métricas, los gráficos se pueden ver por sector. A diferencia de las métricas, solo se pueden mostrar los gráficos de un valor de sector en particular, por lo que se debe usar tfma.SlicingSpec y debe especificar tanto el nombre como el valor de la característica del sector. Si no se proporciona ningún sector, se utilizan los gráficos del sector Overall .

En el siguiente ejemplo, mostramos las gráficas CalibrationPlot y ConfusionMatrixPlot que se calcularon para trip_start_hour:1 segmento.

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…

Seguimiento del rendimiento del modelo a lo largo del tiempo

Su conjunto de datos de entrenamiento se utilizará para entrenar su modelo y, con suerte, será representativo de su conjunto de datos de prueba y los datos que se enviarán a su modelo en producción. Sin embargo, si bien los datos en las solicitudes de inferencia pueden seguir siendo los mismos que sus datos de entrenamiento, en muchos casos comenzarán a cambiar lo suficiente como para que el rendimiento de su modelo cambie.

Eso significa que necesita monitorear y medir el desempeño de su modelo de manera continua, para que pueda estar al tanto de los cambios y reaccionar ante ellos. Echemos un vistazo a cómo puede ayudar TFMA.

Carguemos 3 ejecuciones de modelos diferentes y usemos TFMA para ver cómo se comparan usando 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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
WARNING:absl:Tensorflow version (2.3.1) found. Note that TFMA support for TF 2.0 is currently in beta

Primero, imaginaremos que hemos entrenado e implementado nuestro modelo ayer, y ahora queremos ver cómo le está yendo con los nuevos datos que ingresan hoy. La visualización comenzará mostrando AUC. Desde la interfaz de usuario puede:

  • Agregue otras métricas mediante el menú "Agregar serie de métricas".
  • Cierre los gráficos no deseados haciendo clic en x
  • Desplácese sobre los puntos de datos (los extremos de los segmentos de línea en el gráfico) para obtener más detalles
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': {'': {'': {'calibration': {'doubleValue': …

Ahora imaginaremos que ha pasado otro día y queremos ver cómo les va con los nuevos datos que llegan hoy, en comparación con los dos días 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': {'': {'': {'calibration': {'doubleValue': …

Modelo de validación

TFMA se puede configurar para evaluar varios modelos al mismo tiempo. Por lo general, esto se hace para comparar un nuevo modelo con una línea de base (como el modelo de servicio actual) para determinar cuáles son las diferencias de rendimiento en las métricas (por ejemplo, AUC, etc.) en relación con la línea de base. Cuando se configuran los umbrales , TFMA producirá un registro tfma.ValidationResult indica si el rendimiento coincide con las expectativas.

Reconfiguremos nuestra evaluación de keras para comparar dos modelos: un candidato y una línea de base. También tmfa.MetricThreshold el desempeño del candidato contra la línea de base estableciendo un tmfa.MetricThreshold en la 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.3.1) found. Note that TFMA support for TF 2.0 is currently in beta
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_model_analysis/evaluators/metrics_validator.py:66: RuntimeWarning: invalid value encountered in true_divide
  ratio = diff / metrics[key.make_baseline_key(baseline_model_name)]

Cuando se ejecutan evaluaciones con uno o más modelos contra una línea de base, TFMA agrega automáticamente métricas de diferencia para todas las métricas calculadas durante la evaluación. Estas métricas llevan el nombre de la métrica correspondiente, pero con _diff añadido al nombre de la métrica.

Echemos un vistazo a las métricas producidas por nuestra carrera:

tfma.view.render_time_series(eval_result_with_validation)
TimeSeriesViewer(config={'isModelCentric': True}, data=[{'metrics': {'': {'': {'calibration_diff': {'doubleVal…

Ahora veamos el resultado de nuestras comprobaciones de validación. Para ver los resultados de la validación usamostfma.load_validator_result . Para nuestro ejemplo, la validación falla porque AUC está por debajo del umbral.

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