Criar jobs de treinamento personalizados

Os jobs de treinamento personalizados (recursos CustomJob na Vertex AI API) são a maneira básica de executar o código de treinamento personalizado de machine learning (ML) na Vertex AI.

Antes de enviar uma tarefa

Antes de criar um CustomJob na Vertex AI, é preciso criar um aplicativo de treinamento em Python ou uma imagem de contêiner personalizada para definir o código de treinamento e as dependências que você quer executar na Vertex AI.

Recomendamos que você use o recurso de empacotamento automático da CLI do Google Cloud, descrito em uma seção posterior deste guia, para criar uma imagem de contêiner do Docker a partir do código na máquina local, envie essa imagem para o Artifact Registry e crie um CustomJob, tudo com um único comando.

Caso contrário, crie manualmente um aplicativo de treinamento Python ou uma imagem de contêiner personalizada.

Se você não tiver certeza de qual dessas opções escolher, consulte os requisitos do código de treinamento para saber mais.

O que um job personalizado inclui

Ao criar um job personalizado, você especifica as configurações que a Vertex AI precisa executar no seu código de treinamento, incluindo:

Nos pools de workers, é possível especificar as seguintes configurações:

Também é possível configurar jobs personalizados para serem executados em um recurso persistente em vez de criar novos recursos de computação durante a inicialização do job. Para saber mais sobre recursos permanentes, consulte Visão geral de recursos permanentes.

Configurar o treinamento distribuído

É possível configurar um CustomJob para treinamento distribuído especificando vários pools de workers.

A maioria dos exemplos desta página mostra jobs de treinamento de réplica única com um pool de workers. Para modificá-los no treinamento distribuído:

  • Use o primeiro pool de workers para configurar a réplica principal e defina a contagem de réplicas como 1.
  • Adicione mais pools de workers para configurar réplicas de workers, réplicas de servidores de parâmetros ou réplicas de avaliadores se o framework de machine learning for compatível com essas tarefas adicionais do cluster para treinamento distribuído.

Saiba mais sobre como usar o treinamento distribuído.

Criar um CustomJob

Para criar um CustomJob, siga as instruções em uma das seguintes guias, dependendo da ferramenta que você quer usar. Se você usar a gcloud CLI, poderá usar um único comando para empacotar automaticamente o código de treinamento na sua máquina local em uma imagem de contêiner do Docker, enviar a imagem do contêiner para o Artifact Registry e criar umCustomJob Outras opções presumem que você já tenha criado um aplicativo de treinamento em Python ou uma imagem de contêiner personalizada.

gcloud

Os exemplos a seguir usam o comando gcloud ai custom-jobs create.

Se o código de treinamento estiver no seu computador local, recomendamos que você siga a seção Com empacotamento automático. Como alternativa, se você já criou um aplicativo de treinamento em Python ou uma imagem de contêiner personalizada, pule para a seção Sem o empacotamento automático.

Com empacotamento automático

Se você tiver o código de treinamento no seu computador local, use um único comando para fazer o seguinte:

  • Crie uma imagem personalizada do Docker com base no seu código.
  • Envie a imagem para o Artifact Registry
  • Inicia um CustomJob com base na imagem.

O resultado é semelhante à criação de um CustomJob usando qualquer outro contêiner personalizado. Use essa versão do comando se for conveniente para o fluxo de trabalho.

Antes de começar

Como essa versão do comando cria e envia uma imagem do Docker, execute a seguinte configuração no seu computador local:

  1. Instale o Docker Engine.

  2. Se você estiver usando o Linux, configure o Docker para executá-lo sem sudo.

  3. Enable the Artifact Registry API.

    Enable the API

  4. Configure a autenticação para o Docker para enviar imagens do Docker para o Artifact Registry:

    gcloud auth configure-docker

Criar e enviar a imagem do Docker e criar um CustomJob

O comando a seguir cria uma imagem do Docker com base em uma imagem de contêiner de treinamento pré-criada e seu código Python local, envia a imagem para o Artifact Registry e cria um 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

