Executar projetos MLflow no Azure Databricks

Artigo
01/21/2025

Observação

Projetos MLflow deixaram de ser suportados.

Esta documentação foi desativada e pode não ser atualizada. Os produtos, serviços ou tecnologias mencionados neste conteúdo não são mais suportados.

Um Projeto MLflow é um formato para embalar código de ciência de dados de uma forma reutilizável e reproduzível. O componente MLflow Projects inclui uma API e ferramentas de linha de comando para executar projetos, que também se integram ao componente Tracking para registrar automaticamente o parameters e o git commit do seu código-fonte para reprodutibilidade.

Este artigo descreve o formato de um projeto MLflow e como executar um projeto MLflow remotamente em clusters do Azure Databricks usando a CLI MLflow, o que facilita o dimensionamento vertical do código de ciência de dados.

Formato do projeto MLflow

Qualquer diretório local ou repositório Git pode ser tratado como um projeto MLflow. As seguintes convenções definem um projeto:

O nome do projeto é o nome do diretório.
O ambiente de software é especificado em python_env.yaml, se presente. Se nenhum arquivo python_env.yaml estiver presente, o MLflow usará um ambiente virtualenv contendo apenas Python (especificamente, o Python mais recente disponível para virtualenv) ao executar o projeto.
Qualquer arquivo .py ou .sh no projeto pode ser um ponto de entrada, sem parameters explicitamente declarado. Quando executa um tal comando com uma set de parameters, o MLflow passa cada parâmetro na linha de comando usando a sintaxe --key <value>.

Você especifica mais opções adicionando um arquivo MLproject, que é um arquivo de texto na sintaxe YAML. Um exemplo de arquivo MLproject tem esta aparência:

name: My Project

python_env: python_env.yaml

entry_points:
  main:
    parameters:
      data_file: path
      regularization: {type: float, default: 0.1}
    command: "python train.py -r {regularization} {data_file}"
  validate:
    parameters:
      data_file: path
    command: "python validate.py {data_file}"

Para o Databricks Runtime 13.0 ML e superior, os Projetos MLflow não podem ser executados com êxito em um cluster de tipo de trabalho Databricks. Para migrar projetos MLflow existentes para o Databricks Runtime 13.0 ML e superior, consulte MLflow Databricks Spark job project format.

Formato de projeto de trabalho MLflow Databricks Spark

O projeto de trabalho MLflow Databricks Spark é um tipo de projeto MLflow introduzido no MLflow 2.14. Esse tipo de projeto oferece suporte à execução de projetos MLflow de dentro de um cluster Spark Jobs e só pode ser executado usando o back-end databricks.

Os projetos de trabalho do Databricks Spark devem set ou databricks_spark_job.python_file ou entry_points. Não especificar uma ou especificar ambas as configurações gera uma exceção.

A seguir está um exemplo de um arquivo de MLproject que usa a configuração databricks_spark_job.python_file. Essa configuração envolve o uso de um caminho codificado para o arquivo de execução Python e seus argumentos.

name: My Databricks Spark job project 1

databricks_spark_job:
    python_file: "train.py"   # the file which is the entry point file to execute
    parameters: ["param1", "param2"]   # a list of parameter strings
    python_libraries:   # dependencies required by this project
      - mlflow==2.4.1   # MLflow dependency is required
      - scikit-learn

A seguir está um exemplo de um ficheiro MLproject que usa a configuração entry_points.

name: My Databricks Spark job project 2

databricks_spark_job:
    python_libraries: # dependencies to be installed as databricks cluster libraries
      - mlflow==2.4.1
      - scikit-learn

entry_points:
  main:
    parameters:
      model_name: {type: string, default: model}
      script_name: {type: string, default: train.py}
    command: "python {script_name} {model_name}"

A configuração entry_points permite a introdução de parameters utilizando parâmetros de linha de comando, como:

mlflow run . -b databricks --backend-config cluster-spec.json \
 -P script_name=train.py -P model_name=model123 \
 --experiment-id <experiment-id>

As seguintes limitações se aplicam a projetos de trabalho do Databricks Spark:

Este tipo de projeto não suporta a especificação das seguintes seções no arquivo MLproject: docker_env, python_envou conda_env.
As dependências para seu projeto devem ser especificadas no campo python_libraries da seção databricks_spark_job. As versões do Python não podem ser personalizadas com este tipo de projeto.
O ambiente de execução deve usar o ambiente de tempo de execução do driver Spark principal para executar em clusters de tarefas que utilizam o Databricks Runtime 13.0 ou superior.
- Da mesma forma, todas as dependências Python definidas como necessárias para o projeto devem ser instaladas como dependências de cluster Databricks. Esse comportamento é diferente dos comportamentos de execução de projeto anteriores where bibliotecas precisavam ser instaladas em um ambiente separado.

Executar um projeto MLflow

Para executar um projeto MLflow em um cluster do Azure Databricks no espaço de trabalho padrão, use o comando:

mlflow run <uri> -b databricks --backend-config <json-new-cluster-spec>

