Colocar as cargas de trabalho de treino em produção

Importante

Este recurso está no Public Preview.

Utilize DABs para definir uma carga de trabalho de treino do AI Runtime como código. Mantém-no em controlo de versões, implementa-o em vários ambientes, agenda-o e compõe-o com outras tarefas. Esta página aborda o caminho de trazer o seu próprio treino, onde um ai_runtime_task executa o seu próprio comando contra um diretório de código em computação GPU serverless.

Tip

  • Use Pacotes de Automação Declarativa para definir cargas de trabalho de treino como código, implementá-las em ambientes e agenda-las.
  • O ai_runtime_task executa o seu próprio comando num diretório de código (treino fornecido pelo utilizador).
  • Combine tarefas de GPU e CPU em trabalhos multitarefa.

Esta é uma tarefa diferente da execução de um notebook numa GPU sem servidor através de um pacote. Para o exemplo básico do pacote notebook-on-GPU, veja Jobs API e Declarative Automation Bundles.

Requirements

  • Um espaço de trabalho com AI Runtime ativado. Ver Requisitos.
  • A CLI (interface de linha de comandos) Databricks foi instalada e configurada para implementar bundles.

Defina uma tarefa de runtime de IA num pacote

ai_runtime_task dá nome a uma experiência, aponta para o seu código de treino com code_source_path e declara uma implantação: o comando a executar e o GPU onde o executar. Adicione-o a uma tarefa no seu pacote:

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 aponta para o seu código de treino empacotado, e command_path é o script que a tarefa executa. As tentativas, os limites de tempo e as permissões são definidos na tarefa e no trabalho da mesma forma que em qualquer trabalho do Azure Databricks, pelo que as suas práticas existentes de bundles se mantêm aplicáveis. Para saber como empacotar e referenciar o seu código, veja Enviar o seu código de treino.

ai_runtime_task campos

Field Tipo Description
experiment String Required. O nome do experimento MLflow para a execução. Ver Rastreio e observabilidade de experiências.
code_source_path String O código de treino a executar: o ficheiro de saída de um artefacto empacotado tgz, ou um caminho /Workspace ou /Volumes para código que já foi carregado. Veja Enviar o seu código de treino.
deployments Sequência Required. Uma única implementação que descreve o comando e o cálculo para o executar. Cada entrada contém command_path, compute, e um opcional name.
deployments[].command_path String Required. O script que a tarefa executa em cada nó.
deployments[].compute.accelerator_type String Required. O tipo de GPU, por exemplo GPU_1xA10, GPU_1xH100, ou GPU_8xH100.
deployments[].compute.accelerator_count Número inteiro Required. O número total de GPUs em todos os nós—um múltiplo do número por nó codificado em accelerator_type.
deployments[].name String Um nome opcional para a implementação, usado nos registos e na interface.
docker_image_url String Uma imagem Docker personalizada opcional para executar o comando, em vez do ambiente gerido. Veja Usar imagens Docker personalizadas.
mlflow_run String Um nome de exibição opcional para a execução MLflow.
mlflow_experiment_directory String Um diretório opcional de espaço de trabalho sob o qual o experimento é criado. Deve começar com /Workspace. Defina isto ao executar como um service principal que não tem um diretório do utilizador predefinido.
mlflow_artifact_location String Uma localização raiz opcional para artefactos MLflow, por exemplo, um caminho /Volumes/<catalog>/<schema>/<volume>/…. Deve corresponder à localização do artefacto de um experimento existente ou ser omitido.

Defina as tentativas, os tempos limite, as permissões e o ambiente (environment_key) na tarefa e no job — não dentro de ai_runtime_task. Para a referência completa da tarefa, veja a tarefa em tempo de execução de IA.

Configurar o acelerador de hardware

Defina accelerator_type para a GPU de que precisa a carga de trabalho e accelerator_count para o número total de GPUs. A contagem é um múltiplo do número de GPUs por nó: 1 para GPU_1xA10 e GPU_1xH100, e 8 para GPU_8xH100. Uma contagem maior do que o tamanho por nó executa a tarefa em vários nós — por exemplo, GPU_8xH100 com accelerator_count: 16 execuções em dois nós. Para orientações sobre a escolha de um acelerador, consulte Opções de Hardware.

Note

Para execuções multinó, o AI Runtime executa o seu comando em cada nó e define as variáveis de ambiente padrão de treino distribuído no ambiente da tarefa—NUM_NODES, WORLD_SIZE, LOCAL_WORLD_SIZE, MASTER_ADDR e MASTER_PORT. Lê-as a partir do teu comando (por exemplo, um torchrun lançamento); não as defines no pacote.

Definir o ambiente e as dependências

Declare um bloco environments na tarefa agendada e referencie-o a partir da tarefa com environment_key. O AI Runtime instala as dependências listadas antes da execução do seu comando:

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

