Crea trabajos de entrenamiento personalizados

Los trabajos de entrenamiento personalizados son la forma básica de ejecutar el código de entrenamiento personalizado de aprendizaje automático (AA) en Vertex AI.

Antes de enviar un trabajo

Antes de enviar un trabajo de entrenamiento personalizado a Vertex AI, debes crear una aplicación de entrenamiento de Python o un contenedor personalizado para definir el código de entrenamiento y las dependencias. que desees ejecutar en Vertex AI. Si creas una aplicación de entrenamiento de Python, puedes usar nuestros contenedores compilados de forma previa para ejecutar tu código. Si no estás seguro de cuál de estas opciones elegir, consulta los requisitos del código de entrenamiento para obtener más información.

Qué incluye un trabajo personalizado

Cuando creas un trabajo personalizado, especificas la configuración que necesita Vertex AI para ejecutar tu código de entrenamiento, incluido lo siguiente:

En los grupos de trabajadores, puedes especificar la siguiente configuración:

Configura el entrenamiento distribuido

Puedes configurar un trabajo de entrenamiento personalizado para el entrenamiento distribuido si especificas varios grupos de trabajadores.

En la mayoría de los ejemplos de esta página, se muestran trabajos de entrenamiento de una sola réplica con un grupo de trabajadores. A fin de modificarlos para el entrenamiento distribuido, sigue estos pasos:

  • Usa tu primer grupo de trabajadores para configurar la réplica principal y establece el recuento de réplicas en 1.
  • Agrega más grupos de trabajadores para configurar réplicas de trabajadores, réplicas del servidor de parámetros o réplicas de evaluadores, si tu framework de aprendizaje automático admite estas tareas adicionales del clúster para el entrenamiento distribuido.

Obtén más información sobre cómo usar el entrenamiento distribuido.

Crea un trabajo personalizado

Para crear un trabajo personalizado, sigue estos pasos:

Console

En Google Cloud Console, no puedes crear un recurso CustomJob directamente. Sin embargo, puedes crear un recurso TrainingPipeline que cree un CustomJob.

En las siguientes instrucciones, se describe cómo crear un TrainingPipeline que cree un CustomJob y no realice ninguna otra acción. Si deseas usar atributos adicionales de TrainingPipeline, como el entrenamiento con un conjunto de datos administrado o la creación de un recurso Model al final del entrenamiento, lee Crea canalizaciones de entrenamiento.

  1. En Cloud Console, en la sección Vertex AI, ve a la página Canalizaciones de entrenamiento.

    Ve a Canalizaciones de entrenamiento

  2. Haz clic en Crear para abrir el panel Entrenar modelo nuevo.

  3. En el paso Elegir método de entrenamiento, especifica las siguientes opciones de configuración:

    1. De lo contrario, en la lista desplegable Conjunto de datos, selecciona No hay ningún conjunto de datos administrado.

    2. Selecciona Entrenamiento personalizado (avanzado).

    Haz clic en Continuar.

  4. En el paso Define tu modelo, ingresa un nombre de tu elección, MODEL_NAME, para tu modelo. Haz clic en Continuar.

  5. En el paso Contenedor de entrenamiento, especifica la siguiente configuración:

    1. Selecciona si deseas usar un contenedor compilado previamente o un contenedor personalizado para el entrenamiento.

    2. Según tu elección, realiza una de las siguientes acciones:

    3. En el campo Directorio de resultado del modelo, puedes especificar el URI de Cloud Storage de un directorio en un bucket al que tengas acceso. No es necesario que el directorio ya esté creado.

      Este valor se pasa a Vertex AI en el campo de API baseOutputDirectory, que establece distintas variables de entorno a las que puede acceder tu aplicación de entrenamiento cuando se ejecuta.

    4. En el campo Argumentos, puedes especificar argumentos para que Vertex AI los use cuando comience a ejecutar tu código de entrenamiento. El comportamiento de estos argumentos difiere según el tipo de contenedor que uses:

    Haz clic en Continuar.

  6. En el paso Ajuste de hiperparámetros, asegúrate de que la casilla de verificación Habilitar el ajuste de hiperparámetros no esté seleccionada. Haz clic en Continuar.

  7. En el paso Procesamiento y precio, especifica las siguientes opciones de configuración:

    1. En la lista desplegable Región, selecciona una región que admita el entrenamiento personalizado.

    2. En la sección Grupo de trabajadores 0, especifica recursos de procesamiento para usar en el entrenamiento.

      Si especificas aceleradores, asegúrate de que el tipo de acelerador que elijas esté disponible en la región que seleccionaste.

      Si quieres realizar un entrenamiento distribuido, haz clic en Agregar más grupos de trabajadores y especifica un conjunto adicional de recursos de procesamiento para cada grupo de trabajadores adicional que quieras.

    Haz clic en Continuar.

  8. En el paso Contenedor de predicción, selecciona Sin contenedor de predicción.

  9. Haz clic en Comenzar el entrenamiento para comenzar la canalización de entrenamiento personalizada.