Substitua:

  • LOCATION: a região em que o contêiner ou o pacote Python será executado.

  • JOB_NAME: obrigatório. Um nome de exibição para CustomJob.

  • MACHINE_TYPE: o tipo da máquina. Consulte os tipos de máquina disponíveis para treinamento.

  • REPLICA_COUNT: o número de réplicas de worker a serem usadas. Na maioria dos casos, defina isso como 1 para o primeiro pool de workers.

  • EXECUTOR_IMAGE_URI: o URI da imagem do contêiner que executa o código fornecido; Consulte os contêineres pré-criados disponíveis para treinamento.

    Essa imagem atua como a imagem base para a nova imagem do Docker que você está criando com esse comando.

  • WORKING_DIRECTORY: um diretório no sistema de arquivos local que tem o script do ponto de entrada que executa o código de treinamento. Consulte o item da lista a seguir.

    É possível usar o diretório pai do script ou um diretório de nível superior. Use um diretório de nível superior para especificar um nome de módulo do Python totalmente qualificado. Consulte o item a seguir. Use um diretório de nível superior se ele contiver um arquivo requirements.txt ou setup.py. Para saber mais, consulte Instalar dependências.

    No entanto, mesmo que você especifique um diretório de nível superior, esse comando só copiará o diretório pai do script do ponto de entrada para a imagem do Docker.

  • SCRIPT_PATH: o caminho, relativo a WORKING_DIRECTORY no seu sistema de arquivos local, para o script que é o ponto de entrada do seu código de treinamento. Pode ser um script Python (terminado em .py) ou um script Bash.

    Por exemplo, se você quiser executar /hello-world/trainer/task.py e WORKING_DIRECTORY for /hello-world, use trainer/task.py para esse valor.

    Use python-module em vez de script

    Se quiser, substitua script=SCRIPT_PATH por python-module=PYTHON_MODULE para especificar o nome de um módulo do Python em WORKING_DIRECTORY a ser executado como o ponto de entrada para treinamento. Por exemplo, em vez de script=trainer/task.py, é possível especificar python-module=trainer.task.

    Nesse caso, o contêiner do Docker resultante carrega o código como um módulo, e não como um script. Essa opção provavelmente será usada se o script de ponto de entrada importar outros módulos Python em WORKING_DIRECTORY.

Instale dependências

Ao usar o empacotamento automático, é possível instalar dependências do Python no contêiner das mesmas maneiras que estão disponíveis quando você usa o comando local-run da CLI gcloud. Para saber mais sobre as várias maneiras de instalar dependências do Python, leia a seção Instalar dependências do guia do comando local-run.

A sintaxe para especificar dependências é um pouco diferente quando você usa o empacotamento automático em comparação com o comando local-run. Em vez de usar sinalizações de linha de comando para especificar dependências, use opções no valor da sinalização --worker-pool-spec. Além disso, os valores dentro dessas opções precisam ser separados por ponto e vírgula em vez de vírgulas. Especificamente, a sintaxe:

  • Em vez da sinalização --local-package-path do comando local-run, use a opção local-package-path no valor da sinalização --worker-pool-spec. Se o diretório de trabalho especificado com essa opção contiver um arquivo requirements.txt ou setup.py, o empacotamento automático instalará dependências com base nesse arquivo.

    O exemplo anterior demonstra essa sintaxe.

  • (Opcional) Em vez da sinalização --requirements, use a opção requirements no valor da sinalização --worker-pool-spec. Em vez de separar dependências PyPI com vírgulas, use ponto e vírgula.

  • (Opcional) Em vez da sinalização --extra-packages, use a opção extra-packages no valor da sinalização --worker-pool-spec. Em vez de separar dependências locais com vírgulas, use ponto e vírgula.

  • (Opcional) Em vez da sinalização --extra-dirs, use a opção extra-dirs no valor da sinalização --worker-pool-spec. Em vez de separar os caminhos de diretório com vírgulas, use ponto e vírgula.

O exemplo a seguir mostra como instalar dependências usando todas as técnicas opcionais. É possível especificar qualquer subconjunto deles. Para demonstrar a sintaxe de ponto e vírgula, o exemplo especifica dois valores para cada opção. Para reduzir o comprimento do exemplo, outras opções --worker-pool-spec são substituídas 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 saber mais sobre os valores apropriados para esses marcadores, consulte "Instalar dependências" no guia para o comando local-run.

Sem empacotamento automático

Se você não usa o empacotamento automático, é possível criar um CustomJob com um comando semelhante a um dos seguintes. Se você tiver criado um aplicativo de treinamento em Python ou uma imagem de contêiner personalizada, escolha uma das seguintes guias:

App de treinamento em 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

Substitua:

  • LOCATION: a região em que o contêiner ou o pacote Python será executado.
  • JOB_NAME: obrigatório. Um nome de exibição para CustomJob.
  • PYTHON_PACKAGE_URIS: lista separada por vírgulas de URIs do Cloud Storage que especificam os arquivos de pacote do Python que são o programa de treinamento e os pacotes dependentes. O número máximo de URIs de pacote é 100.
  • MACHINE_TYPE: o tipo da máquina. Consulte os tipos de máquina disponíveis para treinamento.
  • REPLICA_COUNT: o número de réplicas de worker a serem usadas. Na maioria dos casos, defina isso como 1 para o primeiro pool de workers.
  • EXECUTOR_IMAGE_URI: o URI da imagem do contêiner que executa o código fornecido; Consulte os contêineres pré-criados disponíveis para treinamento.
  • PYTHON_MODULE: o nome do módulo Python que será executado após a instalação dos pacotes.

Imagem de contêiner personalizada

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

Substitua:

  • LOCATION: a região em que o contêiner ou o pacote Python será executado.
  • JOB_NAME: obrigatório. Um nome de exibição para CustomJob.
  • MACHINE_TYPE: o tipo da máquina. Consulte os tipos de máquina disponíveis para treinamento.
  • REPLICA_COUNT: o número de réplicas de worker a serem usadas. Na maioria dos casos, defina isso como 1 para o primeiro pool de workers.
  • CUSTOM_CONTAINER_IMAGE_URI: o URI de uma imagem de contêiner no Artifact Registry ou do Docker Hub a ser executado em cada réplica de worker.

Treinamento distribuído

Para executar treinamento distribuído, especifique a sinalização --worker-pool-spec várias vezes, uma vez para cada pool de workers.

Se você estiver usando o empacotamento automático, especifique apenas local-package-path, script e outras opções relacionadas ao empacotamento automático no primeiro pool de workers. Omita campos relacionados ao código de treinamento em pools de workers subsequentes, que usarão o mesmo contêiner de treinamento criado pelo empacotamento automático.

Por exemplo, o comando a seguir adapta um exemplo de empacotamento automático anterior para usar um segundo pool de workers:

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

Se você não estiver usando o empacotamento automático, especifique cada pool de workers de maneira completa e independente. não omita nenhum campo.

Os comandos a seguir adaptam exemplos anteriores para usar um segundo pool de workers:

App de treinamento em 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

Imagem de contêiner personalizada

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

Configuração avançada

Se você quiser especificar opções de configuração que não estejam disponíveis nos exemplos anteriores, use a sinalização --config para especificar o caminho para um arquivo config.yaml no ambiente local que contém os campos de CustomJobSpec. Por exemplo:

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

Veja um exemplo de arquivo config.yaml.

Console

No console do Google Cloud, não é possível criar um recurso CustomJob diretamente. No entanto, é possível criar um recurso TrainingPipeline que gere um CustomJob.

