Treten Sie der SIG TFX-Addons-Community bei und helfen Sie, TFX noch besser zu machen!
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

ML Metadaten

ML Metadata (MLMD) ist eine Bibliothek zum Aufzeichnen und Abrufen von Metadaten, die mit Workflows von ML-Entwicklern und Datenwissenschaftlern verknüpft sind. MLMD ist ein integraler Bestandteil von TensorFlow Extended (TFX) , wurde jedoch so konzipiert, dass es unabhängig verwendet werden kann.

Jeder Lauf einer Produktions-ML-Pipeline generiert Metadaten, die Informationen zu den verschiedenen Pipeline-Komponenten, deren Ausführung (z. B. Trainingsläufe) und daraus resultierenden Artefakten (z. B. trainierten Modellen) enthalten. Im Falle eines unerwarteten Pipeline-Verhaltens oder von Fehlern können diese Metadaten genutzt werden, um die Herkunft der Pipeline-Komponenten und Debug-Probleme zu analysieren. Denken Sie an diese Metadaten als Äquivalent zur Anmeldung bei der Softwareentwicklung.

MLMD hilft Ihnen, alle miteinander verbundenen Teile Ihrer ML-Pipeline zu verstehen und zu analysieren, anstatt sie isoliert zu analysieren, und kann Ihnen bei der Beantwortung von Fragen zu Ihrer ML-Pipeline helfen, z.

  • Auf welchem ​​Datensatz trainierte das Modell?
  • Mit welchen Hyperparametern wurde das Modell trainiert?
  • Welcher Pipeline-Lauf hat das Modell erstellt?
  • Welcher Trainingslauf führte zu diesem Modell?
  • Welche Version von TensorFlow hat dieses Modell erstellt?
  • Wann wurde das ausgefallene Modell geschoben?

Metadatenspeicher

MLMD registriert die folgenden Arten von Metadaten in einer Datenbank namens Metadata Store .

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

Der Metadatenspeicher bietet APIs zum Aufzeichnen und Abrufen von Metadaten zum und vom Speicher-Backend. Das Speicher-Backend ist steckbar und kann erweitert werden. MLMD bietet sofort Referenzimplementierungen für SQLite (das In-Memory und Festplatte unterstützt) und MySQL.

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

ML Metadaten Übersicht

Metadatenspeicher-Backends und Speicherverbindungskonfiguration

Das MetadataStore Objekt erhält eine Verbindungskonfiguration, die dem verwendeten Speicher-Backend entspricht.

  • Die gefälschte Datenbank bietet eine speicherinterne Datenbank (unter Verwendung von SQLite) für schnelles Experimentieren und lokale Läufe. 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 stellt eine Verbindung zu einem MySQL-Server her.
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)

Wenn Sie eine MySQL-Instanz mit Google CloudSQL verwenden ( Schnellstart , Verbindungsübersicht ), können Sie gegebenenfalls auch die SSL-Option 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 aufzuzeichnen und aus dem Speicher-Backend abzurufen.

  • ArtifactType beschreibt den Typ eines Artefakts und seine Eigenschaften, die im Metadatenspeicher gespeichert sind. Sie können diese Typen direkt im Metadatenspeicher im Code 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 Geschäfts verfügbar.
  • Ein Artifact beschreibt eine bestimmte Instanz eines ArtifactType und seine Eigenschaften, die in den Metadatenspeicher geschrieben werden.
  • Ein ExecutionType beschreibt einen Komponententyp oder -schritt in einem Workflow und seine Laufzeitparameter.
  • Eine Execution ist eine Aufzeichnung eines Komponentenlaufs oder eines Schritts in einem ML-Workflow und der Laufzeitparameter. Eine Ausführung kann als Instanz eines 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 Ausführungen. 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 Verfolgung von Abstammungslinien während eines Workflows. Durch die Betrachtung aller Ereignisse weiß MLMD, welche Ausführungen stattgefunden haben und welche Artefakte als Ergebnis erstellt wurden. MLMD kann dann von jedem Artefakt zu allen seinen Upstream-Eingängen zurückkehren.
  • Ein ContextType beschreibt eine Art konzeptionelle Gruppe von Artefakten und Ausführungen in einem Workflow sowie deren strukturelle Eigenschaften. Zum Beispiel: Projekte, Pipeline-Läufe, Experimente, Eigentümer usw.
  • Ein Context ist eine Instanz eines ContextType . Es erfasst die gemeinsam genutzten Informationen innerhalb der Gruppe. Beispiel: Projektname, Änderungslisten-Commit-ID, Versuchsanmerkungen usw. Der ContextType enthält einen benutzerdefinierten eindeutigen Namen.
  • Eine Attribution ist eine Aufzeichnung der Beziehung zwischen Artefakten und Kontexten.
  • Eine Association ist eine Aufzeichnung der Beziehung zwischen Ausführungen und Kontexten.