gcloud

En los siguientes ejemplos, se usa el comando gcloud beta ai custom-jobs create.

Según si creaste una aplicación de entrenamiento de Python para usar con un contenedor compilado previamente o si usas un contenedor personalizado, ejecuta una de los siguientes comandos:

Contenedor compilado previamente

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

Reemplaza lo siguiente:

  • LOCATION: es la región en la que se ejecutará el contenedor o el paquete de Python.
  • JOB_NAME: Obligatorio. Es un nombre visible para CustomJob.
  • PYTHON_PACKAGE_URIS: es una lista separada por comas de URI de Cloud Storage que especifican los archivos de paquete de Python que son el programa de entrenamiento y sus paquetes dependientes. La cantidad máxima de URI de paquete es 100.
  • MACHINE_TYPE: El tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.
  • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar. En la mayoría de los casos, configura esto como 1 para tu primer grupo de trabajadores.
  • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: El URI de la imagen de contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores compilados de forma previa para el entrenamiento.
  • PYTHON_MODULE: es el nombre del módulo de Python que se ejecutará después de instalar los paquetes.

Contenedor personalizado

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI

Reemplaza lo siguiente:

  • LOCATION: es la región en la que se ejecutará el contenedor o el paquete de Python.
  • JOB_NAME: Obligatorio. Es un nombre visible para CustomJob.
  • MACHINE_TYPE: El tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.
  • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar. En la mayoría de los casos, configura esto como 1 para tu primer grupo de trabajadores.
  • CUSTOM_CONTAINER_IMAGE_URI: es el URI de una imagen de contenedor en Artifact Registry, Container Registry o Docker Hub que se ejecuta en cada réplica de trabajador.

Contenedor personalizado basado en el código local

Si tienes código de entrenamiento en tu computadora local, puedes usar un único comando para realizar las siguientes acciones:

  • Compilar una imagen de Docker personalizada basada en tu código
  • Envía la imagen a Container Registry.
  • Iniciar una CustomJob basada en la imagen

El resultado es similar a crear un CustomJob mediante cualquier otro contenedor personalizado. Puedes usar esta versión del comando si es conveniente para tu flujo de trabajo.

Antes de comenzar

Debido a que esta versión del comando compila y envía una imagen de Docker, debes realizar la siguiente configuración en tu computadora local:

  1. Instala Docker Engine

  2. Si usas Linux, configura Docker para que puedas ejecutarlo sin sudo.

  3. Habilita la API Container Registry.

    Habilita la API

  4. Configura la autenticación para Docker a fin de enviar las imágenes de Docker a Container Registry:

    gcloud auth configure-docker
    

Compila y envía la imagen de Docker y crea un CustomJob

Con el siguiente comando, se compila una imagen de Docker basada en una imagen de contenedor de entrenamiento compilada previamente y en el código de Python local, se envía la imagen a Container Registry y se crea una CustomJob.

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH

