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

Metadatos de AA

ML Metadata (MLMD) es una biblioteca para registrar y recuperar metadatos asociados con los flujos de trabajo de desarrolladores de ML y científicos de datos. MLMD es una parte integral de TensorFlow Extended (TFX) , pero está diseñado para que se pueda usar de forma independiente. Como parte de la plataforma TFX más amplia, la mayoría de los usuarios solo interactúan con MLMD cuando examinan los resultados de los componentes de la canalización, por ejemplo, en portátiles o en TensorBoard.

El siguiente gráfico muestra los componentes que forman parte de MLMD. El backend de almacenamiento se puede conectar y ampliar. MLMD proporciona implementaciones de referencia para SQLite (que admite memoria y disco) y MySQL listas para usar. MetadataStore proporciona API para registrar y recuperar metadatos hacia y desde el backend de almacenamiento. MLMD puede registrarse:

  • metadatos sobre los artefactos generados a través de los componentes / pasos de las canalizaciones
  • metadatos sobre las ejecuciones de estos componentes / pasos
  • metadatos sobre la canalización e información de linaje asociado

Los conceptos se explican con más detalle a continuación.

Descripción general de los metadatos de AA

Funcionalidad habilitada por MLMD

El seguimiento de las entradas y salidas de todos los componentes / pasos en un flujo de trabajo de ML y su linaje permite que las plataformas de ML habiliten varias características importantes. La siguiente lista proporciona una descripción general no exhaustiva de algunos de los principales beneficios.

  • Enumere todos los artefactos de un tipo específico. Ejemplo: todos los modelos que han sido entrenados.
  • Cargue dos artefactos del mismo tipo para compararlos. Ejemplo: compare los resultados de dos experimentos.
  • Muestre un DAG de todas las ejecuciones relacionadas y sus artefactos de entrada y salida de un contexto. Ejemplo: visualice el flujo de trabajo de un experimento para depurar y descubrir.
  • Repita todos los eventos para ver cómo se creó un artefacto. Ejemplos: vea qué datos se incluyeron en un modelo; hacer cumplir los planes de retención de datos.
  • Identifique todos los artefactos que se crearon con un artefacto determinado. Ejemplos: vea todos los modelos entrenados a partir de un conjunto de datos específico; marcar modelos basados ​​en datos incorrectos.
  • Determine si se ha ejecutado una ejecución en las mismas entradas antes. Ejemplo: determine si un componente / paso ya ha completado el mismo trabajo y la salida anterior se puede reutilizar.
  • Registre y consulte el contexto de las ejecuciones del flujo de trabajo. Ejemplos: realizar un seguimiento del propietario y la lista de cambios utilizados para la ejecución de un flujo de trabajo; agrupar el linaje por experimentos; administrar artefactos por proyectos.

Backends de almacenamiento de metadatos y configuración de conexión de tienda

Antes de configurar el almacén de datos, deberá configurar las importaciones.

from ml_metadata import metadata_store
from ml_metadata.proto import metadata_store_pb2

El objeto MetadataStore recibe una configuración de conexión que corresponde al backend de almacenamiento utilizado.

  • Fake Database proporciona una base de datos en memoria (usando SQLite) para experimentación rápida y ejecuciones locales. La base de datos se elimina cuando se destruye el objeto de la tienda.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.fake_database.SetInParent() # Sets an empty fake database proto.
store = metadata_store.MetadataStore(connection_config)
  • SQLite lee y escribe archivos desde el disco.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.sqlite.filename_uri = '...'
connection_config.sqlite.connection_mode = 3 # READWRITE_OPENCREATE
store = metadata_store.MetadataStore(connection_config)
  • MySQL se conecta a un servidor MySQL.
connection_config = metadata_store_pb2.ConnectionConfig()
connection_config.mysql.host = '...'
connection_config.mysql.port = '...'
connection_config.mysql.database = '...'
connection_config.mysql.user = '...'
connection_config.mysql.password = '...'
store = metadata_store.MetadataStore(connection_config)

Almacén de metadatos

Conceptos

El almacén de metadatos utiliza el siguiente modelo de datos para registrar y recuperar metadatos del backend de almacenamiento.

  • ArtifactType describe el tipo de un artefacto y sus propiedades que se almacenan en Metadata Store. Estos tipos se pueden registrar sobre la marcha con Metadata Store en código, o se pueden cargar en la tienda desde un formato serializado. Una vez que se registra un tipo, su definición está disponible durante toda la vida útil de la tienda.
  • Artifact describe instancias específicas de ArtifactType y sus propiedades que se escriben en Metadata Store.
  • ExecutionType describe un tipo de componente o paso en un flujo de trabajo y sus parámetros de tiempo de ejecución.
  • Execution es un registro de la Execution de un componente o un paso en un flujo de trabajo de ML y los parámetros de tiempo de ejecución. Una ejecución se puede considerar como una instancia de un tipo de ExecutionType . Cada vez que un desarrollador ejecuta una canalización o paso de ML, se registran las ejecuciones para cada paso.
  • Event es un registro de la relación entre un Artifact y Executions . Cuando ocurre una Execution , los Event registran cada artefacto que fue utilizado por la Execution y cada Artifact que se produjo. Estos registros permiten el seguimiento de la procedencia a lo largo de un flujo de trabajo. Al observar todos los eventos, MLMD sabe qué ejecuciones sucedieron, qué artefactos se crearon como resultado, y puede recurrir desde cualquier Artifact a todas sus entradas ascendentes.
  • ContextType describe un tipo de grupo conceptual de Artifacts y Executions en un flujo de trabajo y sus propiedades estructurales. Por ejemplo: proyectos, ejecuciones de tuberías, experimentos, propietarios.
  • Context es una instancia de ContextType . Captura la información compartida dentro del grupo. Por ejemplo: nombre del proyecto, ID de confirmación de lista de cambios, anotaciones de experimentos. Tiene un nombre único definido por el usuario dentro de su ContextType .
  • Attribution es un registro de la relación entre artefactos y contextos.
  • Association es un registro de la relación entre ejecuciones y contextos.

Seguimiento de los flujos de trabajo de AA con metadatos de AA

A continuación, se muestra un gráfico que muestra cómo se pueden usar las API de metadatos de aprendizaje automático de bajo nivel para realizar un seguimiento de la ejecución de una tarea de capacitación, seguido de ejemplos de código. Tenga en cuenta que el código de esta sección muestra las API de metadatos de ML que los desarrolladores de la plataforma de ML deben utilizar para integrar su plataforma con los metadatos de ML, y no directamente por los desarrolladores. Además, proporcionaremos API de Python de nivel superior que los científicos de datos pueden utilizar en entornos de portátiles para registrar los metadatos de sus experimentos.

Flujo de ejemplo de metadatos de AA

1) Antes de que se puedan grabar ejecuciones, ArtifactTypes deben registrarse.

# Create ArtifactTypes, e.g., Data and Model
data_type = metadata_store_pb2.ArtifactType()
data_type.name = "DataSet"
data_type.properties["day"] = metadata_store_pb2.INT
data_type.properties["split"] = metadata_store_pb2.STRING
data_type_id = store.put_artifact_type(data_type)

model_type = metadata_store_pb2.ArtifactType()
model_type.name = "SavedModel"
model_type.properties["version"] = metadata_store_pb2.INT
model_type.properties["name"] = metadata_store_pb2.STRING
model_type_id = store.put_artifact_type(model_type)

2) Antes de que se puedan registrar las ejecuciones, se deben registrar ExecutionTypes para todos los pasos de nuestro flujo de trabajo ML.

# Create ExecutionType, e.g., Trainer
trainer_type = metadata_store_pb2.ExecutionType()
trainer_type.name = "Trainer"
trainer_type.properties["state"] = metadata_store_pb2.STRING
trainer_type_id = store.put_execution_type(trainer_type)

3) Una vez que los tipos están registrados, creamos un artefacto de conjunto de datos.

# Declare input artifact of type DataSet
data_artifact = metadata_store_pb2.Artifact()
data_artifact.uri = 'path/to/data'
data_artifact.properties["day"].int_value = 1
data_artifact.properties["split"].string_value = 'train'
data_artifact.type_id = data_type_id
data_artifact_id = store.put_artifacts([data_artifact])[0]

4) Con el artefacto DataSet creado, podemos crear la ejecución para una ejecución de entrenador

# Register the Execution of a Trainer run
trainer_run = metadata_store_pb2.Execution()
trainer_run.type_id = trainer_type_id
trainer_run.properties["state"].string_value = "RUNNING"
run_id = store.put_executions([trainer_run])[0]

5) Declare el evento de entrada y lea los datos.

# Declare the input event
input_event = metadata_store_pb2.Event()
input_event.artifact_id = data_artifact_id
input_event.execution_id = run_id
input_event.type = metadata_store_pb2.Event.DECLARED_INPUT

# Submit input event to the Metadata Store
store.put_events([input_event])

6) Ahora que se lee la entrada, declaramos el artefacto de salida.

# Declare output artifact of type SavedModel
model_artifact = metadata_store_pb2.Artifact()
model_artifact.uri = 'path/to/model/file'
model_artifact.properties["version"].int_value = 1
model_artifact.properties["name"].string_value = 'MNIST-v1'
model_artifact.type_id = model_type_id
model_artifact_id = store.put_artifacts([model_artifact])[0]

7) Con el Model Artifact creado, podemos registrar el evento de salida.

# Declare the output event
output_event = metadata_store_pb2.Event()
output_event.artifact_id = model_artifact_id
output_event.execution_id = run_id
output_event.type = metadata_store_pb2.Event.DECLARED_OUTPUT

# Submit output event to the Metadata Store
store.put_events([output_event])

8) Ahora que todo está registrado, la ejecución se puede marcar como completada.

trainer_run.id = run_id
trainer_run.properties["state"].string_value = "COMPLETED"
store.put_executions([trainer_run])

9) Luego, los artefactos y ejecuciones pueden agruparse en un contexto (por ejemplo, un experimento).

# Similarly, create a ContextType, e.g., Experiment with a `note` property
experiment_type = metadata_store_pb2.ContextType()
experiment_type.name = "Experiment"
experiment_type.properties["note"] = metadata_store_pb2.STRING
experiment_type_id = store.put_context_type(experiment_type)

# Group the model and the trainer run to an experiment.
my_experiment = metadata_store_pb2.Context()
my_experiment.type_id = experiment_type_id
# Give the experiment a name
my_experiment.name = "exp1"
my_experiment.properties["note"].string_value = "My first experiment."
experiment_id = store.put_contexts([my_experiment])[0]

attribution = metadata_store_pb2.Attribution()
attribution.artifact_id = model_artifact_id
attribution.context_id = experiment_id

association = metadata_store_pb2.Association()
association.execution_id = run_id
association.context_id = experiment_id

store.put_attributions_and_associations([attribution], [association])

Con servidor grpc remoto

1) Inicie un servidor con

bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

2) Cree el código auxiliar del cliente y utilícelo en Python

from grpc import insecure_channel
from ml_metadata.proto import metadata_store_pb2
from ml_metadata.proto import metadata_store_service_pb2
from ml_metadata.proto import metadata_store_service_pb2_grpc
channel = insecure_channel('localhost:8080')
stub = metadata_store_service_pb2_grpc.MetadataStoreServiceStub(channel)

3) Utilice MLMD con llamadas RPC

# Create ArtifactTypes, e.g., Data and Model
data_type = metadata_store_pb2.ArtifactType()
data_type.name = "DataSet"
data_type.properties["day"] = metadata_store_pb2.INT
data_type.properties["split"] = metadata_store_pb2.STRING
request = metadata_store_service_pb2.PutArtifactTypeRequest()
request.all_fields_match = True
request.artifact_type.CopyFrom(data_type)
stub.PutArtifactType(request)
model_type = metadata_store_pb2.ArtifactType()
model_type.name = "SavedModel"
model_type.properties["version"] = metadata_store_pb2.INT
model_type.properties["name"] = metadata_store_pb2.STRING
request.artifact_type.CopyFrom(model_type)
stub.PutArtifactType(request)