Rastreie modelos de ML com o MLflow e o Azure Machine Learning

APLICA-SE A: Python SDK azureml v1

Neste artigo, saiba como habilitar o Rastreamento de MLflow para conectar o Azure Machine Learning como o back-end de seus experimentos de MLflow.

MLflow é uma biblioteca de código aberto para gerenciar o ciclo de vida de seus experimentos de aprendizado de máquina. O MLflow Tracking é um componente do MLflow que registra e rastreia suas métricas de execução de treinamento e artefatos de modelo, independentemente do ambiente do experimento - localmente em seu computador, em um destino de computação remoto, em uma máquina virtual ou em um cluster do Azure Databricks.

Consulte MLflow e Azure Machine Learning para obter todas as funcionalidades de MLflow e Azure Machine Learning suportadas, incluindo suporte ao Projeto MLflow (visualização) e implantação de modelo.

Pré-requisitos

• Instale o pacote mlflow.

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

• Instale o pacote azureml-mlflow.

• Crie um Espaço de Trabalho do Azure Machine Learning.

  • Veja quais permissões de acesso você precisa para executar suas operações MLflow com seu espaço de trabalho.

• Instale e configure a CLI do Azure Machine Learning (v1) e certifique-se de instalar a extensão ml.

  Importante

  Alguns dos comandos da CLI do Azure neste artigo usam a extensão , ou v1, para o azure-cli-mlAzure Machine Learning. O suporte para a extensão v1 terminará em 30 de setembro de 2025. Você poderá instalar e usar a extensão v1 até essa data.

  Recomendamos que você faça a transição para a mlextensão , ou v2, antes de 30 de setembro de 2025. Para obter mais informações sobre a extensão v2, consulte Extensão CLI do Azure ML e Python SDK v2.

• Instale e configure o SDK do Azure Machine Learning para Python.

Rastreie execuções a partir de sua máquina local ou computação remota

O acompanhamento usando o MLflow com o Azure Machine Learning permite armazenar as métricas registradas e as execuções de artefatos que foram executadas em sua máquina local em seu espaço de trabalho do Azure Machine Learning.

Configurar o ambiente de rastreamento

Para controlar uma execução que não está sendo executada na computação do Azure Machine Learning (doravante referida como "computação local"), você precisa apontar sua computação local para o URI de Rastreamento de MLflow do Azure Machine Learning.

export MLFLOW_TRACKING_URI=$(az ml workspace show --query mlflow_tracking_uri | sed 's/"//g') 

import mlflow

region = ""
subscription_id = ""
resource_group = ""
workspace_name = ""

azureml_mlflow_uri = f"azureml://{region}.api.azureml.ms/mlflow/v1.0/subscriptions/{subscription_id}/resourceGroups/{resource_group}/providers/Microsoft.MachineLearningServices/workspaces/{workspace_name}"
mlflow.set_tracking_uri(azureml_mlflow_uri)

Definir nome do experimento

Todas as execuções do MLflow são registradas no experimento ativo. Por padrão, as execuções são registradas em um experimento chamado Default que é criado automaticamente para você. Para configurar o experimento no qual você deseja trabalhar, use o comando mlflow.set_experiment()MLflow .

experiment_name = 'experiment_with_mlflow'
mlflow.set_experiment(experiment_name)

Iniciar a corrida de treinamento

Depois de definir o nome do experimento MLflow, você pode iniciar sua execução de treinamento com start_run(). Em seguida, use log_metric() para ativar a API de log MLflow e comece a registrar suas métricas de execução de treinamento.

import os
from random import random

with mlflow.start_run() as mlflow_run:
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")

Para obter detalhes sobre como registrar métricas, parâmetros e artefatos em uma execução usando a visualização MLflow Como registrar e exibir métricas.

Rastrear execuções em execução no Azure Machine Learning

APLICA-SE A: Python SDK azureml v1

As execuções remotas (trabalhos) permitem-lhe treinar os seus modelos de uma forma mais robusta e repetitiva. Eles também podem aproveitar computações mais poderosas, como clusters de computação de aprendizado de máquina. Consulte Usar destinos de computação para treinamento de modelo para saber mais sobre diferentes opções de computação.

Ao enviar execuções, o Aprendizado de Máquina do Azure configura automaticamente o MLflow para trabalhar com o espaço de trabalho em que a execução está sendo executada. Isso significa que não há necessidade de configurar o URI de rastreamento MLflow. Além disso, os experimentos são nomeados automaticamente com base nos detalhes do envio do experimento.

Criar uma rotina de treino

Primeiro, você deve criar um src subdiretório e criar um arquivo com seu código de treinamento em um train.py arquivo no src subdiretório. Todo o seu código de treinamento irá para o src subdiretório, incluindo train.py.

O código de treinamento é retirado deste exemplo de MLflow no repositório de exemplo do Azure Machine Learning.

Copie este código para o arquivo:

# imports
import os
import mlflow

from random import random

# define functions
def main():
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")


# run functions
if __name__ == "__main__":
    # run main function
    main()

Configurando o experimento

Você precisará usar Python para enviar o experimento ao Azure Machine Learning. Em um notebook ou arquivo Python, configure seu ambiente de execução de computação e treinamento com a Environment classe.

from azureml.core import Environment
from azureml.core.conda_dependencies import CondaDependencies

env = Environment(name="mlflow-env")

