Esta página foi traduzida pela API Cloud Translation.
Switch to English

Metadados de ML

ML Metadata (MLMD) é uma biblioteca para registrar e recuperar metadados associados a desenvolvedores de ML e fluxos de trabalho de cientistas de dados. O MLMD é parte integrante do TensorFlow Extended (TFX) , mas foi projetado para que possa ser usado de forma independente.

Cada execução de um pipeline de ML de produção gera metadados contendo informações sobre os vários componentes do pipeline, suas execuções (por exemplo, execuções de treinamento) e artefatos resultantes (por exemplo, modelos treinados). No caso de comportamento inesperado do pipeline ou erros, esses metadados podem ser aproveitados para analisar a linhagem dos componentes do pipeline e problemas de depuração. Pense nesses metadados como o equivalente ao registro no desenvolvimento de software.

O MLMD ajuda você a entender e analisar todas as partes interconectadas de seu pipeline de ML em vez de analisá-las isoladamente e pode ajudá-lo a responder a perguntas sobre seu pipeline de ML, como:

  • Em qual conjunto de dados o modelo foi treinado?
  • Quais foram os hiperparâmetros usados ​​para treinar o modelo?
  • Qual execução de pipeline criou o modelo?
  • Qual corrida de treinamento levou a esse modelo?
  • Qual versão do TensorFlow criou este modelo?
  • Quando o modelo com falha foi lançado?

Metadata store

O MLMD registra os seguintes tipos de metadados em um banco de dados denominado Armazenamento de Metadados .

  1. Metadados sobre os artefatos gerados por meio dos componentes / etapas de seus pipelines de ML
  2. Metadados sobre as execuções desses componentes / etapas
  3. Metadados sobre pipelines e informações de linhagem associadas

O Metadata Store fornece APIs para registrar e recuperar metadados de e para o back-end de armazenamento. O back-end de armazenamento é conectável e pode ser estendido. MLMD fornece implementações de referência para SQLite (que oferece suporte em memória e disco) e MySQL pronto para uso.

Este gráfico mostra uma visão geral de alto nível dos vários componentes que fazem parte do MLMD.

Visão geral dos metadados de ML

Back-ends de armazenamento de metadados e configuração de conexão de armazenamento

O objeto MetadataStore recebe uma configuração de conexão que corresponde ao back-end de armazenamento usado.

  • O banco de dados falso fornece um banco de dados na memória (usando SQLite) para experimentação rápida e execuções locais. O banco de dados é excluído quando o objeto de armazenamento é destruído.
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 lê e grava arquivos do 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)
  • O MySQL se conecta a um servidor 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)

Modelo de dados

O Metadata Store usa o seguinte modelo de dados para registrar e recuperar metadados do back-end de armazenamento.

  • ArtifactType descreve o tipo de um artefato e suas propriedades que são armazenadas no repositório de metadados. Você pode registrar esses tipos instantaneamente com o armazenamento de metadados no código ou pode carregá-los no armazenamento a partir de um formato serializado. Depois de registrar um tipo, sua definição fica disponível durante todo o ciclo de vida da loja.
  • Um Artifact descreve uma instância específica de um ArtifactType e suas propriedades que são gravadas no repositório de metadados.
  • Um ExecutionType descreve um tipo de componente ou etapa em um fluxo de trabalho e seus parâmetros de tempo de execução.
  • Uma Execution é um registro de uma execução de componente ou uma etapa em um fluxo de trabalho de ML e os parâmetros de tempo de execução. Uma execução pode ser considerada uma instância de um ExecutionType . As execuções são registradas quando você executa um pipeline ou etapa de ML.
  • Um Event é um registro da relação entre artefatos e execuções. Quando uma execução acontece, os eventos registram cada artefato que foi usado pela execução e cada artefato que foi produzido. Esses registros permitem o rastreamento da linhagem em um fluxo de trabalho. Olhando para todos os eventos, o MLMD sabe quais execuções aconteceram e quais artefatos foram criados como resultado. O MLMD pode então retornar de qualquer artefato para todas as suas entradas upstream.
  • Um ContextType descreve um tipo de grupo conceitual de artefatos e execuções em um fluxo de trabalho e suas propriedades estruturais. Por exemplo: projetos, execuções de pipeline, experimentos, proprietários etc.
  • Um Context é uma instância de um ContextType . Ele captura as informações compartilhadas dentro do grupo. Por exemplo: nome do projeto, id do commit da lista de mudanças, anotações do experimento, etc. Ele tem um nome exclusivo definido pelo usuário em seu ContextType .
  • Uma Attribution é um registro da relação entre artefatos e contextos.
  • Uma Association é um registro da relação entre execuções e contextos.

