Crie uma tarefa de preparação personalizada

gcloud

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

Se o código de preparação estiver no seu computador local, recomendamos que siga a secção Com embalagem automática. Em alternativa, se já tiver criado uma aplicação de preparação Python ou uma imagem de contentor personalizada, avance para a secção Sem preparação automática.

Com embalagem automática

Se tiver código de preparação no seu computador local, pode usar um único comando para fazer o seguinte:

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

O resultado é semelhante ao da criação de um CustomJob através de qualquer outro contentor personalizado. Pode usar esta versão do comando se for conveniente para o seu fluxo de trabalho.

Antes de começar

Uma vez que esta versão do comando cria e envia uma imagem de Docker, tem de fazer a seguinte configuração no seu computador local:

1. Instale o Docker Engine.

2. Se estiver a usar o Linux, configure o Docker para o poder executar sem 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. Configure a autenticação para o Docker, para poder enviar imagens de Docker para o Artifact Registry:

   gcloud auth configure-docker
   

Crie e envie a imagem do Docker e crie um CustomJob

O comando seguinte cria uma imagem de Docker com base numa imagem de contentor de preparação pré-criada e no 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 o seguinte:

• LOCATION: a região onde o contentor ou o pacote Python vai ser executado.

• JOB_NAME: obrigatório. Um nome a apresentar para o CustomJob.

• MACHINE_TYPE: o tipo de máquina. Consulte os tipos de máquinas disponíveis para a preparação.

• REPLICA_COUNT: o número de réplicas de trabalhadores a usar. Na maioria dos casos, defina esta opção como 1 para o seu primeiro conjunto de trabalhadores.

• EXECUTOR_IMAGE_URI: o URI da imagem do contentor que executa o código facultado. Consulte os contentores pré-criados disponíveis para formação.

  Esta imagem funciona como a imagem de base para a nova imagem do Docker que está a criar com este comando.

• WORKING_DIRECTORY: um diretório no seu sistema de ficheiros local que contém o script do ponto de entrada que executa o seu código de preparação (consulte o seguinte item da lista).

  Pode usar o diretório principal do script ou um diretório de nível superior. Pode usar um diretório de nível superior para especificar um nome de módulo Python totalmente qualificado (consulte o item da lista seguinte). Também pode querer usar um diretório de nível superior se contiver um ficheiro requirements.txt ou setup.py. Para saber mais, consulte o artigo Instale dependências.

  Tenha em atenção que, mesmo que especifique um diretório de nível superior, este comando apenas copia o diretório principal do seu script de ponto de entrada para a imagem do Docker.

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

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

  Use python-module em vez de script

  Opcionalmente, pode substituir script=SCRIPT_PATH por python-module=PYTHON_MODULE para especificar o nome de um módulo Python em WORKING_DIRECTORY para executar como ponto de entrada para a preparação. Por exemplo, em vez de script=trainer/task.py, pode especificar python-module=trainer.task.

  Neste caso, o contentor Docker resultante carrega o seu código como um módulo em vez de como um script. É provável que queira usar esta opção se o script do ponto de entrada importar outros módulos Python em WORKING_DIRECTORY.

Instale dependências

Quando usa a criação automática de pacotes, pode instalar dependências do Python no seu contentor da mesma forma que está disponível quando usa o comando local-run da CLI gcloud. Para saber mais sobre as várias formas de instalar dependências do Python, leia a secção Instalar dependências do guia para o comando local-run.

A sintaxe para especificar dependências difere ligeiramente quando usa a criação automática de pacotes em comparação com quando usa o comando local-run. Em vez de usar flags da linha de comandos para especificar dependências, tem de usar opções no valor da flag --worker-pool-spec. Além disso, os valores nestas opções têm de ser separados por pontos e vírgulas em vez de vírgulas. Especificamente, a sintaxe:

• Em vez da flag --local-package-path do comando local-run, use a opção local-package-path no valor da flag --worker-pool-spec. Se o diretório de trabalho que especificar com esta opção contiver um ficheiro requirements.txt ou setup.py, a criação automática de pacotes instala dependências com base neste ficheiro.

  O exemplo anterior demonstra esta sintaxe.

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

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

