Rejoignez la communauté SIG TFX-Addons et contribuez à rendre TFX encore meilleur ! Rejoignez SIG TFX-Addons

Métadonnées ML

ML métadonnées (MLMD) est une bibliothèque pour l' enregistrement et la récupération de métadonnées associées à des flux de travail de développeur ML et scientifique des données. MLMD fait partie intégrante de tensorflow étendu (TFX) , mais est conçu de sorte qu'il peut être utilisé indépendamment.

Chaque exécution d'un pipeline ML de production génère des métadonnées contenant des informations sur les différents composants du pipeline, leurs exécutions (par exemple, les exécutions d'entraînement) et les artefacts résultants (par exemple, les modèles entraînés). En cas de comportement inattendu ou d'erreurs du pipeline, ces métadonnées peuvent être utilisées pour analyser la lignée des composants du pipeline et les problèmes de débogage. Considérez ces métadonnées comme l'équivalent de la connexion au développement logiciel.

MLMD vous aide à comprendre et à analyser toutes les parties interconnectées de votre pipeline de ML au lieu de les analyser isolément et peut vous aider à répondre à des questions sur votre pipeline de ML telles que :

  • Sur quel jeu de données le modèle s'est-il entraîné ?
  • Quels ont été les hyperparamètres utilisés pour entraîner le modèle ?
  • Quelle exécution de pipeline a créé le modèle ?
  • Quel parcours d'entraînement a conduit à ce modèle ?
  • Quelle version de TensorFlow a créé ce modèle ?
  • Quand le modèle défaillant a-t-il été poussé ?

Magasin de métadonnées

MLMD enregistre les types suivants de métadonnées dans une base de données appelée les métadonnées Store.

  1. Métadonnées sur les artefacts générés via les composants/étapes de vos pipelines de ML
  2. Métadonnées sur les exécutions de ces composants/étapes
  3. Métadonnées sur les pipelines et les informations de lignée associées

Le magasin de métadonnées fournit des API pour enregistrer et récupérer des métadonnées vers et depuis le backend de stockage. Le backend de stockage est enfichable et peut être étendu. MLMD fournit des implémentations de référence pour SQLite (qui prend en charge la mémoire et le disque) et MySQL prêtes à l'emploi.

Ce graphique montre une vue d'ensemble de haut niveau des divers composants qui font partie de MLMD.

Présentation des métadonnées de ML

Backends de stockage de métadonnées et configuration de connexion de magasin

Le MetadataStore objet reçoit une configuration de connexion qui correspond à l'arrière - plan de stockage utilisés.

  • Base de données de faux fournit une mémoire de la DB ( en utilisant SQLite) pour l' expérimentation rapide et pistes locales. La base de données est supprimée lorsque l'objet magasin est détruit.
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 lit et écrit des fichiers à partir du disque.
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 connecte à un serveur 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)

De même, lorsque vous utilisez une instance de MySQL avec Google CloudSQL ( QuickStart , connexion-overview ), on pourrait aussi utiliser l' option SSL le cas échéant.

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)

Modèle de données

Le magasin de métadonnées utilise le modèle de données suivant pour enregistrer et récupérer les métadonnées du backend de stockage.

  • Type de ArtifactType décrit le type d'un artefact et ses propriétés qui sont stockées dans le stockage des métadonnées. Vous pouvez enregistrer ces types à la volée avec le magasin de métadonnées sous forme de code, ou vous pouvez les charger dans le magasin à partir d'un format sérialisé. Une fois que vous avez enregistré un type, sa définition est disponible pendant toute la durée de vie de la boutique.
  • Un Artifact décrit une instance spécifique d'un type de ArtifactType , et ses propriétés qui sont écrites dans le magasin des métadonnées.
  • Un ExecutionType décrit un type de composant ou de l' étape dans un flux de production, et de ses paramètres d'exécution.
  • Une Execution est un enregistrement d'une course de composant ou une étape dans un flux de production ML et les paramètres d'exécution. Une exécution peut être considérée comme une instance d'un ExecutionType . Les exécutions sont enregistrées lorsque vous exécutez un pipeline ou une étape de ML.
  • Un Event est un enregistrement de la relation entre les objets et les exécutions. Lorsqu'une exécution se produit, les événements enregistrent chaque artefact qui a été utilisé par l'exécution et chaque artefact qui a été produit. Ces enregistrements permettent le suivi de la lignée tout au long d'un flux de travail. En examinant tous les événements, MLMD sait quelles exécutions se sont produites et quels artefacts ont été créés en conséquence. MLMD peut ensuite revenir de n'importe quel artefact à toutes ses entrées en amont.
  • A ContextType décrit un type de groupe conceptuel d'artefacts et les exécutions dans un flux de production, et de ses propriétés structurelles. Par exemple : projets, exécutions de pipelines, expériences, propriétaires, etc.
  • Un Context est une instance d'un ContextType . Il capture les informations partagées au sein du groupe. Par exemple: le nom du projet, ChangeList id engager, expérimenter des annotations , etc. Il a un nom unique défini par l' utilisateur dans son ContextType .
  • Une Attribution est un enregistrement de la relation entre les artefacts et les contextes.
  • Une Association est un enregistrement de la relation entre les exécutions et les contextes.

