Configura los recursos de procesamiento para el entrenamiento personalizado

Cuando realizas un entrenamiento personalizado, tu código de entrenamiento se ejecuta en una o más instancias de máquina virtual (VM). Puedes configurar qué tipos de VM usar para el entrenamiento: el uso de VM con más recursos de procesamiento puede acelerar el entrenamiento y te permite trabajar con conjuntos de datos más grandes, pero también pueden generar mayores costos de entrenamiento.

En algunos casos, también puedes usar las GPU para acelerar el entrenamiento. Las GPU generan costos adicionales.

De manera opcional, puedes personalizar el tipo y el tamaño de los discos de arranque de tus VM de entrenamiento.

En este documento, se describen los diferentes recursos de procesamiento que puedes usar para el entrenamiento personalizado y cómo configurarlos.

Administra el costo y la disponibilidad

Para ayudar a administrar los costos o garantizar la disponibilidad de los recursos de VM, Vertex AI proporciona lo siguiente:

• Para asegurarte de que los recursos de VM estén disponibles cuando tus trabajos de entrenamiento los necesiten, puedes usar las reservas de Compute Engine. Las reservas proporcionan un nivel de seguridad alto a fin de obtener capacidad para los recursos zonales de Compute Engine. Para obtener más información, consulta Usa reservas con entrenamiento.

• Para reducir el costo de ejecutar tus trabajos de entrenamiento, puedes usar las VMs Spot. Las VMs Spot son instancias de máquina virtual (VM) que son un excedente de capacidad de Compute Engine. Las VMs Spot tienen descuentos significativos, pero Compute Engine podría detener o borrar las VMs Spot de forma preventiva para recuperar la capacidad en cualquier momento. Para obtener más información, consulta Usa VMs Spot con 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 programarlos según el momento en que los recursos de GPU solicitados estén disponibles. Para obtener más información, consulta Programa trabajos de entrenamiento según la disponibilidad de recursos.

Dónde especificar recursos de procesamiento

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

• Si creas un recurso CustomJob, especifica el WorkerPoolSpec en CustomJob.jobSpec.workerPoolSpecs.

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

  Obtén más información sobre cómo crear un CustomJob.

• Si creas un recurso HyperparameterTuningJob, 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 de los grupos de trabajadores.

  Obtén más información sobre cómo crear un HyperparameterTuningJob.

• Si creas un recurso TrainingPipeline sin ajuste de hiperparámetros, especifica el WorkerPoolSpec en TrainingPipeline.trainingTaskInputs.workerPoolSpecs.

  Obtén más información sobre cómo crear un recurso TrainingPipeline personalizado.

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

Si realizas un entrenamiento distribuido, puedes usar opciones de configuración diferentes 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 en el grupo de trabajadores se ejecuta en una VM independiente que tiene el tipo de máquina especificado.

* Los tipos de máquina marcados con asteriscos en la lista anterior deben usarse con ciertas GPU o TPU. Consulta las siguientes secciones de esta guía.

Para obtener más información sobre las especificaciones técnicas de cada tipo de máquina, consulta la documentación de Compute Engine sobre tipos de máquinas. Si deseas obtener información sobre el costo del uso de cada tipo de máquina para el entrenamiento personalizado, lee Precios.

En los siguientes ejemplos, se indica dónde debes especificar el tipo de máquina cuando creas 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_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();

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, lee la guía para crear un CustomJob.

GPU

Si escribiste tu código de entrenamiento para usar GPU, puedes configurar tu grupo de trabajadores a fin de que use una o más GPU en cada VM. Para usar las GPU, debes usar un tipo de máquina A2, N1 o G2. Además, el uso de tipos de máquinas más pequeños, como n1-highmem-2 con GPU, puede hacer que el registro falle en algunas cargas de trabajo debido a restricciones de CPU. Si tu trabajo de entrenamiento deja de mostrar registros, considera seleccionar un tipo de máquina más grande.

Vertex AI es compatible con los siguientes tipos de GPU para el entrenamiento personalizado:

• NVIDIA_H100_80GB
• NVIDIA_A100_80GB
• NVIDIA_TESLA_A100 (NVIDIA A100 40 GB)
• NVIDIA_TESLA_P4
• NVIDIA_TESLA_P100
• NVIDIA_TESLA_T4
• NVIDIA_TESLA_V100
• NVIDIA_L4

Si deseas obtener más información sobre la especificación técnica para cada tipo de GPU, consulta la documentación breve de Compute Engine sobre GPU para cargas de trabajo de procesamiento. Si deseas obtener información sobre el costo del uso de cada tipo de máquina para el entrenamiento personalizado, lee Precios.

En tu WorkerPoolSpec, especifica el tipo de GPU que deseas usar en el campo machineSpec.acceleratorType y la cantidad de GPU que quieres que cada VM en el grupo de trabajadores use en el campomachineSpec.acceleratorCount. Sin embargo, tus elecciones para estos campos deben cumplir con las siguientes restricciones:

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

