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. Come parte della più ampia piattaforma TFX, la maggior parte degli utenti interagisce con MLMD solo quando si esaminano i risultati dei componenti della pipeline, ad esempio nei notebook o in TensorBoard.

Il grafico seguente mostra i componenti che fanno parte di MLMD. Il back-end di archiviazione è collegabile e può essere esteso. MLMD fornisce implementazioni di riferimento per SQLite (che supporta in memoria e su disco) e MySQL. MetadataStore fornisce API per registrare e recuperare metadati da e verso il back-end di archiviazione. MLMD può registrarsi:

  • metadati relativi agli artefatti generati attraverso i componenti / i passaggi delle condotte
  • metadati sulle esecuzioni di questi componenti / passaggi
  • metadati sulla pipeline e informazioni sul lignaggio associate

I concetti sono spiegati in maggior dettaglio di seguito.

Panoramica sui metadati ML

Funzionalità abilitata da MLMD

Il tracciamento degli input e degli output di tutti i componenti / passaggi in un flusso di lavoro ML e il loro lignaggio consente alle piattaforme ML di abilitare diverse importanti funzionalità. L'elenco seguente offre una panoramica non esaustiva di alcuni dei principali vantaggi.

  • Elenca tutti i manufatti di un tipo specifico. Esempio: tutti i modelli che sono stati addestrati.
  • Carica due manufatti dello stesso tipo per il confronto. Esempio: confrontare 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: visualizzare il flusso di lavoro di un esperimento per il debug e il rilevamento.
  • Ripassa 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 creati utilizzando un determinato artefatto. Esempi: vedi tutti i modelli addestrati da un set di dati specifico; contrassegnare i modelli sulla base di dati errati.
  • Determina se in precedenza è stata eseguita un'esecuzione sugli stessi input. Esempio: determinare se un componente / passaggio ha già completato lo stesso lavoro e l'output precedente può essere appena riutilizzato.
  • Registrare e interrogare il contesto delle esecuzioni del flusso di lavoro. Esempi: tenere traccia del proprietario e dell'elenco modifiche utilizzati per un'esecuzione del flusso di lavoro; raggruppare il lignaggio per esperimenti; gestire gli artefatti dai progetti.

Metadata Storage Backend e Store Connection Configuration

Prima di configurare l'archivio dati, è necessario impostare le importazioni.

 from ml_metadata import metadata_store
from ml_metadata.proto import metadata_store_pb2
 

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

  • Il database falso fornisce un DB in memoria (usando SQLite) per una rapida sperimentazione ed esecuzioni locali. Il database viene eliminato quando l'oggetto store viene distrutto.
 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 collega 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)
 

Negozio di metadati

concetti

Metadata Store utilizza il seguente modello di dati per registrare e recuperare metadati dal back-end di archiviazione.

  • ArtifactType descrive il tipo di un artefatto e le sue proprietà che sono archiviate nel Metadata Store. Questi tipi possono essere registrati al volo con il Metadata Store nel codice oppure possono essere caricati nel negozio da un formato serializzato. Una volta registrato un tipo, la sua definizione è disponibile per tutta la durata del negozio.
  • Artifact descrive un'istanza specifica di un ArtifactType e le sue proprietà che sono scritte nel Metadata Store.
  • ExecutionType descrive un tipo di componente o passaggio in un flusso di lavoro e i suoi 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 come un'istanza di un tipo di ExecutionType . Ogni volta che uno sviluppatore esegue una pipeline o un passaggio ML, le esecuzioni vengono registrate per ogni passaggio.
  • Event è una registrazione della relazione tra un Artifact e le Executions . Quando un Execution accade, Event s registrano ogni Manufatto, che è stato utilizzato dal Execution , e ogni Artifact che è stato prodotto. Questi record consentono il monitoraggio della provenienza durante un flusso di lavoro. Osservando tutti gli eventi MLMD sa cosa sono avvenute le esecuzioni, quali artefatti sono stati creati di conseguenza e può ricorrere da qualsiasi Artifact a tutti i suoi input a monte.
  • ContextType descrive un tipo di gruppo concettuale di Artifacts ed Executions in un flusso di lavoro e le sue proprietà strutturali. Ad esempio: progetti, condutture, esperimenti, proprietari.
  • Context è un'istanza di un ContextType . Cattura le informazioni condivise all'interno del gruppo. Ad esempio: nome del progetto, ID commit elenco modifiche, annotazioni esperimento. Ha un nome univoco definito dall'utente all'interno del suo ContextType .
  • Attribution è una registrazione della relazione tra artefatti e contesti.
  • Association è una registrazione della relazione tra esecuzioni e contesti.

Monitoraggio dei flussi di lavoro ML con i metadati ML

Di seguito è riportato un grafico che illustra come le API di metadati ML di basso livello possono essere utilizzate per tenere traccia dell'esecuzione di un'attività di formazione, seguita da esempi di codice. Si noti che il codice in questa sezione mostra le API dei metadati ML che devono essere utilizzate dagli sviluppatori della piattaforma ML per integrare la propria piattaforma con i metadati ML e non direttamente dagli sviluppatori. Inoltre, forniremo API Python di livello superiore che possono essere utilizzate dai data scientist negli ambienti notebook per registrare i loro metadati dell'esperimento.

Esempio di flusso di metadati ML

1) Prima di poter registrare le esecuzioni, è necessario registrare ArtifactTypes.

 # 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) Prima di poter registrare le esecuzioni, i ExecutionTypes devono essere registrati per tutte le fasi del nostro flusso di lavoro ML.

 # Create 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) Una volta registrati i tipi, creiamo un artefatto DataSet.

 # Declare 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) Con il DataSet Artefact creato, possiamo creare l'esecuzione per una corsa Trainer

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

5) Dichiarare l'evento di input e leggere i dati.

 # Declare 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

# Submit input event to the Metadata Store
store.put_events([input_event])
 

6) Ora che l'input viene letto, dichiariamo l'artefatto di output.

 # Declare 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) Con il modello Artefatto creato, possiamo registrare l'evento di output.

 # 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) Ora che tutto è registrato, l'Esecuzione può essere contrassegnata come completata.

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

9) Quindi i manufatti e le esecuzioni possono essere raggruppati in un contesto (ad esempio, esperimento).

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

Con server remoto grpc

1) Avviare un server con

 bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
 

2) Creare lo stub client e usarlo 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)
 

3) Utilizzare MLMD con 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)