Para os ambientes disponíveis, veja Configurar o seu ambiente.

Envie o seu código de treino

code_source_path Diz à tarefa onde está o teu código de treino. Assume uma de duas formas:

  • Um artefacto empacotado tgz — declare um artefacto e aponte code_source_path para o seu ficheiro de saída. O Azure Databricks gera o tarball e carrega-o para databricks bundle deploy. É assim que se envia código a partir de um diretório de projeto local ou de uma revisão Git comprometida.
  • Um caminho de espaço de trabalho ou de volume — código que já foi carregado, utilizado tal como está.

Artefacto embalado

Declare um tgz artefacto e aponte code_source_path para o respetivo ficheiro de saída. Em databricks bundle deploy, a CLI constrói o tarball, carrega-o, e a tarefa extrai-o e executa o teu comando contra ele:

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

Use include para empacotar ficheiros da sua árvore de trabalho, ou git para fazer snapshots de um branch ou commit confirmado.

Caminho de espaço de trabalho ou de volume

Para usar código já carregado, defina code_source_path para um caminho /Workspace/… ou /Volumes/…. Azure Databricks usa o caminho as-is e não empacota nada.

Os tgz campos de artefactos:

Field Description
type tgz constrói um tarball com gzip a partir dos ficheiros fonte, em vez de executar um build comando.
path O diretório base para criar o pacote. include os caminhos e os nomes das entradas do arquivo são relativos a ele.
include Uma lista de subcaminhos de path para embalar. Omitir da embalagem de todos os path. Honras .gitignore; o pacote completo sync.include e sync.exclude não se aplicam. Alternativa a um build comando.
git Faz snapshot de um ref Git comprometido em vez da árvore de trabalho. Defina git.branch ou git.commit (commit tem prioridade quando estiverem ambos definidos). Alternativa a um build comando.
files[].source O caminho da bola de alcatrão construída. Aponte code_source_path para aqui.

Note

O AI Runtime extrai o seu código para um diretório e expõe-o como variável CODE_SOURCE_PATH de ambiente. Referencia-o a partir do teu comando para que os caminhos relativos se resolvam, por exemplo cd "$CODE_SOURCE_PATH" , antes de executares o teu script.

Exemplo completo

Este exemplo treina numa única GPU A10 a partir de um projeto local, sem qualquer configuração prévia de CLI para além da instalação e configuração da CLI do Azure Databricks. O projeto tem três ficheiros:

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

command.sh é o ponto de entrada nomeado por command_path. Muda para o diretório de código extraído e executa o script de treino:

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

databricks.yml atribui um nome ao bundle, empacota src/ como um tgz artefacto, executa-o como um ai_runtime_task, instala numpy no ambiente da tarefa e define destinos de desenvolvimento e de produção:

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

Instala o pacote e executa a tarefa. databricks bundle deploy constrói e carrega o tgz artefacto e cria o trabalho; databricks bundle run inicia-o:

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

Construir fluxos de trabalho multitarefa

An ai_runtime_task é uma tarefa de job do Azure Databricks, pelo que se integra com o resto da tarefa. Podes executar um passo de preparação antes do treino, combinar tarefas de GPU e CPU num só trabalho, e usar aceleradores diferentes por tarefa.

Ordenar tarefas com depends_on

Use depends_on para executar tarefas em sequência. O pipeline seguinte executa um caderno de preparação, depois uma tarefa de treino da GPU que só começa após o sucesso da tarefa de preparação:

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

Combinar tarefas de GPU e CPU

No pipeline acima, só a etapa de treino precisa de uma GPU. Manter trabalhos não relacionados com a GPU, como a preparação de dados, em tarefas separadas mantém o tempo da GPU focado no treino.

Note

An ai_runtime_task não suporta valores de tarefas do Azure Databricks ({{tasks.<task_key>.values.<name>}} ou dbutils.jobs.taskValues). Para passar dados entre etapas, grave-os numa localização partilhada a que ambas as tarefas possam aceder, como um volume do Unity Catalog ou um ficheiro no espaço de trabalho, e refira esse caminho em cada tarefa.

Agenda a carga de trabalho

Adiciona um schedule ao trabalho para que seja executado com regularidade. Envia o cronograma pausado para que a implementação do pacote não inicie as execuções sozinhas, depois despausa-o quando estiveres pronto:

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

Passar de desenvolvimento para produção

A promoção de desenvolvimento para produção é uma funcionalidade padrão do pacote que a tarefa AI Runtime herda sem alterações.

Destinos e modos do pacote

Defina um objetivo de produção mode: production a par do seu objetivo de desenvolvimento. O alvo controla onde o pacote é implantado e como os seus recursos são nomeados:

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

Desdobrar e executar

Implante e execute o pacote contra um alvo com os comandos padrão do bundle:

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

Passos seguintes

  • Last updated on