RSVP per il tuo evento TensorFlow Everywhere locale oggi!
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Metadati ML

ML Metadata (MLMD) è una libreria per la registrazione e il recupero di metadati associati ai flussi di lavoro di sviluppatori ML e data scientist. MLMD è parte integrante di TensorFlow Extended (TFX) , ma è progettato in modo da poter essere utilizzato in modo indipendente.

Ogni esecuzione di una pipeline ML di produzione genera metadati contenenti informazioni sui vari componenti della pipeline, le loro esecuzioni (es. Esecuzioni di addestramento) e artefatti risultanti (es. Modelli addestrati). In caso di errori o comportamenti imprevisti della pipeline, è possibile utilizzare questi metadati per analizzare la derivazione dei componenti della pipeline e i problemi di debug. Considera questi metadati come l'equivalente del login nello sviluppo del software.

MLMD ti aiuta a comprendere e analizzare tutte le parti interconnesse della tua pipeline ML invece di analizzarle isolatamente e può aiutarti a rispondere a domande sulla tua pipeline ML come:

  • Su quale set di dati è stato eseguito il training del modello?
  • Quali sono stati gli iperparametri utilizzati per addestrare il modello?
  • Quale percorso di pipeline ha creato il modello?
  • Quale percorso formativo ha portato a questo modello?
  • Quale versione di TensorFlow ha creato questo modello?
  • Quando è stato spinto il modello fallito?

Archivio metadati

MLMD registra i seguenti tipi di metadati in un database chiamato Metadata Store .

  1. Metadati sugli artefatti generati attraverso i componenti / passaggi delle pipeline ML
  2. Metadati sulle esecuzioni di questi componenti / passaggi
  3. Metadati sulle pipeline e informazioni di derivazione associate

L'archivio metadati fornisce API per registrare e recuperare metadati da e verso il back-end di archiviazione. Il backend di archiviazione è collegabile e può essere esteso. MLMD fornisce implementazioni di riferimento per SQLite (che supporta in-memory e disco) e MySQL immediatamente.

Questo grafico mostra una panoramica di alto livello dei vari componenti che fanno parte di MLMD.

Panoramica dei metadati ML

Backend di archiviazione dei metadati e configurazione della connessione dell'archivio

L'oggetto MetadataStore riceve una configurazione di connessione che corrisponde al back-end di archiviazione utilizzato.

  • Fake Database fornisce un DB in memoria (utilizzando SQLite) per una rapida sperimentazione e l'esecuzione locale. Il database viene eliminato quando l'oggetto del negozio viene distrutto.
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 legge e scrive file dal disco.
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 si connette a un server 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)

Modello di dati

L'archivio metadati utilizza il seguente modello di dati per registrare e recuperare i metadati dal back-end di archiviazione.

  • ArtifactType descrive il tipo di artefatto e le sue proprietà archiviate nell'archivio dei metadati. È possibile registrare questi tipi al volo con l'archivio dei metadati in codice oppure caricarli nell'archivio da un formato serializzato. Una volta registrato un tipo, la sua definizione è disponibile per tutta la durata del negozio.
  • Un Artifact descrive un'istanza specifica di un oggetto ArtifactType e le sue proprietà scritte nell'archivio dei metadati.
  • Un ExecutionType descrive un tipo di componente o passaggio in un flusso di lavoro e i relativi parametri di runtime.
  • Execution è un record dell'esecuzione di un componente o di un passaggio in un flusso di lavoro ML e dei parametri di runtime. Un'esecuzione può essere considerata un'istanza di un ExecutionType . Le esecuzioni vengono registrate quando si esegue una pipeline o un passaggio ML.
  • Un Event è una registrazione della relazione tra artefatti ed esecuzioni. Quando si verifica un'esecuzione, gli eventi registrano ogni artefatto utilizzato dall'esecuzione e ogni artefatto prodotto. Questi record consentono il tracciamento della derivazione durante un flusso di lavoro. Osservando tutti gli eventi, MLMD sa quali esecuzioni sono avvenute e quali artefatti sono stati creati di conseguenza. MLMD può quindi ricorrere da qualsiasi artefatto a tutti i suoi input a monte.
  • Un ContextType descrive un tipo di gruppo concettuale di artefatti ed esecuzioni in un flusso di lavoro e le sue proprietà strutturali. Ad esempio: progetti, condutture, esperimenti, proprietari ecc.
  • Un Context è un'istanza di ContextType . Cattura le informazioni condivise all'interno del gruppo. Ad esempio: nome del progetto, ID commit dell'elenco modifiche, annotazioni dell'esperimento, ecc. Ha un nome univoco definito dall'utente all'interno del suo ContextType .
  • Attribution è una registrazione della relazione tra artefatti e contesti.
  • Un Association è un record del rapporto tra esecuzioni e contesti.