MLMD-Funktionalität

Durch die Verfolgung der Ein- und Ausgänge aller Komponenten / Schritte in einem ML-Workflow und ihrer Herkunft können ML-Plattformen mehrere wichtige Funktionen 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 Modelle, die trainiert wurden.
  • Laden Sie zum Vergleich zwei Artefakte desselben Typs. Beispiel: Vergleichen Sie die Ergebnisse von zwei Experimenten.
  • Zeigen Sie eine DAG aller zugehörigen Ausführungen und ihrer Eingabe- und Ausgabeartefakte eines Kontexts an. Beispiel: Visualisieren Sie den Workflow eines Experiments zum Debuggen und Erkennen.
  • Gehen Sie alle Ereignisse durch, um zu sehen, wie ein Artefakt erstellt wurde. Beispiele: Sehen Sie, welche Daten in ein Modell eingegeben wurden. Pläne zur Vorratsdatenspeicherung durchsetzen.
  • Identifizieren Sie alle Artefakte, die mit einem bestimmten Artefakt erstellt wurden. Beispiele: Alle Modelle anzeigen, die anhand eines bestimmten Datensatzes trainiert wurden. Markieren Sie Modelle basierend auf schlechten Daten.
  • Stellen Sie fest, ob zuvor eine Ausführung mit denselben Eingaben ausgeführt wurde. Beispiel: Stellen Sie fest, ob eine Komponente / ein Schritt bereits dieselbe Arbeit abgeschlossen hat und die vorherige Ausgabe einfach wiederverwendet werden kann.
  • Aufzeichnen und Abfragen des Kontextes von Workflow-Läufen. Beispiele: Verfolgen Sie den Eigentümer und die Änderungsliste, die für einen Workflow-Lauf verwendet werden. gruppieren Sie die Linie durch Experimente; Verwalten von Artefakten nach Projekten.

Im MLMD-Lernprogramm finden Sie ein Beispiel, das Ihnen zeigt, wie Sie die MLMD-API und den Metadatenspeicher zum Abrufen von Herkunftsinformationen verwenden.

Integrieren Sie ML-Metadaten in Ihre ML-Workflows

Wenn Sie ein Plattformentwickler sind, der an der Integration von MLMD in Ihr System interessiert ist, verwenden Sie den folgenden Beispielworkflow, um mithilfe der MLMD-APIs auf niedriger Ebene die Ausführung einer Schulungsaufgabe zu verfolgen. Sie können auch übergeordnete Python-APIs in Notebook-Umgebungen verwenden, um Experiment-Metadaten aufzuzeichnen.

Beispielfluss für ML-Metadaten

1) Registrieren Sie Artefakttypen

# 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) Registrieren Sie die Ausführungstypen für alle Schritte im ML-Workflow

# 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 Sie Artefakte und Ausführungen in einem Kontext unter Verwendung 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 Sie MLMD mit einem Remote-gRPC-Server

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

  • Starten Sie einen Server
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
  • 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 allgemeine API, die Sie problemlos mit Ihren ML-Pipelines verwenden können. Weitere Informationen finden Sie in der MLMD-API-Dokumentation .

Lesen Sie auch das MLMD-Tutorial , um zu erfahren, wie Sie mit MLMD die Herkunft Ihrer Pipeline-Komponenten verfolgen können.