Configurar recursos de computación para el entrenamiento personalizado

Cuando realizas un entrenamiento personalizado, tu código de entrenamiento se ejecuta en una o varias instancias de máquina virtual (VM). Puedes configurar los tipos de VM que quieres usar para el entrenamiento: si usas VMs con más recursos de computación, puedes acelerar el entrenamiento y trabajar con conjuntos de datos más grandes, pero también puedes incurrir en costes de entrenamiento más elevados.

En algunos casos, también puedes usar GPUs para acelerar el entrenamiento. Las GPUs conllevan costes adicionales.

También puedes personalizar el tipo y el tamaño de los discos de arranque de tus VMs de entrenamiento.

En este documento se describen los diferentes recursos de computación que puede usar para el entrenamiento personalizado y cómo configurarlos.

Gestionar costes y disponibilidad

Para ayudar a gestionar los costes o asegurar la disponibilidad de los recursos de las VMs, Vertex AI ofrece lo siguiente:

• Para asegurarte de que los recursos de VM estén disponibles cuando los necesiten tus trabajos de entrenamiento, puedes usar reservas de Compute Engine. Las reservas ofrecen un alto nivel de garantía a la hora de obtener capacidad para los recursos de Compute Engine. Para obtener más información, consulta Usar reservas con entrenamiento.

• Para reducir el coste de ejecutar tus trabajos de entrenamiento, puedes usar VMs de acceso puntual. Las VMs de aprovisionamiento esporádico son instancias de máquina virtual (VM) que corresponden a la capacidad excedente de Compute Engine. Las Spot VMs tienen descuentos significativos, pero Compute Engine puede detener o eliminar de forma preventiva las Spot VMs para recuperar la capacidad en cualquier momento. Para obtener más información, consulta Usar VMs de acceso puntual con el entrenamiento.

• En el caso de los trabajos de entrenamiento personalizados que solicitan recursos de GPU, el programador de cargas de trabajo dinámico te permite programar los trabajos en función de cuándo estén disponibles los recursos de GPU solicitados. Para obtener más información, consulta Programar trabajos de entrenamiento en función de la disponibilidad de recursos.

Dónde especificar los recursos de computación

Especifica los detalles de la configuración en un elemento WorkerPoolSpec. En función de cómo realices el entrenamiento personalizado, coloca este WorkerPoolSpec en uno de los siguientes campos de la API:

• Si vas a crear un CustomJob recurso, especifica el WorkerPoolSpec en CustomJob.jobSpec.workerPoolSpecs.

  Si usas la CLI de Google Cloud, puedes usar la marca --worker-pool-spec o la marca --config en el comando gcloud ai custom-jobs create para especificar las opciones del grupo de trabajadores.

  Más información sobre cómo crear un CustomJob

• Si vas a crear un HyperparameterTuningJob recurso, especifica el WorkerPoolSpec en HyperparameterTuningJob.trialJobSpec.workerPoolSpecs.

  Si usas la CLI de gcloud, puedes usar la marca --config en el comando gcloud ai hpt-tuning-jobs create para especificar las opciones del grupo de trabajadores.

  Más información sobre cómo crear un HyperparameterTuningJob

• Si vas a crear un TrainingPipelinerecurso sin ajuste de hiperparámetros, especifica el WorkerPoolSpec en TrainingPipeline.trainingTaskInputs.workerPoolSpecs.

  Más información sobre cómo crear un TrainingPipeline personalizado

• Si vas a crear un TrainingPipeline con ajuste de hiperparámetros, especifica el WorkerPoolSpec en TrainingPipeline.trainingTaskInputs.trialJobSpec.workerPoolSpecs.

Si realizas un entrenamiento distribuido, puedes usar diferentes ajustes para cada grupo de trabajadores.

Tipos de máquina

En tu WorkerPoolSpec, debes especificar uno de los siguientes tipos de máquina en el campo machineSpec.machineType. Cada réplica del grupo de trabajadores se ejecuta en una VM independiente que tiene el tipo de máquina especificado.

* Los tipos de máquinas marcados con asteriscos en la lista anterior deben usarse con determinadas GPUs o TPUs. Consulta las siguientes secciones de esta guía.

