Mise en production des charges de travail d’entraînement

Important

Cette fonctionnalité est disponible en préversion publique.

Utilisez DABs pour définir sous forme de code une charge de travail d’entraînement pour AI Runtime. Gardez-le sous contrôle de version, déployez-le sur différents environnements, planifiez-le et combinez-le à d’autres tâches. Cette page décrit la procédure d’entraînement personnalisé, dans laquelle ai_runtime_task exécute votre propre commande à partir d’un répertoire de code sur une infrastructure de calcul GPU sans serveur.

C’est une tâche différente de celle de faire tourner un notebook sur une carte graphique serverless via un bundle. Pour l’exemple de base du pack notebook-on-GPU, voir API de jobs et bundles d’automatisation déclarative.

Requirements

  • Un espace de travail avec le Runtime IA activé. Consultez Spécifications.
  • La ligne de commande (CLI) Databricks (interface en ligne) s’installait et configurait pour déployer des bundles.

Définissez une tâche d’exécution IA dans un ensemble

An ai_runtime_task nomme une expérience, pointe votre code d’entraînement avec code_source_path, et déclare un déploiement : la commande à exécuter et la carte graphique sur laquelle l’exécuter. Ajoutez cette offre d’emploi à votre pack :

resources:
  jobs:
    train:
      tasks:
        - task_key: train
          ai_runtime_task:
            experiment: my-experiment
            code_source_path: ./dist/code.tgz
            deployments:
              - command_path: ./command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1

code_source_path pointe vers votre code d’entraînement emballé, et command_path c’est le script que la tâche exécute. Les nouvelles tentatives, les délais d’attente et les autorisations sont définis sur la tâche et le job de la même manière que pour n’importe quel job Azure Databricks ; vos pratiques existantes pour les bundles restent donc valables. Pour savoir comment emballer et référencer votre code, voir Envoyer votre code d’entraînement.

Champs ai_runtime_task

Champ Type Description
experiment Chaîne Required. Le nom de l’expérience MLflow pour l’exécution. Voir Suivi et observabilité de l’expérience.
code_source_path Chaîne Le code d’entraînement à exécuter : le fichier généré d’un artefact tgz empaqueté, ou un chemin /Workspace ou /Volumes vers du code déjà téléversé. Voir Envoyer votre code de formation.
deployments Série Required. Un seul déploiement décrivant la commande et le calcul sur lequel l’exécuter. Chaque entrée contient command_path, compute et un name facultatif.
deployments[].command_path Chaîne Required. Le script sur lequel la tâche s’exécute sur chaque nœud.
deployments[].compute.accelerator_type Chaîne Required. Le type de GPU, par exemple GPU_1xA10, GPU_1xH100, ou GPU_8xH100.
deployments[].compute.accelerator_count Integer Required. Le nombre total de GPU sur tous les nœuds — un multiple du nombre par nœud encodé dans accelerator_type.
deployments[].name Chaîne Un nom optionnel pour le déploiement, utilisé dans les journaux et l’interface utilisateur.
docker_image_url Chaîne Une image Docker personnalisée optionnelle pour exécuter la commande, au lieu de l’environnement géré. Consultez Utiliser des images Docker personnalisées.
mlflow_run Chaîne Nom d’affichage facultatif pour l’exécution MLflow.
mlflow_experiment_directory Chaîne Un répertoire d’espace de travail optionnel sous lequel l’expérience est créée. Doit commencer par /Workspace. Réglez cela lors de l’exécution en tant que principal de service sans repertoire utilisateur par défaut.
mlflow_artifact_location Chaîne Un emplacement racine facultatif pour les artefacts MLflow, par exemple un chemin /Volumes/<catalog>/<schema>/<volume>/…. Doit correspondre à l’emplacement de l’artefact d’une expérience existante ou être omis.

Définissez les nouvelles tentatives, les délais d’attente, les autorisations et l’environnement (environment_key) sur la tâche et le travail — pas à l’intérieur de ai_runtime_task. Pour la référence complète de la tâche, voir Tâche d’exécution IA.

Configurez l’accélérateur matériel