Reemplaza lo siguiente:

  • LOCATION: es la región en la que se ejecutará el contenedor o el paquete de Python.

  • JOB_NAME: Obligatorio. Es un nombre visible para CustomJob.

  • MACHINE_TYPE: El tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.

  • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar. En la mayoría de los casos, configura esto como 1 para tu primer grupo de trabajadores.

  • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: El URI de la imagen de contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores compilados de forma previa para el entrenamiento.

    Esta imagen actúa como la imagen base para la imagen de Docker nueva que compilas con este comando.

  • WORKING_DIRECTORY: Un directorio en tu sistema de archivos local que contiene la secuencia de comandos del punto de entrada que ejecuta el código de entrenamiento (consulta el siguiente elemento de la lista)

    Puedes usar el directorio superior de la secuencia de comandos o un directorio de nivel superior. Te recomendamos usar un directorio de nivel superior para especificar un nombre de módulo de Python completamente calificado (consulta el siguiente elemento de la lista). También puedes usar un directorio de nivel superior si contiene un archivo requirements.txt o un archivo setup.py, para instalar dependencias adicionales en el contenedor. Esta funcionalidad es similar a la funcionalidad correspondiente en el comando gcloud beta ai custom-jobs local-run. Sin embargo, incluso si especificas un directorio de nivel superior, este comando solo copia el directorio superior de la secuencia de comandos del punto de entrada en la imagen de Docker.

  • SCRIPT_PATH: La ruta de acceso (en relación con WORKING_DIRECTORY en el sistema de archivos local) a la secuencia de comandos que es el punto de entrada del código de entrenamiento Puede ser una secuencia de comandos de Python (que termina en .py) o una de Bash.

    Por ejemplo, si deseas ejecutar /hello-world/trainer/task.py y WORKING_DIRECTORY es /hello-world, usa trainer/task.py para este valor.

    Usa python-module en lugar de script

    De manera opcional, puedes reemplazar script=SCRIPT_PATH por python-module=PYTHON_MODULE a fin de especificar el nombre de un módulo de Python en WORKING_DIRECTORY para que se ejecute como el punto de entrada del entrenamiento. Por ejemplo, en lugar de script=trainer/task.py, puedes especificar python-module=trainer.task.

    En este caso, el contenedor resultante de Docker carga el código como un módulo en lugar de como una secuencia de comandos. Es probable que desees usar esta opción si la secuencia de comandos del punto de entrada importa otros módulos de Python en WORKING_DIRECTORY.

Configura el entrenamiento distribuido

Si deseas realizar un entrenamiento distribuido, puedes especificar la marca --worker-pool-spec varias veces, una para cada grupo de trabajadores. En los siguientes ejemplos, se adaptan los ejemplos anteriores para usar un segundo grupo de trabajadores:

Contenedor compilado previamente

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,executor-image-uri=SECOND_POOL_PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

Contenedor personalizado

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,container-image-uri=SECOND_POOL_CUSTOM_CONTAINER_IMAGE_URI

Contenedor personalizado basado en el código local

Cuando usas local-package-path=WORKING_DIRECTORY en el comando, solo debes configurar un único grupo de trabajadores. El entrenamiento distribuido no está disponible.

Configuración avanzada

Si deseas especificar opciones de configuración que no están disponibles en los ejemplos anteriores, puedes usar la marca --config para especificar la ruta a un archivo config.yaml en tu entorno local que contiene los campos de CustomJobSpec. Por ejemplo:

gcloud beta ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

Consulta un ejemplo de un archivo config.yaml.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION: es la región en la que se ejecutará el contenedor o el paquete de Python.
  • PROJECT_ID: es tu ID del proyecto o número de proyecto.
  • JOB_NAME: Obligatorio. Es un nombre visible para CustomJob.
  • Define el trabajo de entrenamiento personalizado:
    • MACHINE_TYPE: El tipo de máquina. Consulta los tipos de máquinas disponibles para el entrenamiento.
    • ACCELERATOR_TYPE: es el tipo de acelerador para adjuntar al trabajo.
    • ACCELERATOR_COUNT: es la cantidad de aceleradores que se adjuntarán al trabajo.
    • DISK_TYPE: El tipo de disco de arranque que se usará para el trabajo, ya sea pd-standard (predeterminado) o pd-ssd. Obtén más información sobre los tipos de discos.
    • DISK_SIZE: es el tamaño en GB del disco de arranque que se usará para el trabajo. El valor predeterminado es 100.
    • REPLICA_COUNT: La cantidad de réplicas de trabajadores que se deben usar. En la mayoría de los casos, configura esto como 1 para tu primer grupo de trabajadores.
    • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
      • CUSTOM_CONTAINER_IMAGE_URI: es el URI de una imagen de contenedor en Artifact Registry, Container Registry o Docker Hub que se ejecuta en cada réplica de trabajador.
      • CUSTOM_CONTAINER_COMMAND: El comando que se invocará cuando se inicie el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
      • CUSTOM_CONTAINER_ARGS: son los argumentos que se transmitirán cuando se inicia el contenedor (opcional).
    • Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor compilado previamente, especifica lo siguiente:
      • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI: El URI de la imagen de contenedor que ejecuta el paquete de Python proporcionado. Consulta los contenedores compilados de forma previa para el entrenamiento.
      • PYTHON_PACKAGE_URIS: es una lista separada por comas de URI de Cloud Storage que especifican los archivos de paquete de Python que son el programa de entrenamiento y sus paquetes dependientes. La cantidad máxima de URI de paquete es 100.
      • PYTHON_MODULE: es el nombre del módulo de Python que se ejecutará después de instalar los paquetes.
      • PYTHON_PACKAGE_ARGS: son los argumentos de la línea de comandos que se pasarán al módulo de Python.
    • Obtén más información sobre las opciones de programación de trabajos.
    • TIMEOUT: es el tiempo máximo de ejecución para el trabajo.
  • Especifica LABEL_NAME y LABEL_VALUE para las etiquetas que desees aplicar a este trabajo personalizado.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs

