Metadane ML

ML Metadata (MLMD) to biblioteka służąca do rejestrowania i pobierania metadanych związanych z przepływami pracy programistów i naukowców zajmujących się danymi. MLMD jest integralną częścią TensorFlow Extended (TFX) , ale został zaprojektowany tak, aby można go było używać niezależnie.

Każde uruchomienie produkcyjnego potoku ML generuje metadane zawierające informacje o różnych składnikach potoku, ich wykonaniach (np. uruchomieniach trenowania) i powstałych artefaktach (np. trenowanych modelach). W przypadku nieoczekiwanego zachowania potoku lub błędów, te metadane można wykorzystać do analizy pochodzenia składników potoku i problemów z debugowaniem. Pomyśl o tych metadanych jako o ekwiwalencie logowania do tworzenia oprogramowania.

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

• Na którym zbiorze danych trenował model?
• Jakie hiperparametry zostały użyte do trenowania modelu?
• Które uruchomienie potoku utworzyło model?
• Które szkolenie doprowadziło do tego modelu?
• Która wersja TensorFlow stworzyła ten model?
• Kiedy wypchnięto nieudany model?

Magazyn metadanych

MLMD rejestruje następujące typy metadanych w bazie danych zwanej magazynem metadanych .

1. Metadane dotyczące artefaktów generowanych przez komponenty/kroki Twoich potoków ML
2. Metadane o wykonaniach tych komponentów/kroków
3. Metadane dotyczące potoków i powiązane informacje 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 implementacje referencyjne dla SQLite (obsługującego pamięć i dysk) oraz MySQL po wyjęciu z pudełka.

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

Backendy przechowywania metadanych i konfiguracja połączenia magazynu

Obiekt MetadataStore odbiera konfigurację połączenia odpowiadającą używanemu zapleczu magazynu.

• Fałszywa baza danych zapewnia bazę danych w pamięci (przy użyciu SQLite) do szybkiego eksperymentowania i uruchamiania lokalnego. Baza danych jest usuwana po zniszczeniu obiektu magazynu.

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

Podobnie, używając instancji MySQL z Google CloudSQL ( szybki start , connect-overview ), można również użyć opcji SSL, jeśli ma to zastosowanie.

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)

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 załadować je do magazynu 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 w czasie wykonywania.
• Execution to zapis uruchomienia komponentu lub kroku w przepływie pracy ML i parametrów środowiska wykonawczego. Wykonanie można traktować jako wystąpienie ExecutionType . Wykonania są rejestrowane po uruchomieniu potoku lub kroku ML.
• Event to zapis relacji między artefaktami a egzekucjami. Kiedy następuje wykonanie, zdarzenia rejestrują każdy artefakt użyty przez wykonanie i każdy artefakt, który został wyprodukowany. Rekordy te umożliwiają śledzenie pochodzenia w całym przepływie pracy. Patrząc na wszystkie zdarzenia, MLMD wie, jakie egzekucje miały miejsce i jakie artefakty powstały w ich wyniku. MLMD może następnie powrócić z dowolnego artefaktu do wszystkich swoich wejściowych 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 jest instancją ContextType . Przechwytuje udostępniane informacje w grupie. Na przykład: nazwa projektu, identyfikator zatwierdzenia listy zmian, adnotacje eksperymentu itp. Ma unikalną nazwę zdefiniowaną przez użytkownika w swoim ContextType .
• Attribution to zapis relacji między artefaktami a kontekstami.
• Association to zapis relacji między egzekucjami a kontekstami.

Funkcjonalność MLMD

Śledzenie danych wejściowych i wyjściowych wszystkich składników/kroków w przepływie pracy ML oraz 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 Modele, które zostały przeszkolone.
• Załaduj dwa artefakty tego samego typu do porównania. Przykład: porównaj wyniki z dwóch eksperymentów.
• Pokaż DAG wszystkich powiązanych wykonań oraz ich artefakty wejściowe i wyjściowe kontekstu. Przykład: wizualizacja przepływu pracy eksperymentu w celu debugowania i wykrywania.
• Wróć do wszystkich wydarzeń, 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 wytrenowane z określonego zestawu danych; markuj modele na podstawie złych danych.
• Sprawdź, czy wykonanie zostało wcześniej uruchomione na tych samych wejściach. Przykład: określ, czy składnik/krok wykonał już tę samą pracę, a poprzednie dane wyjściowe można po prostu ponownie wykorzystać.
• Rejestruj i zapytaj kontekst przebiegów przepływu pracy. Przykłady: śledź właściciela i listę zmian używanych do uruchomienia przepływu pracy; pogrupuj rodowód przez eksperymenty; zarządzaj artefaktami według projektów.
• Możliwości deklaratywnego filtrowania węzłów we właściwościach i węzłach sąsiedztwa z jednym przeskokiem. Przykłady: szukaj artefaktów typu i w pewnym kontekście potoku; zwracają artefakty wpisane, gdy wartość danej właściwości mieści się w zakresie; znajdź poprzednie wykonania w kontekście z tymi samymi danymi wejściowymi.

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 zainteresowanym integracją MLMD ze swoim systemem, skorzystaj z poniższego przykładowego przepływu pracy, aby użyć niskopoziomowych interfejsów API MLMD do śledzenia wykonania zadania szkoleniowego. Możesz także używać interfejsów API języka Python wyższego poziomu w środowiskach notebooków do rejestrowania metadanych eksperymentu.

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)

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

2) Zarejestruj typy wykonania 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)

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

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

# 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) Utwórz wykonanie biegu Trenera

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

7) Nagraj 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 przy użyciu 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])

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

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

Domyślnie serwer używa fałszywej bazy danych w pamięci na żądanie i nie przechowuje metadanych między wywołaniami. Można go również skonfigurować za pomocą MLMD MetadataStoreServerConfig , aby używać plików SQLite lub instancji MySQL. Konfiguracja może być przechowywana w tekstowym pliku protobuf i przekazywana do pliku binarnego z --metadata_store_server_config_file=path_to_the_config_file .

Przykładowy plik MetadataStoreServerConfig w formacie tekstowym protobuf:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}

• Utwórz skrót klienta i używaj 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żyj 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ę z deklaratywnym filtrowaniem węzłów MLMD , aby dowiedzieć się, jak używać funkcji deklaratywnego filtrowania węzłów MLMD we właściwościach i węzłach sąsiedztwa z jednym przeskokiem.

Zapoznaj się również z samouczkiem MLMD , aby dowiedzieć się, jak używać MLMD do śledzenia pochodzenia składników potoku.

MLMD zapewnia narzędzia do obsługi migracji schematów i danych w różnych wydaniach. Więcej informacji można znaleźć w przewodniku MLMD.