Gerenciar registro de modelos no Azure Machine Learning com o MLflow

O Azure Machine Learning dá suporte ao MLflow para gerenciamento de modelos quando conectado a um workspace. Essa abordagem é uma maneira conveniente de dar suporte a todo o ciclo de vida do modelo para usuários familiarizados com o cliente do MLflow.

Este artigo descreve as funcionalidades para gerenciar um registro de modelos com o MLflow e como esse método se compara a outras opções de gerenciamento.

Pré-requisitos

• Instale o pacote do SDK do MLflow mlflow e o plugin azureml-mlflow do Azure Machine Learning para MLflow:

  pip install mlflow azureml-mlflow
  

  Dica

  Você pode usar o pacote mlflow-skinny, que é um pacote MLflow leve sem dependências de servidor, interface do usuário, ciência de dados ou armazenamento do SQL. O mlflow-skinny é recomendado para usuários que precisam, principalmente, dos recursos de acompanhamento e registro em log do MLflow sem importar o conjunto completo de recursos, incluindo implantações.

• Um workspace do Azure Machine Learning. Para criar um espaço de trabalho, confira o tutorial Criar recursos de machine learning. Analise quais permissões de acesso você precisa para executar suas operações do MLflow no seu espaço de trabalho.

• Se estiver efetuando o acompanhamento remoto (ou seja, acompanhando experimentos que estão sendo executados fora do Azure Machine Learning), configure o MLflow para apontar para o URI de acompanhamento do seu espaço de trabalho do Azure Machine Learning. Para obter mais informações sobre como conectar o MLflow ao seu workspace, consulte Configurar o MLflow para o Azure Machine Learning.

• Os procedimentos deste artigo usam um objeto client para se referir ao cliente do MLflow.

  Algumas operações podem ser executadas diretamente usando a API fluent do MLflow, mlflow.<method>. Outras operações exigem um cliente do MLflow para habilitar a comunicação com o Machine Learning no protocolo MLflow. O código a seguir cria um objeto MlflowClient:

  import mlflow
  
  client = mlflow.tracking.MlflowClient()
  

Limitações

• O Azure Machine Learning não dá suporte para renomear modelos.

• O Machine Learning não dá suporte para excluir o contêiner inteiro do modelo.

• Registros organizacionais não tem suporte no gerenciamento de modelos com o MLflow.

• A implantação de modelos de uma preparação específica não tem suporte atualmente no Machine Learning.

• Operações entre espaços de trabalho não tem suporte atualmente no Machine Learning.

Registrar novos modelos

O registro de modelos oferece uma maneira conveniente e centralizada de gerenciar modelos em um espaço de trabalho. Cada workspace tem seu próprio registro de modelos independentes. As seções a seguir demonstram duas maneiras de registrar modelos no registro usando o SDK do MLflow.

Criar modelos a partir de uma execução existente

Se você tiver um modelo do MLflow registrado em uma execução e quiser registrá-lo em um registro, use a ID da execução e o caminho no qual o modelo foi registrado. Você pode consultar essas informações seguindo as instruções em Gerenciar experimentos e execuções com o MLflow.

mlflow.register_model(f"runs:/{run_id}/{artifact_path}", model_name)

Criar modelos a partir de ativos

Se você tiver uma pasta com um modelo MLModel do MLflow, poderá registrá-lo diretamente. Não é necessário que o modelo esteja sempre no contexto de uma execução. Para essa abordagem, você pode usar o esquema URI file://path/to/model para registrar modelos do MLflow armazenados no sistema de arquivos local.

O código a seguir cria um modelo simples usando o pacote scikit-learn e salva o modelo no formato MLflow no armazenamento local:

from sklearn import linear_model

reg = linear_model.LinearRegression()
reg.fit([[0, 0], [1, 1], [2, 2]], [0, 1, 2])

mlflow.sklearn.save_model(reg, "./regressor")

O código a seguir registra o modelo usando o caminho local:

import os

model_local_path = os.path.abspath("./regressor")
mlflow.register_model(f"file://{model_local_path}", "local-model-test")

Consultar registros de modelos

Você pode usar o SDK do MLflow para consultar e pesquisar modelos registrados no registro. As seções a seguir demonstram duas maneiras de consultar um modelo.

Consultar todos os modelos no registro

Você pode consultar todos os modelos registrados no registro usando o cliente do MLflow.

O código a seguir imprime os nomes de todos os modelos no registro:

for model in client.search_registered_models():
    print(f"{model.name}")

Use o método order_bypara organizar a saída por uma propriedade específica, como name, version, creation_timestamp ou last_updated_timestamp:

client.search_registered_models(order_by=["name ASC"])

Obter versões específicas de modelos

O método search_registered_models()recupera o objeto do modelo, que contém todas as versões do modelo. Para obter a última versão registrada de um modelo, você pode usar o método get_registered_model():

client.get_registered_model(model_name)

