Configure recursos de computação para o treino personalizado

Quando realiza uma preparação personalizada, o seu código de preparação é executado numa ou mais instâncias de máquinas virtuais (VM). Pode configurar os tipos de MV a usar para a preparação: a utilização de MVs com mais recursos de computação pode acelerar a preparação e permitir-lhe trabalhar com conjuntos de dados maiores, mas também pode incorrer em custos de preparação mais elevados.

Em alguns casos, também pode usar GPUs para acelerar a preparação. As GPUs incorrem em custos adicionais.

Opcionalmente, também pode personalizar o tipo e o tamanho dos discos de arranque das VMs de preparação.

Este documento descreve os diferentes recursos de computação que pode usar para o treino personalizado e como configurá-los.

Faça a gestão do custo e da disponibilidade

Para ajudar a gerir os custos ou garantir a disponibilidade dos recursos de VMs, o Vertex AI oferece o seguinte:

• Para garantir que os recursos de VMs estão disponíveis quando as tarefas de preparação os precisam, pode usar as reservas do Compute Engine. As reservas oferecem um elevado nível de garantia na obtenção de capacidade para recursos do Compute Engine. Para mais informações, consulte o artigo Use reservas com preparação.

• Para reduzir o custo de execução das tarefas de preparação, pode usar VMs de capacidade instantânea. As VMs do Spot são instâncias de máquinas virtuais (VMs) que representam capacidade excedentária do Compute Engine. As VMs do Spot têm descontos significativos, mas o Compute Engine pode parar ou eliminar preventivamente as VMs do Spot para reclamar a capacidade em qualquer altura. Para mais informações, consulte o artigo Use VMs de spot com preparação.

• Para tarefas de preparação personalizadas que pedem recursos de GPU, o Dynamic Workload Scheduler permite-lhe agendar as tarefas com base no momento em que os recursos de GPU pedidos ficam disponíveis. Para mais informações, consulte o artigo Agende tarefas de preparação com base na disponibilidade de recursos.

Onde especificar os recursos de computação

Especifique os detalhes da configuração num elemento WorkerPoolSpec. Consoante a forma como realiza a preparação personalizada, coloque este WorkerPoolSpec num dos seguintes campos da API:

• Se estiver a criar um CustomJob recurso, especifique o WorkerPoolSpec em CustomJob.jobSpec.workerPoolSpecs.

  Se estiver a usar a CLI gcloud, pode usar a flag --worker-pool-spec ou a flag --config no comando gcloud ai custom-jobs create para especificar as opções do conjunto de trabalhadores.

  Saiba mais sobre como criar um CustomJob.

• Se estiver a criar um HyperparameterTuningJob recurso, especifique o WorkerPoolSpec em HyperparameterTuningJob.trialJobSpec.workerPoolSpecs.

  Se estiver a usar a CLI gcloud, pode usar a flag --config no comando gcloud ai hpt-tuning-jobs create para especificar as opções do conjunto de trabalhadores.

  Saiba mais sobre como criar um HyperparameterTuningJob.

• Se estiver a criar um TrainingPipeline recurso sem ajuste de hiperparâmetros, especifique o WorkerPoolSpec em TrainingPipeline.trainingTaskInputs.workerPoolSpecs.

  Saiba como criar um público-alvo personalizado.TrainingPipeline

• Se estiver a criar um TrainingPipeline com o aperfeiçoamento de hiperparâmetros, especifique o WorkerPoolSpec em TrainingPipeline.trainingTaskInputs.trialJobSpec.workerPoolSpecs.

Se estiver a realizar treino distribuído, pode usar diferentes definições para cada conjunto de trabalhadores.

Tipos de máquinas

No seu WorkerPoolSpec, tem de especificar um dos seguintes tipos de máquinas no campo machineSpec.machineType. Cada réplica no conjunto de trabalhadores é executada numa VM separada com o tipo de máquina especificado.

* Os tipos de máquinas marcados com asteriscos na lista anterior têm de ser usados com determinadas GPUs ou TPUs. Consulte as secções seguintes deste guia.

Para saber mais sobre as especificações técnicas de cada tipo de máquina, leia a documentação do Compute Engine sobre os tipos de máquinas. Para saber mais sobre o custo de utilização de cada tipo de máquina para a preparação personalizada, leia o artigo Preços.

Os exemplos seguintes realçam onde especifica um tipo de máquina quando 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,container-image-uri=CUSTOM_CONTAINER_IMAGE_URI

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());
    }
  }
}

