Créer des tâches d'entraînement personnalisées

Les tâches d'entraînement personnalisées (ressources CustomJob dans l'API Vertex AI) constituent le moyen de base pour exécuter votre code d'entraînement de machine learning (ML) personnalisé dans Vertex AI.

Avant d'envoyer une tâche

Avant de créer une tâche CustomJob dans Vertex AI, vous devez créer une application d'entraînement Python ou une image de conteneur personnalisée pour définir le code d'entraînement et les dépendances que vous souhaitez exécuter sur Vertex AI.

Nous vous recommandons d'utiliser la fonctionnalité d'empaquetage automatique de Google Cloud CLI, décrite dans une section ultérieure de ce guide, pour créer une image de conteneur Docker à partir du code sur votre ordinateur local, transférer cette image de conteneur vers Artifact Registry et créer un objet CustomJob, le tout à l'aide d'une seule commande.

Sinon, vous devez créer manuellement une application d'entraînement Python ou une image de conteneur personnalisée.

Si vous ne savez pas quelle option choisir, reportez-vous aux exigences concernant le code d'entraînement pour en savoir plus.

Contenu d'une tâche personnalisée

Lorsque vous créez une tâche personnalisée, vous spécifiez les paramètres dont Vertex AI a besoin pour exécuter votre code d'entraînement, y compris :

Au sein des pools de nœuds de calcul, vous pouvez spécifier les paramètres suivants :

Vous pouvez également configurer des tâches personnalisées pour qu'elles s'exécutent sur une ressource persistante au lieu de créer de nouvelles ressources de calcul lors du démarrage de la tâche. Pour en savoir plus sur les ressources persistantes, consultez la section Présentation des ressources persistantes.

Configurer l'entraînement distribué

Vous pouvez configurer une tâche CustomJob pour l'entraînement distribué en spécifiant plusieurs pools de nœuds de calcul.

La plupart des exemples de cette page présentent des tâches d'entraînement à instance dupliquée unique avec un pool de nœuds de calcul. Pour les modifier pour un entraînement distribué, procédez comme suit :

  • Utilisez votre premier pool de nœuds de calcul pour configurer votre instance dupliquée principale, puis définissez le nombre d'instances dupliquées sur 1.
  • Ajoutez ensuite d'autres pools de nœuds de calcul pour configurer des instances dupliquées de nœuds de calcul, des instances dupliquées de serveurs de paramètres ou des instances dupliquées d'évaluateurs, si votre framework de machine learning est compatible avec ces tâches de cluster supplémentaires pour l'entraînement distribué.

Découvrez comment utiliser l'entraînement distribué.

Créer un objet CustomJob

Pour créer un objet CustomJob, suivez les instructions de l'un des onglets suivants, selon l'outil que vous souhaitez utiliser. Si vous utilisez la CLI gcloud, vous pouvez utiliser une seule commande pour empaqueter automatiquement le code d'entraînement de votre ordinateur local dans une image de conteneur Docker, transférer l'image de conteneur dans Artifact Registry, puis créer une CustomJob. D'autres options supposent que vous ayez déjà créé une application d'entraînement Python ou une image de conteneur personnalisée.

gcloud

Les exemples suivants utilisent la commande gcloud ai custom-jobs create.

Si votre code d'entraînement se trouve sur votre ordinateur local, nous vous recommandons de suivre la section Avec empaquetage automatique. Si vous avez déjà créé une application d'entraînement Python ou une image de conteneur personnalisée, passez à la section Sans empaquetage automatique.

Avec empaquetage automatique

Si vous disposez d'un code d'entraînement sur votre ordinateur local, vous pouvez utiliser une seule commande pour effectuer les opérations suivantes :

  • Créer une image Docker personnalisée basée sur votre code
  • Transférer l'image vers Artifact Registry
  • Démarrer une opération CustomJob basée sur l'image

Le résultat est semblable à la création d'un CustomJob à l'aide de tout autre conteneur personnalisé. Vous pouvez utiliser cette version de la commande si cela convient à votre workflow.

Avant de commencer

Étant donné que cette version de la commande crée et transfère une image Docker, vous devez effectuer la configuration suivante sur votre ordinateur local :

  1. Installez Docker Engine

  2. Si vous utilisez Linux, configurez Docker pour pouvoir l'exécuter sans sudo.

  3. Enable the Artifact Registry API.

    Enable the API

  4. Configurez l'authentification pour Docker afin de pouvoir stocker des images Docker dans Artifact Registry :

    gcloud auth configure-docker

