Dzień Społeczności ML jest 9 listopada! Dołącz do nas na aktualizacje z TensorFlow Jax i więcej Dowiedz się więcej

Metadane ML

ML Metadane (MLMD) jest biblioteką do zapisu i odczytu metadane związane z ML deweloperskich i naukowiec danych przepływów pracy. MLMD jest integralną częścią TensorFlow Extended (TFX) , ale jest zaprojektowany tak, że może być stosowane niezależnie od siebie.

Każde uruchomienie produkcyjnego potoku ML generuje metadane zawierające informacje o różnych składnikach potoku, ich wykonaniach (np. uruchomieniach szkolenia) i wynikających z nich 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 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 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 rodzaje metadanych w bazie danych o nazwie Metadane Store.

  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.

Przegląd metadanych ML

Backendy przechowywania metadanych i konfiguracja połączenia magazynu

MetadataStore obiekt otrzymuje konfiguracji połączenia, który odpowiada przechowywaniu backend używany.

  • Fałszywe Baza zapewnia DB w pamięci (przy użyciu SQLite) do szybkiego eksperymentowania i lokalnych tras. 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, gdy za pomocą instancji MySQL z Google CloudSQL ( QuickStart , connect-głównej ), można było również skorzystać z opcji SSL, jeśli dotyczy.

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 rodzaj 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 serializowanego formatu. Po zarejestrowaniu typu, jego definicja jest dostępna przez cały okres istnienia sklepu.
  • Artifact opisuje konkretne wystąpienie danego ArtifactType , a jego właściwości, które są zapisywane w magazynie metadanych.
  • ExecutionType opisuje typ składnika lub etapu w obiegu, a jego parametry wykonawczego.
  • Execution jest zapisem przebiegu składnik lub krokiem w obiegu ml i parametrów uruchomieniowych. Egzekucja może być traktowane jako wystąpienie ExecutionType . Wykonania są rejestrowane po uruchomieniu potoku lub kroku ML.
  • Event jest zapisem relacji między artefaktami i egzekucji. Kiedy następuje wykonanie, zdarzenia rejestrują każdy artefakt użyty przez wykonanie i każdy artefakt, który został wyprodukowany. Te rekordy 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 rodzaj pojęciowej grupy artefaktów i egzekucji w przepływie pracy, a jego właściwości strukturalnych. Na przykład: projekty, przebiegi rurociągów, eksperymenty, właściciele itp.
  • Context jest wystąpienie ContextType . Przechwytuje udostępniane informacje w grupie. Na przykład: nazwa projektu, listy zmian popełnić id, eksperymentować adnotacje itp Ma zdefiniowany przez użytkownika unikalną nazwę w swojej ContextType .
  • Attribution jest zapisem relacji między artefaktami i kontekstach.
  • Association jest zapisem relacji między egzekucjami i kontekstach.

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 do debugowania i odnajdywania.
  • Wróć do wszystkich wydarzeń, aby zobaczyć, jak powstał artefakt. Przykłady: zobacz, jakie dane trafiły do ​​modelu; egzekwowania planów 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: śledzenie właściciela i listy 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, w których wartość danej właściwości mieści się w zakresie; znajdź poprzednie wykonania w kontekście z tymi samymi danymi wejściowymi.

Zobacz poradnik MLMD na przykład, który pokazuje, jak używać API MLMD i sklep metadane do pobierania informacji rodowodu.

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.

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)

# 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że być również skonfigurowany z MLMD MetadataStoreServerConfig użycie plików SQLite lub instancji MySQL. Config mogą być przechowywane w pliku Protobuf tekst i przekazywane do binarnych z --metadata_store_server_config_file=path_to_the_config_file .

Przykładem MetadataStoreServerConfig plik 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. Zobacz dokumentację API MLMD więcej szczegółów.

Sprawdź MLMD deklaratywnej węzły Filtering , aby dowiedzieć się, jak korzystać z MLMD deklaratywnych węzły możliwości filtrowania na właściwości i 1-hop węzłów sąsiedztwa.

Zapoznaj się także z samouczkiem MLMD aby nauczyć się korzystać MLMD prześledzić rodowód z elementów rurociągowych.

MLMD zapewnia narzędzia do obsługi migracji schematów i danych w różnych wydaniach. Zobacz MLMD Przewodnik po więcej szczegółów.