Llevar las cargas de trabajo de entrenamiento a producción

Importante

Esta característica está en versión preliminar pública.

Utiliza DABs para definir una carga de trabajo de entrenamiento en tiempo de ejecución de IA como código. Mantenlo en un sistema de control de versiones, desplégalo en distintos entornos, prográmalo y compónlo con otras tareas. Esta página trata sobre la ruta de trae tu propio entrenamiento, en la que un ai_runtime_task ejecuta tu propio comando sobre un directorio de código en un entorno de proceso de GPUs sin servidor.

Tip

  • Utiliza Paquetes de Automatización Declarativa para definir cargas de trabajo de entrenamiento como código, desplegarlas en diferentes entornos y programarlas.
  • El ai_runtime_task ejecuta tu propio comando en un directorio de código (con tu propio entrenamiento).
  • Combina tareas de GPU y CPU en trabajos multitarea.

Esta es una tarea distinta de la de ejecutar un cuaderno en una GPU sin servidor mediante un paquete. Para el ejemplo básico del paquete notebook-on-GPU, véase Schedule with the Jobs API y Declarative Automation Bundles.

Requirements

  • Un espacio de trabajo con AI Runtime activado. Ver Requisitos.
  • La CLI de Databricks (interfaz de línea de comandos) se instaló y configuró para desplegar paquetes.

Defina una tarea de tiempo de ejecución de IA en un paquete

An ai_runtime_task nombra un experimento, señala tu código de entrenamiento con code_source_path, y declara un despliegue: el comando para ejecutarlo y la GPU para ejecutarlo. Añádelo a una tarea de tu paquete:

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 apunta a tu código de entrenamiento empaquetado, y command_path es el script que ejecuta la tarea. Los reintentos, los tiempos de espera y los permisos se configuran en la tarea y el trabajo de la misma forma que en cualquier trabajo de Azure Databricks, por lo que tus prácticas actuales de paquetes siguen siendo aplicables. Para saber cómo empaquetar y referenciar tu código, consulta Enviar tu código de entrenamiento.

Campos ai_runtime_task

Campo Tipo Description
experiment String Required. El nombre del experimento de MLflow para la ejecución. Consulta Seguimiento y observabilidad de experimentos.
code_source_path String El código de entrenamiento que se va a ejecutar: el archivo de salida de un artefacto tgz empaquetado, o una ruta /Workspace o /Volumes al código que ya se ha cargado. Consulta Envía tu código de formación.
deployments Secuencia Required. Un único despliegue que describa el comando y el cálculo para ejecutarlo. Cada entrada contiene command_path, compute, y un opcional name.
deployments[].command_path String Required. El script que la tarea ejecuta en cada nodo.
deployments[].compute.accelerator_type String Required. El tipo de GPU, por ejemplo GPU_1xA10, GPU_1xH100, o GPU_8xH100.
deployments[].compute.accelerator_count Entero Required. El número total de GPUs en todos los nodos—un múltiplo del conteo por nodo codificado en accelerator_type.
deployments[].name String Un nombre opcional para el despliegue, usado en los registros y la interfaz.
docker_image_url String Una imagen Docker opcional personalizada para ejecutar el comando, en lugar del entorno gestionado. Consulte Uso de imágenes personalizadas de Docker.
mlflow_run String Un nombre de visualización opcional para la ejecución MLflow.
mlflow_experiment_directory String Un directorio opcional de espacio de trabajo bajo el cual se crea el experimento. Debe comenzar con /Workspace. Configúralo cuando se ejecute como un principal de servicio que no tenga directorio de usuario predeterminado.
mlflow_artifact_location String Una ubicación raíz opcional para los artefactos de MLflow, por ejemplo, una ruta /Volumes/<catalog>/<schema>/<volume>/…. Debe coincidir con la ubicación del artefacto de un experimento existente o ser omitido.

Configura los reintentos, los tiempos de espera, los permisos y el entorno (environment_key) en la tarea y el trabajo, no dentro de ai_runtime_task. Para la referencia completa de la tarea, véase tarea en tiempo de ejecución de IA.

Configurar el acelerador de hardware

Ajusta accelerator_type a la GPU que requiere tu carga de trabajo y accelerator_count al número total de GPU. El recuento es un múltiplo del número de GPUs por nodo: 1 para GPU_1xA10 y GPU_1xH100, y 8 para GPU_8xH100. Una cantidad superior al tamaño por nodo hace que la tarea se ejecute en varios nodos; por ejemplo, GPU_8xH100 con accelerator_count: 16 se ejecuta en dos nodos. Para orientación sobre la elección de un acelerador, consulte Opciones de hardware.

Nota:

Para ejecuciones multi-nodo, AI Runtime ejecuta tu comando en cada nodo y completa las variables estándar del entorno de entrenamiento distribuido en el entorno de tareas—NUM_NODES, WORLD_SIZE, LOCAL_WORLD_SIZE, MASTER_ADDR, y MASTER_PORT. Léelos desde tu comando (por ejemplo, un torchrun lanzamiento); no se configuran en el paquete.

Establecer el entorno y las dependencias

