Crea trabajos de entrenamiento personalizados

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

Antes de enviar un trabajo

Antes de crear un CustomJob en Vertex AI, debes crear una aplicación de entrenamiento de Python o una imagen de contenedor personalizada para definir el código de entrenamiento y las dependencias que deseas ejecutar en Vertex AI.

Te recomendamos que uses la función de empaquetado automático de Google Cloud CLI, que se describe en la sección posterior de esta guía, para crear una imagen de contenedor de Docker a partir del código en tu máquina local, envía esta imagen de contenedor a Artifact Registry y crea un CustomJob, todo con un solo comando.

De lo contrario, debes crear manualmente una aplicación de entrenamiento de Python o una imagen de contenedor personalizada.

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:

También puedes configurar trabajos personalizados para que se ejecuten en un recurso persistente en lugar de crear nuevos recursos de procesamiento durante el inicio del trabajo. Para obtener más información sobre los recursos persistentes, consulta Descripción general de los recursos persistentes.

Configura el entrenamiento distribuido

A fin de configurar un CustomJob para el entrenamiento distribuido, especifica 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 una CustomJob

Para crear un CustomJob, sigue las instrucciones en una de las siguientes pestañas, según la herramienta que desees usar. Si usas la gcloud CLI, puedes usar un solo comando para empaquetar de forma automática el código de entrenamiento en tu máquina local en una imagen de contenedor de Docker, enviarla a Artifact Registry y crear un CustomJob. Otras opciones suponen que ya creaste una aplicación de entrenamiento de Python o una imagen de contenedor personalizada.

gcloud

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

Si el código de entrenamiento está en tu computadora local, te recomendamos que sigas la sección Con empaquetado automático. De forma alternativa, si ya creaste una aplicación de entrenamiento de Python o una imagen de contenedor personalizada, ve directamente a la sección Sin empaquetado automático.

Con empaquetado automático

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 Artifact 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. Enable the Artifact Registry API.

    Enable the API

  4. Configura la autenticación para Docker a fin de enviar las imágenes de Docker a Artifact 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 el código de Python local envía la imagen a Artifact Registry y crea un CustomJob.

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=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.

  • EXECUTOR_IMAGE_URI: Es el URI de la imagen de contenedor que ejecuta el código proporcionado. Consulta los contenedores compilados previamente disponibles 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 setup.py. Para obtener más información, consulta Instala dependencias.

    Ten en cuenta que 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.

Instale dependencias

Cuando usas el empaquetado automático, puedes instalar dependencias de Python en tu contenedor de la misma forma en que están disponibles cuando usas el comando local-run de la CLI de gcloud. Para obtener información sobre las diversas formas de instalar dependencias de Python, lee la sección Instala dependencias de la guía para el comando local-run.

La sintaxis para especificar dependencias difiere un poco cuando usas el empaquetado automático en comparación con el uso del comando local-run. En lugar de usar marcas de línea de comandos para especificar dependencias, debes usar las opciones del valor de la marca --worker-pool-spec. Además, los valores dentro de estas opciones deben estar separados por punto y coma en lugar de comas. Específicamente, la sintaxis

  • En lugar de la marca --local-package-path del comando local-run, usa la opción local-package-path en el valor de la marca --worker-pool-spec. Si el directorio de trabajo que especificas con esta opción contiene un archivo requirements.txt o setup.py, el empaquetado automático instala dependencias basadas en este archivo.

    En el ejemplo anterior, se demuestra esta sintaxis.

  • En lugar de la marca --requirements, usa la opción requirements en el valor de la marca --worker-pool-spec (opcional). En lugar de separar las dependencias de PyPI con las comas, usa punto y coma.

  • En lugar de la marca --extra-packages, usa la opción extra-packages en el valor de la marca --worker-pool-spec (opcional). En lugar de separar las dependencias locales con comas, usa punto y coma.

  • En lugar de la marca --extra-dirs, usa la opción extra-dirs en el valor de la marca --worker-pool-spec (opcional). En lugar de separar las rutas de directorio con comas, usa punto y coma.

En el siguiente ejemplo, se muestra cómo instalar dependencias mediante todas las técnicas opcionales. (Puedes especificar cualquier subconjunto de ellas). A fin de demostrar la sintaxis de punto y coma, en el ejemplo se especifican dos valores para cada opción. A fin de reducir la longitud del ejemplo, otras opciones de --worker-pool-spec se reemplazan por [...].

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=[...],requirements=PYPI_DEP_1;PYPI_DEP_2,extra-packages=LOCAL_DEP_1;LOCAL_DEP_2,extra-dirs=EXTRA_DIR_1;EXTRA_DIR_2