# Specify conda dependencies with scikit-learn and temporary pointers to mlflow extensions
cd = CondaDependencies.create(
    conda_packages=["scikit-learn", "matplotlib"],
    pip_packages=["azureml-mlflow", "pandas", "numpy"]
    )

env.python.conda_dependencies = cd

Em seguida, construa ScriptRunConfig com sua computação remota como o destino de computação.

from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory="src",
                      script=training_script,
                      compute_target="<COMPUTE_NAME>",
                      environment=env)

Com essa configuração de execução de computação e treinamento, use o Experiment.submit() método para enviar uma execução. Esse método define automaticamente o URI de rastreamento MLflow e direciona o log do MLflow para seu espaço de trabalho.

from azureml.core import Experiment
from azureml.core import Workspace
ws = Workspace.from_config()

experiment_name = "experiment_with_mlflow"
exp = Experiment(workspace=ws, name=experiment_name)

run = exp.submit(src)

Visualize métricas e artefatos em seu espaço de trabalho

As métricas e artefatos do log MLflow são rastreados em seu espaço de trabalho. Para visualizá-los a qualquer momento, navegue até seu espaço de trabalho e localize o experimento pelo nome em seu espaço de trabalho no estúdio de Aprendizado de Máquina do Azure. Ou execute o código abaixo.

Recupere a métrica de execução usando MLflow get_run().

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
run_id = mlflow_run.info.run_id
finished_mlflow_run = MlflowClient().get_run(run_id)

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

print(metrics,tags,params)

Para exibir os artefatos de uma execução, você pode usar MlFlowClient.list_artifacts()

client.list_artifacts(run_id)

Para baixar um artefato para o diretório atual, você pode usar MLFlowClient.download_artifacts()

client.download_artifacts(run_id, "helloworld.txt", ".")

Para obter mais detalhes sobre como recuperar informações de experimentos e execuções no Azure Machine Learning usando o modo de exibição MLflow, gerencie experimentos e execuções com MLflow.

Comparar e consultar

Compare e consulte todas as execuções de MLflow em seu espaço de trabalho do Azure Machine Learning com o código a seguir. Saiba mais sobre como consultar execuções com MLflow.

from mlflow.entities import ViewType

all_experiments = [exp.experiment_id for exp in MlflowClient().list_experiments()]
query = "metrics.hello_metric > 0"
runs = mlflow.search_runs(experiment_ids=all_experiments, filter_string=query, run_view_type=ViewType.ALL)

runs.head(10)

Registo automático

Com o Azure Machine Learning e o MLFlow, os usuários podem registrar métricas, parâmetros de modelo e artefatos de modelo automaticamente ao treinar um modelo. Uma variedade de bibliotecas populares de aprendizado de máquina são suportadas.

Para habilitar o registro automático, insira o seguinte código antes do código de treinamento:

mlflow.autolog()

Saiba mais sobre o registo automático com MLflow.

Gerir modelos

Registre e acompanhe seus modelos com o registro de modelo do Azure Machine Learning, que dá suporte ao registro do modelo MLflow. Os modelos do Azure Machine Learning estão alinhados com o esquema de modelo MLflow, facilitando a exportação e importação desses modelos em diferentes fluxos de trabalho. Os metadados relacionados ao MLflow, como o ID de execução, também são rastreados com o modelo registrado para rastreabilidade. Os usuários podem enviar execuções de treinamento, registrar e implantar modelos produzidos a partir de execuções MLflow.

Se você quiser implantar e registrar seu modelo pronto para produção em uma etapa, consulte Implantar e registrar modelos MLflow.

Para registrar e exibir um modelo de uma execução, use as seguintes etapas:

1. Quando uma execução estiver concluída, chame o register_model() método.

   # the model folder produced from a run is registered. This includes the MLmodel file, model.pkl and the conda.yaml.
   model_path = "model"
   model_uri = 'runs:/{}/{}'.format(run_id, model_path) 
   mlflow.register_model(model_uri,"registered_model_name")
   

2. Exiba o modelo registrado em seu espaço de trabalho com o estúdio do Azure Machine Learning.

   No exemplo a seguir, my-model o modelo registrado tem metadados de rastreamento MLflow marcados.

   

3. Selecione a guia Artefatos para ver todos os arquivos de modelo que se alinham com o esquema do modelo MLflow (conda.yaml, MLmodel, model.pkl).

   

4. Selecione MLmodel para ver o arquivo MLmodel gerado pela execução.

   

Clean up resources (Limpar recursos)

Se você não planeja usar as métricas e artefatos registrados em seu espaço de trabalho, a capacidade de excluí-los individualmente não está disponível no momento. Em vez disso, exclua o grupo de recursos que contém a conta de armazenamento e o espaço de trabalho, para não incorrer em nenhum custo:

1. No portal do Azure, selecione Grupos de recursos na extremidade esquerda.

   

2. Na lista, selecione o grupo de recursos que criou.

3. Selecione Eliminar grupo de recursos.

4. Insira o nome do grupo de recursos. Em seguida, selecione Eliminar.

Blocos de notas de exemplo

O MLflow com blocos de anotações do Azure Machine Learning demonstra e expande os conceitos apresentados neste artigo. Consulte também o repositório orientado pela comunidade, AzureML-Examples.

Próximos passos

• Implante modelos com MLflow.
• Monitore seus modelos de produção quanto ao desvio de dados.
• Acompanhe as execuções do Azure Databricks com MLflow.
• Faça a gestão dos seus modelos.