Képzési feladatok gyártása

Important

Ez a funkció nyilvános előzetes verzióban van.

Használja a DAB-eket egy AI Runtime tanítási munkaterhelés kódként való meghatározásához. Tartsd verziókezelőben, telepítsd több környezetbe, ütemezd, és kombináld más feladatokkal. Ez az oldal a saját betanítási útvonalat ismerteti, amelyben a(z) ai_runtime_task a saját parancsodat futtatja egy kódokat tartalmazó könyvtáron, szerver nélküli GPU-s számítási környezetben.

Ez más feladat, mint egy notebookot szerver nélküli GPU-n futtatni egy csomagon keresztül. Az alapvető notebook-on-GPU bundle példáért lásd: Jobs API és Declarative Automation Bundles.

Requirements

  • Egy munkaterület, ahol AI Runtime engedélyezve. Lásd: Követelmények.
  • A Databricks CLI (parancssori interfész) telepítve és konfigurálva csomagok telepítésére.

Definiáljunk egy AI Runtime feladatot egy csomagban

A ai_runtime_task elnevez egy kísérletet, a code_source_path segítségével a betanítási kódra mutat, és meghatároz egy üzembe helyezést: a futtatandó parancsot és a GPU-t, amelyen fut. Add hozzá a csomagodban lévő feladathoz:

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 a csomagolt betanítási kódra mutat, command_path pedig a feladat által futtatott szkript. Az újrapróbálkozások, az időkorlátok és a jogosultságok ugyanúgy állíthatók be a feladaton és a munkán, mint bármely más Azure Databricks-munka esetében, így a meglévő bundle-gyakorlataid itt is alkalmazhatók. A kódod csomagolásáról és hivatkozásáról lásd: Ship your training code.

ai_runtime_task Mezők

Field Típus Description
experiment Lánc Required. Az MLflow kísérlet neve a futásnak. Lásd : Kísérleti követés és megfigyelhetőség.
code_source_path Lánc A futtatandó betanítási kód: egy becsomagolt tgz-összetevő kimeneti fájlja, vagy a már feltöltött kód /Workspace- vagy /Volumes-elérési útja. Lásd: A betanítási kód szállítása.
deployments Sequence Required. Egyetlen telepítés, amely leírja a parancsot és a futtatandó számítást. Minden bejegyzés tartalmaz command_path, compute, és egy opcionális name.
deployments[].command_path Lánc Required. A küldetés minden csomópontján futó szkript.
deployments[].compute.accelerator_type Lánc Required. A GPU típusa, például GPU_1xA10, GPU_1xH100, vagy GPU_8xH100.
deployments[].compute.accelerator_count Egész szám Required. Az összes csomóponton lévő GPU-k teljes száma — a(z) accelerator_type elemben kódolt csomópontonkénti darabszám többszöröse.
deployments[].name Lánc Opcionális név a telepítésre, amelyet a naplókban és a UI-ban használnak.
docker_image_url Lánc Egy opcionális egyedi Docker kép, amelyben a parancsot futtathatod, nem pedig a kezelt környezetben. Lásd: Egyéni Docker-rendszerképek használata.
mlflow_run Lánc Az MLflow futamhoz opcionális megjelenítési név.
mlflow_experiment_directory Lánc Egy opcionális munkaterület-könyvtár, amely alatt a kísérlet jön létre. Ezzel kell kezdődnie: /Workspace. Ezt akkor állítsd be, amikor szolgáltatásfőként futsz, amelynek nincs alapértelmezett felhasználói könyvtára.
mlflow_artifact_location Lánc Az MLflow-artefaktumok opcionális gyökérhelye, például egy /Volumes/<catalog>/<schema>/<volume>/… elérési út. Meg kell egyeznie egy meglévő kísérlet műtárgy helyével, különben ki kell hagyni.

Állítsd be az újrapróbálkozásokat, az időkorlátokat, a jogosultságokat és a környezetet (environment_key) a feladaton és a munkán — ne a ai_runtime_task belül. A teljes feladat referencia érdekében lásd: AI Runtime feladat.

Konfiguráld a hardveres gyorsítót

Állítsd accelerator_type be a GPU-t, amire a terhelésed szükséges, és accelerator_count a GPU-k teljes számát. A darabszám a csomópontonkénti GPU-k számának többszöröse: 1 a(z) GPU_1xH100 és GPU_1xA10 esetén, valamint 8 a(z) GPU_8xH100 esetén. Egy csomópontonkénti méretnél nagyobb szám több csomóponton futtatja le a feladatot – például GPU_8xH100accelerator_count: 16 két csomóponton fut. A gyorsító kiválasztásához vonatkozó útmutatásért lásd a Hardver opciókat.

Note

Többcsomópontos futtatások esetén az AI Runtime minden csomóponton futtatja a parancsodat, és feltölti a szabványos elosztott képzési környezeti változókat a feladatkörnyezetben—NUM_NODES, WORLD_SIZE, MASTER_ADDRLOCAL_WORLD_SIZE, és MASTER_PORT. Ezeket a parancsból olvassa ki (például egy torchrun indításból); nem a csomagban állítja be őket.

Állítsuk be a környezetet és a függőségeket

Definiálj egy environments blokkot a jobon, és hivatkozz rá a feladatból a environment_key használatával. Az AI Runtime telepíti a felsorolt függőségeket, mielőtt a parancsod elindulna:

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

Az elérhető környezetekről lásd a A környezet beállítása című részt.

Küldd el a kiképzési kódodat