• Solo puedes usar una cantidad determinada de GPU en tu configuración. Por ejemplo, puedes usar 2 o 4 GPU NVIDIA_TESLA_T4 en una VM, pero no 3. A fin de averiguar 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 CPU virtuales y memoria para el 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 tiene 32 CPU virtuales y 120 GB de memoria. Debido a que cada GPU NVIDIA_TESLA_V100 puede proporcionar hasta 12 CPU virtuales y 76 GB de memoria, debes usar al menos 4 GPU para cada VM n1-standard-32 a fin de cumplir con sus requisitos. (2 GPU no proporcionan los recursos suficientes y no puedes especificar 3 GPU).

  En la siguiente tabla de compatibilidad, se explica este requisito.

  Ten en cuenta la limitación siguiente adicional sobre el uso de GPU para el entrenamiento personalizado que difiere del uso de GPU con Compute Engine:

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

• Para los trabajos que usan el programador de cargas de trabajo dinámico o las VMs Spot, actualiza el campo scheduling.strategy de CustomJob a la estrategia elegida.

En la siguiente tabla de compatibilidad, se enumeran los valores válidos de machineSpec.acceleratorCount según tus elecciones para machineSpec.machineType y machineSpec.acceleratorType:

^* El tipo de máquina especificado solo está disponible cuando se usa el programador dinámico de cargas de trabajo o las VMs Spot.

En los ejemplos siguientes, se indica dónde puedes especificar las GPU cuando creas un 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_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();

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, lee la guía para crear un CustomJob.

TPU

Si deseas usar las Unidades de procesamiento tensorial (TPU) para el entrenamiento personalizado en Vertex AI, puedes configurar un grupo de trabajadores a fin de usar 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 de trabajadores a fin de 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 WorkerPoolSpec:

  • Establece machineSpec.machineType en cloud-tpu.
  • Establece machineSpec.acceleratorType en TPU_V2.
  • Establece machineSpec.acceleratorCount en 8 para una sola TPU o 32 or multiple of 32 en Pods de TPU.
  • Establece replicaCount en 1.

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

  • Establece machineSpec.machineType en cloud-tpu.
  • Establece machineSpec.acceleratorType en TPU_V3.
  • Establece machineSpec.acceleratorCount en 8 para una sola TPU o 32+ en Pods de TPU.
  • Establece replicaCount en 1.

TPU v5e

La 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:

• Establece machineSpec.machineType como ct5lp-hightpu-1t, ct5lp-hightpu-4t o ct5lp-hightpu-8t.
• Establece machineSpec.tpuTopology en una topología compatible para el tipo de máquina. Para obtener más información, consulta la siguiente tabla:
• Establece replicaCount en 1.

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

Los trabajos de entrenamiento personalizados que se ejecutan en las VMs de TPU v5e están optimizados para la capacidad de procesamiento y la disponibilidad. Para obtener más información, consulta los tipos de aceleradores de entrenamiento v5e.

Las máquinas TPU v5e están disponibles en us-west1 y us-west4 para el entrenamiento personalizado de Vertex AI. Para obtener más información sobre TPU v5e, consulta Entrenamiento de Cloud TPU v5e.

Comparación del tipo de máquina:

Ejemplo CustomJob que especifica una VM de TPU

En el siguiente ejemplo, se destaca cómo especificar una VM de TPU cuando se crea 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 un trabajo de entrenamiento personalizado, consulta Crea trabajos de entrenamiento personalizados.

Opciones de disco de arranque

De manera opcional, puedes personalizar los discos de arranque para tus VM de entrenamiento. Todas las VM en un grupo 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.

  Puedes configurar este campo como pd-standard para usar un disco persistente estándar respaldado por un disco duro estándar, o puedes configurarlo como pd-ssd a fin de usar un disco persistente SSD respaldado por una unidad de estado sólido. El valor predeterminado es pd-ssd.

  Usar pd-ssd puede mejorar el rendimiento si tu código de entrenamiento lee y escribe en el disco. Obtén más información sobre los tipos de discos.

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

  Puedes configurar este campo en un número entero entre 100 y 64,000, inclusive. El valor predeterminado es 100.

  Es posible 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 después de completar el entrenamiento.

Cambiar el tipo y el tamaño de los discos de arranque afecta el precio del entrenamiento personalizado.

En los siguientes ejemplos, se destaca dónde puedes especificar opciones del disco de arranque cuando creas 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, lee la guía para crear un CustomJob.

¿Qué sigue?

• Obtén información sobre cómo crear un recurso persistente para ejecutar trabajos de entrenamiento personalizados.
• Obtén información sobre cómo realizar un entrenamiento personalizado mediante la creación de un CustomJob.