 Ver en TensorFlow.org |  Ejecutar en Google Colab |  Ver fuente en GitHub |  Descargar libreta |
Suponga un escenario en el que configura una canalización de ML de producción para clasificar pingüinos. La canalización ingiere sus datos de entrenamiento, entrena y evalúa un modelo y lo lleva a producción.
Sin embargo, cuando luego intenta usar este modelo con un conjunto de datos más grande que contiene diferentes tipos de pingüinos, observa que su modelo no se comporta como se esperaba y comienza a clasificar las especies de manera incorrecta.
En este punto, te interesa saber:
- ¿Cuál es la forma más eficiente de depurar el modelo cuando el único artefacto disponible es el modelo en producción?
- ¿Qué conjunto de datos de entrenamiento se utilizó para entrenar el modelo?
- ¿Qué ejecución de entrenamiento condujo a este modelo erróneo?
- ¿Dónde están los resultados de la evaluación del modelo?
- ¿Por dónde empezar a depurar?
ML metadatos (MLMD) es una biblioteca que aprovecha los metadatos asociados a los modelos ML para ayudarle a responder a estas preguntas y mucho más. Una analogía útil es pensar en estos metadatos como el equivalente a iniciar sesión en el desarrollo de software. MLMD le permite realizar un seguimiento confiable de los artefactos y el linaje asociado con los diversos componentes de su canalización de ML.
En este tutorial, configurará un canal TFX para crear un modelo que clasifique a los pingüinos en tres especies en función de la masa corporal y la longitud y profundidad de sus culmen, y la longitud de sus aletas. Luego usa MLMD para rastrear el linaje de los componentes de la canalización.
Canalizaciones TFX en Colab
Colab es un entorno de desarrollo ligero que difiere significativamente de un entorno de producción. En producción, puede tener varios componentes de canalización como ingesta de datos, transformación, entrenamiento de modelos, historiales de ejecución, etc. en múltiples sistemas distribuidos. Para este tutorial, debe tener en cuenta que existen diferencias significativas en la orquestación y el almacenamiento de metadatos: todo se maneja localmente dentro de Colab. Más información sobre TFX en Colab aquí .
Configuración
Primero, instalamos e importamos los paquetes necesarios, configuramos rutas y descargamos datos.
Actualizar Pip
Para evitar actualizar Pip en un sistema cuando se ejecuta localmente, verifique que se esté ejecutando en Colab. Por supuesto, los sistemas locales se pueden actualizar por separado.
try:
import colab
!pip install --upgrade pip
except:
pass
Instalar e importar TFX
pip install -q -U tfx
Importar paquetes
¿Reiniciaste el tiempo de ejecución?
Si está utilizando Google Colab, la primera vez que ejecuta la celda anterior, debe reiniciar el tiempo de ejecución haciendo clic en el botón "REINICIAR TIEMPO DE EJECUCIÓN" o usando el menú "Tiempo de ejecución > Reiniciar tiempo de ejecución...". Esto se debe a la forma en que Colab carga los paquetes.
import os
import tempfile
import urllib
import pandas as pd
import tensorflow_model_analysis as tfma
from tfx.orchestration.experimental.interactive.interactive_context import InteractiveContext
Compruebe las versiones TFX y MLMD.
from tfx import v1 as tfx
print('TFX version: {}'.format(tfx.__version__))
import ml_metadata as mlmd
print('MLMD version: {}'.format(mlmd.__version__))
TFX version: 1.4.0 MLMD version: 1.4.0
Descargar el conjunto de datos
En este colab, se utiliza el conjunto de datos Palmer Pingüinos que se puede encontrar en Github . Se procesaron el conjunto de datos al dejar fuera ningún registros incompletos, y las gotas island y sex columnas, y convertido etiquetas a int32 . El conjunto de datos contiene 334 registros de la masa corporal y la longitud y profundidad de los culmen de los pingüinos, y la longitud de sus aletas. Usas estos datos para clasificar a los pingüinos en una de tres especies.
DATA_PATH = 'https://raw.githubusercontent.com/tensorflow/tfx/master/tfx/examples/penguin/data/labelled/penguins_processed.csv'
_data_root = tempfile.mkdtemp(prefix='tfx-data')
_data_filepath = os.path.join(_data_root, "penguins_processed.csv")
urllib.request.urlretrieve(DATA_PATH, _data_filepath)
('/tmp/tfx-datal9104odr/penguins_processed.csv',
<http.client.HTTPMessage at 0x7f9c6d8d2290>)
Crear un contexto interactivo
Para ejecutar componentes TFX interactiva en este bloc de notas, crear una InteractiveContext . El InteractiveContext utiliza un directorio temporal con una instancia de base de datos efímeros MLMD. Tenga en cuenta que las llamadas a InteractiveContext hay-ops fuera del entorno Colab.
En general, es una buena práctica para carreras de grupo de ductos similares bajo un Context .
interactive_context = InteractiveContext()
WARNING:absl:InteractiveContext pipeline_root argument not provided: using temporary directory /tmp/tfx-interactive-2021-12-05T11_15_56.285625-5hcexlo8 as root for pipeline outputs. WARNING:absl:InteractiveContext metadata_connection_config not provided: using SQLite ML Metadata database at /tmp/tfx-interactive-2021-12-05T11_15_56.285625-5hcexlo8/metadata.sqlite.
Construya la tubería TFX
Una canalización de TFX consta de varios componentes que realizan diferentes aspectos del flujo de trabajo de ML. En este bloc de notas, crear y ejecutar los ExampleGen , StatisticsGen , SchemaGen y Trainer componentes y utiliza el Evaluator y el Pusher componente para evaluar y empuje el modelo entrenado.
Consulte el tutorial de componentes para obtener más información sobre los componentes de canalización TFX.
Cree una instancia y ejecute el componente ExampleGen
example_gen = tfx.components.CsvExampleGen(input_base=_data_root)
interactive_context.run(example_gen)
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.
Cree una instancia y ejecute el componente StatisticsGen
statistics_gen = tfx.components.StatisticsGen(
examples=example_gen.outputs['examples'])
interactive_context.run(statistics_gen)
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
Cree una instancia y ejecute el componente SchemaGen
infer_schema = tfx.components.SchemaGen(
statistics=statistics_gen.outputs['statistics'], infer_feature_shape=True)
interactive_context.run(infer_schema)
WARNING: Logging before InitGoogleLogging() is written to STDERR I1205 11:16:00.941947 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type
Cree una instancia y ejecute el componente de entrenador
# Define the module file for the Trainer component
trainer_module_file = 'penguin_trainer.py'
%%writefile {trainer_module_file}
# Define the training algorithm for the Trainer module file
import os
from typing import List, Text
import tensorflow as tf
from tensorflow import keras
from tfx import v1 as tfx
from tfx_bsl.public import tfxio
from tensorflow_metadata.proto.v0 import schema_pb2
# Features used for classification - culmen length and depth, flipper length,
# body mass, and species.
_LABEL_KEY = 'species'
_FEATURE_KEYS = [
'culmen_length_mm', 'culmen_depth_mm', 'flipper_length_mm', 'body_mass_g'
]
def _input_fn(file_pattern: List[Text],
data_accessor: tfx.components.DataAccessor,
schema: schema_pb2.Schema, batch_size: int) -> tf.data.Dataset:
return data_accessor.tf_dataset_factory(
file_pattern,
tfxio.TensorFlowDatasetOptions(
batch_size=batch_size, label_key=_LABEL_KEY), schema).repeat()
def _build_keras_model():
inputs = [keras.layers.Input(shape=(1,), name=f) for f in _FEATURE_KEYS]
d = keras.layers.concatenate(inputs)
d = keras.layers.Dense(8, activation='relu')(d)
d = keras.layers.Dense(8, activation='relu')(d)
outputs = keras.layers.Dense(3)(d)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
optimizer=keras.optimizers.Adam(1e-2),
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[keras.metrics.SparseCategoricalAccuracy()])
return model
def run_fn(fn_args: tfx.components.FnArgs):
schema = schema_pb2.Schema()
tfx.utils.parse_pbtxt_file(fn_args.schema_path, schema)
train_dataset = _input_fn(
fn_args.train_files, fn_args.data_accessor, schema, batch_size=10)
eval_dataset = _input_fn(
fn_args.eval_files, fn_args.data_accessor, schema, batch_size=10)
model = _build_keras_model()
model.fit(
train_dataset,
epochs=int(fn_args.train_steps / 20),
steps_per_epoch=20,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps)
model.save(fn_args.serving_model_dir, save_format='tf')
Writing penguin_trainer.py
Ejecutar el Trainer componente.
trainer = tfx.components.Trainer(
module_file=os.path.abspath(trainer_module_file),
examples=example_gen.outputs['examples'],
schema=infer_schema.outputs['schema'],
train_args=tfx.proto.TrainArgs(num_steps=100),
eval_args=tfx.proto.EvalArgs(num_steps=50))
interactive_context.run(trainer)
running bdist_wheel running build running build_py creating build creating build/lib copying penguin_trainer.py -> build/lib installing to /tmp/tmpum1crtxy running install running install_lib copying build/lib/penguin_trainer.py -> /tmp/tmpum1crtxy running install_egg_info running egg_info creating tfx_user_code_Trainer.egg-info writing tfx_user_code_Trainer.egg-info/PKG-INFO writing dependency_links to tfx_user_code_Trainer.egg-info/dependency_links.txt writing top-level names to tfx_user_code_Trainer.egg-info/top_level.txt writing manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt' reading manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt' writing manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt' Copying tfx_user_code_Trainer.egg-info to /tmp/tmpum1crtxy/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3.7.egg-info running install_scripts creating /tmp/tmpum1crtxy/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/WHEEL creating '/tmp/tmpo87nn6ey/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3-none-any.whl' and adding '/tmp/tmpum1crtxy' to it adding 'penguin_trainer.py' adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/METADATA' adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/WHEEL' adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/top_level.txt' adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/RECORD' removing /tmp/tmpum1crtxy /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/setuptools/command/install.py:37: SetuptoolsDeprecationWarning: setup.py install is deprecated. Use build and pip and other standards-based tools. setuptools.SetuptoolsDeprecationWarning, listing git files failed - pretending there aren't any I1205 11:16:01.389324 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type I1205 11:16:01.392832 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type Processing /tmp/tfx-interactive-2021-12-05T11_15_56.285625-5hcexlo8/_wheels/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3-none-any.whl Installing collected packages: tfx-user-code-Trainer Successfully installed tfx-user-code-Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4 Epoch 1/5 20/20 [==============================] - 1s 11ms/step - loss: 0.9891 - sparse_categorical_accuracy: 0.4300 - val_loss: 0.9594 - val_sparse_categorical_accuracy: 0.4800 Epoch 2/5 20/20 [==============================] - 0s 6ms/step - loss: 0.8369 - sparse_categorical_accuracy: 0.6350 - val_loss: 0.7484 - val_sparse_categorical_accuracy: 0.8200 Epoch 3/5 20/20 [==============================] - 0s 6ms/step - loss: 0.5289 - sparse_categorical_accuracy: 0.8350 - val_loss: 0.5068 - val_sparse_categorical_accuracy: 0.7800 Epoch 4/5 20/20 [==============================] - 0s 6ms/step - loss: 0.4481 - sparse_categorical_accuracy: 0.7800 - val_loss: 0.4125 - val_sparse_categorical_accuracy: 0.8600 Epoch 5/5 20/20 [==============================] - 0s 6ms/step - loss: 0.3068 - sparse_categorical_accuracy: 0.8650 - val_loss: 0.3279 - val_sparse_categorical_accuracy: 0.8300 2021-12-05 11:16:06.493168: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them. INFO:tensorflow:Assets written to: /tmp/tfx-interactive-2021-12-05T11_15_56.285625-5hcexlo8/Trainer/model/4/Format-Serving/assets INFO:tensorflow:Assets written to: /tmp/tfx-interactive-2021-12-05T11_15_56.285625-5hcexlo8/Trainer/model/4/Format-Serving/assets
Evaluar y empujar el modelo
Utilizar el Evaluator componente para evaluar y 'bendice' el modelo antes de usar el Pusher componente para impulsar el modelo a un directorio de servir.
_serving_model_dir = os.path.join(tempfile.mkdtemp(),
'serving_model/penguins_classification')
eval_config = tfma.EvalConfig(
model_specs=[
tfma.ModelSpec(label_key='species', signature_name='serving_default')
],
metrics_specs=[
tfma.MetricsSpec(metrics=[
tfma.MetricConfig(
class_name='SparseCategoricalAccuracy',
threshold=tfma.MetricThreshold(
value_threshold=tfma.GenericValueThreshold(
lower_bound={'value': 0.6})))
])
],
slicing_specs=[tfma.SlicingSpec()])
evaluator = tfx.components.Evaluator(
examples=example_gen.outputs['examples'],
model=trainer.outputs['model'],
schema=infer_schema.outputs['schema'],
eval_config=eval_config)
interactive_context.run(evaluator)
I1205 11:16:07.075275 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type I1205 11:16:07.078761 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type 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/writers/metrics_plots_and_validations_writer.py:114: 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:114: 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)`
pusher = tfx.components.Pusher(
model=trainer.outputs['model'],
model_blessing=evaluator.outputs['blessing'],
push_destination=tfx.proto.PushDestination(
filesystem=tfx.proto.PushDestination.Filesystem(
base_directory=_serving_model_dir)))
interactive_context.run(pusher)
I1205 11:16:11.935312 6108 rdbms_metadata_access_object.cc:686] No property is defined for the Type
La ejecución de la canalización de TFX llena la base de datos de MLMD. En la siguiente sección, utilizará la API de MLMD para consultar esta base de datos en busca de información de metadatos.
Consultar la base de datos de MLMD
La base de datos MLMD almacena tres tipos de metadatos:
- Metadatos sobre la tubería y la información de linaje asociada con los componentes de la tubería
- Metadatos sobre artefactos que se generaron durante la ejecución de la canalización
- Metadatos sobre las ejecuciones del pipeline
Una canalización de entorno de producción típica sirve a múltiples modelos a medida que llegan nuevos datos. Cuando encuentre resultados erróneos en los modelos servidos, puede consultar la base de datos de MLMD para aislar los modelos erróneos. Luego puede rastrear el linaje de los componentes de canalización que corresponden a estos modelos para depurar sus modelos.
Configurar el almacén de metadatos (MD) con el InteractiveContext definido previamente para consultar la base de datos MLMD.
connection_config = interactive_context.metadata_connection_config
store = mlmd.MetadataStore(connection_config)
# All TFX artifacts are stored in the base directory
base_dir = connection_config.sqlite.filename_uri.split('metadata.sqlite')[0]
Cree algunas funciones auxiliares para ver los datos del almacén MD.
def display_types(types):
# Helper function to render dataframes for the artifact and execution types
table = {'id': [], 'name': []}
for a_type in types:
table['id'].append(a_type.id)
table['name'].append(a_type.name)
return pd.DataFrame(data=table)
def display_artifacts(store, artifacts):
# Helper function to render dataframes for the input artifacts
table = {'artifact id': [], 'type': [], 'uri': []}
for a in artifacts:
table['artifact id'].append(a.id)
artifact_type = store.get_artifact_types_by_id([a.type_id])[0]
table['type'].append(artifact_type.name)
table['uri'].append(a.uri.replace(base_dir, './'))
return pd.DataFrame(data=table)
def display_properties(store, node):
# Helper function to render dataframes for artifact and execution properties
table = {'property': [], 'value': []}
for k, v in node.properties.items():
table['property'].append(k)
table['value'].append(
v.string_value if v.HasField('string_value') else v.int_value)
for k, v in node.custom_properties.items():
table['property'].append(k)
table['value'].append(
v.string_value if v.HasField('string_value') else v.int_value)
return pd.DataFrame(data=table)
En primer lugar, consulta el almacén de MD para obtener una lista de todos sus almacenados ArtifactTypes .
display_types(store.get_artifact_types())
A continuación, todas las consultas PushedModel artefactos.
pushed_models = store.get_artifacts_by_type("PushedModel")
display_artifacts(store, pushed_models)
Consulte la tienda MD para obtener el último modelo enviado. Este tutorial tiene solo un modelo empujado.
pushed_model = pushed_models[-1]
display_properties(store, pushed_model)
Uno de los primeros pasos para depurar un modelo enviado es observar qué modelo entrenado se envía y ver qué datos de entrenamiento se usan para entrenar ese modelo.
MLMD proporciona API transversales para recorrer el gráfico de procedencia, que puede usar para analizar la procedencia del modelo.
def get_one_hop_parent_artifacts(store, artifacts):
# Get a list of artifacts within a 1-hop of the artifacts of interest
artifact_ids = [artifact.id for artifact in artifacts]
executions_ids = set(
event.execution_id
for event in store.get_events_by_artifact_ids(artifact_ids)
if event.type == mlmd.proto.Event.OUTPUT)
artifacts_ids = set(
event.artifact_id
for event in store.get_events_by_execution_ids(executions_ids)
if event.type == mlmd.proto.Event.INPUT)
return [artifact for artifact in store.get_artifacts_by_id(artifacts_ids)]
Consulta los artefactos principales para el modelo enviado.
parent_artifacts = get_one_hop_parent_artifacts(store, [pushed_model])
display_artifacts(store, parent_artifacts)
Consulta las propiedades del modelo.
exported_model = parent_artifacts[0]
display_properties(store, exported_model)
Consulta los artefactos ascendentes para el modelo.
model_parents = get_one_hop_parent_artifacts(store, [exported_model])
display_artifacts(store, model_parents)
Obtenga los datos de entrenamiento con los que se entrenó el modelo.
used_data = model_parents[0]
display_properties(store, used_data)
Ahora que tiene los datos de entrenamiento con los que se entrenó el modelo, vuelva a consultar la base de datos para encontrar el paso de entrenamiento (ejecución). Consulte el almacén de MD para obtener una lista de los tipos de ejecución registrados.
display_types(store.get_execution_types())
El paso de la formación es la ExecutionType llamado tfx.components.trainer.component.Trainer . Atraviese la tienda MD para ejecutar el entrenador que corresponde al modelo empujado.
def find_producer_execution(store, artifact):
executions_ids = set(
event.execution_id
for event in store.get_events_by_artifact_ids([artifact.id])
if event.type == mlmd.proto.Event.OUTPUT)
return store.get_executions_by_id(executions_ids)[0]
trainer = find_producer_execution(store, exported_model)
display_properties(store, trainer)
Resumen
En este tutorial, aprendió cómo puede aprovechar MLMD para rastrear el linaje de los componentes de su canalización TFX y resolver problemas.
Para obtener más información sobre cómo usar MLMD, consulte estos recursos adicionales: