Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Metadatos de AA

ML metadatos (MLMD) es una biblioteca para grabar y recuperar los metadatos asociados con el desarrollador ML y científico de datos de flujos de trabajo. MLMD es una parte integral de TensorFlow extendido (TFX) , pero está diseñado de modo que pueda ser utilizado independientemente.

Cada ejecución de una canalización de ML de producción genera metadatos que contienen información sobre los diversos componentes de la canalización, sus ejecuciones (por ejemplo, ejecuciones de entrenamiento) y los artefactos resultantes (por ejemplo, modelos entrenados). En caso de errores o comportamientos inesperados de la canalización, estos metadatos se pueden aprovechar para analizar el linaje de los componentes de la canalización y depurar problemas. Piense en estos metadatos como el equivalente a iniciar sesión en el desarrollo de software.

MLMD lo ayuda a comprender y analizar todas las partes interconectadas de su canal de ML en lugar de analizarlas de forma aislada y puede ayudarlo a responder preguntas sobre su canal de ML, tales como:

  • ¿En qué conjunto de datos se entrenó el modelo?
  • ¿Cuáles fueron los hiperparámetros utilizados para entrenar el modelo?
  • ¿Qué canalización creó el modelo?
  • ¿Qué entrenamiento llevó a este modelo?
  • ¿Qué versión de TensorFlow creó este modelo?
  • ¿Cuándo se impulsó el modelo fallido?

Almacén de metadatos

MLMD registra los siguientes tipos de metadatos en una base de datos llamada el almacén de metadatos.

  1. Metadatos sobre los artefactos generados a través de los componentes / pasos de sus canalizaciones de AA
  2. Metadatos sobre las ejecuciones de estos componentes / pasos
  3. Metadatos sobre canalizaciones e información de linaje asociado

El almacén de metadatos proporciona API para registrar y recuperar metadatos desde y hacia el backend de almacenamiento. 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.

Este gráfico muestra una descripción general de alto nivel de los diversos componentes que forman parte de MLMD.

Descripción general de los metadatos de AA

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

El MetadataStore objeto recibe una configuración de conexión que backend usado corresponde a la de almacenamiento.

  • Base de datos falso proporciona un DB en memoria (usando SQLite) para la experimentación rápido y carreras locales. La base de datos se elimina cuando se destruye el objeto de la tienda.
import ml_metadata as mlmd
from ml_metadata.metadata_store import metadata_store
from ml_metadata.proto import metadata_store_pb2

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

Del mismo modo, cuando se utiliza una instancia de MySQL con Google CloudSQL ( inicio rápido , Connect-visión general ), se podría también utilizar la opción SSL si procede.

connection_config.mysql.ssl_options.key = '...'
connection_config.mysql.ssl_options.cert = '...'
connection_config.mysql.ssl_options.ca = '...'
connection_config.mysql.ssl_options.capath = '...'
connection_config.mysql.ssl_options.cipher = '...'
connection_config.mysql.ssl_options.verify_server_cert = '...'
store = metadata_store.MetadataStore(connection_config)

Modelo de datos

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 el almacén de metadatos. Puede registrar estos tipos sobre la marcha con la tienda de metadatos en código, o puede cargarlos en la tienda desde un formato serializado. Una vez que registra un tipo, su definición está disponible durante toda la vida útil de la tienda.
  • Un Artifact describe un ejemplo específico de un ArtifactType , y sus propiedades que se escriben en el almacén de metadatos.
  • Un ExecutionType describe un tipo de componente o paso de un flujo de trabajo, y sus parámetros de tiempo de ejecución.
  • Una Execution es un registro de una carrera componente o un paso en un flujo de trabajo ML y los parámetros de tiempo de ejecución. Una ejecución puede ser pensado como una instancia de un ExecutionType . Las ejecuciones se registran cuando ejecuta una canalización o paso de ML.
  • Un Event es un registro de la relación entre artefactos y ejecuciones. Cuando ocurre una ejecución, los eventos registran cada artefacto que fue utilizado por la ejecución y cada artefacto que se produjo. Estos registros permiten el seguimiento del linaje a lo largo de un flujo de trabajo. Al observar todos los eventos, MLMD sabe qué ejecuciones sucedieron y qué artefactos se crearon como resultado. Entonces, MLMD puede regresar desde cualquier artefacto a todas sus entradas de flujo ascendente.
  • A ContextType describe un tipo de grupo conceptual de artefactos y ejecuciones en un flujo de trabajo, y sus propiedades estructurales. Por ejemplo: proyectos, ejecuciones de canalizaciones, experimentos, propietarios, etc.
  • A Context es una instancia de una ContextType . Captura la información compartida dentro del grupo. Por ejemplo: nombre del proyecto, changeList Commit Identificación, experimentar anotaciones etc. Tiene un nombre único definido por el usuario dentro de su ContextType .
  • Un Attribution es un registro de la relación entre los objetos y contextos.
  • Una Association es un registro de la relación entre ejecuciones y contextos.

Funcionalidad 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.
  • Capacidades de filtrado de nodos declarativos en propiedades y nodos de vecindad de 1 salto. Ejemplos: busque artefactos de un tipo y bajo algún contexto de canalización; devuelve artefactos con tipo donde el valor de una propiedad determinada está dentro de un rango; encontrar ejecuciones anteriores en un contexto con las mismas entradas.

Ver el tutorial MLMD para un ejemplo que muestra cómo utilizar la API de MLMD y el almacén de metadatos para recuperar información linaje.

Integre metadatos de aprendizaje automático en sus flujos de trabajo de aprendizaje automático

Si es un desarrollador de plataforma interesado en integrar MLMD en su sistema, use el flujo de trabajo de ejemplo a continuación para usar las API de MLMD de bajo nivel para realizar un seguimiento de la ejecución de una tarea de capacitación. También puede utilizar API de Python de nivel superior en entornos de notebook para registrar metadatos de experimentos.

Flujo de ejemplo de metadatos de AA

1) Registrar tipos de artefactos

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

# Query all registered Artifact types.
artifact_types = store.get_artifact_types()

2) Registre los tipos de ejecución para todos los pasos del flujo de trabajo de ML

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

# Query a registered Execution type with the returned id
[registered_type] = store.get_execution_types_by_id([trainer_type_id])

3) Cree un artefacto de DataSet ArtifactType

# Create an 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])

# Query all registered Artifacts
artifacts = store.get_artifacts()

# Plus, there are many ways to query the same Artifact
[stored_data_artifact] = store.get_artifacts_by_id([data_artifact_id])
artifacts_with_uri = store.get_artifacts_by_uri(data_artifact.uri)
artifacts_with_conditions = store.get_artifacts(
      list_options=mlmd.ListOptions(
          filter_query='uri LIKE "%/data" AND properties.day.int_value > 0'))

4) Cree una ejecución de la carrera del 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])

# Query all registered Execution
executions = store.get_executions_by_id([run_id])
# Similarly, the same execution can be queried with conditions.
executions_with_conditions = store.get_executions(
    list_options = mlmd.ListOptions(
        filter_query='type = "Trainer" AND properties.state.string_value IS NOT NULL'))

5) Definir el evento de entrada y leer los datos.

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

# Record the input event in the metadata store
store.put_events([input_event])

6) Declare el artefacto de salida

# Declare the 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])

7) Grabe 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) Marcar la ejecución como completada

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

9) Agrupar artefactos y ejecuciones bajo un contexto usando atribuciones y artefactos de afirmaciones

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

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

# Query the Artifacts and Executions that are linked to the Context.
experiment_artifacts = store.get_artifacts_by_context(experiment_id)
experiment_executions = store.get_executions_by_context(experiment_id)

# You can also use neighborhood queries to fetch these artifacts and executions
# with conditions.
experiment_artifacts_with_conditions = store.get_artifacts(
    list_options = mlmd.ListOptions(
        filter_query=('contexts_a.type = "Experiment" AND contexts_a.name = "exp1"')))
experiment_executions_with_conditions = store.get_executions(
    list_options = mlmd.ListOptions(
        filter_query=('contexts_a.id = {}'.format(experiment_id))))

Utilice MLMD con un servidor gRPC remoto

Puede utilizar MLMD con servidores gRPC remotos como se muestra a continuación:

  • Iniciar un servidor
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

De forma predeterminada, el servidor utiliza una base de datos en memoria falsa por solicitud y no conserva los metadatos entre las llamadas. También se puede configurar con un MLMD MetadataStoreServerConfig utilizar archivos SQLite o instancias de MySQL. La configuración se puede almacenar en un archivo de texto protobuf y se pasa al binario con --metadata_store_server_config_file=path_to_the_config_file .

Un ejemplo MetadataStoreServerConfig archivo en formato de texto protobuf:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • 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)
  • 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)

Recursos

La biblioteca MLMD tiene una API de alto nivel que puede usar fácilmente con sus canalizaciones de ML. Consulte la documentación de la API MLMD para más detalles.

Salida MLMD declarativa nodos de filtrado para aprender cómo utilizar MLMD nodos declarativas capacidades de filtrado en las propiedades y los nodos de vecindad a 1 salto.

También puedes ver el tutorial MLMD a aprender a utilizar MLMD rastrear el linaje de sus componentes de canalización.

MLMD proporciona utilidades para manejar esquemas y migraciones de datos entre versiones. Ver el MLMD Guía para más detalles.