Créez et transférez l'image Docker, puis créez une tâche CustomJob.

La commande suivante permet de créer une image Docker basée sur une image de conteneur d'entraînement prédéfinie et votre code Python local, de transférer l'image vers Artifact Registry et de créer un fichier CustomJob.

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH

Remplacez les éléments suivants :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.

  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.

  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.

  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.

  • EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le code fourni. Pour en savoir plus, consultez la liste des conteneurs prédéfinis disponibles pour l'entraînement.

    Cette image sert d'image de base pour la nouvelle image Docker que vous créez à l'aide de cette commande.

  • WORKING_DIRECTORY : répertoire de votre système de fichiers local contenant le script de point d'entrée qui exécute le code d'entraînement (consultez l'élément de liste suivant).

    Vous pouvez utiliser le répertoire parent du script ou un répertoire de niveau supérieur. Si vous souhaitez spécifier un nom de module Python complet, vous pouvez utiliser un répertoire de niveau supérieur (voir l'élément de liste suivant). Vous pouvez également utiliser un répertoire de niveau supérieur s'il contient un fichier requirements.txt ou setup.py. Pour en savoir plus, consultez la section Installer des dépendances.

    Toutefois, même si vous spécifiez un répertoire de niveau supérieur, cette commande ne copie que le répertoire parent de votre script de point d'entrée dans l'image Docker.

  • SCRIPT_PATH : chemin d'accès, par rapport à WORKING_DIRECTORY sur votre système de fichiers local, vers le script qui est le point d'entrée de votre code d'entraînement. Il peut s'agir d'un script Python (se terminant par .py) ou d'un script Bash.

    Par exemple, si vous souhaitez exécuter /hello-world/trainer/task.py et que WORKING_DIRECTORY est défini sur /hello-world, utilisez trainer/task.py pour cette valeur.

    Utilisez python-module à la place de script.

    Vous pouvez éventuellement remplacer script=SCRIPT_PATH par python-module=PYTHON_MODULE pour spécifier dans WORKING_DIRECTORY le nom d'un module Python à exécuter en tant que point d'entrée pour l'entraînement. Par exemple, au lieu de script=trainer/task.py, vous pouvez spécifier python-module=trainer.task.

    Dans ce cas, le conteneur Docker obtenu charge votre code en tant que module plutôt que sous forme de script. Vous souhaiterez probablement utiliser cette option si votre script de point d'entrée importe d'autres modules Python dans WORKING_DIRECTORY.

Installer des dépendances

Lorsque vous utilisez l'empaquetage automatique, vous pouvez installer des dépendances Python dans votre conteneur de la même manière que lorsque vous utilisez la commande local-run de la CLI gcloud. Pour en savoir plus sur les différentes manières d'installer des dépendances Python, consultez la section Installer des dépendances du guide sur la commande local-run.

La syntaxe de spécification des dépendances diffère légèrement lorsque vous utilisez l'empaquetage automatique par rapport à la commande local-run. Au lieu d'utiliser des options de ligne de commande pour spécifier des dépendances, vous devez utiliser des options dans la valeur de l'option --worker-pool-spec. De plus, les valeurs au sein de ces options doivent être séparées par un point-virgule plutôt que par une virgule. Plus précisément, utilisez la syntaxe suivante :

  • Au lieu de l'option --local-package-path de la commande local-run, utilisez l'option local-package-path dans la valeur de l'option --worker-pool-spec. Si le répertoire de travail que vous spécifiez avec cette option contient un fichier requirements.txt ou setup.py, l'empaquetage automatique installe les dépendances en fonction de ce fichier.

    L'exemple précédent illustre cette syntaxe.

  • (Facultatif) Au lieu de l'option --requirements, utilisez l'option requirements dans la valeur de l'option --worker-pool-spec. Au lieu de séparer les dépendances PyPI avec des virgules, utilisez des points-virgules.

  • (Facultatif) Au lieu de l'option --extra-packages, utilisez l'option extra-packages dans la valeur de l'option --worker-pool-spec. Au lieu de séparer les dépendances locales avec des virgules, utilisez des points-virgules.

  • (Facultatif) Au lieu de l'option --extra-dirs, utilisez l'option extra-dirs dans la valeur de l'option --worker-pool-spec. Au lieu de séparer les chemins d'accès aux répertoires avec des virgules, utilisez des points-virgules.

L'exemple suivant montre comment installer des dépendances à l'aide de toutes les techniques facultatives (vous pouvez spécifier n'importe quel sous-ensemble d'entre elles). Pour illustrer la syntaxe du point-virgule, l'exemple spécifie deux valeurs pour chaque option. Pour réduire la longueur de l'exemple, les autres options de --worker-pool-spec sont remplacées par [...].

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=[...],requirements=PYPI_DEP_1;PYPI_DEP_2,extra-packages=LOCAL_DEP_1;LOCAL_DEP_2,extra-dirs=EXTRA_DIR_1;EXTRA_DIR_2

Pour en savoir plus sur les valeurs appropriées de ces espaces réservés, consultez la section "Installer des dépendances" du guide sur la commande local-run.

Sans empaquetage automatique

Si vous n'utilisez pas l'empaquetage automatique, vous pouvez créer une tâche CustomJob avec une commande semblable à l'une des suivantes. Selon que vous avez créé une application d'entraînement Python ou une image de conteneur personnalisée, choisissez l'un des onglets suivants :

Application d'entraînement Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE

Remplacez les éléments suivants :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • PYTHON_PACKAGE_URIS : liste d'URI Cloud Storage séparés par une virgule spécifiant les fichiers de package Python correspondant au programme d'entraînement et ses packages dépendants. Le nombre maximal d'URI de package est de 100.
  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
  • EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le code fourni. Pour en savoir plus, consultez la liste des conteneurs prédéfinis disponibles pour l'entraînement.
  • PYTHON_MODULE : nom du module Python à exécuter après l'installation des packages.

Image de conteneur personnalisée

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

Remplacez les éléments suivants :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
  • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
  • CUSTOM_CONTAINER_IMAGE_URI : URI d'une image de conteneur dans Artifact Registry, Container Registry ou Docker Hub à exécuter sur chaque instance dupliquée de nœud de calcul.

Entraînement distribué

Pour effectuer un entraînement distribué, spécifiez l'option --worker-pool-spec plusieurs fois, une fois pour chaque pool de nœuds de calcul.

Si vous utilisez l'empaquetage automatique, vous ne devez spécifier que local-package-path, script et les autres options liées à l'empaquetage automatique dans le premier pool de nœuds de calcul. Omettez les champs liés à votre code d'entraînement dans les pools de nœuds de calcul suivants, qui utiliseront tous le même conteneur d'entraînement créé par l'empaquetage automatique.

Par exemple, la commande suivante adapte un exemple d'empaquetage précédent pour utiliser un deuxième pool de nœuds de calcul :

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,local-package-path=WORKING_DIRECTORY,script=SCRIPT_PATH \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT

Si vous n'utilisez pas l'empaquetage automatique, spécifiez chaque pool de nœuds de calcul de manière complète et indépendante. N'omettez aucun champ.

Les commandes suivantes adaptent les exemples précédents à l'utilisation d'un deuxième pool de nœuds de calcul :

Application d'entraînement Python

gcloud ai custom-jobs create \
  --region=LOCATION \
  --display-name=JOB_NAME \
  --python-package-uris=PYTHON_PACKAGE_URIS \
  --worker-pool-spec=machine-type=MACHINE_TYPE,replica-count=REPLICA_COUNT,executor-image-uri=EXECUTOR_IMAGE_URI,python-module=PYTHON_MODULE \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,executor-image-uri=SECOND_POOL_EXECUTOR_IMAGE_URI,python-module=SECOND_POOL_PYTHON_MODULE

Image de conteneur personnalisée

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 \
  --worker-pool-spec=machine-type=SECOND_POOL_MACHINE_TYPE,replica-count=SECOND_POOL_REPLICA_COUNT,container-image-uri=SECOND_POOL_CUSTOM_CONTAINER_IMAGE_URI

Configuration avancée

Si vous souhaitez spécifier des options de configuration qui ne sont pas disponibles dans les exemples précédents, vous pouvez utiliser l'indicateur --config pour spécifier le chemin d'accès à un fichier config.yaml de votre environnement local contenant les champs CustomJobSpec. Exemple :

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

Consultez un exemple de fichier config.yaml.

Console

Dans la console Google Cloud, vous ne pouvez pas créer directement une ressource CustomJob. Toutefois, vous pouvez créer une ressource TrainingPipeline qui crée un CustomJob.

Les instructions suivantes décrivent comment créer un TrainingPipeline qui crée une CustomJob et qui ne fait rien d'autre. Si vous souhaitez utiliser des fonctionnalités TrainingPipeline supplémentaires, telles que l'entraînement avec un ensemble de données géré ou la création d'une ressource Model à la fin de l'entraînement, consultez la section Créer des pipelines d'entraînement

  1. Dans la console Google Cloud, accédez à la section Vertex AI, accédez à la page Entraînement des pipelines.

    Accéder à la page Pipelines d'entraînement

  2. Cliquez sur Créer pour ouvrir le volet Entraîner le nouveau modèle.

  3. À l'étape Méthode d'entraînement, spécifiez les paramètres suivants :

    1. Dans la liste déroulante Ensemble de données, sélectionnez Aucun ensemble de données géré.

    2. Sélectionnez Entraînement personnalisé (avancé).

    Cliquez sur Continuer.

  4. À l'étape Informations sur le modèle, sélectionnez Entraîner un nouveau modèle ou Entraîner la nouvelle version. Si vous sélectionnez "Entraîner un nouveau modèle", saisissez le nom de votre choix, MODEL_NAME. Cliquez sur Continuer.

  5. À l'étape Entraînement du conteneur, spécifiez les paramètres suivants :

    1. Indiquez si vous souhaitez utiliser un conteneur prédéfini ou un conteneur personnalisé pour l'entraînement.

    2. Selon votre choix, effectuez l'une des opérations suivantes :

    3. Dans le champ Répertoire de sortie du modèle, spécifiez l'URI Cloud Storage d'un répertoire d'un bucket auquel vous avez accès. Le répertoire n'a pas besoin d'exister pour le moment.

      Cette valeur est transmise à Vertex AI dans le champ d'API baseOutputDirectory, qui définit plusieurs variables d'environnement auxquelles votre application d'entraînement peut accéder lorsqu'elle s'exécute.

    4. Facultatif : dans le champ Arguments, vous pouvez spécifier des arguments que Vertex AI doit utiliser lorsqu'il commence à exécuter votre code d'entraînement. La longueur maximale de l'ensemble des arguments combinés est de 100 000 caractères. Le comportement de ces arguments varie en fonction du type de conteneur que vous utilisez :

    Cliquez sur Continuer.

  6. À l'étape Réglage des hyperparamètres, assurez-vous que la case Activer le réglage d'hyperparamètres n'est pas cochée. Cliquez sur Continuer.

  7. À l'étape Calcul et tarification, spécifiez les paramètres suivants :

    1. Dans la liste déroulante Région, sélectionnez une région compatible avec l'entraînement personnalisé.

    2. Dans la section Pool de nœuds de calcul 0, spécifiez les ressources de calcul à utiliser pour l'entraînement.

      Si vous spécifiez des accélérateurs, assurez-vous que le type d'accélérateur que vous choisissez est disponible dans la région sélectionnée.

      Si vous souhaitez effectuer un entraînement distribué, cliquez sur Ajouter d'autres pools de nœuds de calcul et spécifiez un ensemble supplémentaire de ressources de calcul pour chaque pool de nœuds de calcul supplémentaire souhaité.

    Cliquez sur Continuer.

  8. À l'étape Prédiction de conteneur, sélectionnez Aucun conteneur de prédiction.

  9. Cliquez sur Démarrer l'entraînement pour démarrer le pipeline d'entraînement personnalisé.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • LOCATION : région où le conteneur ou le package Python sera exécuté.
  • PROJECT_ID : l'ID de votre projet.
  • JOB_NAME : valeur obligatoire. nom à afficher pour CustomJob.
  • Définissez la tâche d'entraînement personnalisée :
    • MACHINE_TYPE : type de la machine. Consultez la section Types de machines disponibles pour l'entraînement.
    • ACCELERATOR_TYPE : (Facultatif) Type d'accélérateur à associer à la tâche.
    • ACCELERATOR_COUNT : (Facultatif) Nombre d'accélérateurs à associer à la tâche.
    • DISK_TYPE : (Facultatif) Type de disque de démarrage à utiliser pour la tâche (pd-standard par défaut) ou pd-ssd. En savoir plus sur les types de disques
    • DISK_SIZE : (Facultatif) Taille en Go du disque de démarrage à utiliser pour la tâche. La valeur par défaut est 100.
    • REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser. Dans la plupart des cas, définissez cette valeur sur 1 pour votre premier pool de nœuds de calcul.
    • Si votre application d'entraînement s'exécute dans un conteneur personnalisé, spécifiez les éléments suivants :
      • CUSTOM_CONTAINER_IMAGE_URI : URI d'une image de conteneur dans Artifact Registry, Container Registry ou Docker Hub à exécuter sur chaque instance dupliquée de nœud de calcul.
      • CUSTOM_CONTAINER_COMMAND : (Facultatif) Commande à appeler au démarrage du conteneur. Cette commande ignore le point d'entrée par défaut du conteneur.
      • CUSTOM_CONTAINER_ARGS : (Facultatif) Arguments à transmettre lors du démarrage du conteneur.
    • Si votre application d'entraînement est un package Python qui s'exécute dans un conteneur prédéfini, spécifiez les éléments suivants :
      • EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le code fourni. Pour en savoir plus, consultez la liste des conteneurs prédéfinis disponibles pour l'entraînement.
      • PYTHON_PACKAGE_URIS : liste d'URI Cloud Storage séparés par une virgule spécifiant les fichiers de package Python correspondant au programme d'entraînement et ses packages dépendants. Le nombre maximal d'URI de package est de 100.
      • PYTHON_MODULE : nom du module Python à exécuter après l'installation des packages.
      • PYTHON_PACKAGE_ARGS : (Facultatif) Arguments de ligne de commande à transmettre au module Python.
    • Découvrez les options de planification des tâches.
    • TIMEOUT : (Facultatif) Durée d'exécution maximale pour la tâche.
  • Spécifiez les éléments LABEL_NAME et LABEL_VALUE pour tous les libellés que vous souhaitez appliquer à cette tâche personnalisée.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs

Corps JSON de la requête : 

{
  "displayName": "JOB_NAME",
  "jobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": MACHINE_TYPE,
          "acceleratorType": ACCELERATOR_TYPE,
          "acceleratorCount": ACCELERATOR_COUNT
        },
        "replicaCount": REPLICA_COUNT,
        "diskSpec": {
          "bootDiskType": DISK_TYPE,
          "bootDiskSizeGb": DISK_SIZE
        },

        // Union field task can be only one of the following:
        "containerSpec": {
          "imageUri": CUSTOM_CONTAINER_IMAGE_URI,
          "command": [
            CUSTOM_CONTAINER_COMMAND
          ],
          "args": [
            CUSTOM_CONTAINER_ARGS
          ]
        },
        "pythonPackageSpec": {
          "executorImageUri": EXECUTOR_IMAGE_URI,
          "packageUris": [
            PYTHON_PACKAGE_URIS
          ],
          "pythonModule": PYTHON_MODULE,
          "args": [
            PYTHON_PACKAGE_ARGS
          ]
        }
        // End of list of possible types for union field task.
      }
      // Specify one workerPoolSpec for single replica training, or multiple workerPoolSpecs
      // for distributed training.
    ],
    "scheduling": {
      "timeout": TIMEOUT
    }
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs"

PowerShell

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/customJobs" | Select-Object -Expand Content

La réponse contient des informations sur les spécifications, ainsi que sur TRAININGPIPELINE_ID.

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. 

def create_custom_job_with_experiment_autologging_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    service_account: str,
    experiment: str,
    experiment_run: Optional[str] = None,
) -> None:
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket, experiment=experiment)

    job = aiplatform.CustomJob.from_local_script(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        enable_autolog=True,
    )

    job.run(
        service_account=service_account,
        experiment=experiment,
        experiment_run=experiment_run,
    )

Étape suivante

  • Découvrez comment identifier les goulots d'étranglement de performance d'entraînement afin d'entraîner les modèles plus rapidement et à moindre coût à l'aide de Cloud Profiler.
  • Consultez la page Créer des pipelines d'entraînement pour apprendre à créer des pipelines d'entraînement afin d'exécuter des applications d'entraînement personnalisées sur Vertex AI.