As instruções a seguir descrevem como criar um TrainingPipeline que cria um CustomJob e não faz mais nada. Se você quiser usar outros recursos de TrainingPipeline, como treinamento com um conjunto de dados gerenciado ou criação de um recurso Model ao final do treinamento, leia Como criar pipelines de treinamento:

  1. No Console do Google Cloud, na seção "Vertex AI", acesse a página Pipelines de treinamento.

    Acessar pipelines de treinamento

  2. Clique em Criar para abrir o painel Treinar novo modelo.

  3. Na etapa Escolher método de treinamento, especifique as seguintes configurações:

    1. Na lista suspensa Conjunto de dados, selecione Nenhum conjunto de dados gerenciado.

    2. Selecione Treinamento personalizado (avançado).

    Clique em Continuar.

  4. Na etapa Detalhes do modelo, escolha Treinar novo modelo ou Treinar nova versão. Se você selecionar "Treinar novo modelo", insira um nome para sua escolha, MODEL_NAME, para seu modelo. Clique em Continuar.

  5. Na etapa Contêiner de treinamento, especifique as seguintes configurações:

    1. Selecione se precisa usar um contêiner pré-criado ou um contêiner personalizado para treinamento.

    2. Dependendo do que você escolher, siga um destes procedimentos:

    3. No campo Diretório de saída do modelo, especifique o URI do Cloud Storage de um diretório em um bucket a que você tenha acesso. O conjunto de dados ainda não precisa existir.

      Esse valor é transmitido à Vertex AI no campo da API baseOutputDirectory, que define várias variáveis de ambiente que o aplicativo de treinamento pode acessar quando é executado.

    4. Opcional: no campo Arguments, é possível especificar argumentos para que a Vertex AI use quando começar a executar seu código de treinamento. O tamanho máximo de todos os argumentos combinados é de 100.000 caracteres. O comportamento desses argumentos varia de acordo com o tipo de contêiner que você está usando:

    Clique em Continuar.

  6. Na etapa Ajuste de hiperparâmetros, verifique se a caixa de seleção Ativar ajuste de hiperparâmetros não está marcada. Clique em Continuar.

  7. Na etapa Computação e preços, especifique as seguintes configurações:

    1. Na lista suspensa Região, selecione uma região compatível com o treinamento personalizado.

    2. Na seção Pool de worker 0, especifique recursos de computação que serão usados no treinamento.

      Se você especificar aceleradores, verifique se o tipo de acelerador escolhido está disponível na região selecionada.

      Se você quiser executar o treinamento distribuído, clique em Adicionar mais pools de workers e especifique um conjunto adicional de recursos de computação para cada um deles. que você quiser.

    Clique em Continuar.

  8. Na etapa Contêiner de previsão, selecione Nenhum contêiner de previsão.

  9. Clique em Iniciar treinamento.

REST

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região em que o contêiner ou o pacote Python será executado.
  • PROJECT_ID: o ID do projeto.
  • JOB_NAME: obrigatório. Um nome de exibição para CustomJob.
  • Defina o job de treinamento personalizado:
    • MACHINE_TYPE: o tipo da máquina. Consulte os tipos de máquina disponíveis para treinamento.
    • ACCELERATOR_TYPE: opcional. O tipo de acelerador a ser anexado ao job.
    • ACCELERATOR_COUNT: opcional. O número de aceleradores a serem anexados ao job.
    • DISK_TYPE: opcional. O tipo de disco de inicialização a ser usado para o job, pd-standard (padrão) ou pd-ssd. Saiba mais sobre tipos de disco.
    • DISK_SIZE: opcional. O tamanho em GB do disco de inicialização a ser usado para o job. O valor padrão é 100.
    • REPLICA_COUNT: o número de réplicas de worker a serem usadas. Na maioria dos casos, defina isso como 1 para o primeiro pool de workers.
    • Se o aplicativo de treinamento for executado em um contêiner personalizado, especifique o seguinte:
      • CUSTOM_CONTAINER_IMAGE_URI: o URI de uma imagem de contêiner no Artifact Registry ou do Docker Hub a ser executado em cada réplica de worker. /li>
      • CUSTOM_CONTAINER_COMMAND: opcional. O comando que será invocado quando o contêiner for iniciado. Esse comando substitui o ponto de entrada padrão do contêiner.
      • CUSTOM_CONTAINER_ARGS: opcional. Argumentos a serem passados ao iniciar o contêiner.
    • Se o aplicativo de treinamento for um pacote Python executado em um contêiner pré-criado, especifique o seguinte:
      • EXECUTOR_IMAGE_URI: o URI da imagem do contêiner que executa o código fornecido; Consulte os contêineres pré-criados disponíveis para treinamento.
      • PYTHON_PACKAGE_URIS: lista separada por vírgulas de URIs do Cloud Storage que especificam os arquivos de pacote do Python que são o programa de treinamento e os pacotes dependentes. O número máximo de URIs de pacote é 100.
      • PYTHON_MODULE: o nome do módulo Python que será executado após a instalação dos pacotes.
      • PYTHON_PACKAGE_ARGS: opcional. Argumentos da linha de comando a serem passados para o módulo Python.
    • Saiba mais sobre as opções de programação de jobs.
    • TIMEOUT: opcional. O tempo máximo de execução do job.
  • Especifique LABEL_NAME e LABEL_VALUE para todos os rótulos que você quiser aplicar a esse job personalizado.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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 a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

A resposta contém informações sobre especificações, bem como o TRAININGPIPELINE_ID.

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da 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,
    )

A seguir