Portare in produzione i carichi di lavoro di training

Importante

Questa funzionalità è in Anteprima Pubblica.

Usa DABs per definire come codice un carico di lavoro di training di AI Runtime. Mantienilo nel controllo del codice sorgente, distribuiscilo in tutti gli ambienti, pianificalo e integralo con altri task. Questa pagina descrive il flusso bring-your-own-training, in cui un ai_runtime_task esegue il tuo comando su una directory di codice sorgente su risorse di calcolo serverless con GPU.

Tip

  • Usa i Declarative Automation Bundles per definire i carichi di lavoro di addestramento come codice, distribuili tra diversi ambienti e programmarli.
  • Il ai_runtime_task esegue il tuo comando su una directory contenente codice (bring-your-own-training).
  • Combina compiti di GPU e CPU in lavori multitasking.

Si tratta di un'operazione diversa dall'eseguire un notebook su una GPU serverless tramite un bundle. Per l'esempio base del pacchetto notebook-on-GPU, vedi Schedule with the Jobs API e Declarative Automation Bundles.

Requirements

  • Uno spazio di lavoro con l'AI Runtime abilitato. Vedi requisiti.
  • La CLI (interfaccia a riga di comando) di Databricks è installata e configurata per distribuire bundle.

Definisci un compito di esecuzione AI in un bundle

Un ai_runtime_task assegna un nome a un esperimento, punta al tuo codice di addestramento con code_source_path e dichiara un deployment: il comando da eseguire e la GPU su cui eseguirlo. Aggiungilo a un lavoro nel tuo bundle:

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 indica il tuo codice di addestramento confezionato, ed command_path è lo script che il compito esegue. I tentativi, i timeout e le autorizzazioni vengono impostati sull'attività e sul processo allo stesso modo di qualsiasi altro processo di Azure Databricks, quindi le procedure esistenti relative ai bundle continuano ad applicarsi. Per informazioni su come creare il pacchetto del tuo codice e fare riferimento ad esso, vedi Distribuisci il tuo codice di training.

Campi ai_runtime_task

Campo TIPO Description
experiment Stringa Required. Il nome dell'esperimento MLflow per l'esecuzione. Vedi Tracciamento e osservabilità degli esperimenti.
code_source_path Stringa Il codice di addestramento da eseguire: il file di output di un artefatto pacchettizzato tgz, oppure un percorso /Workspace o /Volumes del codice già caricato. Vedi Invia il tuo codice di addestramento.
deployments Sequenza Required. Un singolo deployment che descrive il comando e le risorse di calcolo su cui eseguirlo. Ogni voce contiene command_path, compute, e un opzionale name.
deployments[].command_path Stringa Required. Lo script che fa eseguire il compito su ogni nodo.
deployments[].compute.accelerator_type Stringa Required. Il tipo di GPU, ad esempio GPU_1xA10, GPU_1xH100, o GPU_8xH100.
deployments[].compute.accelerator_count Numero intero Required. Il numero totale di GPU su tutti i nodi—un multiplo del conteggio per nodo codificato in accelerator_type.
deployments[].name Stringa Un nome opzionale per la distribuzione, usato nei log e nell'interfaccia utente.
docker_image_url Stringa Un'immagine Docker personalizzata opzionale per eseguire il comando, invece dell'ambiente gestito. Vedere Usare immagini Docker personalizzate.
mlflow_run Stringa Un nome di visualizzazione opzionale per l'esecuzione MLflow.
mlflow_experiment_directory Stringa Una directory opzionale dello spazio di lavoro sotto cui viene creato l'esperimento. Deve iniziare con /Workspace. Imposta questo quando si esegue come principale di servizio senza una directory utente predefinita.
mlflow_artifact_location Stringa Un percorso radice facoltativo per gli artefatti di MLflow, ad esempio un percorso /Volumes/<catalog>/<schema>/<volume>/…. Deve corrispondere alla posizione dell'artefatto di un esperimento esistente o essere omesso.

Imposta tentativi, timeout, autorizzazioni e l'ambiente (environment_key) nell'attività e nel job, non all'interno di ai_runtime_task. Per il riferimento completo al compito, vedi compito AI Runtime.

Configura l'acceleratore hardware

Imposta accelerator_type la GPU di cui hai bisogno e accelerator_count il numero totale di GPU. Il conteggio è un multiplo del numero di GPU per nodo: 1 per GPU_1xA10 e GPU_1xH100, e 8 per GPU_8xH100. Un numero superiore alla dimensione per nodo esegue l’attività su più nodi; ad esempio, GPU_8xH100 con accelerator_count: 16 viene eseguito su due nodi. Per indicazioni sulla scelta di un acceleratore, vedi Opzioni hardware.

Note

Per le esecuzioni su più nodi, AI Runtime esegue il comando su ogni nodo e imposta nell'ambiente dell'attività le variabili d'ambiente standard per l'addestramento distribuito: NUM_NODES, WORLD_SIZE, LOCAL_WORLD_SIZE, MASTER_ADDR e MASTER_PORT. Leggili dal tuo comando (ad esempio, un torchrun lancio); non li imposti nel bundle.

Impostare l'ambiente e le dipendenze

