Configurer des ressources de calcul pour l'entraînement personnalisé

Lorsque vous réalisez un entraînement personnalisé, votre code d'entraînement s'exécute sur une ou plusieurs instances de machine virtuelle (VM). Vous pouvez configurer les types de VM à utiliser pour l'entraînement : l'utilisation de VM avec davantage de ressources de calcul peut accélérer l'entraînement et vous permettre de travailler avec des ensembles de données plus volumineux, mais peut également entraîner des coûts d'entraînement plus élevés.

Dans certains cas, vous pouvez également utiliser des GPU pour accélérer l'entraînement. Les GPU entraînent des coûts supplémentaires.

Vous pouvez également personnaliser le type et la taille des disques de démarrage des VM d'entraînement.

Ce document décrit les différentes ressources de calcul que vous pouvez utiliser pour l'entraînement personnalisé et explique comment les configurer.

Où spécifier les ressources de calcul

Spécifiez les détails de la configuration dans un objet WorkerPoolSpec. Selon votre type d'entraînement personnalisé, placez cet objet WorkerPoolSpec dans l'un des champs d'API suivants :

Si vous réalisez un entraînement distribué, vous pouvez utiliser des paramètres différents pour chaque pool de nœuds de calcul.

Types de machine

Dans votre WorkerPoolSpec, vous devez spécifier l'un des types de machines suivants dans le champ machineSpec.machineType. Chaque instance dupliquée du pool de nœuds de calcul s'exécute sur une VM distincte dotée du type de machine spécifié.

  • a2-ultragpu-1g*
  • a2-ultragpu-2g*
  • a2-ultragpu-4g*
  • a2-ultragpu-8g*
  • a2-highgpu-1g*
  • a2-highgpu-2g*
  • a2-highgpu-4g*
  • a2-highgpu-8g*
  • a2-megagpu-16g*
  • a3-highgpu-8g*
  • e2-standard-4
  • e2-standard-8
  • e2-standard-16
  • e2-standard-32
  • e2-highmem-2
  • e2-highmem-4
  • e2-highmem-8
  • e2-highmem-16
  • e2-highcpu-16
  • e2-highcpu-32
  • n2-standard-4
  • n2-standard-8
  • n2-standard-16
  • n2-standard-32
  • n2-standard-48
  • n2-standard-64
  • n2-standard-80
  • n2-highmem-2
  • n2-highmem-4
  • n2-highmem-8
  • n2-highmem-16
  • n2-highmem-32
  • n2-highmem-48
  • n2-highmem-64
  • n2-highmem-80
  • n2-highcpu-16
  • n2-highcpu-32
  • n2-highcpu-48
  • n2-highcpu-64
  • n2-highcpu-80
  • n1-standard-4
  • n1-standard-8
  • n1-standard-16
  • n1-standard-32
  • n1-standard-64
  • n1-standard-96
  • n1-highmem-2
  • n1-highmem-4
  • n1-highmem-8
  • n1-highmem-16
  • n1-highmem-32
  • n1-highmem-64
  • n1-highmem-96
  • n1-highcpu-16
  • n1-highcpu-32
  • n1-highcpu-64
  • n1-highcpu-96
  • c2-standard-4
  • c2-standard-8
  • c2-standard-16
  • c2-standard-30
  • c2-standard-60
  • ct5lp-hightpu-1t*
  • ct5lp-hightpu-4t*
  • ct5lp-hightpu-8t*
  • c2-standard-60
  • c2-standard-60
  • c2-standard-60
  • c2-standard-60
  • m1-ultramem-40
  • m1-ultramem-80
  • m1-ultramem-160
  • m1-megamem-96
  • g2-standard-4*
  • g2-standard-8*
  • g2-standard-12*
  • g2-standard-16*
  • g2-standard-24*
  • g2-standard-32*
  • g2-standard-48*
  • g2-standard-96*
  • cloud-tpu*

* Les types de machines marqués par un astérisque dans la liste ci-dessus doivent être utilisés avec certains GPU ou TPU. Consultez les sections suivantes de ce guide.

Pour en savoir plus sur les caractéristiques techniques de chaque type de machine, consultez la documentation de Compute Engine sur les types de machines. Pour en savoir plus sur le coût d'utilisation de chaque type de machine pour l'entraînement personnalisé, consultez la page Tarifs.

Les exemples suivants indiquent où spécifier un type de machine lorsque vous créez un CustomJob :

Console

Dans la console Google Cloud, vous ne pouvez pas créer directement un CustomJob. Toutefois, vous pouvez créer un TrainingPipeline qui crée un objet CustomJob. Lorsque vous créez un TrainingPipeline dans la console Google Cloud, spécifiez un type de machine pour chaque pool de nœuds de calcul lors de l'étape Options de calcul et tarifs, dans la section Type de machine.

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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'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)