Réglez accelerator_type sur la charge de travail dont vous avez besoin, et accelerator_count sur le nombre total de GPU. Le nombre est un multiple du nombre de GPU par nœud : 1 pour GPU_1xA10 et GPU_1xH100, et 8 pour GPU_8xH100. Un nombre supérieur à la taille par nœud exécute la tâche sur plusieurs nœuds — par exemple, GPU_8xH100 avec accelerator_count: 16 s’exécute sur deux nœuds. Pour des conseils sur le choix d’un accélérateur, voir Options matérielles.

Note

Pour les exécutions sur plusieurs nœuds, AI Runtime exécute votre commande sur chaque nœud et renseigne les variables d’environnement standard pour l’entraînement distribué dans l’environnement de la tâche — NUM_NODES, WORLD_SIZE, LOCAL_WORLD_SIZE, MASTER_ADDR et MASTER_PORT. Lisez-les à partir de votre commande (par exemple, lors d’un torchrun lancement) ; vous ne les définissez pas dans le bundle.

Définir l’environnement et les dépendances

Déclarez un bloc environments sur le job et faites-y référence depuis la tâche avec environment_key. AI Runtime installe les dépendances listées avant que votre commande ne s’exécute :

resources:
  jobs:
    train:
      tasks:
        - task_key: train
          environment_key: default
          ai_runtime_task:
            # experiment, code_source_path, and deployments as above
      environments:
        - environment_key: default
          spec:
            environment_version: '5'
            dependencies:
              - numpy

Pour les environnements disponibles, voir Configurer votre environnement.

Envoyez votre code d’entraînement

code_source_path indique à la tâche où se trouve votre code d’entraînement. Elle prend l’une des deux formes suivantes :

  • Un artefact empaqueté tgz — déclarez un artefact et pointez code_source_path vers son fichier de sortie. Azure Databricks génère l’archive tar et la charge sur databricks bundle deploy. C’est ainsi que vous envoyez du code depuis un annuaire de projet local ou une révision Git engagée.
  • Un chemin d’espace de travail ou de volume — code déjà téléchargé, utilisé as-is.

Artefact emballé

Déclarez un tgz artefact et pointez code_source_path vers son fichier de sortie. Sur databricks bundle deploy, la CLI crée l’archive tar, la télécharge, puis la tâche l’extrait et exécute votre commande sur celle-ci :

artifacts:
  code:
    type: tgz
    path: .
    include: [src]
    files:
      - source: ./dist/code.tgz
resources:
  jobs:
    train:
      tasks:
        - task_key: train
          ai_runtime_task:
            code_source_path: ./dist/code.tgz

Utilisez include pour empaqueter les fichiers de votre arborescence de travail, ou git pour créer un instantané d’une branche ou d’un commit validé.

Chemin de l’espace de travail ou du volume

Pour utiliser du code déjà téléversé, définissez code_source_path sur un chemin /Workspace/… ou /Volumes/…. Azure Databricks utilise le chemin tel quel et n’empaquette rien.

Les champs d’artefact tgz :

Champ Description
type tgz crée une archive tar compressée avec gzip à partir de fichiers sources, au lieu d’exécuter la commande build.
path Le répertoire de base à empaqueter. include les chemins et les noms des entrées de l’archive sont relatifs à celle-ci.
include Une liste des sous-chemins de path à empaqueter. Omettre l’empaquetage de l’ensemble de path. Respecte .gitignore ; les sync.include et sync.exclude à l’échelle du lot ne s’appliquent pas. Alternative à une build commande.
git Faites un instantané d’une référence Git engagée au lieu de l’arbre de travail. Définissez git.branch ou git.commit (commit prévaut lorsque les deux sont définis). Alternative à une build commande.
files[].source Le chemin du bitume construit. Pointez code_source_path vers ceci.

Note

L’exécution IA extrait votre code dans un répertoire et l’expose comme variable d’environnement CODE_SOURCE_PATH . Référencez-le depuis votre commande pour que les chemins relatifs se résolvent, par exemple cd "$CODE_SOURCE_PATH" avant d’exécuter votre script.

Exemple complet

