Condividi tramite

Eseguire progetti MLflow in Azure Databricks

  • Articolo

Avviso

I progetti MLflow non sono più supportati.

Un progetto MLflow è un formato che permette la creazione di pacchetti di codice di data science in modo riutilizzabile e riproducibile. Il componente progetti MLflow include un'API e utilità da riga di comando per l'esecuzione di progetti, che si integrano anche con il componente di rilevamento per registrare automaticamente i parametri e il commit Git del codice sorgente per la riproducibilità.

Questo articolo descrive il formato di un progetto MLflow e come eseguire un progetto MLflow da remoto nei cluster di Azure Databricks usando la CLI di MLflow, che semplifica la scalabilità verticale del codice di data science.

Formato del progetto MLflow

Qualsiasi directory locale o repository Git è da considerarsi come un progetto MLflow. Le seguenti convenzioni definiscono un progetto:

  • Il nome del progetto corrisponde al nome della directory.
  • L'ambiente software, se presente, è specificato in python_env.yaml. Se non è presente alcun file python_env.yaml, MLflow usa un ambiente virtualenv contenente solo Python (in particolare, la versione più recente di Python disponibile per virtualenv) durante l'esecuzione del progetto.
  • Qualsiasi file .py o .sh nel progetto può essere un punto di ingresso, senza parametri dichiarati in modo esplicito. Quando si esegue un comando di questo tipo con un set di parametri, MLflow passa ogni parametro nella riga di comando usando la sintassi --key <value>.

È possibile specificare altre opzioni aggiungendo un file MLproject, ovvero un file di testo nella sintassi YAML. Un file MLproject di esempio è simile al seguente:

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}"

Per Databricks Runtime 13.0 ML e versioni successive, i progetti MLflow non possono essere eseguiti correttamente all'interno di un cluster con tipo di processo Databricks. Per eseguire la migrazione di progetti MLflow esistenti a Databricks Runtime 13.0 ML e versioni successive, vedere Formato del progetto di processo MLflow Databricks Spark.

Formato del progetto di processo MLflow Databricks Spark

Il progetto di processo MLflow Databricks Spark è un tipo di progetto MLflow introdotto in MLflow 2.14. Questo tipo di progetto supporta l'esecuzione di progetti MLflow dall'interno di un cluster di processi di Spark e può essere eseguito solo usando il back-end databricks.

I progetti di processo Databricks Spark devono impostare databricks_spark_job.python_file o entry_points. Se non si specificano o si specificano entrambe le impostazioni, viene generata un'eccezione.

Di seguito è riportato un esempio di file MLproject che utilizza l'impostazione databricks_spark_job.python_file. Questa impostazione prevede l'uso di un percorso hardcoded per il file di esecuzione python e i relativi argomenti.

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

Di seguito è riportato un esempio di file MLproject che utilizza l'impostazione 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}"

L'impostazione entry_points consente di passare parametri che utilizzano params della riga di comando, ad esempio:

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

Per i progetti di processo Databricks Spark si applicano le seguenti limitazioni:

  • Questo tipo di progetto non supporta la specifica delle sezioni seguenti nel file MLproject: docker_env, python_envo conda_env.
  • Le dipendenze per il progetto devono essere specificate nel campo python_libraries della sezione databricks_spark_job. Le versioni di Python non possono essere personalizzate con questo tipo di progetto.
  • L'ambiente in esecuzione deve usare l'ambiente di runtime del driver Spark principale per l'esecuzione in cluster di processi che usano Databricks Runtime 13.0 o versione successiva.
    • Analogamente, tutte le dipendenze Python definite come necessarie per il progetto devono essere installate come dipendenze del cluster Databricks. Questo comportamento è diverso dai comportamenti di esecuzione del progetto precedenti in cui le librerie dovevano essere installate in un ambiente separato.

Eseguire un progetto MLflow

