Join us at DevFest for Ukraine June 14-15 Online Register now

Introducción al análisis de modelos de TensorFlow

Visión de conjunto

TensorFlow Model Analysis (TFMA) es una biblioteca para realizar la evaluación de modelos.

  • Para : ingenieros de aprendizaje automático o científicos de datos
  • quién : desea analizar y comprender sus modelos de TensorFlow
  • es : una biblioteca independiente o un componente de una canalización TFX
  • eso : evalúa modelos en grandes cantidades de datos de manera distribuida en las mismas métricas definidas en el entrenamiento. Estas métricas se comparan en porciones de datos y se visualizan en cuadernos de Jupyter o Colab.
  • a diferencia de: algunas herramientas de introspección de modelos como tensorboard que ofrecen introspección de modelos

TFMA realiza sus cálculos de manera distribuida sobre grandes cantidades de datos utilizando Apache Beam . Las siguientes secciones describen cómo configurar una canalización de evaluación básica de TFMA. Consulte la arquitectura para obtener más detalles sobre la implementación subyacente.

Si solo desea participar y comenzar, consulte nuestro cuaderno de colaboración .

Esta página también se puede ver desde tensorflow.org .

Tipos de modelos admitidos

TFMA está diseñado para admitir modelos basados ​​en tensorflow, pero también se puede ampliar fácilmente para admitir otros marcos. Históricamente, TFMA requería que se creara un EvalSavedModel para usar TFMA, pero la última versión de TFMA admite varios tipos de modelos según las necesidades del usuario. La configuración de un EvalSavedModel solo debería ser necesaria si se usa un modelo basado en tf.estimator y se requieren métricas de tiempo de entrenamiento personalizadas.

Tenga en cuenta que debido a que TFMA ahora se ejecuta en función del modelo de servicio, TFMA ya no evaluará automáticamente las métricas agregadas en el momento del entrenamiento. La excepción a este caso es si se usa un modelo de keras, ya que keras guarda las métricas usadas junto con el modelo guardado. Sin embargo, si este es un requisito difícil, el TFMA más reciente es compatible con versiones anteriores, de modo que aún se puede ejecutar un EvalSavedModel en una canalización de TFMA.

La siguiente tabla resume los modelos admitidos por defecto:

Tipo de modelo Métricas de tiempo de entrenamiento Métricas posteriores al entrenamiento
TF2 (keras) Y* Y
TF2 (genérico) N / A Y
EvalSavedModel (estimador) Y Y
Ninguno (pd.DataFrame, etc.) N / A Y
  • Las métricas de tiempo de entrenamiento se refieren a las métricas definidas en el tiempo de entrenamiento y guardadas con el modelo (ya sea TFMA EvalSavedModel o modelo guardado de Keras). Las métricas posteriores al entrenamiento se refieren a las métricas agregadas a través tfma.MetricConfig .
  • Los modelos genéricos de TF2 son modelos personalizados que exportan firmas que se pueden usar para la inferencia y no se basan en keras ni en el estimador.

Consulte las preguntas frecuentes para obtener más información sobre cómo instalar y configurar estos diferentes tipos de modelos.

Configuración

Antes de ejecutar una evaluación, se requiere una pequeña cantidad de configuración. Primero, se debe definir un objeto tfma.EvalConfig que proporcione especificaciones para el modelo, las métricas y los sectores que se van a evaluar. En segundo lugar, se debe crear un tfma.EvalSharedModel que apunte al modelo (o modelos) real que se usará durante la evaluación. Una vez que se han definido, la evaluación se realiza llamando a tfma.run_model_analysis con un conjunto de datos apropiado. Para obtener más detalles, consulte la guía de configuración .

Si se ejecuta dentro de una canalización de TFX, consulte la guía de TFX para saber cómo configurar TFMA para que se ejecute como un componente de TFX Evaluator .

Ejemplos

Evaluación de modelo único

Lo siguiente usa tfma.run_model_analysis para realizar la evaluación en un modelo de servicio. Para obtener una explicación de los diferentes ajustes necesarios, consulte la guía de configuración .

# 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 la evaluación distribuida, construya una canalización de Apache Beam mediante un corredor distribuido. En la canalización, use tfma.ExtractEvaluateAndWriteResults para evaluar y escribir los resultados. Los resultados se pueden cargar para su visualización mediante tfma.load_eval_result .

Por ejemplo:

# 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)

Modelo de validación

Para realizar la validación del modelo con un candidato y una línea de base, actualice la configuración para incluir una configuración de umbral y pase dos modelos a tfma.run_model_analysis .

Por ejemplo:

# 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)

Visualización

Los resultados de la evaluación de TFMA se pueden visualizar en un cuaderno Jupyter utilizando los componentes de interfaz incluidos en TFMA. Por ejemplo:

Navegador de métricas de corte TFMA .

Más información