Metadados de ML

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

ML Metadata (MLMD) é uma biblioteca para gravar e recuperar metadados associados a fluxos de trabalho de desenvolvedores de ML e cientistas de dados. O MLMD é parte integrante do TensorFlow Extended (TFX) , mas foi projetado para 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 ou erros inesperados do pipeline, esses metadados podem ser aproveitados para analisar a linhagem dos componentes do pipeline e depurar problemas. Pense nesses metadados como o equivalente a fazer login 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 treino levou a este modelo?
  • Qual versão do TensorFlow criou esse modelo?
  • Quando o modelo com falha foi empurrado?

Armazenamento de metadados

O MLMD registra os seguintes tipos de metadados em um banco de dados chamado Metadata Store .

  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. O MLMD fornece implementações de referência para SQLite (que suporta in-memory 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 backend de armazenamento usado.

  • O Fake Database 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.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 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)
  • 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)

Da mesma forma, ao usar uma instância MySQL com o Google CloudSQL ( quickstart , connect-overview ), também é possível usar a opção SSL, se aplicável.

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)

Modelo de dados

O Metadata Store usa o modelo de dados a seguir 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 dinamicamente com o repositório de metadados no código ou pode carregá-los no repositório a partir de um formato serializado. Depois de registrar um tipo, sua definição fica disponível durante toda a vida útil 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 como 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 do relacionamento entre artefatos e execuções. Quando uma execução acontece, os eventos registram todos os artefatos que foram usados ​​pela execução e todos os artefatos que foram produzidos. Esses registros permitem o rastreamento de linhagem em todo o fluxo de trabalho. Ao observar todos os eventos, o MLMD sabe quais execuções aconteceram e quais artefatos foram criados como resultado. O MLMD pode então recorrer 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 alterações, anotações do experimento etc. Ele tem um nome exclusivo definido pelo usuário em seu ContextType .
  • Uma Attribution é um registro do relacionamento entre artefatos e contextos.
  • Uma Association é um registro do relacionamento entre execuções e contextos.

Funcionalidade MLMD

O rastreamento das 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 ativem 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: comparar 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.
  • Recorra a todos os eventos para ver como um artefato foi criado. Exemplos: ver quais dados entraram em um modelo; impor 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á completou o mesmo trabalho e a saída anterior pode ser reutilizada.
  • Contexto de registro e consulta de execuções de fluxo de trabalho. Exemplos: rastrear o proprietário e a lista de alterações usados ​​para uma execução de fluxo de trabalho; agrupar a linhagem por experimentos; gerenciar artefatos por projetos.
  • Recursos de filtragem de nós declarativos em propriedades e nós de vizinhança de 1 salto. Exemplos: procurar artefatos de um tipo e sob algum contexto de pipeline; retorna artefatos tipados onde o valor de uma determinada propriedade está dentro de um intervalo; encontrar execuções anteriores em um contexto com as mesmas entradas.

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 metadados de ML em seus fluxos de trabalho de ML

Se você for um desenvolvedor de plataforma interessado em integrar o MLMD ao seu sistema, use o fluxo de trabalho de exemplo 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 artefatos

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

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

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

# 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) Crie uma execução da execução do Treinador

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

7) Grave 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) Agrupe artefatos e execuções em 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])

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

Use MLMD com um servidor gRPC remoto

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

  • Iniciar um servidor
bazel run -c opt --define grpc_no_ares=true  //ml_metadata/metadata_store:metadata_store_server

Por padrão, o servidor usa um banco de dados falso na memória por solicitação e não persiste os metadados nas chamadas. Ele também pode ser configurado com um MLMD MetadataStoreServerConfig para usar arquivos SQLite ou instâncias MySQL. A configuração pode ser armazenada em um arquivo protobuf de texto e passada para o binário com --metadata_store_server_config_file=path_to_the_config_file .

Um exemplo de arquivo MetadataStoreServerConfig no formato de texto protobuf:

connection_config {
  sqlite {
    filename_uri: '/tmp/test_db'
    connection_mode: READWRITE_OPENCREATE
  }
}
  • 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.

Confira Filtragem de nós declarativos MLMD para saber como usar os recursos de filtragem de nós declarativos MLMD em propriedades e nós de vizinhança de 1 salto.

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

O MLMD fornece utilitários para lidar com migrações de esquema e dados entre versões. Consulte o Guia MLMD para obter mais detalhes.