Aller au contenu principal
Dernière mise à jour le

Mettez en production les charges de travail d'entraînement

info

Aperçu

Cette fonctionnalité est en Aperçu public.

Utilisez DABs pour définir une charge de travail d’entraînement AI Runtime sous forme de code. Conservez-le dans le contrôle des sources, déployez-le dans tous les environnements, planifiez-le et associez-le à d’autres tâches. Cette page présente la méthode d’entraînement personnalisée (« bring-your-own-training »), dans laquelle un ai_runtime_task exécute votre propre commande sur un répertoire de code sur un compute GPU serverless.

Il s’agit d’une tâche différente de l’exécution d’un notebook sur un GPU serverless via un bundle. Pour un exemple de base de bundle avec notebook sur GPU, consultez Jobs API et Declarative Automation Bundles.

Configuration requise​

  • Un workspace avec AI Runtime activé. Consultez Requirements.
  • La CLI Databricks (interface en ligne de commande) installée et configurée pour déployer des bundles.

Définir une tâche AI Runtime dans un bundle​

Un ai_runtime_task nomme un Experimentation, pointe vers votre code d'entraînement avec code_source_path, et déclare un déploiement : la commande à exécuter et le GPU sur lequel l'exécuter. Ajoutez-le à un Job dans votre bundle :

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

command_path correspond au script exécuté par la tâche. Les nouvelles tentatives, les délais d’expiration 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 Databricks ; vos pratiques de bundle actuelles restent donc applicables.

Configurez l'accélérateur matériel​

Définissez accelerator_type sur le GPU dont votre charge de travail a besoin, et accelerator_count sur le nombre total de GPU. Le décompte est un multiple du nombre de GPU par nœud : 1 pour GPU_1xA10 et GPU_1xH100, et 8 pour GPU_8xH100. Un décompte 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 obtenir des conseils sur le choix d’un accélérateur, consultez les options matérielles.

remarque

Pour les exécutions multi-nœuds, AI Runtime exécute votre commande sur chaque nœud et renseigne les variables d’environnement d’entraînement distribué standard 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, un lancement torchrun) ; 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. Runtime installe les dépendances répertoriées avant l'exécution de votre commande :

YAML
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, consultez Set up your environment.

Livrez votre code d’entraînement​

code_source_path indique à la tâche où se trouve votre code d’entraînement. Il accepte trois formulaires :

  • Un répertoire local — le CLI le package et l’upload sur databricks bundle deploy. Il s’agit de la forme la plus simple et de celle que les exemples ci-dessus utilisent.
  • Un artéfact tgz explicite — vous déclarez vous-même l’artéfact et pointez vers son fichier de sortie. Utilisez cette option lorsque vous devez packager uniquement un sous-ensemble de fichiers ou créer un instantané d’une révision Git validée au lieu de votre arbre de travail.
  • Un chemin de Workspace ou de volume — code déjà upload, utilisé tel quel.

Pointez code_source_path vers un répertoire. Sur databricks bundle deploy, la CLI compresse le répertoire en package, effectue l’upload, puis la tâche l’extrait et exécute votre commande sur celui-ci :

YAML
code_source_path: ./src
remarque

AI Runtime extrait votre code dans un répertoire et l’expose en tant que variable d’environnement CODE_SOURCE_PATH. Référencez-le à partir de votre commande pour que les chemins relatifs soient résolus, par exemple cd "$CODE_SOURCE_PATH" avant d’exécuter votre script.

Créer des flux de travail multi-tâches​

Un ai_runtime_task est une tâche de job Databricks ; il s’intègre donc au reste d’un job. Vous pouvez exécuter une étape de préparation avant l’entraînement, combiner des tâches GPU et CPU dans un même job et utiliser différents accélérateurs par tâche.

Ordonnez les tâches avec depends_on​

Utilisez depends_on pour exécuter des tâches en séquence. Le pipeline suivant exécute un Notebook de préparation, puis une tâche d’entraînement sur GPU qui ne start qu’une fois la tâche de préparation terminée avec succès :

YAML
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: ./src
            deployments:
              - command_path: ./command.sh
                compute:
                  accelerator_type: GPU_1xA10
                  accelerator_count: 1

Associer des tâches GPU et CPU​

Dans le pipeline ci-dessus, seule l’étape d’entraînement nécessite un GPU. Confier les tâches sans GPU, telles que la préparation des données, à des tâches distinctes permet de consacrer le temps GPU à l’entraînement.

remarque

Un ai_runtime_task ne prend pas en charge les valeurs de tâche de job Databricks ({{tasks.<task_key>.values.<name>}} ou dbutils.jobs.taskValues). Pour transférer des données entre les étapes, écrivez-les dans un emplacement partagé que les deux tâches peuvent lire, tel qu'un volume Unity Catalog ou un fichier de workspace, et faites référence à cet chemin depuis chaque tâche.

Programmer la charge de travail​

Ajoutez un schedule au job pour l’exécuter à intervalle régulier. Déployez le planning en mode suspendu afin que le déploiement du bundle ne start pas les exécutions de manière autonome, puis réactivez-le lorsque vous êtes prêt :

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

Passer du développement à la production​

La promotion du développement à la production est une fonctionnalité standard du bundle que la tâche AI Runtime hérite sans modification.

Cibles et modes de bundle​

Définissez une cible de production avec mode: production en même temps que votre cible de développement. La cible contrôle l'endroit où le bundle se déploie et la façon dont ses Ressources sont nommées :

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

Déployez et exécutez​

Déployez et exécutez le bundle sur une cible à l’aide des commandes de bundle standard :

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

Étapes suivantes​

Sur cette page