Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

ML Metadata

ML Metadata (MLMD) to biblioteka służąca do rejestrowania i pobierania metadanych związanych z przepływami pracy deweloperów i naukowców danych ML. MLMD jest integralną częścią TensorFlow Extended (TFX) , ale jest zaprojektowany tak, aby mógł być używany niezależnie.

Każdy przebieg produkcyjnego potoku ML generuje metadane zawierające informacje o różnych składnikach potoku, ich wykonaniach (np. Przebiegach szkoleniowych) i wynikowych artefaktach (np. Wytrenowane modele). W przypadku nieoczekiwanego zachowania lub błędów potoku metadane można wykorzystać do analizy pochodzenia składników potoku i problemów z debugowaniem. Potraktuj te metadane jako odpowiednik logowania w rozwoju oprogramowania.

MLMD pomaga zrozumieć i przeanalizować wszystkie połączone ze sobą części potoku ML zamiast analizować je oddzielnie i może pomóc w udzieleniu odpowiedzi na pytania dotyczące potoku ML, takie jak:

  • Na którym zestawie danych trenował model?
  • Jakie hiperparametry były używane do trenowania modelu?
  • Który przebieg potoku utworzył model?
  • Który bieg treningowy doprowadził do tego modelu?
  • Która wersja TensorFlow stworzyła ten model?
  • Kiedy zepchnięto uszkodzony model?

Magazyn metadanych

MLMD rejestruje następujące typy metadanych w bazie danych o nazwie Magazyn metadanych .

  1. Metadane dotyczące artefaktów wygenerowanych przez składniki / kroki potoków ML
  2. Metadane dotyczące wykonywania tych komponentów / kroków
  3. Metadane dotyczące rurociągów i powiązanych informacji o pochodzeniu

Magazyn metadanych udostępnia interfejsy API do rejestrowania i pobierania metadanych do i z zaplecza magazynu. Backend pamięci masowej jest podłączany i można go rozszerzyć. MLMD zapewnia referencyjne implementacje dla SQLite (który obsługuje w pamięci i na dysku) i MySQL po wyjęciu z pudełka.

Ta grafika przedstawia ogólny przegląd różnych komponentów wchodzących w skład MLMD.

Omówienie metadanych ML

Backendy magazynu metadanych i konfiguracja połączenia magazynu

Obiekt MetadataStore odbiera konfigurację połączenia, która odpowiada używanemu zapleczu magazynu.

  • Fałszywa baza danych zapewnia bazę danych w pamięci (przy użyciu SQLite) do szybkich eksperymentów i lokalnych uruchomień. Baza danych jest usuwana po zniszczeniu obiektu magazynu.
import ml_metadata as mlmd
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 czyta i zapisuje pliki z dysku.
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 łączy się z serwerem 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)

Model danych

Magazyn metadanych używa następującego modelu danych do rejestrowania i pobierania metadanych z zaplecza magazynu.

  • ArtifactType opisuje typ artefaktu i jego właściwości, które są przechowywane w magazynie metadanych. Możesz zarejestrować te typy w locie w magazynie metadanych w kodzie lub możesz je załadować do sklepu z formatu serializowanego. Po zarejestrowaniu typu jego definicja jest dostępna przez cały okres istnienia sklepu.
  • Artifact opisuje określone wystąpienie ArtifactType i jego właściwości, które są zapisywane w magazynie metadanych.
  • ExecutionType opisuje typ składnika lub kroku w przepływie pracy oraz jego parametry wykonawcze.
  • Execution to zapis działania składnika lub kroku w przepływie pracy ML oraz parametry środowiska wykonawczego. Wykonanie można traktować jako wystąpienie typu ExecutionType . Wykonania są rejestrowane podczas uruchamiania potoku lub kroku ML.
  • Event to zapis relacji między artefaktami a egzekucjami. Gdy dochodzi do egzekucji, zdarzenia rejestrują każdy artefakt, który został użyty podczas egzekucji, oraz każdy wytworzony artefakt. Te rekordy umożliwiają śledzenie pochodzenia w całym przepływie pracy. Patrząc na wszystkie zdarzenia, MLMD wie, jakie miały miejsce egzekucje i jakie artefakty powstały w wyniku. MLMD może następnie wrócić z dowolnego artefaktu do wszystkich swoich danych wejściowych.
  • ContextType opisuje typ koncepcyjnej grupy artefaktów i wykonań w przepływie pracy oraz jego właściwości strukturalne. Na przykład: projekty, przebiegi rurociągów, eksperymenty, właściciele itp.
  • Context to wystąpienie ContextType . Przechwytuje informacje udostępnione w grupie. Na przykład: nazwa projektu, identyfikator zatwierdzenia listy zmian, adnotacje do eksperymentów itp. Ma zdefiniowaną przez użytkownika unikalną nazwę w swoim ContextType .
  • Attribution jest zapisem relacji między artefaktami i kontekstami.
  • Association to zapis związku między egzekucjami a kontekstami.

