Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten

ML-Metadaten

ML Metadaten (MLMD) ist eine Bibliothek , zum Aufzeichnen und Abrufen von Metadaten , die mit ML - Entwicklern und Daten Wissenschaftler Workflows. MLMD ist ein integraler Bestandteil der TensorFlow Extended (TFX) , aber so ausgelegt ist, dass sie unabhängig voneinander verwendet werden können.

Jeder Lauf einer Produktions-ML-Pipeline generiert Metadaten, die Informationen über die verschiedenen Pipeline-Komponenten, ihre Ausführungen (zB Trainingsläufe) und resultierende Artefakte (zB trainierte Modelle) enthalten. Bei unerwartetem Verhalten oder Fehlern der Pipeline können diese Metadaten genutzt werden, um die Herkunft von Pipelinekomponenten zu analysieren und Probleme zu beheben. Stellen Sie sich diese Metadaten als Äquivalent zur Protokollierung in der Softwareentwicklung vor.

MLMD hilft Ihnen, alle miteinander verbundenen Teile Ihrer ML-Pipeline zu verstehen und zu analysieren, anstatt sie isoliert zu analysieren, und kann Ihnen helfen, Fragen zu Ihrer ML-Pipeline zu beantworten, wie zum Beispiel:

  • Auf welchem ​​Datensatz wurde das Modell trainiert?
  • Welche Hyperparameter wurden zum Trainieren des Modells verwendet?
  • Welcher Pipelinelauf hat das Modell erstellt?
  • Welcher Trainingslauf führte zu diesem Modell?
  • Welche Version von TensorFlow hat dieses Modell erstellt?
  • Wann wurde das gescheiterte Modell gepusht?

Metadatenspeicher

MLMD registriert die folgenden Arten von Metadaten in einer Datenbank des Metadatenspeicher genannt.

  1. Metadaten zu den Artefakten, die durch die Komponenten/Schritte Ihrer ML-Pipelines generiert wurden
  2. Metadaten zu den Ausführungen dieser Komponenten/Schritte
  3. Metadaten zu Pipelines und zugehörige Herkunftsinformationen

Der Metadatenspeicher stellt APIs zum Aufzeichnen und Abrufen von Metadaten zum und vom Speicher-Back-End bereit. Das Speicher-Backend ist steckbar und kann erweitert werden. MLMD bietet Referenzimplementierungen für SQLite (das In-Memory und Disk unterstützt) und MySQL out-of-the-box.

Diese Grafik zeigt einen groben Überblick über die verschiedenen Komponenten, die Teil von MLMD sind.

Übersicht über ML-Metadaten

Metadatenspeicher-Back-Ends und Speicherverbindungskonfiguration

Das MetadataStore Objekt empfängt eine Verbindungskonfiguration, entspricht den Speicher verwendet Backend.

  • Gefälschte Datenbank bietet eine In-Memory - DB (mit SQLite) für schnelles Experimentieren und lokal läuft. Die Datenbank wird gelöscht, wenn das Speicherobjekt zerstört wird.
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 liest und schreibt Dateien von der Festplatte.
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 eine Verbindung zu einem MySQL - Server.
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)

Ebenso, wenn eine MySQL - Instanz mit Google CloudSQL (mit Quickstart , connect-Übersicht ), könnte man auch SSL - Option ggf. verwenden.

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)

Datenmodell

Der Metadatenspeicher verwendet das folgende Datenmodell, um Metadaten vom Speicher-Back-End aufzuzeichnen und abzurufen.

  • ArtifactType beschreibt ein Artefakt der Art und seine Eigenschaften , die im Metadatenspeicher gespeichert sind. Sie können diese Typen im Code im laufenden Betrieb im Metadatenspeicher registrieren oder sie aus einem serialisierten Format in den Speicher laden. Sobald Sie einen Typ registriert haben, ist seine Definition während der gesamten Lebensdauer des Shops verfügbar.
  • Ein Artifact wird eine bestimmte Instanz eines ArtifactType und dessen Eigenschaften, die für den Metadatenspeicher geschrieben werden.
  • Ein ExecutionType beschreibt eine Art der Komponente oder der Schritt in einem Workflow, und seine Laufzeit - Parameter.
  • Eine Execution ist eine Aufzeichnung einer Komponente Lauf oder ein Schritt in einem ML Arbeitsablauf und die Laufzeitparameter. Eine Ausführung kann als eine Instanz eines gedacht werden ExecutionType . Ausführungen werden aufgezeichnet, wenn Sie eine ML-Pipeline oder einen ML-Schritt ausführen.
  • Ein Event ist eine Aufzeichnung der Beziehung zwischen Artefakten und Hinrichtungen. Wenn eine Ausführung stattfindet, zeichnen Ereignisse jedes Artefakt auf, das von der Ausführung verwendet wurde, und jedes Artefakt, das erzeugt wurde. Diese Datensätze ermöglichen die Nachverfolgung der Herkunft während eines gesamten Workflows. Durch die Betrachtung aller Ereignisse weiß MLMD, welche Hinrichtungen stattgefunden haben und welche Artefakte dabei entstanden sind. MLMD kann dann von jedem Artefakt auf alle seine Upstream-Eingänge zurückgehen.
  • Ein ContextType beschreibt eine Art konzeptionelle Gruppe von Artefakten und Hinrichtungen in einem Workflow und seine strukturellen Eigenschaften. Zum Beispiel: Projekte, Pipelineläufe, Experimente, Eigentümer usw.
  • Ein Context ist eine Instanz eines ContextType . Es erfasst die geteilten Informationen innerhalb der Gruppe. Zum Beispiel: Projektnamen, Änderungs id begehen, experimentieren Anmerkungen etc. Es hat einen benutzerdefinierten eindeutigen Namen innerhalb seiner ContextType .
  • Eine Attribution ist eine Aufzeichnung der Beziehung zwischen Artefakten und Kontexte.
  • Ein Association ist eine Aufzeichnung der Beziehung zwischen Hinrichtungen und Kontexten.