Pour plus de contexte, lisez le guide de création d'un CustomJob.

GPU

Si vous avez rédigé votre code d'entraînement pour utiliser des GPU, vous pouvez configurer votre pool de nœuds de calcul de sorte qu'il utilise un ou plusieurs GPU sur chaque VM. Pour utiliser des GPU, vous devez utiliser un type de machine A2, N1 ou G2. En outre, l'utilisation de types de machines de capacité moindre, tels que n1-highmem-2, avec des GPU peut entraîner l'échec de la journalisation avec certaines charges de travail, en raison des contraintes exercées sur le processeur. Si votre job d'entraînement arrête de renvoyer des journaux, envisagez de sélectionner un type de machine de capacité supérieure.

Vertex AI est compatible avec les types de GPU suivants pour l'entraînement personnalisé :

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

Pour en savoir plus sur les caractéristiques techniques de chaque type de GPU, consultez la documentation courte de Compute Engine sur les GPU pour les charges de travail de calcul. Pour en savoir plus sur le coût d'utilisation de chaque type de machine pour l'entraînement personnalisé, consultez la page Tarifs.

Dans votre WorkerPoolSpec, spécifiez le type de GPU que vous souhaitez utiliser dans le champ machineSpec.acceleratorType et le nombre de GPU que vous souhaitez associer à chaque VM du pool de nœuds de calcul dans le champ machineSpec.acceleratorCount. Toutefois, vos choix pour ces champs doivent respecter les restrictions suivantes :

  • Le type de GPU que vous choisissez doit être disponible à l'emplacement où vous effectuez l'entraînement personnalisé. Certains types de GPU ne sont pas disponibles dans toutes les régions. Apprenez-en plus sur la disponibilité régionale.

  • Vous ne pouvez utiliser qu'un certain nombre de GPU dans votre configuration. Par exemple, vous pouvez utiliser deux ou quatre GPU NVIDIA_TESLA_T4 sur une VM, mais pas trois. Pour connaître les valeurs acceleratorCount valides pour chaque type de GPU, consultez le tableau de compatibilité suivant.

  • Vous devez vous assurer que votre configuration de GPU fournit suffisamment de processeurs virtuels et de mémoire pour le type de machine que vous utilisez. Par exemple, si vous utilisez le type de machine n1-standard-32 dans votre pool de nœuds de calcul, chaque VM dispose de 32 processeurs virtuels et de 120 Go de mémoire. Comme chaque GPU NVIDIA_TESLA_V100 peut fournir jusqu'à 12 processeurs virtuels et 76 Go de mémoire, vous devez utiliser au moins quatre GPU pour chaque VM n1-standard-32 afin de répondre à ses besoins. (deux GPU fournissent des ressources insuffisantes et vous ne pouvez pas spécifier trois GPU).

    Le tableau de compatibilité suivant tient compte de cette exigence.

    Notez que les limites supplémentaires ci-dessous s'appliquent à l'utilisation de GPU pour l'entraînement personnalisé (qui diffère de l'utilisation des GPU avec Compute Engine) :

    • Une configuration avec quatre GPU NVIDIA_TESLA_P100 ne fournit que jusqu'à 64 processeurs virtuels et jusqu'à 208 Go de mémoire dans l'ensemble des régions et zones.

Le tableau de compatibilité suivant répertorie les valeurs valides pour machineSpec.acceleratorCount en fonction de vos choix pour machineSpec.machineType et machineSpec.acceleratorType :