where <uri> é um URI de repositório Git ou pasta que contém um projeto MLflow e <json-new-cluster-spec> é um documento JSON que contém uma estrutura new_cluster. O URI do Git deve ter o formato: https://github.com/<repo>#<project-folder>.

Um exemplo de especificação de cluster é:

{
  "spark_version": "7.3.x-scala2.12",
  "num_workers": 1,
  "node_type_id": "Standard_DS3_v2"
}

Se você precisar instalar bibliotecas no trabalhador, use o formato "especificação de cluster". Observe que os arquivos wheel do Python devem ser carregados no DBFS e especificados como dependências de pypi. Por exemplo:

{
  "new_cluster": {
    "spark_version": "7.3.x-scala2.12",
    "num_workers": 1,
    "node_type_id": "Standard_DS3_v2"
  },
  "libraries": [
    {
      "pypi": {
        "package": "tensorflow"
      }
    },
    {
      "pypi": {
         "package": "/dbfs/path_to_my_lib.whl"
      }
    }
  ]
}

Importante

As dependências .egg e .jar não são suportadas em projetos MLflow.
Não há suporte para a execução de projetos MLflow com ambientes Docker.
Você deve usar uma nova especificação de cluster ao executar um projeto MLflow no Databricks. Não há suporte para a execução de projetos em clusters existentes.

Usando o SparkR

Para usar o SparkR em uma execução de projeto MLflow, o código do projeto deve primeiro instalar e importar o SparkR da seguinte maneira:

if (file.exists("/databricks/spark/R/pkg")) {
    install.packages("/databricks/spark/R/pkg", repos = NULL)
} else {
    install.packages("SparkR")
}

library(SparkR)

Seu projeto pode então inicializar uma sessão do SparkR e usar o SparkR normalmente:

sparkR.session()
...

Exemplo

Este exemplo mostra como criar um experimento, executar o projeto tutorial MLflow em um cluster do Azure Databricks, exibir a saída da execução do trabalho e exibir a execução no experimento.

Requerimentos

Instale o MLflow usando pip install mlflow.
Instale e configure a CLI do Databricks. O mecanismo de autenticação da CLI do Databricks é necessário para executar trabalhos em um cluster do Azure Databricks.

Etapa 1: Criar um experimento

No espaço de trabalho, selectCriar > Experimento MLflow.
No campo Nome, digite Tutorial.
Clique Criar. Observe a ID do experimento. Neste exemplo, é 14622565.

Etapa 2: Executar o projeto tutorial MLflow

As etapas a seguir set a variável de ambiente MLFLOW_TRACKING_URI e executar o projeto, registrando o parametersde treinamento, as métricas e o modelo treinado para o experimento observado na etapa anterior:

Set a variável de ambiente MLFLOW_TRACKING_URI para o espaço de trabalho do Azure Databricks.
```
export MLFLOW_TRACKING_URI=databricks
```

Execute o projeto tutorial MLflow, treinando um modelo de vinho . Substitua <experiment-id> pelo ID do experimento que você anotou na etapa anterior.

mlflow run https://github.com/mlflow/mlflow#examples/sklearn_elasticnet_wine -b databricks --backend-config cluster-spec.json --experiment-id <experiment-id>

=== Fetching project from https://github.com/mlflow/mlflow#examples/sklearn_elasticnet_wine into /var/folders/kc/l20y4txd5w3_xrdhw6cnz1080000gp/T/tmpbct_5g8u ===
=== Uploading project to DBFS path /dbfs/mlflow-experiments/<experiment-id>/projects-code/16e66ccbff0a4e22278e4d73ec733e2c9a33efbd1e6f70e3c7b47b8b5f1e4fa3.tar.gz ===
=== Finished uploading project to /dbfs/mlflow-experiments/<experiment-id>/projects-code/16e66ccbff0a4e22278e4d73ec733e2c9a33efbd1e6f70e3c7b47b8b5f1e4fa3.tar.gz ===
=== Running entry point main of project https://github.com/mlflow/mlflow#examples/sklearn_elasticnet_wine on Databricks ===
=== Launched MLflow run as Databricks job run with ID 8651121. Getting run status page URL... ===
=== Check the run's status at https://<databricks-instance>#job/<job-id>/run/1 ===

Copie a URL https://<databricks-instance>#job/<job-id>/run/1 na última linha da saída de execução MLflow.

Etapa 3: Exibir a execução do trabalho do Azure Databricks

Abra a URL copiada na etapa anterior em um navegador para exibir a saída de execução do trabalho do Azure Databricks:

Etapa 4: Exibir o experimento e os detalhes da execução do MLflow

Navegue até o experimento em seu espaço de trabalho do Azure Databricks.
Clique no experimento.
Para exibir os detalhes da execução, clique num link na Data column.

Você pode visualizar os registos da sua corrida clicando no link Logs no campo Resultado do Trabalho.

Recursos

Para alguns exemplos de projetos MLflow, consulte o MLflow App Library, que contém um repositório de projetos prontos para execução com o objetivo de facilitar a inclusão da funcionalidade ML em seu código.

Partilhar via