/**
 * 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();

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 de criação de um CustomJob.

GPUs

Se escreveu o seu código de preparação para usar GPUs, pode configurar o seu conjunto de trabalhadores para usar uma ou mais GPUs em cada VM. Para usar GPUs, tem de usar um tipo de máquina A2, N1 ou G2. Além disso, a utilização de tipos de máquinas mais pequenos, como n1-highmem-2 com GPUs, pode fazer com que o registo falhe para algumas cargas de trabalho devido a restrições da CPU. Se a tarefa de preparação deixar de devolver registos, considere selecionar um tipo de máquina maior.

A Vertex AI suporta os seguintes tipos de GPU para preparação personalizada:

• NVIDIA_GB200⁺ (inclui GPUDirect-RDMA)
• NVIDIA_B200^* (inclui GPUDirect-RDMA)
• NVIDIA_H100_MEGA_80GB^* (inclui GPUDirect-TCPXO)
• NVIDIA_H100_80GB
• NVIDIA_H200_141GB^* (inclui GPUDirect-RDMA)
• NVIDIA_A100_80GB
• NVIDIA_TESLA_A100 (NVIDIA A100 40GB)
• NVIDIA_TESLA_P4
• NVIDIA_TESLA_P100
• NVIDIA_TESLA_T4
• NVIDIA_TESLA_V100
• NVIDIA_L4

⁺ Requer a obtenção de capacidade através de reservas partilhadas.

Para saber mais acerca da especificação técnica de cada tipo de GPU, leia a documentação resumida do Compute Engine sobre GPUs para cargas de trabalho de computação. Para saber mais sobre o custo de utilização de cada tipo de máquina para o treino personalizado, leia o artigo Preços.

No seu WorkerPoolSpec, especifique o tipo de GPU que quer usar no campo machineSpec.acceleratorType e o número de GPUs que quer que cada VM no conjunto de trabalhadores use no campo machineSpec.acceleratorCount. No entanto, as suas escolhas para estes campos têm de cumprir as seguintes restrições:

• O tipo de GPU que escolher tem de estar disponível na localização onde está a realizar o treino personalizado. Nem todos os tipos de GPU estão disponíveis em todas as regiões. Saiba mais acerca da disponibilidade regional.

• Só pode usar um determinado número de GPUs na sua configuração. Por exemplo, pode usar 2 ou 4 GPUs NVIDIA_TESLA_T4 numa MV, mas não 3. Para ver que valores são válidos para cada tipo de GPU, consulte a seguinte tabela de compatibilidade.acceleratorCount

• Tem de se certificar de que a configuração da GPU fornece CPUs virtuais e memória suficientes para o tipo de máquina com que a usa. Por exemplo, se usar o tipo de máquina n1-standard-32 no seu conjunto de trabalhadores, cada VM tem 32 CPUs virtuais e 120 GB de memória. Uma vez que cada GPU NVIDIA_TESLA_V100 pode fornecer até 12 CPUs virtuais e 76 GB de memória, tem de usar, pelo menos, 4 GPUs para cada VM n1-standard-32 de modo a suportar os respetivos requisitos. (2 GPUs fornecem recursos insuficientes e não pode especificar 3 GPUs.)

  A tabela de compatibilidade seguinte tem em conta este requisito.

  Tenha em atenção a seguinte limitação adicional na utilização de GPUs para o treino personalizado que difere da utilização de GPUs com o Compute Engine:

  • Uma configuração com 4 GPUs NVIDIA_TESLA_P100 só fornece até 64 CPUs virtuais e até 208 GB de memória em todas as regiões e zonas.

• Para tarefas que usam o Dynamic Workload Scheduler ou as VMs Spot, atualize o campo scheduling.strategy do CustomJob para a estratégia escolhida.

A tabela de compatibilidade seguinte apresenta os valores válidos para machineSpec.acceleratorCount consoante as suas escolhas para machineSpec.machineType e machineSpec.acceleratorType:

^* O tipo de máquina especificado só está disponível quando usa o Dynamic Workload Scheduler ou as VMs do Spot.

Os exemplos seguintes realçam onde pode especificar GPUs quando cria um CustomJob:

workerPoolSpecs:
  machineSpec:
    machineType: MACHINE_TYPE
    acceleratorType: ACCELERATOR_TYPE
    acceleratorCount: ACCELERATOR_COUNT
  replicaCount: REPLICA_COUNT
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

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

/**
 * 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();

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 de criação de um CustomJob.

GPUDirect Networking

No Vertex AI Training, algumas máquinas das séries H100, H200, B200 e GB200 são pré-configuradas com a pilha de rede GPUDirect. O GPUDirect pode aumentar a velocidade de rede entre GPUs até 2 vezes em comparação com as GPUs sem GPUDirect.

O GPUDirect faz isto reduzindo a sobrecarga necessária para transferir payloads de pacotes entre GPUs, o que melhora significativamente o débito em grande escala.

GPUDirect-TCPXO

O tipo de máquina a3-megagpu-8g tem:

• 8 GPUs NVIDIA H100 por máquina
• Largura de banda até 200 Gbps na NIC principal
• 8 NICs secundárias que suportam até 200 Gbps para transferência de dados da GPU
• GPUDirect-TCPXO, que melhora ainda mais a comunicação entre a GPU e a VM

As GPUs com GPUDirect estão especialmente equipadas para a preparação distribuída de modelos grandes.

GPUDirect-RDMA

Os a4x-highgpu-4gtipos de máquinas têm:

• 4 GPUs GB200 por máquina
• 2 NICs de anfitrião que oferecem uma largura de banda de 400 Gbps
• 6 NICs que oferecem até 2400 Gbps para transferência de dados da GPU
• GPUDirect-RDMA, que permite um desempenho de rede mais elevado para a comunicação da GPU para cargas de trabalho de preparação de AA em grande escala através de RoCE (RDMA over Converged Ethernet)

Os tipos de máquinas a3-ultragpu-8g e a4-highgpu-8g têm:

• 8 GPUs NVIDIA H200/B200 por máquina
• 2 NICs de anfitrião que oferecem uma largura de banda de 400 Gbps
• 8 NICs que oferecem até 3200 Gbps para transferência de dados da GPU
• GPUDirect-RDMA, que permite um desempenho de rede mais elevado para a comunicação da GPU para cargas de trabalho de preparação de AA em grande escala através de RoCE (RDMA over Converged Ethernet)

TPUs

Para usar unidades de processamento tensorial (TPUs) para preparação personalizada no Vertex AI, pode configurar um conjunto de trabalhadores para usar uma VM da TPU.

Quando usa uma VM de TPU na Vertex AI, só pode usar um único conjunto de trabalhadores para a preparação personalizada e tem de configurar este conjunto de trabalhadores para usar apenas uma réplica.

TPUs v2 e v3

Para usar VMs de TPU v2 ou v3 no seu conjunto de trabalhadores, tem de usar uma das seguintes configurações:

• Para configurar uma VM da TPU com a TPU v2, especifique os seguintes campos em WorkerPoolSpec:

  • Defina machineSpec.machineType como cloud-tpu.
  • Defina machineSpec.acceleratorType como TPU_V2.
  • Defina machineSpec.acceleratorCount como 8 para uma única TPU ou 32 or multiple of 32 para TPU Pods.
  • Defina replicaCount como 1.

• Para configurar uma VM da TPU com a TPU v3, especifique os seguintes campos em WorkerPoolSpec:

  • Defina machineSpec.machineType como cloud-tpu.
  • Defina machineSpec.acceleratorType como TPU_V3.
  • Defina machineSpec.acceleratorCount como 8 para uma única TPU ou 32+ para TPU Pods.
  • Defina replicaCount como 1.

Para obter informações sobre a disponibilidade regional das TPUs, consulte o artigo Usar aceleradores.

TPU v5e

A TPU v5e requer o JAX 0.4.6 ou superior, o TensorFlow 2.15 ou superior, ou o PyTorch 2.1 ou superior. Para configurar uma VM da TPU com a TPU v5e, especifique os seguintes campos no WorkerPoolSpec:

• Defina machineSpec.machineType como ct5lp-hightpu-1t, ct5lp-hightpu-4t ou ct5lp-hightpu-8t.
• Defina machineSpec.tpuTopology para uma topologia suportada para o tipo de máquina. Para ver detalhes, consulte a tabela seguinte.
• Defina replicaCount como 1.

A tabela seguinte mostra os tipos de máquinas e as topologias de TPU v5e que são suportados para a preparação personalizada:

As tarefas de formação personalizadas executadas em VMs de TPU v5e são otimizadas para débito e disponibilidade. Para mais informações, consulte o artigo Tipos de aceleradores de preparação v5e.

Para obter informações sobre a disponibilidade regional das TPUs, consulte o artigo Usar aceleradores. Para mais informações sobre a TPU v5e, consulte o artigo Preparação da Cloud TPU v5e.

Comparação de tipos de máquinas:

TPU v6e

A TPU v6e requer o Python 3.10 ou superior, o JAX 0.4.37 ou superior, o PyTorch 2.1 ou superior com o PJRT como tempo de execução predefinido ou o TensorFlow com apenas a versão 2.18 ou superior do tempo de execução tf-nightly. Para configurar uma VM da TPU com a TPU v6e, especifique os seguintes campos no WorkerPoolSpec:

• Defina machineSpec.machineType como ct6e.
• Defina machineSpec.tpuTopology para uma topologia suportada para o tipo de máquina. Para ver detalhes, consulte a tabela seguinte.
• Defina replicaCount como 1.

A tabela seguinte mostra os tipos de máquinas e as topologias de TPU v6e que são suportados para a preparação personalizada:

Para obter informações sobre a disponibilidade regional das TPUs, consulte o artigo Usar aceleradores. Para mais informações sobre a TPU v6e, consulte o artigo Preparação da Cloud TPU v6e.

Comparação de tipos de máquinas:

Exemplo CustomJob que especifica uma VM da TPU

O exemplo seguinte realça como especificar uma VM da TPU quando cria um CustomJob:

workerPoolSpecs:
  machineSpec:
    machineType: cloud-tpu
    acceleratorType: TPU_V2
    acceleratorCount: 8
  replicaCount: 1
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

workerPoolSpecs:
  machineSpec:
    machineType: ct5lp-hightpu-4t
    tpuTopology: 4x4
  replicaCount: 1
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

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

from google.cloud.aiplatform import aiplatform

job = aiplatform.CustomContainerTrainingJob(
    display_name='DISPLAY_NAME',
    location='us-west1',
    project='PROJECT_ID',
    staging_bucket="gs://CLOUD_STORAGE_URI",
    container_uri='CONTAINER_URI')

job.run(machine_type='ct5lp-hightpu-4t', tpu_topology='2x2')

Para mais informações sobre como criar uma tarefa de preparação personalizada, consulte o artigo Crie tarefas de preparação personalizadas.

Opções do disco de arranque

Opcionalmente, pode personalizar os discos de arranque das suas VMs de preparação. Todas as VMs num worker pool usam o mesmo tipo e tamanho de disco de arranque.

• Para personalizar o tipo de disco de arranque que cada VM de preparação usa, especifique o campo diskSpec.bootDiskType no seu WorkerPoolSpec.

  Pode definir este campo para um dos seguintes valores:

  • pd-standard para usar um disco persistente padrão suportado por um disco rígido padrão
  • pd-ssd para usar um disco persistente SSD suportado por uma unidade de estado sólido
  • hyperdisk-balanced para taxas de IOPS e débito mais elevadas.

  O valor predefinido é pd-ssd (hyperdisk-balanced é o valor predefinido para a3-ultragpu-8g e a4-highgpu-8g).

  A utilização de pd-ssd ou hyperdisk-balanced pode melhorar o desempenho se o seu código de preparação ler e escrever no disco. Saiba mais sobre os tipos de discos. Consulte também as máquinas compatíveis com o hyperdisk.

• Para personalizar o tamanho (em GB) do disco de arranque que cada VM de preparação usa, especifique o campo diskSpec.bootDiskSizeGb no seu WorkerPoolSpec.

  Pode definir este campo como um número inteiro entre 100 e 64 000, inclusive. O valor predefinido é 100.

  Pode querer aumentar o tamanho do disco de arranque se o seu código de preparação escrever muitos dados temporários no disco. Tenha em atenção que todos os dados que escreve no disco de arranque são temporários e não os pode recuperar após a conclusão da preparação.

A alteração do tipo e do tamanho dos discos de arranque afeta os preços do treino personalizado.

Os exemplos seguintes realçam onde pode especificar opções de disco de arranque quando cria um CustomJob:

workerPoolSpecs:
  machineSpec:
    machineType: MACHINE_TYPE
  diskSpec:
    bootDiskType: DISK_TYPE
    bootDiskSizeGb: DISK_SIZE
  replicaCount: REPLICA_COUNT
  containerSpec:
    imageUri: CUSTOM_CONTAINER_IMAGE_URI

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

Para mais contexto, leia o guia de criação de um CustomJob.

O que se segue?

• Saiba como criar um recurso persistente para executar tarefas de preparação personalizadas.
• Saiba como realizar uma preparação personalizada criando um CustomJob.