h
Nombre de GPU autorisés pour chaque type de machine
Type de machine NVIDIA_H100_80GB NVIDIA_A100_80GB NVIDIA_TESLA_A100 NVIDIA_TESLA_P4 NVIDIA_TESLA_P100 NVIDIA_TESLA_T4 NVIDIA_TESLA_V100 NVIDIA_L4
a3-highgpu-8g 8
a2-ultragpu-1g 1
a2-ultragpu-2g 2
a2-ultragpu-4g 4
a2-ultragpu-8g 8
a2-highgpu-1g 1
a2-highgpu-2g 2
a2-highgpu-4g 4
a2-highgpu-8g 8
a2-megagpu-16g 16
n1-standard-4 1, 2, 4 1, 2, 4 1, 2, 4 1, 2, 4, 8
n1-standard-8 1, 2, 4 1, 2, 4 1, 2, 4 1, 2, 4, 8
n1-standard-16 1, 2, 4 1, 2, 4 1, 2, 4 2, 4, 8
n1-standard-32 2, 4 2, 4 2, 4 4, 8
n1-standard-64 4 4 8
n1-standard-96 4 4 8
n1-highmem-2 1, 2, 4 1, 2, 4 1, 2, 4 1, 2, 4, 8
n1-highmem-4 1, 2, 4 1, 2, 4 1, 2, 4 1, 2, 4, 8
n1-highmem-8 1, 2, 4 1, 2, 4 1, 2, 4 1, 2, 4, 8
n1-highmem-16 1, 2, 4 1, 2, 4 1, 2, 4 2, 4, 8
n1-highmem-32 2, 4 2, 4 2, 4 4, 8
n1-highmem-64 4 4 8
n1-highmem-96 4 4 8
n1-highcpu-16 1, 2, 4 1, 2, 4 1, 2, 4 2, 4, 8
n1-highcpu-32 2, 4 2, 4 2, 4 4, 8
n1-highcpu-64 4 4 4 8
n1-highcpu-96 4 4 8
g2-standard-4 1
g2-standard-8 1
g2-standard-12 1
g2-standard-16 1
g2-standard-24 2
g2-standard-32 1
g2-standard-48 4
g2-standard-96 8

Les exemples suivants indiquent où spécifier des GPU lorsque vous créez un CustomJob :

Console

Dans la console Google Cloud, vous ne pouvez pas créer directement un CustomJob. Cependant, vous pouvez créer un TrainingPipeline qui crée un objet CustomJob. Lorsque vous créez un TrainingPipeline dans la console Google Cloud, vous pouvez spécifier des GPU pour chaque pool de nœuds de calcul lors de l'étape Options de calcul et tarifs. Commencez par spécifier un type de machine. Vous pouvez ensuite spécifier les détails concernant les GPU dans les champs Type d'accélérateur et Nombre d'accélérateurs.

gcloud

Pour spécifier des GPU à l'aide de l'outil Google Cloud CLI, vous devez utiliser un fichier config.yaml. Exemple :

config.yaml

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

Exécutez ensuite une commande semblable à celle-ci :

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

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'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)

Pour plus de contexte, lisez le guide de création d'un CustomJob.

TPU

Pour utiliser des TPU (Tensor Processing Units) pour l'entraînement personnalisé sur Vertex AI, vous pouvez configurer un pool de nœuds de calcul pour utiliser une VM TPU.

Lorsque vous utilisez une VM TPU dans Vertex AI, vous ne devez utiliser qu'un seul pool de nœuds de calcul pour l'entraînement personnalisé. Vous devez le configurer de sorte qu'il n'utilise qu'une seule instance dupliquée.

TPU v2 et v3

Pour utiliser des VM TPU v2 ou TPU v3 dans votre pool de nœuds de calcul, vous devez utiliser l'une des configurations suivantes :

  • Pour configurer une VM TPU avec TPU v2, spécifiez les champs suivants dans WorkerPoolSpec :

    • Définissez machineSpec.machineType sur cloud-tpu.
    • Définissez machineSpec.acceleratorType sur TPU_V2.
    • Définissez machineSpec.acceleratorCount sur 8 pour un seul TPU ou 32 or multiple of 32 pour les pods TPU.
    • Définissez replicaCount sur 1.

  • Pour configurer une VM TPU avec TPU v3, spécifiez les champs suivants dans WorkerPoolSpec :

    • Définissez machineSpec.machineType sur cloud-tpu.
    • Définissez machineSpec.acceleratorType sur TPU_V3.
    • Définissez machineSpec.acceleratorCount sur 8 pour un seul TPU ou 32+ pour les pods TPU.
    • Définissez replicaCount sur 1.

TPU v5e

TPU v5e nécessite JAX 0.4.6+, TensorFlow 2.15+ ou PyTorch 2.1+. Pour configurer une VM TPU avec TPU v5e, spécifiez les champs suivants dans WorkerPoolSpec :

  • Définissez machineSpec.machineType sur ct5lp-hightpu-1t, ct5lp-hightpu-4t ou ct5lp-hightpu-8t.
  • Définissez machineSpec.tpuTopology sur une topologie compatible avec le type de machine. Pour en savoir plus, consultez le tableau suivant.
  • Définissez replicaCount sur 1.

Le tableau suivant présente les types de machines et les topologies TPU v5e compatibles avec l'entraînement personnalisé :

