Crear un trabajo de entrenamiento personalizado

gcloud

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

Si tu código de entrenamiento está en tu ordenador local, te recomendamos que sigas la sección Con empaquetado automático. Si ya has creado una aplicación de entrenamiento de Python o una imagen de contenedor personalizada, ve a la sección Sin empaquetado automático.

Con empaquetado automático

Si tienes código de entrenamiento en tu ordenador local, puedes usar un solo comando para hacer lo siguiente:

• Crea una imagen Docker personalizada basada en tu código.
• Envía la imagen a Artifact Registry.
• Inicia una CustomJob basada en la imagen.

El resultado es similar a la creación de un CustomJob con cualquier otro contenedor personalizado. Puedes usar esta versión del comando si te resulta útil en tu flujo de trabajo.

Antes de empezar

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

1. Instala Docker Engine.

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

3. Enable the Artifact Registry API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

4. Configura la autenticación de Docker para poder enviar imágenes Docker a Artifact Registry:

   gcloud auth configure-docker
   

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

El siguiente comando crea una imagen de Docker basada en una imagen de contenedor de entrenamiento prediseñada y en tu código 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

Haz los cambios siguientes:

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

• JOB_NAME: obligatorio. Nombre visible de la CustomJob.

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

• REPLICA_COUNT: número de réplicas de trabajadores que se deben usar. En la mayoría de los casos, asigna el valor 1 a tu primer grupo de trabajadores.