• (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 dos diretórios com vírgulas, use pontos e vírgulas.

O exemplo seguinte mostra como pode instalar dependências usando todas as técnicas opcionais. (Pode especificar qualquer subconjunto das mesmas.) 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 adequados para estes marcadores de posição, consulte "Instalar dependências" no guia do comando local-run.

Sem embalagem automática

Se não usar a embalagem automática, pode criar um CustomJob com um comando semelhante a um dos seguintes. Consoante tenha criado uma aplicação de preparação Python ou uma imagem de contentor personalizada, escolha um dos seguintes separadores:

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

Preparação distribuída

Para realizar a preparação distribuída, especifique a flag --worker-pool-spec várias vezes, uma para cada conjunto de trabalhadores.

Se estiver a usar a embalagem automática, só tem de especificar local-package-path,script e outras opções relacionadas com a embalagem automática no primeiro conjunto de trabalhadores. Omita os campos relacionados com o seu código de formação nos conjuntos de trabalhadores subsequentes, que vão usar todos o mesmo contentor de formação criado pela embalagem automática.

Por exemplo, o comando seguinte adapta um exemplo de autocondicionamento anterior para usar um segundo conjunto de trabalhadores:

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 não estiver a usar a união automática, especifique cada conjunto de trabalhadores de forma completa e independente; não omita nenhum campo.

Os comandos seguintes adaptam exemplos anteriores para usar um segundo conjunto de trabalhadores:

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

Configuração avançada

Se quiser especificar opções de configuração que não estão disponíveis nos exemplos anteriores, pode usar a flag --config para especificar o caminho para um ficheiro config.yaml no seu ambiente local que contenha os campos de CustomJobSpec. Por exemplo:

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

Veja um exemplo de um config.yamlficheiro.

Consola

Na consola Google Cloud , não pode criar um recurso CustomJob diretamente. No entanto, pode criar um recurso TrainingPipeline que crie um CustomJob.

As instruções seguintes descrevem como criar um TrainingPipeline que cria um CustomJob e não faz mais nada. Se quiser usar funcionalidades TrainingPipeline adicionais, como a preparação com um conjunto de dados gerido ou a criação de um recurso Model no final da preparação, leia o artigo Criar pipelines de preparação.

1. Na Google Cloud consola, na secção Vertex AI, aceda à página Pipelines de preparação.

   Aceda a Pipelines de formação

2. Clique em add_box Criar para abrir o painel Formar novo modelo.

3. No passo Método de preparação, especifique as seguintes definições:

   1. Na lista pendente Conjunto de dados, selecione Nenhum conjunto de dados gerido.

   2. Selecione Preparação personalizada (avançada).

   Clique em Continuar.

4. No passo Detalhes do modelo, escolha Treinar novo modelo ou Treinar nova versão. Se selecionar Preparar novo modelo, introduza um nome à sua escolha, MODEL_NAME, para o modelo. Clique em Continuar.

5. No passo Contentor de preparação, especifique as seguintes definições:

   1. Selecione se quer usar um contentor pré-criado ou um contentor personalizado para a preparação.

   2. Consoante a sua escolha, opte por uma das seguintes ações:

      • Se quiser usar um contentor pré-criado para a preparação, forneça ao Vertex AI as informações necessárias para usar o pacote de preparação que carregou para o Cloud Storage:

        1. Use as listas pendentes Estrutura do modelo e Versão da estrutura do modelo para especificar o recipiente predefinido que quer usar.

        2. No campo Localização do pacote, especifique o URI do Cloud Storage da aplicação de preparação Python que criou e carregou. Normalmente, este ficheiro termina com .tar.gz.

        3. No campo Módulo Python, introduza o nome do módulo do ponto de entrada da sua aplicação de preparação.

      • Se quiser usar um contentor personalizado para a preparação, no campo Imagem do contentor, especifique o URI do Artifact Registry ou do Docker Hub da imagem do contentor.

   3. No campo Diretório de saída do modelo, pode especificar o URI do Cloud Storage de um diretório num contentor ao qual tem acesso. O diretório não tem de existir.

      Este valor é transmitido para a Vertex AI no campo baseOutputDirectoryAPI, que define várias variáveis de ambiente às quais a sua aplicação de preparação pode aceder quando é executada.

   4. Opcional: no campo Argumentos, pode especificar argumentos para o Vertex AI usar quando começar a executar o código de preparação. O comprimento máximo de todos os argumentos combinados é de 100 000 carateres. O comportamento destes argumentos difere consoante o tipo de contentor que está a usar:

      • Se estiver a usar um contentor pré-criado, o Vertex AI transmite os argumentos como flags de linha de comandos ao seu módulo Python.

      • Se estiver a usar um contentor personalizado, o Vertex AI substitui a instrução CMD do seu contentor pelos argumentos.

   Clique em Continuar.

6. No passo Aperfeiçoamento de hiperparâmetros, certifique-se de que a caixa de verificação Ativar aperfeiçoamento de hiperparâmetros não está selecionada. Clique em Continuar.

7. No passo Calcular e preços, especifique as seguintes definições:

   1. Na lista pendente Região, selecione uma "região que suporte a preparação personalizada"

   2. Na secção Worker pool 0, especifique os recursos de computação a usar para a preparação.

      Se especificar aceleradores, certifique-se de que o tipo de acelerador que escolher está disponível na região selecionada.

      Se quiser realizar treino distribuído, clique em Adicionar mais conjuntos de trabalhadores e especifique um conjunto adicional de recursos de computação para cada conjunto de trabalhadores adicional que quiser.

   Clique em Continuar.

8. No passo Contentor de previsão, selecione Nenhum contentor de previsão.

9. Clique em Iniciar preparação para iniciar o pipeline de preparação personalizado.

REST

Antes de usar qualquer um dos dados do pedido, faça as seguintes substituições:

• LOCATION: a região onde o contentor ou o pacote Python vai ser executado.
• PROJECT_ID: o seu ID do projeto.
• JOB_NAME: obrigatório. Um nome a apresentar para o CustomJob.
• Defina a tarefa de formação personalizada:
  • MACHINE_TYPE: o tipo de máquina. Consulte os tipos de máquinas disponíveis para a preparação.
  • ACCELERATOR_TYPE: (opcional.) O tipo de acelerador a anexar à tarefa.
  • ACCELERATOR_COUNT: (opcional.) O número de aceleradores a associar à tarefa.
  • DISK_TYPE: (opcional.) O tipo de disco de arranque a usar para a tarefa, pd-standard (predefinição) ou pd-ssd. Saiba mais sobre os tipos de discos.
  • DISK_SIZE: (opcional.) O tamanho em GB do disco de arranque a usar para a tarefa. O valor predefinido é 100.
  • REPLICA_COUNT: o número de réplicas de trabalhadores a usar. Na maioria dos casos, defina esta opção como 1 para o seu primeiro conjunto de trabalhadores.
  • Se a sua aplicação de preparação for executada num contentor personalizado, especifique o seguinte:
    • CUSTOM_CONTAINER_IMAGE_URI: o URI de uma imagem de contentor no Artifact Registry ou no Docker Hub que vai ser executada em cada réplica de worker. /li>
    • CUSTOM_CONTAINER_COMMAND: (opcional.) O comando a invocar quando o contentor é iniciado. Este comando substitui o ponto de entrada predefinido do contentor.
    • CUSTOM_CONTAINER_ARGS: (opcional.) Os argumentos a transmitir quando iniciar o contentor.
  • Se a sua aplicação de preparação for um pacote Python executado num contentor pré-criado, especifique o seguinte:
    • EXECUTOR_IMAGE_URI: o URI da imagem do contentor que executa o código facultado. Consulte os contentores pré-criados disponíveis para formação.
    • PYTHON_PACKAGE_URIS: lista separada por vírgulas de URIs do Cloud Storage que especificam os ficheiros de pacotes Python que são o programa de preparação e os respetivos pacotes dependentes. O número máximo de URIs de pacotes é 100.
    • PYTHON_MODULE: o nome do módulo Python a executar após a instalação dos pacotes.
    • PYTHON_PACKAGE_ARGS: (opcional.) Argumentos da linha de comandos a transmitir ao módulo Python.
  • Saiba mais sobre as opções de agendamento de tarefas.
  • TIMEOUT: (opcional.) O tempo de execução máximo da tarefa.
• Especifique os elementos LABEL_NAME e LABEL_VALUE para todas as etiquetas que quer aplicar a esta tarefa personalizada.

Método HTTP e URL:

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

Corpo JSON do pedido:

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

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

A resposta contém informações sobre as especificações, bem como o 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 experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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_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 como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API.

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,
    )