Para obtener información sobre las especificaciones técnicas de cada tipo de máquina, consulta la documentación de Compute Engine sobre los tipos de máquinas. Para obtener información sobre el coste de usar cada tipo de máquina para el entrenamiento personalizado, consulta la página Precios.

En los siguientes ejemplos se muestra dónde se especifica un tipo de máquina al crear un 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 obtener más información, consulta la guía para crear un CustomJob.

GPUs

Si has escrito tu código de entrenamiento para usar GPUs, puedes configurar tu grupo de trabajadores para que use una o varias GPUs en cada VM. Para usar GPUs, debes usar un tipo de máquina A2, N1 o G2. Además, si usas tipos de máquinas más pequeños, como n1-highmem-2 con GPUs, es posible que se produzcan errores de registro en algunas cargas de trabajo debido a las limitaciones de la CPU. Si tu trabajo de entrenamiento deja de devolver registros, considera la posibilidad de seleccionar un tipo de máquina más grande.

Vertex AI admite los siguientes tipos de GPU para el entrenamiento personalizado:

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

⁺ Requiere obtener capacidad mediante reservas compartidas.

Para obtener más información sobre las especificaciones técnicas de cada tipo de GPU, consulta la documentación breve de Compute Engine sobre las GPUs para cargas de trabajo de computación. Para obtener información sobre el coste de usar cada tipo de máquina para el entrenamiento personalizado, consulta la sección Precios.

En tu WorkerPoolSpec, especifica el tipo de GPU que quieras usar en el campo machineSpec.acceleratorType y el número de GPUs que quieras que use cada VM del grupo de trabajadores en el campo machineSpec.acceleratorCount. Sin embargo, las opciones que elijas para estos campos deben cumplir las siguientes restricciones:

• El tipo de GPU que elijas debe estar disponible en la ubicación en la que realices el entrenamiento personalizado. No todos los tipos de GPU están disponibles en todas las regiones. Consulta información sobre la disponibilidad por regiones.

• Solo puedes usar un número determinado de GPUs en tu configuración. Por ejemplo, puedes usar 2 o 4 GPUs NVIDIA_TESLA_T4 en una VM, pero no 3. Para ver qué valores de acceleratorCount son válidos para cada tipo de GPU, consulta la siguiente tabla de compatibilidad.

• Debes asegurarte de que tu configuración de GPU proporcione suficientes CPUs virtuales y memoria al tipo de máquina con el que la uses. Por ejemplo, si usas el tipo de máquina n1-standard-32 en tu grupo de trabajadores, cada VM tendrá 32 CPUs virtuales y 120 GB de memoria. Como cada GPU NVIDIA_TESLA_V100 puede proporcionar hasta 12 CPUs virtuales y 76 GB de memoria, debes usar al menos 4 GPUs por cada VM n1-standard-32 para cumplir sus requisitos. (2 GPUs proporcionan recursos insuficientes y no puedes especificar 3 GPUs).

  En la siguiente tabla de compatibilidad se tiene en cuenta este requisito.

  Ten en cuenta la siguiente limitación adicional sobre el uso de GPUs para el entrenamiento personalizado, que es diferente del uso de GPUs con Compute Engine:

  • Una configuración con 4 GPUs NVIDIA_TESLA_P100 solo proporciona hasta 64 CPUs virtuales y hasta 208 GB de memoria en todas las regiones y zonas.

• En el caso de las tareas que usen Dynamic Workload Scheduler o VMs de acceso puntual, actualiza el campo scheduling.strategy del CustomJob a la estrategia elegida.

En la siguiente tabla de compatibilidad se muestran los valores válidos de machineSpec.acceleratorCount en función de las opciones que elijas para machineSpec.machineType y machineSpec.acceleratorType:

^* El tipo de máquina especificado solo está disponible cuando se usa Dynamic Workload Scheduler o máquinas virtuales de Spot.

En los siguientes ejemplos se muestra dónde puede especificar GPUs al crear una 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 obtener más información, consulta la guía para crear un CustomJob.

Redes GPUDirect