Type de machine Topology Nombre de puces TPU Nombre de VM Cas d'utilisation recommandé
ct5lp-hightpu-1t 1x1 1 1 Entraînement à petite et moyenne échelle
ct5lp-hightpu-4t 2x2 4 1 Entraînement à petite et moyenne échelle
ct5lp-hightpu-8t 2x4 8 1 Entraînement à petite et moyenne échelle
ct5lp-hightpu-4t 2x4 8 2 Entraînement à petite et moyenne échelle
ct5lp-hightpu-4t 4x4 16 4 Entraînement à grande échelle
ct5lp-hightpu-4t 4x8 32 8 Entraînement à grande échelle
ct5lp-hightpu-4t 8x8 64 16 Entraînement à grande échelle
ct5lp-hightpu-4t 8x16 128 32 Entraînement à grande échelle
ct5lp-hightpu-4t 16x16 256 64 Entraînement à grande échelle

Les jobs d'entraînement personnalisés exécutés sur des VM TPU v5e sont optimisés pour le débit et la disponibilité. Pour en savoir plus, consultez la section Types d'accélérateurs d'entraînement v5e.

Les machines TPU v5e sont disponibles dans us-west1 et us-west4 pour l'entraînement personnalisé Vertex AI. Pour en savoir plus sur les TPU v5e, consultez la page Entraînement Cloud TPU v5e.

Comparaison des types de machines :

Type de machine ct5lp-hightpu-1t ct5lp-hightpu-4t ct5lp-hightpu-8t
Nombre de puces v5e 1 4 8
Nombre de vCPU 24 112 224
Mémoire RAM (Go) 48 192 384
Nombre de nœuds NUMA 1 1 2
Probabilité de préemption Élevée Moyenne Faible

Exemple de CustomJob spécifiant une VM TPU

L'exemple suivant montre comment spécifier une VM TPU lors de la création d'une tâche personnalisée (CustomJob) :

gcloud

Pour spécifier une VM TPU à l'aide de l'outil gcloud CLI, vous devez utiliser un fichier config.yaml. Sélectionnez l'un des onglets suivants pour voir un exemple :

TPU v2/v3 

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

TPU v5e 

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

Exécutez ensuite une commande semblable à celle-ci :

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

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Python.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Pour spécifier une VM TPU à l'aide de SDK Vertex AI pour Python, consultez l'exemple suivant :

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

Pour en savoir plus sur la création d'un job d'entraînement personnalisé, consultez la section Créer des jobs d'entraînement personnalisés.

Options du disque de démarrage

Vous pouvez éventuellement personnaliser les disques de démarrage pour vos VM d'entraînement. Toutes les VM d'un pool de nœuds de calcul utilisent le même type et la même taille de disque de démarrage.

  • Pour personnaliser le type de disque de démarrage utilisé par chaque VM d'entraînement, spécifiez le champ diskSpec.bootDiskType dans votre WorkerPoolSpec.

    Vous pouvez définir ce champ sur pd-standard pour utiliser un disque persistant standard avec sauvegarde sur disque dur standard ou le définir sur pd-ssd pour utiliser un disque persistant SSD avec sauvegarde sur disque dur SSD. La valeur par défaut est pd-ssd.

    L'utilisation de pd-ssd peut améliorer les performances si votre code d'entraînement lit et écrit sur le disque. Obtenez plus d'informations sur les types de disques.

  • Pour personnaliser la taille (en Go) du disque de démarrage utilisé par chaque VM d'entraînement, procédez comme suit : spécifiez le champ diskSpec.bootDiskSizeGb dans votre WorkerPoolSpec.

    Vous pouvez définir ce champ sur un entier compris entre 100 et 64 000 inclus. La valeur par défaut est 100.

    Vous pouvez envisager d'augmenter la taille du disque de démarrage si votre code d'entraînement écrit un grand nombre de données temporaires sur le disque. Notez que toutes les données que vous écrivez sur le disque de démarrage sont temporaires et ne peuvent pas être récupérées une fois l'entraînement terminé.

La modification du type et de la taille de vos disques de démarrage affecte les tarifs de l'entraînement personnalisé.

Les exemples suivants mettent en évidence les cas où vous pouvez spécifier des options de disque de démarrage lorsque vous créez un CustomJob :

Console

Dans la console Google Cloud, vous ne pouvez pas créer directement un CustomJob. Cependant, vous pouvez créer un TrainingPipeline qui crée un objet CustomJob. Lorsque vous créez un TrainingPipeline dans la console Google Cloud, vous pouvez spécifier des options de disque de démarrage pour chaque pool de nœuds de calcul à l'étape Options de calcul et tarifs, dans la liste déroulante Type de disque et le champ Taille du disque (Go).

gcloud

Pour spécifier des options de disque de démarrage à l'aide de l'outil Google Cloud CLI, vous devez utiliser un fichier config.yaml. Exemple :

config.yaml

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

Exécutez ensuite une commande semblable à celle-ci :

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

Pour plus de contexte, lisez le guide de création d'un CustomJob.

Étapes suivantes