Cuerpo JSON de la solicitud:

{
  "displayName": "JOB_NAME",
  "jobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": MACHINE_TYPE,
          "acceleratorType": ACCELERATOR_TYPE,
          "acceleratorCount": ACCELERATOR_COUNT
        },
        "replicaCount": REPLICA_COUNT,
        "diskSpec": {
          "bootDiskType": DISK_TYPE,
          "bootDiskSizeGb": DISK_SIZE
        },

        // Union field task can be only one of the following:
        "containerSpec": {
          "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
          "command": [
            CUSTOM_CONTAINER_COMMAND
          ],
          "args": [
            CUSTOM_CONTAINER_ARGS
          ]
        },
        "pythonPackageSpec": {
          "executorImageUri": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
          "packageUris": [
            PYTHON_PACKAGE_URIS
          ],
          "pythonModule": PYTHON_MODULE,
          "args": [
            PYTHON_PACKAGE_ARGS
          ]
        }
        // End of list of possible types for union field task.
      }
      // Specify one workerPoolSpec for single replica training, or multiple workerPoolSpecs
      // for distributed training.
    ],
    "scheduling": {
      "timeout": TIMEOUT
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

La respuesta contiene información sobre las especificaciones y los TRAININGPIPELINE_ID.

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const customJobDisplayName = 'YOUR_CUSTOM_JOB_DISPLAY_NAME';
// const containerImageUri = 'YOUR_CONTAINER_IMAGE_URI';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Job Service Client library
const {JobServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const jobServiceClient = new JobServiceClient(clientOptions);

async function createCustomJob() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const customJob = {
    displayName: customJobDisplayName,
    jobSpec: {
      workerPoolSpecs: [
        {
          machineSpec: {
            machineType: 'n1-standard-4',
            acceleratorType: 'NVIDIA_TESLA_K80',
            acceleratorCount: 1,
          },
          replicaCount: 1,
          containerSpec: {
            imageUri: containerImageUri,
            command: [],
            args: [],
          },
        },
      ],
    },
  };
  const request = {parent, customJob};

  // Create custom job request
  const [response] = await jobServiceClient.createCustomJob(request);

  console.log('Create custom job response');
  console.log(`${JSON.stringify(response)}`);
}
createCustomJob();

Python

En este ejemplo, se usa el SDK de Vertex para Python. Antes de ejecutar la siguiente muestra de código, debes configurar la autenticación.

from google.cloud import aiplatform

def create_custom_job_sample(
    project: str,
    display_name: str,
    container_image_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.JobServiceClient(client_options=client_options)
    custom_job = {
        "display_name": display_name,
        "job_spec": {
            "worker_pool_specs": [
                {
                    "machine_spec": {
                        "machine_type": "n1-standard-4",
                        "accelerator_type": aiplatform.gapic.AcceleratorType.NVIDIA_TESLA_K80,
                        "accelerator_count": 1,
                    },
                    "replica_count": 1,
                    "container_spec": {
                        "image_uri": container_image_uri,
                        "command": [],
                        "args": [],
                    },
                }
            ]
        },
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_custom_job(parent=parent, custom_job=custom_job)
    print("response:", response)

¿Qué sigue?

  • Consulta Importa modelos a Vertex AI para obtener más información sobre cómo crear trabajos de entrenamiento personalizado a fin de ejecutar tus aplicaciones de entrenamiento personalizadas en Vertex AI.