Dichiara un environments blocco sul lavoro e riferiscilo dal compito con environment_key. AI Runtime installa le dipendenze elencate prima che il comando venga eseguito:

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: '6'
            dependencies:
              - numpy

Per gli ambienti disponibili, vedi Configura il tuo ambiente.

Invia il tuo codice di formazione

code_source_path indica al task dove si trova il tuo codice di training. Assume una di due forme:

  • Un artefatto tgz pacchettizzato — dichiara un artefatto e punta code_source_path al relativo file di output. Azure Databricks compila il tarball e lo carica su databricks bundle deploy. Ecco come distribuire il codice da una directory del progetto locale o da una revisione Git di cui è stato eseguito il commit.
  • Un percorso di spazio di lavoro o di volume — codice già caricato, usato as-is.

Artefatto confezionato

Definisci un artefatto tgz e indirizza code_source_path al file di output corrispondente. Su databricks bundle deploy, la CLI compila il tarball, lo carica, e il task lo estrae ed esegue il tuo comando su di esso:

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

Usa include per creare un pacchetto di file dalla tua directory di lavoro, oppure git per creare un'istantanea di un branch sottoposto a commit o di un commit.

Percorso dello spazio di lavoro o del volume

Per usare codice già caricato, imposta code_source_path su un percorso /Workspace/… o /Volumes/…. Azure Databricks usa il percorso as-is e non impacchetta nulla.

I campi tgz dell’artefatto:

Campo Description
type tgz crea un archivio tar compresso con gzip dai file sorgente, invece di eseguire il comando build.
path La directory di base per creare il pacchetto. include i percorsi e i nomi degli elementi dell'archivio sono relativi a esso.
include Elenco dei sottopercorsi di path da includere nel pacchetto. Omettere di confezionare tutti i path. Onori .gitignore; l'intero sync.include fascio e sync.exclude non si applicano. Alternativa a un build comando.
git Crea uno snapshot di un riferimento Git con commit invece che della directory di lavoro. Set git.branch o git.commit (commit vince quando entrambi sono set). Alternativa a un build comando.
files[].source Il percorso del tarball generato. Punta code_source_path verso questo.

Note

AI Runtime estrae il tuo codice in una cartella e lo rende disponibile come variabile d'ambiente CODE_SOURCE_PATH. Riferisciti a esso nel comando in modo che i percorsi relativi vengano risolti correttamente, ad esempio cd "$CODE_SOURCE_PATH" prima di eseguire il tuo script.

Esempio completo

Questo esempio si allena su una singola GPU A10 da un progetto locale, senza alcuna configurazione precedente della CLI oltre all'installazione e configurazione della CLI di Azure Databricks. Il progetto comprende tre file:

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

command.sh è il punto d'ingresso denominato da command_path. Passa alla directory del codice estratto ed esegue lo script di addestramento:

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

databricks.yml denomina il bundle, impacchetta src/ come artefatto tgz, lo esegue come un ai_runtime_task, installa numpy nell'ambiente del task e definisce target di sviluppo e produzione:

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: '6'
            dependencies:
              - numpy

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

Distribuisci il bundle ed esegui il lavoro. databricks bundle deploy costruisce e carica l'artefatto tgz e crea il lavoro; databricks bundle run lo avvia:

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

Crea flussi di lavoro multi-attività

An ai_runtime_task è un'attività di un processo di Azure Databricks, quindi si integra con il resto del processo. Puoi eseguire un passaggio di preparazione prima dell'addestramento, combinare compiti GPU e CPU in un unico lavoro e usare acceleratori diversi per ogni attività.

Ordina le attività con depends_on

Usarlo depends_on per eseguire i compiti in sequenza. La seguente pipeline esegue un notebook di preparazione, poi un compito di addestramento GPU che inizia solo dopo che il compito di preparazione ha avuto successo:

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

Combina i compiti di GPU e CPU

Nella pipeline sopra, solo il passaggio di addestramento richiede una GPU. Mantenere il lavoro non legato alla GPU, come la preparazione dei dati, in compiti separati mantiene il tempo della GPU concentrato sull'addestramento.

Note

Un ai_runtime_task non supporta i valori delle attività del processo di Azure Databricks ({{tasks.<task_key>.values.<name>}} o dbutils.jobs.taskValues). Per passare i dati tra i passaggi, scrivili in una posizione condivisa che entrambe le attività possano leggere, ad esempio un volume di Unity Catalog o un file dell'area di lavoro, e fai riferimento a tale percorso da ciascuna attività.

Organizza il carico di lavoro

Aggiungi un schedule al processo per eseguirlo a intervalli regolari. Pubblica la pianificazione in pausa, in modo che la distribuzione del bundle non avvii automaticamente le esecuzioni, quindi riattivala quando sei pronto:

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

Promuovere dallo sviluppo alla produzione

La promozione dallo sviluppo alla produzione è una funzionalità standard del bundle che l'attività AI Runtime eredita senza modifiche.

Target e modalità del pacchetto

Definisci un obiettivo di produzione mode: production assieme al tuo obiettivo di sviluppo. Il target controlla dove il bundle viene distribuito e come le sue risorse sono denominate:

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

Implementare ed eseguire

Distribuisci ed esegui il bundle su una destinazione con i comandi standard del bundle:

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

Passaggi successivi

  • Last updated on