Si quieres obtener información sobre los valores apropiados para estos marcadores de posición, consulta “Instala dependencias” en la guía para el comando de local-run.

Sin empaquetado automático

Si no usas el empaquetado automático, puedes crear un CustomJob con un comando similar a uno de los siguientes. Según si creaste una aplicación de entrenamiento de Python o una imagen de contenedor personalizada, elige una de las siguientes pestañas:

App de entrenamiento de Python

gcloud 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=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.
  • EXECUTOR_IMAGE_URI: Es el URI de la imagen de contenedor que ejecuta el código proporcionado. Consulta los contenedores compilados previamente disponibles para el entrenamiento.
  • PYTHON_MODULE: es el nombre del módulo de Python que se ejecutará después de instalar los paquetes.

Imagen del contenedor personalizado

gcloud 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 o Docker Hub que se ejecuta en cada réplica de trabajador.

Entrenamiento distribuido

Para realizar un entrenamiento distribuido, especifica la marca --worker-pool-spec varias veces, una vez por cada grupo de trabajadores.

Si usas el empaquetado automático, solo debes especificar local-package-path, script y otras opciones relacionadas con el empaquetado automático en el primer grupo de trabajadores. Omite campos relacionados con tu código de entrenamiento en grupos de trabajadores posteriores, que usarán el mismo contenedor de entrenamiento que se compila mediante el empaquetado automático.

Por ejemplo, con el siguiente comando, se adapta un ejemplo de empaquetado automático anterior para usar un segundo grupo de trabajadores:

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

Si no usas el empaquetado automático, especifica cada grupo de trabajadores de forma independiente y completa; no omitas ningún campo.

Con los siguientes comandos, se adaptan los ejemplos anteriores para usar un segundo grupo de trabajadores:

App de entrenamiento de Python

gcloud 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=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_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

Imagen del contenedor personalizado

gcloud 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

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 ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --config=config.yaml

Consulta un ejemplo de un archivo config.yaml.

Console

En la consola de Google Cloud, 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 la consola de Google Cloud, 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 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 Detalles del modelo, elige Entrenar modelo nuevo o Entrenar versión nueva. Si seleccionas el modelo nuevo, ingresa el nombre que desees, MODEL_NAME, para el 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. Opcional: En el campo Argumentos, puedes especificar argumentos para que Vertex AI los use cuando comience a ejecutar tu código de entrenamiento. La longitud máxima para todos los argumentos combinados es de 100,000 caracteres. 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.

REST

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: El ID del 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: es 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 o Docker Hub que se ejecuta en cada réplica de trabajador. /li>
      • 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:
      • EXECUTOR_IMAGE_URI: Es el URI de la imagen de contenedor que ejecuta el código proporcionado. Consulta los contenedores compilados previamente disponibles 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": 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 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 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 JOB_ID.

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.ContainerSpec;
import com.google.cloud.aiplatform.v1.CustomJob;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;

// Create a custom job to run machine learning training code in Vertex AI
public class CreateCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";

    // Vertex AI runs your training application in a Docker container image. A Docker container
    // image is a self-contained software package that includes code and all dependencies. Learn
    // more about preparing your training application at
    // https://cloud.google.com/vertex-ai/docs/training/overview#prepare_your_training_application
    String containerImageUri = "CONTAINER_IMAGE_URI";
    createCustomJobSample(project, displayName, containerImageUri);
  }

  static void createCustomJobSample(String project, String displayName, String containerImageUri)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();

      ContainerSpec containerSpec =
          ContainerSpec.newBuilder().setImageUri(containerImageUri).build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setContainerSpec(containerSpec)
              .build();

      CustomJobSpec customJobSpecJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();

      CustomJob customJob =
          CustomJob.newBuilder()
              .setDisplayName(displayName)
              .setJobSpec(customJobSpecJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      CustomJob response = client.createCustomJob(parent, customJob);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

/**
 * 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:\n', JSON.stringify(response));
}
createCustomJob();

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python. 

def create_custom_job_with_experiment_autologging_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    service_account: str,
    experiment: str,
    experiment_run: Optional[str] = None,
) -> None:
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket, experiment=experiment)

    job = aiplatform.CustomJob.from_local_script(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        enable_autolog=True,
    )

    job.run(
        service_account=service_account,
        experiment=experiment,
        experiment_run=experiment_run,
    )

¿Qué sigue?