Para obter uma versão específica de um modelo, use o código a seguir:

client.get_model_version(model_name, version=2)

Carregar os modelos do registro

Você pode carregar modelos diretamente do registro para restaurar objetos de modelos registrados. Para essa tarefa, use as funções mlflow.<flavor>.load_model()ou mlflow.pyfunc.load_model() e indique o URI do modelo para carregar.

Você pode implementar essas funções com a seguinte sintaxe:

• models:/<model-name>/latest: Carregar a última versão do modelo.
• models:/<model-name>/<version-number>: Carregar uma versão específica do modelo.
• models:/<model-name>/<stage-name>: Carregar uma versão específica em uma preparação determinado de um modelo. Para mais informações, consulte Trabalhar com preparação de modelos.

Para entender as diferenças entre as funções mlflow.<flavor>.load_model()e mlflow.pyfunc.load_model(), consulte Fluxos de trabalho para carregar modelos do MLflow.

Trabalhar com preparações de modelos

O MLflow dá suporte a preparações para um modelo, permitindo gerenciar o ciclo de vida do modelo. A versão do modelo pode transitar de um preparação para outro. Preparações são atribuídos a versões específicas de um modelo. Um modelo pode ter várias versões em preparações diferentes.

Consultar os preparações de modelos

O código a seguir usa o cliente do MLflow para verificar todas as possíveis preparações de um modelo:

client.get_model_version_stages(model_name, version="latest")

Você pode ver as versões do modelo para cada preparação recuperando o modelo do registro. O código a seguir obtém a versão do modelo que está atualmente na preparação Staging:

client.get_latest_versions(model_name, stages=["Staging"])

Várias versões de modelo podem estar na mesma preparação ao mesmo tempo no MLflow. No exemplo anterior, o método retorna a versão mais recente entre todas as versões para a preparação.

Transição da versão de modelo

A transição de uma versão de modelo para uma preparação específica pode ser feita usando o cliente do MLflow:

client.transition_model_version_stage(model_name, version=3, stage="Staging")

Quando você faz a transição de uma versão de modelo para uma preparação específica, se a preparação já tiver outras versões de modelo, as versões existentes permanecerão inalteradas. Esse comportamento se aplica por padrão.

Outra abordagem é definir o parâmetro archive_existing_versions=Truedurante a transição. Essa abordagem instrui o MLflow a mover quaisquer versões de modelo existentes para a preparação Archived:

client.transition_model_version_stage(
    model_name, version=3, stage="Staging", archive_existing_versions=True
)

Carregar modelos de preparações

Você pode carregar um modelo em uma preparação específica diretamente do Python usando a função load_model e o seguinte formato de URI. Para que esse método seja bem-sucedido, todas as bibliotecas e dependências devem estar instaladas no seu ambiente de trabalho.

Carregar o modelo a partir da preparação Staging:

model = mlflow.pyfunc.load_model(f"models:/{model_name}/Staging")

Editar e excluir modelos

A edição de modelos registrados tem suporte tanto com o MLflow quanto com o Azure Machine Learning, mas há algumas diferenças importantes. As seções a seguir descrevem algumas opções.

Editar a descrição e marcas de modelos

Você pode editar a descrição e as marcas de um modelo usando o SDK do MLflow:

client.update_model_version(model_name, version=1, description="My classifier description")

Para editar marcas, use os métodos set_model_version_tag e remove_model_version_tag:

client.set_model_version_tag(model_name, version="1", key="type", value="classification")

Para remover uma marca, use o método delete_model_version_tag:

client.delete_model_version_tag(model_name, version="1", key="type")

Excluir versão do modelo

Você pode excluir qualquer versão de modelo no registro usando o cliente do MLflow:

client.delete_model_version(model_name, version="2")

Revisar as funcionalidades com suporte para o gerenciamento de modelos

O cliente MLflow expõe vários métodos para recuperar e gerenciar modelos. A tabela a seguir lista os métodos atualmente com suporte no MLflow quando conectado ao Azure Machine Learning. A tabela também compara o MLflow com outras funcionalidades de gerenciamento de modelos no Azure Machine Learning.

Notas de rodapé da tabela:

• ¹ Usar Identificadores de Recursos Uniformes (URIs) com o formato runs:/<ruin-id>/<path>.
• ² Usar URIs com o formato azureml://jobs/<job-id>/outputs/artifacts/<path>.
• ³ Os modelos registrados são objetos imutáveis no Azure Machine Learning.
• ⁴ Usar a caixa de pesquisa no Estúdio do Azure Machine Learning. É permitida a correspondência parcial.
• ⁵ Usar registros para mover modelos entre diferentes espaços de trabalho e preservar a linhagem.

Conteúdo relacionado

• Explore o registro em log de modelos do MLflow
• Consultar e comparar experimentos e execuções com o MLflow
• Examinar as diretrizes para implantar modelos do MLflow