En Vertex Training, algunas máquinas de las series H100, H200, B200 y GB200 vienen preconfiguradas con la pila de redes GPUDirect. GPUDirect puede aumentar la velocidad de la red entre GPUs hasta el doble en comparación con las GPUs que no tienen GPUDirect.

GPUDirect lo consigue reduciendo la sobrecarga necesaria para transferir las cargas útiles de los paquetes entre GPUs, lo que mejora significativamente el rendimiento a gran escala.

GPUDirect-TCPXO

El tipo de máquina a3-megagpu-8g tiene lo siguiente:

• 8 GPUs NVIDIA H100 por máquina
• Hasta 200 Gbps de ancho de banda en la NIC principal
• 8 NICs secundarias, cada una de ellas compatible con hasta 200 Gbps para la transferencia de datos de la GPU
• GPUDirect-TCPXO, que mejora aún más la comunicación entre la GPU y la VM

Las GPUs con GPUDirect están especialmente equipadas para el entrenamiento distribuido de modelos grandes.

GPUDirect RDMA

Los tipos de máquina a4x-highgpu-4g tienen las siguientes características:

• 4 GPUs GB200 por máquina
• 2 NICs de host que proporcionan un ancho de banda de 400 Gbps
• 6 NICs que ofrecen hasta 2400 Gbps para la transferencia de datos de GPU
• GPUDirect-RDMA, que permite un mayor rendimiento de la red para la comunicación entre GPUs en cargas de trabajo de entrenamiento de aprendizaje automático a gran escala mediante RoCE (RDMA sobre Ethernet convergente)

Los tipos de máquinas a3-ultragpu-8g y a4-highgpu-8g tienen las siguientes características:

• 8 GPUs NVIDIA H200/B200 por máquina
• 2 NICs de host que proporcionan un ancho de banda de 400 Gbps
• 8 NICs que ofrecen hasta 3200 Gbps para la transferencia de datos de GPU
• GPUDirect-RDMA, que permite un mayor rendimiento de la red para la comunicación entre GPUs en cargas de trabajo de entrenamiento de aprendizaje automático a gran escala mediante RoCE (RDMA sobre Ethernet convergente)

TPUs

Para usar unidades de procesamiento de tensor (TPUs) en el entrenamiento personalizado en Vertex AI, puedes configurar un grupo de trabajadores para que use una VM de TPU.

Cuando usas una VM de TPU en Vertex AI, solo debes usar un grupo de trabajadores para el entrenamiento personalizado y debes configurar este grupo para que use solo una réplica.

TPU v2 y v3

Para usar VMs de TPU v2 o v3 en tu grupo de trabajadores, debes usar una de las siguientes configuraciones:

• Para configurar una VM de TPU con TPU v2, especifica los siguientes campos en el WorkerPoolSpec:

  • Asigna el valor cloud-tpu a machineSpec.machineType.
  • Asigna el valor TPU_V2 a machineSpec.acceleratorType.
  • Asigna el valor 8 a machineSpec.acceleratorCount para una sola TPU o 32 or multiple of 32 para pods de TPUs.
  • Asigna el valor 1 a replicaCount.

• Para configurar una VM de TPU con TPU v3, especifica los siguientes campos en WorkerPoolSpec:

  • Asigna el valor cloud-tpu a machineSpec.machineType.
  • Asigna el valor TPU_V3 a machineSpec.acceleratorType.
  • Asigna el valor 8 a machineSpec.acceleratorCount para una sola TPU o 32+ para pods de TPUs.
  • Asigna el valor 1 a replicaCount.

Para obtener información sobre la disponibilidad regional de las TPUs, consulta el artículo Usar aceleradores.

TPU v5e

TPU v5e requiere JAX 0.4.6+, TensorFlow 2.15+ o PyTorch 2.1+. Para configurar una VM de TPU con TPU v5e, especifica los siguientes campos en WorkerPoolSpec:

• Asigna a machineSpec.machineType el valor ct5lp-hightpu-1t, ct5lp-hightpu-4t o ct5lp-hightpu-8t.
• Asigna a machineSpec.tpuTopology una topología compatible con el tipo de máquina. Para obtener más información, consulta la tabla que se incluye más abajo.
• Asigna el valor 1 a replicaCount.

