Exécuter des projets MLflow sur Azure Databricks

Remarque

Les projets MLflow ne sont plus pris en charge.

Cette documentation a été supprimée et peut ne pas être mise à jour. Les produits, services ou technologies mentionnés dans ce contenu ne sont plus pris en charge.

Un projet MLflow est un format permettant d’empaqueter du code de science des données de manière réutilisable et reproductible. Le composant Projets MLflow inclut une API et des outils en ligne de commande pour l’exécution de projets, qui s’intègrent également au composant Tracking pour enregistrer automatiquement les paramètres et la validation Git de votre code source pour la reproductibilité.

Cet article décrit le format d’un projet MLflow et comment exécuter un projet MLflow à distance sur des clusters Azure Databricks à l’aide de l’interface CLI MLflow, ce qui facilite la mise à l’échelle verticale de votre code de science des données.

Format du projet MLflow

Tout répertoire local ou référentiel Git peut être traité comme un projet MLflow. Les conventions suivantes définissent un projet :

  • Le nom du projet est le nom du répertoire.
  • L’environnement logiciel est spécifié dans python_env.yaml, le cas échéant. Si aucun fichier n’est python_env.yaml présent, MLflow utilise un environnement virtualenv contenant uniquement Python (en particulier, la dernière version de Python disponible pour virtualenv) lors de l’exécution du projet.
  • Tout .py ou .sh fichier du projet peut être un point d’entrée, sans paramètres explicitement déclarés. Lorsque vous exécutez une telle commande avec un ensemble de paramètres, MLflow transmet chaque paramètre sur la ligne de commande à l’aide --key <value> de la syntaxe.

Vous spécifiez d’autres options en ajoutant un fichier MLproject, qui est un fichier texte dans la syntaxe YAML. Un exemple de fichier MLproject ressemble à ceci :

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

Pour Databricks Runtime 13.0 ML et versions ultérieures, les projets MLflow ne peuvent pas s’exécuter correctement dans un cluster de type de travail Databricks. Pour migrer des projets MLflow existants vers Databricks Runtime 13.0 ML et versions ultérieures, consultez le format du projet de travail MLflow Databricks Spark.

Format du projet de travail MLflow Databricks Spark

Le projet de travail MLflow Databricks Spark est un type de projet MLflow introduit dans MLflow 2.14. Ce type de projet prend en charge l’exécution de projets MLflow à partir d’un cluster de travaux Spark et ne peut uniquement être exécuté avec le backend databricks.

Les projets Databricks Spark doivent définir soit databricks_spark_job.python_file soit entry_points. Ne pas spécifier ni spécifier les deux paramètres déclenche une exception.

Voici un exemple de MLproject fichier qui utilise le databricks_spark_job.python_file paramètre. Ce paramètre implique l’utilisation d’un chemin codé en dur pour le fichier d’exécution Python et ses arguments.

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

Voici un exemple de MLproject fichier qui utilise le entry_points paramètre :

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

Le entry_points paramètre vous permet de transmettre des paramètres qui utilisent des params de ligne de commande, comme :

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

Les limitations suivantes s’appliquent aux projets de travail Databricks Spark :

  • Ce type de projet ne prend pas en charge la spécification des sections suivantes dans le MLproject fichier : docker_env, python_envou conda_env.
  • Les dépendances de votre projet doivent être spécifiées dans le python_libraries champ de la databricks_spark_job section. Les versions de Python ne peuvent pas être personnalisées avec ce type de projet.
  • L’environnement en cours d’exécution doit utiliser l’environnement d’exécution du pilote Spark principal pour s’exécuter dans des clusters de travaux qui utilisent Databricks Runtime 13.0 ou version ultérieure.
    • De même, toutes les dépendances Python définies comme requises pour le projet doivent être installées en tant que dépendances de cluster Databricks. Ce comportement est différent des exécutions de projets précédentes où les bibliothèques devaient être installées dans un environnement distinct.

Exécuter un projet MLflow