Funzionalità MLMD

Il monitoraggio degli input e degli output di tutti i componenti / passaggi in un flusso di lavoro ML e la loro discendenza consente alle piattaforme ML di abilitare diverse importanti funzionalità. Il seguente elenco fornisce una panoramica non esaustiva di alcuni dei principali vantaggi.

  • Elenca tutti gli artefatti di un tipo specifico. Esempio: tutti i modelli che sono stati addestrati.
  • Carica due artefatti dello stesso tipo per il confronto. Esempio: confronta i risultati di due esperimenti.
  • Mostra un DAG di tutte le esecuzioni correlate e i relativi artefatti di input e output di un contesto. Esempio: visualizza il flusso di lavoro di un esperimento per il debug e la scoperta.
  • Ricorso a tutti gli eventi per vedere come è stato creato un artefatto. Esempi: vedere quali dati sono stati inseriti in un modello; applicare piani di conservazione dei dati.
  • Identifica tutti gli artefatti che sono stati creati utilizzando un dato artefatto. Esempi: vedi tutti i modelli addestrati da un dataset specifico; contrassegnare i modelli basati su dati errati.
  • Determina se un'esecuzione è stata eseguita in precedenza sugli stessi input. Esempio: determinare se un componente / passaggio ha già completato lo stesso lavoro e l'output precedente può essere semplicemente riutilizzato.
  • Registrare e interrogare il contesto delle esecuzioni del flusso di lavoro. Esempi: tenere traccia del proprietario e dell'elenco modifiche utilizzato per un'esecuzione del flusso di lavoro; raggruppare il lignaggio mediante esperimenti; gestire gli artefatti per progetti.

Consulta il tutorial MLMD per un esempio che mostra come utilizzare l'API MLMD e l'archivio dei metadati per recuperare le informazioni di derivazione.

Integra i metadati ML nei tuoi flussi di lavoro ML

Se sei uno sviluppatore di piattaforme interessato a integrare MLMD nel tuo sistema, utilizza il flusso di lavoro di esempio riportato di seguito per utilizzare le API MLMD di basso livello per monitorare l'esecuzione di un'attività di formazione. Puoi anche utilizzare API Python di livello superiore in ambienti notebook per registrare i metadati dell'esperimento.

Flusso di esempio dei metadati ML

1) Registrare i tipi di artefatto

# 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) Registrare i tipi di esecuzione per tutti i passaggi del flusso di lavoro 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) Creare un artefatto di 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) Crea l'esecuzione per la corsa Trainer (tipicamente un 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) Definire l'evento di input e leggere i dati

# 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) Dichiarare l'artefatto di output

# 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) Registra l'evento di uscita

# 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) Contrassegna l'esecuzione come completata

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

9) Raggruppa artefatti ed esecuzioni in un contesto utilizzando attribuzioni e asserzioni artefatti

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

Usa MLMD con un server gRPC remoto

È possibile utilizzare MLMD con server gRPC remoti come mostrato di seguito:

  • Avvia un server
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
  • Crea lo stub del client e usalo 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)
  • Usa MLMD con le chiamate 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)

Risorse

La libreria MLMD ha un'API di alto livello che puoi utilizzare prontamente con le tue pipeline ML. Consulta la documentazione dell'API MLMD per maggiori dettagli.

Controlla anche il tutorial MLMD per imparare a utilizzare MLMD per tracciare la discendenza dei componenti della pipeline.