Define un bloque environments en el trabajo y haz referencia a él desde la tarea con environment_key. AI Runtime instala las dependencias listadas antes de que se ejecute tu 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 los entornos disponibles, consulta Configurar tu entorno.

Envía tu código de entrenamiento

code_source_path Indica a la tarea dónde está tu código de entrenamiento. Adopta una de dos formas:

  • Un artefacto tgz empaquetado: declara un artefacto y señala code_source_path su archivo de salida. Azure Databricks construye el tarball y lo sube en databricks bundle deploy. Así es como se envía código desde un directorio local de proyectos o una revisión Git confirmada.
  • Un espacio de trabajo o ruta de volumen — código que ya está subido, usado as-is.

Artefacto empaquetado

Define un tgz artefacto y haz que code_source_path apunte a su archivo de salida. En databricks bundle deploy, la CLI construye el tarball, lo sube y la tarea lo extrae y ejecuta tu comando contra él:

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

Utiliza include para empaquetar archivos de tu árbol de trabajo, o git para crear una instantánea de una rama o una confirmación.

Ruta del espacio de trabajo o del volumen

Para utilizar código que ya está cargado, establece code_source_path en una ruta /Workspace/… o /Volumes/…. Azure Databricks usa la ruta tal cual y no empaqueta nada.

Los campos del tgz artefacto:

Campo Description
type tgz crea un archivo tar comprimido con gzip a partir de archivos de origen, en lugar de ejecutar el comando build.
path El directorio base para empaquetar. include Las rutas y los nombres de entrada del archivo son relativos a él.
include Una lista de subrutas de path que se van a empaquetar. Omítela para empaquetar todo path. Respeta .gitignore; los valores sync.include y sync.exclude aplicables a todo el paquete no se tienen en cuenta. Alternativa a un build comando.
git Crea una instantánea de una referencia Git confirmada en lugar del árbol de trabajo. Establece git.branch o git.commit (commit prevalece cuando ambos están establecidos). Alternativa a un build comando.
files[].source La ruta del archivo tar generado. Apunta code_source_path a esta ruta.

Nota:

AI Runtime extrae tu código a un directorio y lo expone como la CODE_SOURCE_PATH variable de entorno. Haz referencia a ello en tu comando para que las rutas relativas se resuelvan, por ejemplo cd "$CODE_SOURCE_PATH", antes de ejecutar tu script.

Ejemplo completo

Este ejemplo entrena en una única GPU A10 de un proyecto local, sin configuración previa de CLI más allá de instalar y configurar la CLI de Azure Databricks. El proyecto tiene tres archivos:

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

command.sh es el punto de entrada nombrado por command_path. Cambia al directorio de código extraído y ejecuta el script de entrenamiento:

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

databricks.yml nombra el paquete, empaqueta src/ como un tgz artefacto, lo ejecuta como un ai_runtime_task, se instala numpy en el entorno de tareas y define objetivos de desarrollo y producción:

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

Despliega el paquete y ejecuta la tarea. databricks bundle deploy construye y sube el tgz artefacto y crea el trabajo; databricks bundle run lo inicia:

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

Crear flujos de trabajo multitarea

Un ai_runtime_task es una tarea de un trabajo de Azure Databricks, por lo que se integra con el resto del trabajo. Puedes hacer un paso de preparación antes de entrenar, combinar tareas de GPU y CPU en un solo trabajo, y usar diferentes aceleradores por tarea.

Ordena tareas con depends_on

Úsalo depends_on para ejecutar tareas en secuencia. La siguiente canalización ejecuta un cuaderno de preparación y, a continuación, una tarea de entrenamiento con GPU que se inicia solo cuando la tarea de preparación se completa correctamente:

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 tareas de GPU y CPU

En la cadena anterior, solo el paso de entrenamiento necesita una GPU. Mantener el trabajo no relacionado con la GPU, como la preparación de datos, en tareas separadas mantiene el tiempo de la GPU centrado en el entrenamiento.

Nota:

An ai_runtime_task no soporta valores de tarea de trabajo de Azure Databricks ({{tasks.<task_key>.values.<name>}} o dbutils.jobs.taskValues). Para pasar datos entre pasos, escríbelos en una ubicación compartida que ambas tareas puedan leer, como un volumen de Unity Catalog o un archivo de espacio de trabajo, y haz referencia a esa ruta desde cada tarea.

Planifica la carga de trabajo

Añade schedule al trabajo para ejecutarlo periódicamente. Publica la programación en pausa para que al desplegar el paquete no se inicien ejecuciones automáticamente y, cuando estés listo, reanúdala:

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

Promocionar desde el desarrollo hasta la producción

La promoción del desarrollo a la producción es una función estándar del paquete que la tarea de IA en tiempo de ejecución hereda sin cambios.

Destinos y modos del paquete

Define un objetivo de producción con mode: production junto a tu objetivo de desarrollo. El objetivo controla dónde se despliega el paquete y cómo se nombran sus recursos:

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

Despliegue y ejecución

Despliega y ejecuta el paquete contra un objetivo con los comandos estándar de bundle:

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

Pasos siguientes

  • Last updated on