MLMD-Funktionalität

Das Verfolgen der Eingaben und Ausgaben aller Komponenten/Schritte in einem ML-Workflow und ihrer Herkunft ermöglicht es ML-Plattformen, mehrere wichtige Funktionen zu aktivieren. Die folgende Liste bietet einen nicht erschöpfenden Überblick über einige der wichtigsten Vorteile.

  • Listen Sie alle Artefakte eines bestimmten Typs auf. Beispiel: alle trainierten Modelle.
  • Laden Sie zwei Artefakte desselben Typs zum Vergleich. Beispiel: Vergleichen Sie die Ergebnisse von zwei Experimenten.
  • Zeigen Sie einen DAG aller zugehörigen Ausführungen und ihrer Eingabe- und Ausgabeartefakte eines Kontexts an. Beispiel: Visualisieren Sie den Workflow eines Experiments für Debugging und Discovery.
  • Gehen Sie alle Ereignisse durch, um zu sehen, wie ein Artefakt erstellt wurde. Beispiele: Sehen Sie, welche Daten in ein Modell eingeflossen sind; Datenaufbewahrungspläne durchsetzen.
  • Identifizieren Sie alle Artefakte, die mit einem bestimmten Artefakt erstellt wurden. Beispiele: alle Modelle anzeigen, die aus einem bestimmten Datensatz trainiert wurden; Markieren von Modellen basierend auf schlechten Daten.
  • Stellen Sie fest, ob bereits eine Ausführung mit denselben Eingaben ausgeführt wurde. Beispiel: Ermitteln, ob eine Komponente/ein Schritt die gleiche Arbeit bereits erledigt hat und die vorherige Ausgabe nur wiederverwendet werden kann.
  • Aufzeichnen und Abfragen des Kontexts von Workflowausführungen. Beispiele: Verfolgen Sie den Eigentümer und die Änderungsliste, die für einen Workflow-Lauf verwendet werden; gruppieren Sie die Abstammung nach Experimenten; Artefakte nach Projekten verwalten.

Siehe die MLMD Tutorial für ein Beispiel , das zeigt , wie Sie die MLMD API verwenden und den Metadatenspeicher Herkunftsinformationen abzurufen.

Integrieren Sie ML-Metadaten in Ihre ML-Workflows

Wenn Sie ein Plattformentwickler sind, der MLMD in Ihr System integrieren möchte, verwenden Sie den folgenden Beispielworkflow, um die MLMD-APIs auf niedriger Ebene zu verwenden, um die Ausführung einer Trainingsaufgabe zu verfolgen. Sie können auch Python-APIs höherer Ebene in Notebook-Umgebungen verwenden, um Experimentmetadaten aufzuzeichnen.

Beispielablauf für ML-Metadaten

1) Artefakttypen registrieren

# 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) Ausführungsarten für alle Schritte im ML-Workflow registrieren

# 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) Erstellen Sie ein Artefakt von 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) Erstellen Sie eine Ausführung des Trainerlaufs

# 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) Definieren Sie das Eingabeereignis und lesen Sie die Daten

# 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) Deklarieren Sie das Ausgabeartefakt

# 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) Zeichnen Sie das Ausgabeereignis auf

# 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) Markieren Sie die Ausführung als abgeschlossen

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

9) Gruppieren von Artefakten und Ausführungen in einem Kontext mithilfe von Attributions- und Assertionsartefakten

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

Verwenden von MLMD mit einem Remote-gRPC-Server

Sie können MLMD mit Remote-gRPC-Servern wie unten gezeigt verwenden:

  • Starten Sie einen Server
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

Standardmäßig verwendet der Server pro Anfrage eine gefälschte In-Memory-DB und behält die Metadaten nicht über Aufrufe hinweg bei. Es kann auch mit einem MLMD konfiguriert werden MetadataStoreServerConfig verwenden SQLite - Dateien oder MySQL - Instanzen. Die Konfiguration kann in einem Text protobuf Datei gespeichert werden und auf den binären weitergegeben mit --metadata_store_server_config_file=path_to_the_config_file .

Ein Beispiel MetadataStoreServerConfig Datei in Text protobuf Format:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • Erstellen Sie den Client-Stub und verwenden Sie ihn in 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)
  • Verwenden Sie MLMD mit RPC-Aufrufen
# 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)

Ressourcen

Die MLMD-Bibliothek verfügt über eine High-Level-API, die Sie problemlos mit Ihren ML-Pipelines verwenden können. Siehe die MLMD API - Dokumentation für weitere Details.

Sie können auch die MLMD Tutorial zu lernen , wie man MLMD verwenden , um die Linie Ihrer Pipeline - Komponenten zu verfolgen.

MLMD bietet Dienstprogramme zur Abwicklung von Schema- und Datenmigrationen über mehrere Releases hinweg. Siehe das MLMD Handbuch für weitere Details.