Junte-se à comunidade SIG TFX-Addons e ajude a tornar o TFX ainda melhor!

Metadados de ML

ML Metadados (MLMD) é uma biblioteca para gravar e recuperar metadados associados desenvolvedor ML e cientista de dados fluxos de trabalho. MLMD é uma parte integrante da TensorFlow prolongado (TFX) , mas é concebido de modo que possa ser utilizado 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

MLMD registra os seguintes tipos de metadados em um banco de dados chamado o 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 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 MetadataStore objecto recebe uma configuração de ligação que corresponde ao armazenamento backend utilizado.

  • Falso banco de dados fornece uma DB na memória (usando SQLite) para a experimentação rápida e corridas 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, quando se utiliza uma instância MySQL com o Google CloudSQL ( início rápido , conectar-visão geral ), pode-se também usar a opção SSL se for o caso.

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 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 um exemplo específico de um ArtifactType , e as suas propriedades que são escritas no armazenamento de metadados.
  • Um ExecutionType descreve um tipo de componente ou passo de um fluxo de trabalho, e os seus parâmetros de tempo de execução.
  • Uma Execution é uma ficha de uma corrida componente ou uma etapa de um fluxo de trabalho ML e os parâmetros de tempo de execução. Uma execução pode ser pensado 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 da relação entre artefatos e execuções. Quando uma execução acontece, os eventos registram todos os artefatos usados ​​pela execução e todos os artefatos produzidos. Esses registros permitem o rastreamento da linhagem em um fluxo de trabalho. Observando todos os eventos, o MLMD sabe quais execuções aconteceram e quais artefatos foram criados como resultado. O MLMD pode então retroceder de qualquer artefato para todas as suas entradas upstream.
  • Um ContextType descreve um tipo de grupo conceptual de artefactos e de execuções em um fluxo de trabalho, e as suas propriedades estruturais. Por exemplo: projetos, execuções de pipeline, experimentos, proprietários etc.
  • Um Context é um exemplo de um ContextType . Ele captura as informações compartilhadas dentro do grupo. Por exemplo: nome do projeto, de alterações cometer id, experimentar anotações etc. Ele tem um nome exclusivo definido pelo usuário dentro de sua ContextType .
  • Uma Attribution é um registo da relação entre artefactos e contextos.
  • Uma Association é um registro da relação entre as 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.

Veja o tutorial MLMD para um exemplo que mostra como usar a API MLMD e 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)

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

4) Crie uma execução da corrida do 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])

# Query all registered Execution
executions = store.get_executions_by_id([run_id])

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

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)

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

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 usar arquivos SQLite ou instâncias do MySQL. A configuração pode ser armazenado em um arquivo de texto protobuf e passado para o binário com --metadata_store_server_config_file=path_to_the_config_file .

Um exemplo MetadataStoreServerConfig arquivo no formato protobuf texto:

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. Veja a documentação da API MLMD para mais detalhes.

Também confira o tutorial MLMD para aprender a usar MLMD para rastrear a linhagem de seus componentes de pipeline.

O MLMD fornece utilitários para lidar com migrações de esquemas e dados entre versões. Veja a MLMD Guia para mais detalhes.