Pour exécuter un projet MLflow sur un cluster Azure Databricks dans l’espace de travail par défaut, utilisez la commande :

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

où <uri> est un URI de référentiel Git ou un dossier contenant un projet MLflow et <json-new-cluster-spec> est un document JSON contenant une structure new_cluster. L’URI Git doit être de la forme suivante : https://github.com/<repo>#<project-folder>.

Voici un exemple de spécification de cluster :

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

Si vous devez installer des bibliothèques sur le worker, utilisez le format « spécification du cluster ». Notez que les fichiers de roue Python doivent être chargés dans DBFS et spécifiés en tant que pypi dépendances. Par exemple:

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

Important

  • .egg et .jar dépendances ne sont pas prises en charge pour les projets MLflow.
  • L’exécution pour les projets MLflow avec des environnements Docker n’est pas prise en charge.
  • Vous devez utiliser une nouvelle spécification de cluster lors de l’exécution d’un projet MLflow sur Databricks. L’exécution de projets sur des clusters existants n’est pas prise en charge.

Utilisation de SparkR

Pour utiliser SparkR dans une exécution de projet MLflow, votre code de projet doit d’abord installer et importer SparkR comme suit :

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

library(SparkR)

Votre projet peut ensuite initialiser une session SparkR et utiliser SparkR comme étant normal :

sparkR.session()
...

Exemple

Cet exemple montre comment créer une expérience, exécuter le projet de didacticiel MLflow sur un cluster Azure Databricks, afficher la sortie de l’exécution du travail et afficher l’exécution dans l’expérience.

Spécifications

  1. Installez MLflow en utilisant pip install mlflow.
  2. Installez et configurez l’interface CLI Databricks. Le mécanisme d’authentification De l’interface CLI Databricks est nécessaire pour exécuter des travaux sur un cluster Azure Databricks.

Étape 1 : Créer une expérience

  1. Dans l’espace de travail, sélectionnez Créer une > expérience MLflow.

  2. Dans le champ Nom, entrez Tutorial.

  3. Cliquez sur Créer. Notez l’ID d’expérience. Dans cet exemple, il s’agit de 14622565.

    Identifiant d’expérience

Étape 2 : Exécuter le projet de didacticiel MLflow

Les étapes suivantes configurent la MLFLOW_TRACKING_URI variable d’environnement et exécutent le projet, en enregistrant les paramètres d’entraînement, les métriques et le modèle entraîné dans l’expérience notée à l’étape précédente :

  1. Définissez la variable d’environnement MLFLOW_TRACKING_URI sur l’espace de travail Azure Databricks.

    export MLFLOW_TRACKING_URI=databricks

  2. Exécutez le projet de didacticiel MLflow, en formant un modèle de vin. Remplacez <experiment-id> par l’ID d’expérience que vous avez noté à l’étape précédente.

    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. Copiez l’URL https://<databricks-instance>#job/<job-id>/run/1 dans la dernière ligne de la sortie d’exécution MLflow.

Étape 3 : Consulter l’exécution d’un processus Azure Databricks

  1. Ouvrez l’URL que vous avez copiée à l’étape précédente dans un navigateur pour afficher la sortie d’exécution du travail Azure Databricks :

    Résultat d'exécution de tâche

Étape 4 : Afficher les détails de l’expérience et de l’exécution MLflow

  1. Accédez à l’expérience dans votre espace de travail Azure Databricks.

    Accéder à l’expérience

  2. Cliquez sur l'expérience.

    Afficher une expérience

  3. Pour afficher les détails de l’exécution, cliquez sur un lien dans la colonne Date.

    Détails de l’exécution

Vous pouvez afficher les logs à partir de votre exécution en cliquant sur le lien Logs dans le champ Résultat du travail.

Ressources

Pour obtenir des exemples de projets MLflow, consultez la bibliothèque d’applications MLflow, qui contient un référentiel de projets prêts à l’exécution visant à faciliter l’intégration des fonctionnalités ML dans votre code.

  • Last updated on