Funcionalidade MLMD

Rastrear as entradas e saídas de todos os componentes / etapas em um fluxo de trabalho de ML e sua linhagem permite que as plataformas de ML habilitem vários recursos importantes. A lista a seguir fornece uma visão geral não exaustiva de alguns dos principais benefícios.

  • Liste todos os artefatos de um tipo específico. Exemplo: todos os modelos que foram treinados.
  • Carregue dois artefatos do mesmo tipo para comparação. Exemplo: compare os resultados de dois experimentos.
  • Mostre um DAG de todas as execuções relacionadas e seus artefatos de entrada e saída de um contexto. Exemplo: visualize o fluxo de trabalho de um experimento para depuração e descoberta.
  • Percorra novamente todos os eventos para ver como um artefato foi criado. Exemplos: veja quais dados foram para um modelo; aplicar planos de retenção de dados.
  • Identifique todos os artefatos que foram criados usando um determinado artefato. Exemplos: veja todos os modelos treinados a partir de um conjunto de dados específico; marcar modelos com base em dados incorretos.
  • Determine se uma execução foi executada nas mesmas entradas antes. Exemplo: determine se um componente / etapa já concluiu o mesmo trabalho e a saída anterior pode apenas ser reutilizada.
  • Registre e consulte o contexto das execuções do fluxo de trabalho. Exemplos: rastreie o proprietário e a lista de alterações usada para uma execução de fluxo de trabalho; agrupar a linhagem por experimentos; gerenciar artefatos por projetos.

Consulte o tutorial MLMD para obter um exemplo que mostra como usar a API MLMD e o repositório de metadados para recuperar informações de linhagem.

Integre os metadados de ML em seus fluxos de trabalho de ML

Se você for um desenvolvedor de plataforma interessado em integrar MLMD em seu sistema, use o exemplo de fluxo de trabalho abaixo para usar as APIs MLMD de baixo nível para rastrear a execução de uma tarefa de treinamento. Você também pode usar APIs Python de nível superior em ambientes de notebook para registrar metadados de experimentos.

Fluxo de exemplo de metadados de ML

1) Registre os tipos de artefato

# 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) Registre os tipos de execução para todas as etapas do fluxo de trabalho de 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) Crie um artefato de 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) Crie a execução para a execução do Trainer (normalmente um 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) Defina o evento de entrada e leia os dados

# 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) Declare o artefato de saída

# 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) Registre o evento de saída

# 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) Marque a execução como concluída

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

9) Artefatos de grupo e execuções sob um contexto usando artefatos de atribuições e asserções

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

Use MLMD com um servidor gRPC remoto

Você pode usar MLMD com servidores gRPC remotos, conforme mostrado abaixo:

  • Inicie um servidor
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server
  • Crie o stub do cliente e use-o em 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)
  • Use MLMD com chamadas 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)

Recursos

A biblioteca MLMD tem uma API de alto nível que você pode usar prontamente com seus pipelines de ML. Consulte a documentação da API MLMD para obter mais detalhes.

Verifique também o tutorial de MLMD para aprender como usar o MLMD para rastrear a linhagem de seus componentes de pipeline.