• EXECUTOR_IMAGE_URI: el URI de la imagen del contenedor que ejecuta el código proporcionado. Consulta los contenedores precompilados disponibles para el entrenamiento.

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

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

  Puedes usar el directorio principal de la secuencia de comandos o un directorio de nivel superior. Puede que quieras usar un directorio de nivel superior para especificar un nombre de módulo de Python completo (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 Instalar dependencias.

  Ten en cuenta que, aunque especifiques un directorio de nivel superior, este comando solo copiará el directorio principal de tu secuencia de comandos del punto de entrada en la imagen de Docker.

• SCRIPT_PATH: la ruta, relativa a WORKING_DIRECTORY en tu sistema de archivos local, de la secuencia de comandos que es el punto de entrada de tu código de entrenamiento. Puede ser una secuencia de comandos de Python (que termina en .py) o una secuencia de comandos de Bash.

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

  Utiliza python-module en lugar de script.

  También puedes sustituir script=SCRIPT_PATH por python-module=PYTHON_MODULE para especificar el nombre de un módulo de Python en WORKING_DIRECTORY que se ejecutará como punto de entrada para el entrenamiento. Por ejemplo, en lugar de script=trainer/task.py, puedes especificar python-module=trainer.task.

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

Instalar dependencias

Cuando usas el empaquetado automático, puedes instalar dependencias de Python en tu contenedor de las mismas formas que cuando usas el comando local-run de la CLI de gcloud. Para obtener información sobre las distintas formas de instalar dependencias de Python, consulta la sección Instalar dependencias de la guía del comando local-run.

La sintaxis para especificar dependencias es ligeramente diferente cuando se usa el empaquetado automático en comparación con el comando local-run. En lugar de usar marcas de línea de comandos para especificar las dependencias, debes usar opciones en el valor de la marca --worker-pool-spec. Además, los valores de estas opciones deben separarse con puntos y comas en lugar de comas. En concreto, 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 especifiques con esta opción contiene un archivo requirements.txt o setup.py, el empaquetado automático instalará las dependencias en función de este archivo.

  En el ejemplo anterior se muestra esta sintaxis.

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

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

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

En el siguiente ejemplo se muestra cómo instalar dependencias usando todas las técnicas opcionales. Puedes especificar cualquier subconjunto de ellos. Para mostrar la sintaxis de punto y coma, en el ejemplo se especifican dos valores para cada opción. Para reducir la longitud del ejemplo, se han sustituido otras opciones de --worker-pool-spec 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

Para obtener información sobre los valores adecuados para estos marcadores de posición, consulta "Instalar dependencias" en la guía del comando 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. En función de si has creado una aplicación de entrenamiento de Python o una imagen de contenedor personalizada, elige una de las siguientes pestañas:

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

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

Preparación distribuida

Para llevar a cabo el entrenamiento distribuido, especifica la marca --worker-pool-spec varias veces, una 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 los campos relacionados con tu código de entrenamiento en los grupos de trabajadores posteriores, que usarán el mismo contenedor de entrenamiento creado por el empaquetado automático.

Por ejemplo, el siguiente comando adapta un ejemplo anterior de empaquetado automático 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 utilizas el empaquetado automático, especifica cada grupo de trabajadores por completo e independientemente. No omitas ningún campo.

Los siguientes comandos adaptan los ejemplos anteriores para usar un segundo grupo de trabajadores:

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

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 quieres 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 contenga los campos de CustomJobSpec. Por ejemplo:

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

Consulta un ejemplo de config.yaml archivo.

Consola

En la Google Cloud consola, 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 haga nada más. Si quieres usar TrainingPipelinefunciones adicionales, como entrenar con un conjunto de datos gestionado o crear un recurso Model al final del entrenamiento, consulta el artículo Crear canalizaciones de entrenamiento.

1. En la Google Cloud consola, en la sección Vertex AI, ve a la página Flujos de procesamiento de entrenamiento.

   Ir a Flujos de procesamiento de entrenamiento

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

3. En el paso Método de entrenamiento, especifica los siguientes ajustes:

   1. En la lista desplegable Conjunto de datos, selecciona Sin conjunto de datos gestionado.

   2. Selecciona Entrenamiento personalizado (avanzado).

   Haz clic en Continuar.

4. En el paso Detalles del modelo, elija Entrenar nuevo modelo o Entrenar nueva versión. Si seleccionas Entrenar nuevo modelo, introduce el nombre que quieras MODEL_NAME para tu modelo. Haz clic en Continuar.

5. En el paso Contenedor de entrenamiento, especifique los siguientes ajustes:

   1. Selecciona si quieres usar un contenedor prediseñado o un contenedor personalizado para el entrenamiento.

   2. En función de lo que elijas, haz una de las siguientes acciones:

      • Si quieres usar un contenedor prediseñado para el entrenamiento, proporciona a Vertex AI la información que necesita para usar el paquete de entrenamiento que has subido a Cloud Storage:

        1. Usa las listas desplegables Framework del modelo y Versión del framework del modelo para especificar el contenedor prediseñado que quieras usar.

        2. En el campo Ubicación del paquete, especifica el URI de Cloud Storage de la aplicación de entrenamiento de Python que has creado y subido. Este archivo suele terminar con .tar.gz.

        3. En el campo Módulo de Python, introduce el nombre del módulo del punto de entrada de tu aplicación de entrenamiento.

      • Si quieres usar un contenedor personalizado para el entrenamiento, en el campo Imagen de contenedor, especifica el URI de Artifact Registry o Docker Hub de la imagen de contenedor.

   3. En el campo Directorio de salida del modelo, puedes especificar el URI de Cloud Storage de un directorio de un segmento al que tengas acceso. No es necesario que el directorio ya exista.

      Este valor se transfiere a Vertex AI en el campo baseOutputDirectory de la API, que define varias variables de entorno a las que puede acceder tu aplicación de entrenamiento cuando se ejecuta.

   4. Opcional: En el campo Arguments (Argumentos), puedes especificar los argumentos que Vertex AI debe usar cuando empiece a ejecutar tu código de entrenamiento. La longitud máxima de todos los argumentos combinados es de 100.000 caracteres. El comportamiento de estos argumentos varía en función del tipo de contenedor que utilices:

      • Si usas un contenedor precompilado, Vertex AI pasará los argumentos como marcas de línea de comandos a tu módulo de Python.

      • Si usas un contenedor personalizado, Vertex AI sustituye la instrucción CMD de tu contenedor por losargumentos.

   Haz clic en Continuar.

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

7. En el paso Computación y precios, especifica los siguientes ajustes:

   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 los recursos de computación que quieres usar para el entrenamiento.

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

      Si quieres llevar a cabo un entrenamiento distribuido, haz clic en Añadir más grupos de trabajo y especifica un conjunto adicional de recursos de computación para cada grupo de trabajo 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 Iniciar entrenamiento para iniciar la canalización de entrenamiento personalizado.

REST

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

• LOCATION: la región en la que se ejecutará el contenedor o el paquete de Python.
• PROJECT_ID: tu ID de proyecto.
• JOB_NAME: obligatorio. Nombre visible de la 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: (opcional). Tipo de acelerador que se va a asociar al trabajo.
  • ACCELERATOR_COUNT: (opcional). Número de aceleradores que se deben asociar a la tarea.
  • DISK_TYPE: (opcional). Tipo de disco de arranque que se va a usar en la tarea. Puede ser pd-standard (valor predeterminado) o pd-ssd. Más información sobre los tipos de discos
  • DISK_SIZE: (opcional). Tamaño en GB del disco de arranque que se va a usar en la tarea. El valor predeterminado es 100.
  • REPLICA_COUNT: número de réplicas de trabajadores que se deben usar. En la mayoría de los casos, asigna el valor 1 a tu primer grupo de trabajadores.
  • Si tu aplicación de entrenamiento se ejecuta en un contenedor personalizado, especifica lo siguiente:
    • CUSTOM_CONTAINER_IMAGE_URI: URI de una imagen de contenedor en Artifact Registry o Docker Hub que se va a ejecutar en cada réplica de trabajador. /li>
    • CUSTOM_CONTAINER_COMMAND: (opcional). El comando que se invoca cuando se inicia el contenedor. Este comando anula el punto de entrada predeterminado del contenedor.
    • CUSTOM_CONTAINER_ARGS: (opcional). Los argumentos que se deben transferir al iniciar el contenedor.
  • Si tu aplicación de entrenamiento es un paquete de Python que se ejecuta en un contenedor prediseñado, especifica lo siguiente:
    • EXECUTOR_IMAGE_URI: el URI de la imagen del contenedor que ejecuta el código proporcionado. Consulta los contenedores precompilados disponibles para el entrenamiento.
    • PYTHON_PACKAGE_URIS: lista separada por comas de URIs de Cloud Storage que especifican los archivos del paquete de Python que son el programa de entrenamiento y sus paquetes dependientes. El número máximo de URIs de paquetes es 100.
    • PYTHON_MODULE: nombre del módulo de Python que se va a ejecutar después de instalar los paquetes.
    • PYTHON_PACKAGE_ARGS: (opcional). Argumentos de línea de comandos que se van a transferir al módulo de Python.
  • Consulta las opciones de programación de trabajos.
  • TIMEOUT: (opcional). Tiempo máximo de ejecución del trabajo.
• Especifica el LABEL_NAME y el LABEL_VALUE de las etiquetas que quieras 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 -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"

$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, así como el elemento JOB_ID.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/customJobs/JOB_ID",
  "displayName": "JOB_NAME",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

Java

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

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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 Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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_T4',
            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

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API 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,
    )