En la siguiente tabla se muestran los tipos de máquinas y las topologías de TPU v5e que se admiten para el entrenamiento personalizado:

Las tareas de entrenamiento personalizadas que se ejecutan en VMs de TPU v5e están optimizadas para el rendimiento y la disponibilidad. Para obtener más información, consulta Tipos de aceleradores de entrenamiento v5e.

Para obtener información sobre la disponibilidad regional de las TPUs, consulta el artículo Usar aceleradores. Para obtener más información sobre la versión 5e de TPU, consulta Entrenamiento con la versión 5e de TPU de Cloud.

Comparación de tipos de máquinas:

TPU v6e

TPU v6e requiere Python 3.10+, JAX 0.4.37+, PyTorch 2.1+ con PJRT como tiempo de ejecución predeterminado o TensorFlow con solo la versión 2.18+ del tiempo de ejecución tf-nightly. Para configurar una VM de TPU con TPU v6e, especifica los siguientes campos en WorkerPoolSpec:

• Asigna el valor ct6e a machineSpec.machineType.
• Asigna a machineSpec.tpuTopology una topología compatible con el tipo de máquina. Para obtener más información, consulta la tabla que se incluye más abajo.
• Asigna el valor 1 a replicaCount.

En la siguiente tabla se muestran los tipos de máquinas y las topologías de TPU v6e que se admiten para el entrenamiento personalizado:

Para obtener información sobre la disponibilidad regional de las TPUs, consulta el artículo Usar aceleradores. Para obtener más información sobre la versión 6e de TPU, consulta el artículo sobre entrenamiento con la versión 6e de TPU de Cloud.

Comparación de tipos de máquinas:

Ejemplo CustomJob para especificar una VM de TPU

En el siguiente ejemplo se muestra cómo especificar una VM de TPU al crear un 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 obtener más información sobre cómo crear una tarea de entrenamiento personalizada, consulta Crear tareas de entrenamiento personalizadas.

Opciones de disco de arranque

También puedes personalizar los discos de arranque de tus VMs de entrenamiento. Todas las máquinas virtuales de un pool de trabajadores usan el mismo tipo y tamaño de disco de arranque.

• Para personalizar el tipo de disco de arranque que usa cada VM de entrenamiento, especifica el campo diskSpec.bootDiskType en tu WorkerPoolSpec.

  Puede asignar a este campo uno de los siguientes valores:

  • pd-standard para usar un disco persistente estándar respaldado por un disco duro estándar
  • pd-ssd para usar un disco persistente SSD respaldado por una unidad de estado sólido
  • hyperdisk-balanced para obtener tasas de IOPS y rendimiento más altas.

  El valor predeterminado es pd-ssd (hyperdisk-balanced es el valor predeterminado de a3-ultragpu-8g y a4-highgpu-8g).

  Usar pd-ssd o hyperdisk-balanced puede mejorar el rendimiento si tu código de entrenamiento lee y escribe en el disco. Consulta información sobre los tipos de discos. Consulta también las máquinas compatibles con hiperdisco.

• Para personalizar el tamaño (en GB) del disco de arranque que usa cada VM de entrenamiento, especifica el diskSpec.bootDiskSizeGb campo en tu WorkerPoolSpec.

  Puedes asignar a este campo un número entero entre 100 y 64.000 (ambos inclusive). El valor predeterminado es 100.

  Puede que quieras aumentar el tamaño del disco de arranque si tu código de entrenamiento escribe muchos datos temporales en el disco. Ten en cuenta que los datos que escribas en el disco de arranque son temporales y no podrás recuperarlos una vez que se haya completado el entrenamiento.

Si cambias el tipo y el tamaño de los discos de arranque, se verá afectado el precio del entrenamiento personalizado.

En los siguientes ejemplos se destaca dónde puede especificar las opciones de disco de arranque al crear un 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 obtener más información, consulta la guía para crear un CustomJob.

Siguientes pasos

• Consulta cómo crear un recurso persistente para ejecutar tareas de entrenamiento personalizadas.
• Consulta cómo llevar a cabo un entrenamiento personalizado creando un CustomJob.