Gör träningsarbetsbelastningar produktionsklara

Important

Den här funktionen finns som allmänt tillgänglig förhandsversion.

Använd DABs för att definiera en träningsarbetsbelastning för AI Runtime som kod. Spara det i versionshanteringen, distribuera det mellan miljöer, schemalägg det och kombinera det med andra uppgifter. Den här sidan behandlar sökvägen bring-your-own-training, där en ai_runtime_task kör ditt eget kommando på en katalog med kod på serverlösa GPU-beräkningsresurser.

Tip

  • Använd Deklarative Automation Bundles för att definiera träningsarbetsbelastningar som kod, distribuera dem över miljöer och schemalägga dem.
  • ai_runtime_task kör ditt eget kommando på en kodkatalog (bring-your-own-training).
  • Kombinera GPU- och CPU-uppgifter i multitask-jobb.

Detta är en annan uppgift än att köra en bärbar dator på serverlös GPU via ett paket. För det grundläggande exemplet med paketet notebook-on-GPU, se Schemalägg med Jobs API och deklarativa automationspaket.

Requirements

  • En arbetsyta med AI Runtime aktiverat. Se Krav.
  • Databricks CLI (kommandoradsgränssnitt) installerades och konfigurerades för att distribuera paket.

Definiera en AI-runtime-uppgift i ett paket

En ai_runtime_task namnger ett experiment, pekar på din träningskod med code_source_path och anger en driftsättning: kommandot som ska köras och GPU:n den ska köras på. Lägg till det i ett jobb i ditt paket:

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 pekar på din paketerade träningskod, och command_path är skriptet som aktiviteten kör. Omförsök, tidsgränser och behörigheter anges för uppgiften och jobbet på samma sätt som för andra Azure Databricks-jobb, så dina befintliga rutiner för bundles kan återanvändas. För hur du paketerar och refererar din kod, se Skicka din träningskod.

ai_runtime_task Fält

Fält Type Description
experiment String Required. MLflow-experimentets namn för körningen. Se Experimentspårning och observerbarhet.
code_source_path String Den träningskod som ska köras: utdatafilen från ett paketerat tgz-artefakt, eller en sökväg av typen /Workspace eller /Volumes till kod som redan har laddats upp. Se Skicka din träningskod.
deployments Sekvens Required. En enda distribution som beskriver kommandot och beräkningen som ska köras på. Varje post innehåller command_path, compute, och ett valfritt name.
deployments[].command_path String Required. Skriptet som uppgiften kör på varje nod.
deployments[].compute.accelerator_type String Required. GPU-typen, till exempel GPU_1xA10, GPU_1xH100, eller GPU_8xH100.
deployments[].compute.accelerator_count Integer Required. Det totala antalet GPU:er över alla noder – en multipel av antalet per nod kodat i accelerator_type.
deployments[].name String Ett valfritt namn för distributionen, som används i loggar och gränssnittet.
docker_image_url String En valfri anpassad Docker-image för att köra kommandot i, istället för den hanterade miljön. Se Använda anpassade Docker-avbildningar.
mlflow_run String Ett valfritt visningsnamn för MLflow-körningen.
mlflow_experiment_directory String En valfri arbetsytkatalog under vilken experimentet skapas. Måste börja med /Workspace. Ange detta när du kör som en tjänsteprincip som inte har någon standardkatalog för användare.
mlflow_artifact_location String En valfri rotplats för MLflow-artefakter, till exempel en /Volumes/<catalog>/<schema>/<volume>/… väg. Måste överensstämma med platsen för artefakter för ett befintligt experiment eller utelämnas.

Ställ in omförsök, tidsgränser, behörigheter och miljön (environment_key) på uppgiften och jobbet – inte i ai_runtime_task. För fullständig uppgiftsreferens, se AI Runtime-uppgiften.

Konfigurera hårdvaruacceleratorn

Ställ in accelerator_type till det grafikkort din arbetsbelastning behöver, och accelerator_count till det totala antalet grafikkort. Antalet är en multipel av antalet GPU:er per nod: 1 för GPU_1xA10 och GPU_1xH100, och 8 för GPU_8xH100. Ett antal som är större än storleken per nod kör uppgiften på flera noder – till exempel körs GPU_8xH100 med accelerator_count: 16 på två noder. För vägledning om val av accelerator, se Hårdvarualternativ.

Note

För körningar med flera noder kör AI Runtime ditt kommando på varje nod och fyller i de standardiserade variablerna för distribuerad träningsmiljö i uppgiftsmiljön—NUM_NODES, , WORLD_SIZE, LOCAL_WORLD_SIZEMASTER_ADDR, , och MASTER_PORT. Läs dem via ditt kommando (till exempel en torchrun-start); du anger dem inte i paketet.

Konfigurera miljö och beroenden.

Deklarera ett environments block på jobbet och referera till det från uppgiften med environment_key. AI Runtime installerar de listade beroendena innan ditt kommando körs:

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

