Definir configurações de contêiner para treinamento personalizado

Ao executar um treinamento personalizado, especifique qual código de machine learning (ML) você quer que a Vertex AI execute. Para fazer isso, defina as configurações do contêiner de treinamento para um contêiner personalizado ou um aplicativo de treinamento em Python que é executado em um contêiner pré-criado.

Para determinar se você quer usar um contêiner personalizado ou pré-criado, leia Requisitos do código de treinamento.

Este documento descreve os campos da API Vertex AI que você precisa especificar em um dos casos anteriores.

Onde especificar as configurações do contêiner

Especifique os detalhes de configuração em um WorkerPoolSpec. Dependendo de como você realiza o treinamento personalizado, coloque esse WorkerPoolSpec em um dos seguintes campos da API:

Se você estiver realizando o treinamento distribuído, use configurações diferentes para cada pool de workers.

Defina as configurações do contêiner

Dependendo se você estiver usando um contêiner pré-criado ou um personalizado, será necessário especificar campos diferentes em WorkerPoolSpec. Selecione a guia do seu cenário:

Contêiner pré-criado

  1. Selecione um contêiner pré-criado compatível com o framework de ML que você planeja usar para o treinamento. Especifique um dos URIs da imagem do contêiner no campo pythonPackageSpec.executorImageUri.

  2. Especifique os URIs do Cloud Storage de seu aplicativo de treinamento em Python no campo pythonPackageSpec.packageUris.

  3. Especifique o módulo de ponto de entrada do aplicativo de treinamento no campo pythonPackageSpec.pythonModule.

  4. Opcionalmente, especifique uma lista de argumentos de linha de comando a serem transmitidos para o módulo de ponto de entrada do seu aplicativo de treinamento no campo pythonPackageSpec.args.

Os exemplos a seguir destacam onde você especifica essas configurações de contêiner ao criar um CustomJob:

Console

No console do Google Cloud, não é possível criar um CustomJob diretamente. No entanto, é possível criar um TrainingPipeline que crie um CustomJob. Ao criar um TrainingPipeline no console do Google Cloud, é possível especificar as configurações de contêiner pré-criadas em determinados campos na etapa do Contêiner de treinamento:

  • pythonPackageSpec.executorImageUri: use as listas suspensas Framework de modelo e Versão do modelo de modelo.

  • pythonPackageSpec.packageUris: use o campo Local do pacote.

  • pythonPackageSpec.pythonModule: use o campo Python Python.

  • pythonPackageSpec.args: use o campo Argumentos.

gcloud

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=PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

Para mais contexto, leia o guia para criar um CustomJob.

Contêiner personalizado

  1. Especifique o URI do Artifact Registry ou do Docker Hub relacionado ao contêiner personalizado no campo containerSpec.imageUri.

  2. Opcionalmente, se você quiser modificar as ENTRYPOINT ou CMD no seu contêiner, especifique a funçãocontainerSpec.command ou containerSpec.args campos para criar um anexo da VLAN de monitoramento. Esses campos afetam como o contêiner é executado de acordo com as regras a seguir:

    • Se você não especificar nenhum campo: seu contêiner será executado de acordo com a instrução ENTRYPOINT e a instrução CMD (se existir). Consulte a documentação do Docker sobre como CMD e ENTRYPOINT interagem (em inglês).

    • Se você especificar apenas containerSpec.command: seu contêiner será executado com o valor de containerSpec.command substituindo a instrução ENTRYPOINT. Se o contêiner tiver uma instrução CMD, ele será ignorado.

    • Se você especificar apenas containerSpec.args: seu contêiner é executado de acordo com a instrução ENTRYPOINT, com o valor de containerSpec.args substituindo a instrução CMD.

    • Se você especificar os dois campos: seu contêiner será executado com containerSpec.command substituindo a instrução ENTRYPOINT e containerSpec.args substituindo a instrução CMD.

O exemplo a seguir destaca onde você pode especificar algumas dessas configurações do contêiner ao criar um CustomJob:

Console

No console do Google Cloud, não é possível criar um CustomJob diretamente. No entanto, é possível criar um TrainingPipeline que crie um CustomJob. Ao criar um TrainingPipeline no console do Google Cloud, é possível especificar configurações de contêiner personalizadas em determinados campos na etapa Contêiner de treinamento:

  • containerSpec.imageUri: use o campo Imagem do contêiner.

  • containerSpec.command: este campo de API não é configurável no console do Google Cloud.

  • containerSpec.args: use o campo Argumentos.

gcloud

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

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_K80)
              .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. 

from google.cloud import aiplatform

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

Para mais contexto, leia o guia para criar um CustomJob.

A seguir