Per eseguire un progetto MLflow in un cluster Azure Databricks nell'area di lavoro predefinita, usare il comando :

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

dove <uri> è un URI o una cartella del repository Git contenente un progetto MLflow e <json-new-cluster-spec> è un documento JSON contenente una struttura new_cluster. Il formato dell'URI del Git deve essere https://github.com/<repo>#<project-folder>.

Una specifica del cluster di esempio è:

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

Se è necessario installare librerie nel ruolo di lavoro, usare il formato "specifica del cluster". Si noti che i file wheel python devono essere caricati in DBFS e specificati come dipendenze pypi. Ad esempio:

{
  "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

  • Le dipendenze .egg e .jar non sono supportate per i progetti MLflow.
  • L'esecuzione per i progetti MLflow con ambienti Docker non è supportata.
  • È necessario usare una nuova specifica del cluster quando si esegue un progetto MLflow in Databricks. L'esecuzione di progetti su cluster esistenti non è supportata.

Uso di SparkR

Per usare SparkR nell'esecuzione di un progetto MLflow, il codice del progetto deve prima installare e importare SparkR come indicato di seguito:

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

library(SparkR)

Il progetto può quindi inizializzare una sessione SparkR e usare SparkR come di consueto:

sparkR.session()
...

Esempio

Questo esempio illustra come creare un esperimento, eseguire il progetto di esercitazione MLflow in un cluster Azure Databricks, visualizzare l'output dell'esecuzione del processo e visualizzare l'esecuzione nell'esperimento.

Requisiti

  1. Installare MLflow usando pip install mlflow.
  2. Installare e configurare la CLI di Databricks. Il meccanismo di autenticazione della CLI di Databricks è necessario per eseguire processi in un cluster di Azure Databricks.

Passaggio 1: creare un esperimento

  1. Nell'area di lavoro selezionare Crea esperimento > di MLflow.

  2. Nel campo Nome immettere Tutorial.

  3. Cliccare su Crea. Prendere nota dell'ID esperimento. In questo esempio si tratta di 14622565.

    ID esperimento

Passaggio 2: eseguire il progetto di esercitazione di MLflow

I passaggi seguenti configurano la variabile di ambiente MLFLOW_TRACKING_URI ed eseguono il progetto, registrano i parametri di training, le metriche e il modello sottoposto a training nell'esperimento annotato nel passaggio precedente:

  1. Impostare la variabile di ambiente MLFLOW_TRACKING_URI sull'area di lavoro di Azure Databricks.

    export MLFLOW_TRACKING_URI=databricks

  2. Eseguire il progetto di esercitazione MLflow ed eseguire il training di un modello di vino. Sostituire <experiment-id> con l'ID esperimento annotato nel passaggio precedente.

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

  3. Copiare l'URL https://<databricks-instance>#job/<job-id>/run/1 nell'ultima riga di output dell'esecuzione di MLflow.

Passaggio 3: visualizzare l'esecuzione del processo di Azure Databricks

  1. Aprire l'URL copiato nel passaggio precedente in un browser per visualizzare l'output dell'esecuzione del processo di Azure Databricks:

    Output dell'esecuzione del processo

Passaggio 4: visualizzare i dettagli dell'esperimento e dell'esecuzione di MLflow

  1. Passare all'esperimento nell'area di lavoro di Azure Databricks.

    Andare all'esperimento

  2. Cliccare sull'esperimento.

    Visualizzare l'esperimento

  3. Per visualizzare i dettagli dell'esecuzione, fare clic su un collegamento nella colonna Data.

    Dettagli esecuzione

È possibile visualizzare i log dall'esecuzione cliccando sul collegamento Log nel campo Output del processo.

Risorse

Per alcuni progetti MLflow di esempio, vedere la libreria di app di MLflow, che contiene un repository di progetti pronti per l'esecuzione volti a semplificare l'inclusione delle funzionalità ML nel codice.