För tillgängliga miljöer, se Sätt upp din miljö.

Skicka din träningskod

code_source_path Berätta för uppgiften var din träningskod finns. Den har en av två former:

  • En paketerad tgz artefakt — deklarera en artefakt och peka code_source_path på dess utdatafil. Azure Databricks bygger tarballen och laddar upp den på databricks bundle deploy. Det är så du skickar kod från en lokal projektkatalog eller en dedikerad Git-revision.
  • En arbetsyta eller volymsökväg — kod som redan har laddats upp och används som den är.

Paketerad artefakt

Deklarera en tgz artefakt och låt code_source_path peka på dess utdatafil. På databricks bundle deploy, bygger CLI tarballen, laddar upp den, och uppgiften extraherar den och kör ditt kommando mot den:

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

Använd include för att paketera filer från ditt arbetsträd, eller git för att ta en snapshot av en committed branch eller commit.

Arbetsyta eller volymväg

För att använda kod som redan är uppladdad, ställ code_source_path in en /Workspace/… eller /Volumes/… sökväg. Azure Databricks använder sökvägen i befintligt skick och skapar inget paket.

Fälten för tgz-artefakten:

Fält Description
type tgz bygger en gzip-komprimerad tarball från källfiler, i stället för att köra ett build-kommando.
path Baskatalogen till paketet. include sökvägar och namnen på arkivets poster är relativa till den.
include En lista över delsökvägar i path som ska paketeras. Utelämna hela path från paketeringen. Tar hänsyn till .gitignore; de paketomfattande sync.include och sync.exclude gäller inte. Alternativ till ett build kommando.
git Skapa en ögonblicksbild av en incheckad Git-referens i stället för arbetskatalogen. Sätt git.branch eller git.commit (commit vinner när båda är satta). Alternativ till ett build kommando.
files[].source Vägen för den byggda tarballen. Peka på detta med code_source_path.

Note

AI Runtime extraherar din kod till en katalog och exponerar den som CODE_SOURCE_PATH miljövariabeln. Referera till det från ditt kommando så att relativa vägar löses, till exempel cd "$CODE_SOURCE_PATH" innan du kör ditt skript.

Fullständigt exempel

Detta exempel tränas på en enda A10-GPU från ett lokalt projekt, utan någon tidigare CLI-uppsättning utöver installation och konfiguration av Azure Databricks CLI. Projektet har tre filer:

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

command.sh är ingångspunkten som namnges av command_path. Den byter till den extraherade kodkatalogen och kör träningsskriptet:

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

databricks.yml namnger paketet, paketerar src/ som en tgz-artefakt, kör det som en ai_runtime_task, installerar numpy i aktivitetsmiljön och definierar utvecklings- och produktionsmål:

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

Distribuera paketet och kör jobbet. databricks bundle deploy bygger och laddar tgz upp artefakten och skapar jobbet; databricks bundle run startar det:

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

Bygg multitask-arbetsflöden

En ai_runtime_task är en jobbaktivitet i Azure Databricks, så den fungerar tillsammans med övriga delar av ett jobb. Du kan köra ett förberedelsesteg innan utbildning, kombinera GPU- och CPU-uppgifter i ett jobb och använda olika acceleratorer per uppgift.

Ordna uppgifter med depends_on

Använd det depends_on för att köra uppgifter i följd. Följande pipeline kör en förberedelseanteckningsbok och sedan en GPU-träningsuppgift som startar först efter att förberedelseuppgiften lyckats:

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

Kombinera GPU- och CPU-uppgifter

I pipelinen ovan behöver endast träningssteget en GPU. Att hålla icke-GPU-arbete som dataförberedelse i separata uppgifter håller GPU-tiden fokuserad på träning.

Note

En ai_runtime_task stöder inte Azure Databricks-värden för jobbuppgifter ({{tasks.<task_key>.values.<name>}} eller dbutils.jobs.taskValues). För att överföra data mellan steg skriver du data till en gemensam plats som båda uppgifterna kan läsa, till exempel en Unity Catalog-volym eller en arbetsytefil, och anger den sökvägen i varje uppgift.

Schemalägg arbetsbördan

Lägg till ett schedule till jobbet för att köra det enligt ett schema. Leverera schemat i pausat läge så att driftsättning av paketet inte startar körningar automatiskt, och aktivera det igen när du är redo:

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

Främja från utveckling till produktion

Befordran från utveckling till produktion är en standardfunktion som AI Runtime-uppgiften ärver oförändrad.

Paketmål och lägen

Definiera ett produktionsmål vid sidan av ditt utvecklingsmål mode: production Målet styr var paketet distribueras och hur dess resurser namnges:

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

Driftsätta och köra

Driftsätt och kör paketet på ett målsystem med standardkommandona för paket:

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

Nästa steg

  • Last updated on