Fonctionnalité MLMD

Le suivi des entrées et des sorties de tous les composants/étapes d'un flux de travail ML et de leur lignée permet aux plates-formes ML d'activer plusieurs fonctionnalités importantes. La liste suivante donne un aperçu non exhaustif de certains des principaux avantages.

  • Répertoriez tous les artefacts d'un type spécifique. Exemple : tous les modèles qui ont été formés.
  • Chargez deux artefacts du même type pour comparaison. Exemple : comparer les résultats de deux expériences.
  • Afficher un DAG de toutes les exécutions associées et de leurs artefacts d'entrée et de sortie d'un contexte. Exemple : visualisez le flux de travail d'une expérience pour le débogage et la découverte.
  • Revenez en arrière dans tous les événements pour voir comment un artefact a été créé. Exemples : voir quelles données sont entrées dans un modèle ; appliquer des plans de conservation des données.
  • Identifiez tous les artefacts créés à l'aide d'un artefact donné. Exemples : voir tous les modèles entraînés à partir d'un ensemble de données spécifique ; marquer les modèles sur la base de données erronées.
  • Déterminez si une exécution a déjà été exécutée sur les mêmes entrées. Exemple : déterminez si un composant/une étape a déjà terminé le même travail et si la sortie précédente peut simplement être réutilisée.
  • Enregistrez et interrogez le contexte des exécutions de workflow. Exemples : suivre le propriétaire et la liste de modifications utilisés pour une exécution de workflow ; regrouper la lignée par expériences; gérer les artefacts par projets.

Voir le tutoriel MLMD pour un exemple qui vous montre comment utiliser l'API MLMD et le magasin de métadonnées pour récupérer des informations de la lignée.

Intégrez les métadonnées ML dans vos workflows ML

Si vous êtes un développeur de plate-forme intéressé par l'intégration de MLMD dans votre système, utilisez l'exemple de workflow ci-dessous pour utiliser les API MLMD de bas niveau afin de suivre l'exécution d'une tâche de formation. Vous pouvez également utiliser des API Python de niveau supérieur dans des environnements de bloc-notes pour enregistrer des métadonnées d'expérience.

Exemple de flux de métadonnées ML

1) Enregistrer les types d'artefacts

# 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) Enregistrer les types d'exécution pour toutes les étapes du workflow 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) Créer un artefact 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)

4) Créer une exécution de la course Trainer

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

5) Définir l'événement d'entrée et lire les données

# 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) Déclarer l'artefact de sortie

# 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) Enregistrer l'événement de sortie

# 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) Marquer l'exécution comme terminée

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

9) Regrouper les artefacts et les exécutions dans un contexte à l'aide d'artefacts d'attributions et d'assertions

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

Utiliser MLMD avec un serveur gRPC distant

Vous pouvez utiliser MLMD avec des serveurs gRPC distants comme indiqué ci-dessous :

  • Démarrer un serveur
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

Par défaut, le serveur utilise une fausse base de données en mémoire par requête et ne conserve pas les métadonnées entre les appels. Il peut également être configuré avec un MLMD MetadataStoreServerConfig d'utiliser des fichiers SQLite ou MySQL instances. La configuration peut être stocké dans un fichier texte protobuf et transmis au binaire avec --metadata_store_server_config_file=path_to_the_config_file .

Un exemple MetadataStoreServerConfig fichier texte format protobuf:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • Créez le stub client et utilisez-le 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)
  • Utiliser MLMD avec les appels 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)

Ressources

La bibliothèque MLMD dispose d'une API de haut niveau que vous pouvez facilement utiliser avec vos pipelines ML. Voir la documentation de l' API MLMD pour plus de détails.

Consultez également le tutoriel MLMD pour apprendre à utiliser MLMD pour tracer la lignée de vos composants de pipeline.

MLMD fournit des utilitaires pour gérer les migrations de schémas et de données entre les versions. Voir le MLMD Guide pour plus de détails.