Funkcjonalność MLMD

Śledzenie danych wejściowych i wyjściowych wszystkich komponentów / kroków w przepływie pracy ML i ich pochodzenia umożliwia platformom ML włączenie kilku ważnych funkcji. Poniższa lista zawiera niewyczerpujący przegląd niektórych głównych korzyści.

  • Wymień wszystkie artefakty określonego typu. Przykład: wszystkie przeszkolone modele.
  • Załaduj dwa artefakty tego samego typu dla porównania. Przykład: porównaj wyniki z dwóch eksperymentów.
  • Pokaż DAG wszystkich powiązanych wykonań oraz ich artefaktów wejściowych i wyjściowych kontekstu. Przykład: wizualizuj przepływ pracy eksperymentu w celu debugowania i wykrywania.
  • Powtarzaj wszystkie zdarzenia, aby zobaczyć, jak powstał artefakt. Przykłady: zobacz, jakie dane trafiły do ​​modelu; egzekwować plany przechowywania danych.
  • Zidentyfikuj wszystkie artefakty, które zostały utworzone przy użyciu danego artefaktu. Przykłady: zobacz wszystkie modele wyszkolone z określonego zestawu danych; zaznacz modele oparte na złych danych.
  • Sprawdź, czy wykonanie zostało uruchomione wcześniej na tych samych danych wejściowych. Przykład: określ, czy komponent / krok wykonał już tę samą pracę i czy poprzedni wynik może być po prostu ponownie wykorzystany.
  • Kontekst nagrywania i zapytań dotyczących uruchomień przepływu pracy. Przykłady: śledź właściciela i listę zmian używaną do uruchomienia przepływu pracy; pogrupuj linię poprzez eksperymenty; zarządzać artefaktami według projektów.

Zobacz samouczek MLMD, aby zapoznać się z przykładem, który pokazuje, jak używać interfejsu API MLMD i magazynu metadanych do pobierania informacji o pochodzeniu.

Zintegruj metadane ML ze swoimi przepływami pracy ML

Jeśli jesteś programistą platformy i chcesz zintegrować MLMD ze swoim systemem, skorzystaj z poniższego przykładowego przepływu pracy, aby użyć niskopoziomowych interfejsów MLMD API do śledzenia wykonania zadania szkoleniowego. Możesz również używać interfejsów API języka Python wyższego poziomu w środowiskach notebooków, aby rejestrować metadane eksperymentu.

Przykładowy przepływ metadanych ML

1) Zarejestruj typy artefaktów

# 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) Zarejestruj typy wykonywania dla wszystkich kroków w przepływie pracy 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)

3) Utwórz artefakt 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])[0]

4) Utwórz wykonanie dla uruchomienia Trainer (zazwyczaj tfx.components.Trainer ExecutionType)

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) Zdefiniuj zdarzenie wejściowe i odczytaj dane

# 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) Zadeklaruj artefakt wyjściowy

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

7) Zapisz zdarzenie wyjściowe

# 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) Oznacz wykonanie jako zakończone

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

9) Grupuj artefakty i egzekucje w kontekście za pomocą atrybucji i artefaktów asercji

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

Użyj MLMD ze zdalnym serwerem gRPC

Możesz używać MLMD ze zdalnymi serwerami gRPC, jak pokazano poniżej:

  • Uruchom serwer
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
  • Utwórz kod pośredniczący klienta i użyj go w Pythonie
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)
  • Używaj MLMD z wywołaniami 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)

Zasoby

Biblioteka MLMD ma interfejs API wysokiego poziomu, którego można łatwo używać z potokami ML. Więcej informacji można znaleźć w dokumentacji interfejsu API MLMD .

Zapoznaj się również z samouczkiem dotyczącym MLMD, aby dowiedzieć się, jak używać MLMD do śledzenia pochodzenia komponentów rurociągu.