code_source_path Megmondja a feladatnak, hol van a képzési kódod. Két formában létezik:

  • Csomagolt tgz artefaktum — deklaráljon egy artefaktumot, és irányítsa code_source_path a kimeneti fájljára. Az Azure Databricks létrehozza a tar-archívumot, és feltölti a(z) databricks bundle deploy helyre. Így küldheted a kódot egy helyi projektkönyvtárból vagy egy elkötelezett Git revizionból.
  • Egy munkaterület vagy kötet elérési útja — már feltöltött kód, amelyet változtatás nélkül használnak.

Csomagolt tárgy

Deklarálj egy tgz artifaktumot, és irányítsd code_source_path a kimeneti fájljára. A -kor databricks bundle deploya CLI megépíti a tarballt, feltölti, és a feladat kinyeri, majd a parancsodat futtatja ellene:

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

Használd a(z) include parancsot a fájlok csomagolásához a munkakönyvtárból, vagy a(z) git parancsot egy véglegesített ágról vagy kommitról való pillanatkép készítéséhez.

Munkaterület vagy térfogat út

A már feltöltött kód használatához állítsa a(z) code_source_path értékét egy /Workspace/… vagy /Volumes/… elérési útra. Azure Databricks használja az as-is útvonalat, és semmit sem csomagol.

A(z) tgz összetevő mezői:

Field Description
type tgz gzip-pel tömörített tar archívumot készít a forrásfájlokból a build parancs futtatása helyett.
path A csomagolandó alapkönyvtár. include az elérési utak és az archívum bejegyzéseinek nevei ehhez viszonyítva relatívak.
include A csomagolandó path részútvonalainak listája. Hagyd ki az összes path csomagolását. Figyelembe veszi a .gitignore elemet; a teljes csomagra vonatkozó sync.include és sync.exclude nem alkalmazható. Alternatíva a build parancs helyett.
git Készítsen pillanatképet egy commitolt Git-hivatkozásról a munkafa helyett. A szett git.branch vagy git.commit (commit nyer, ha mindkettő be van állítva). Alternatíva a build parancs helyett.
files[].source Az épített tarball ösvénye. Erre mutass code_source_path .

Note

Az AI Runtime kihúzza a kódodat egy könyvtárba, és környezeti változóként teszi ki CODE_SOURCE_PATH . Hivatkozz rá a parancsodból, hogy a relatív utak megoldódjanak, például cd "$CODE_SOURCE_PATH" a szkript futtatása előtt.

Teljes példa

Ez a példa egy helyi projektből indulva egyetlen A10 GPU-n tréningez, az Azure Databricks CLI telepítésén és konfigurálásán kívül nem igényel előzetes CLI-beállítást. A projektnek három fájlja van:

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

A command.sh a command_path által megadott belépési pont. Átalakul a kibontott kódkönyvtárba, és elindítja a képzési szkriptet:

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

databricks.yml elnevezi a csomagot, a(z) src/ elemet tgz-artefaktumként csomagolja, azt ai_runtime_task-ként futtatja, telepíti a(z) numpy elemet a feladatkörnyezetben, és meghatározza a fejlesztési és produkciós célokat:

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

Telepítsd a csomagot és futtasd a feladatot. databricks bundle deploy felépíti és feltölti az tgz erektét, és létrehozza a feladatot; databricks bundle run elindítja:

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

Több feladatos munkafolyamatok építése

A(z) ai_runtime_task egy Azure Databricks-feladat, így a feladat többi részével együtt alkot egészet. A képzés előtt futtathatsz egy előkészítő lépést, kombinálhatod a GPU és CPU feladatokat egy munkában, és különböző gyorsítókat használhatsz feladatonként.

Feladatok rendezése depends_on szerint

A feladatok egymás utáni futtatásához használja a depends_on elemet. A következő csővezeték egy előkészítő jegyzetfüzetet, majd egy GPU kiképzési feladatot futtat, amely csak a felkészülési feladat sikeres sikere után indul:

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

GPU és CPU feladatok kombinálása

A fenti pipeline-ban csak a képzési lépéshez kell GPU. Ha nem GPU-s feladatokat, például az adat-előkészítést külön feladatokban tartjuk, a GPU ideje a képzésre fókuszál.

Note

An ai_runtime_task nem támogatja az Azure Databricks munkafeladat értékeit ({{tasks.<task_key>.values.<name>}} vagy dbutils.jobs.taskValues). Az adatok átadásához a lépések között írjuk azokat egy közös helyre, ahol mindkét feladat olvasható, például egy Unity Catalog kötetre vagy egy munkaterületi fájlra, és hivatkozz arra az útra minden feladatból.

Ütemezze a munkaterhelést

Adj a feladathoz egy schedule elemet, hogy ütemezetten fusson. Telepítsd az ütemezést szüneteltetett állapotban, hogy a csomag telepítése ne indítson el futásokat automatikusan, majd oldd fel a szüneteltetést, amikor készen állsz:

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

Fejlesztéstől gyártásig való előrelépés

A fejlesztéstől a gyártásig való előléptetés egy szabványos csomagfunkció, amelyet az AI Runtime feladat változatlanul örököl.

Csomag célpontok és módok

Határozz meg egy produkciós célt a fejlesztési cél mellé mode: production. A célpont szabályozza, hol telepítik a csomagot, és hogyan nevezik el az erőforrásokat:

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

Üzembe helyezés és futtatás

Telepítsd és futtasd a csomagot egy célpont ellen a szabványos csomag parancsokkal:

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

Következő lépések

  • Last updated on