Cet exemple s’entraîne sur un seul GPU A10 depuis un projet local, sans configuration préalable de la CLI au-delà de l’installation et de la configuration de la CLI Azure Databricks. Le projet comprend trois fichiers :

my-training/
├── databricks.yml
├── command.sh
└── src/
    └── train.py

command.sh est le point d’entrée nommé par command_path. Il se transforme dans le répertoire de code extrait et exécute le script d’entraînement :

#!/usr/bin/env bash
set -euo pipefail
cd "$CODE_SOURCE_PATH"
python train.py

databricks.yml nomme le bundle, empaquette src/ en tant qu’artefact tgz, l’exécute en tant que ai_runtime_task, installe numpy dans l’environnement de tâche, et définit des cibles de développement et de production :

bundle:
  name: my-training

artifacts:
  code:
    type: tgz
    path: .
    include: [src]
    files:
      - source: ./dist/code.tgz

resources:
  jobs:
    train:
      name: my-training
      tasks:
        - task_key: train
          environment_key: default
          ai_runtime_task:
            experiment: /Users/me@example.com/my-training
            code_source_path: ./dist/code.tgz
            deployments:
              - command_path: ./command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1
      environments:
        - environment_key: default
          spec:
            environment_version: '5'
            dependencies:
              - numpy

targets:
  dev:
    mode: development
    default: true
  prod:
    mode: production

Déployez le package et exécutez la tâche. databricks bundle deploy construit et télécharge l’artefact tgz et crée le travail ; databricks bundle run le lance :

databricks bundle deploy --target dev
databricks bundle run train --target dev

Construire des flux de travail multitâches

Un ai_runtime_task est une tâche de job Azure Databricks, il s’intègre donc au reste d’un job. Vous pouvez effectuer une étape de préparation avant la formation, combiner les tâches GPU et CPU dans un même poste, et utiliser différents accélérateurs par tâche.

Commander des tâches avec depends_on

Utilisez depends_on pour exécuter des tâches en séquence. Le pipeline suivant exécute un carnet de préparation, puis une tâche d’entraînement GPU qui ne commence qu’après le succès de la tâche de préparation :

resources:
  jobs:
    train_pipeline:
      tasks:
        - task_key: prep
          notebook_task:
            notebook_path: ./prep.py
        - task_key: train
          depends_on:
            - task_key: prep
          ai_runtime_task:
            experiment: my-experiment
            code_source_path: ./dist/code.tgz
            deployments:
              - command_path: ./command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1

Combinez les tâches GPU et CPU

Dans le pipeline ci-dessus, seule l’étape d’entraînement nécessite un GPU. Garder le travail non lié au GPU, comme la préparation des données, dans des tâches séparées permet de concentrer le temps GPU sur l’entraînement.

Note

ai_runtime_task ne prend pas en charge les valeurs de tâche de travail Azure Databricks ({{tasks.<task_key>.values.<name>}} ou dbutils.jobs.taskValues). Pour transmettre les données entre les étapes, écrivez-les dans un emplacement partagé que les deux tâches peuvent lire, comme un volume Unity Catalog ou un fichier workspace, et référez ce chemin depuis chaque tâche.

Planifiez la charge de travail

Ajoutez un schedule à la tâche pour l’exécuter à intervalles réguliers. Envoiez le planning en pause pour que le déploiement du bundle ne démarre pas seul, puis remettez le programme en pause quand vous êtes prêt :

resources:
  jobs:
    train_pipeline:
      schedule:
        quartz_cron_expression: '0 0 9 * * ?'
        timezone_id: UTC
        pause_status: PAUSED

Promotion du développement à la production

La promotion du développement vers la production est une fonctionnalité standard du bundle dont la tâche AI Runtime hérite telle quelle.

Cibles et modes de regroupement

Définissez un objectif de production en mode: production parallèle avec votre objectif de développement. La cible contrôle où le paquet est déployé et comment ses ressources sont nommées :

targets:
  dev:
    mode: development
    default: true
  prod:
    mode: production

Déployer et exécuter des applications

Déployez et exécutez le bundle sur une cible avec les commandes bundle standard :

databricks bundle deploy --target dev
databricks bundle run train_pipeline --target dev

Étapes suivantes

  • Last updated on