Cette page a été traduite par l'API Cloud Translation.

Créer des pipelines d'entraînement

Les pipelines d'entraînement vous permettent d'effectuer un entraînement de machine learning (ML) personnalisé et de créer automatiquement une ressource Model en fonction du résultat de l'entraînement.

Si votre tâche consiste uniquement à exécuter un job d'entraînement et à créer automatiquement une ressource de modèle sans orchestrer un workflow complet, l'utilisation d'un pipeline d'entraînement autonome, comme décrit dans ce document, peut suffire. Toutefois, si votre objectif est de créer un cycle de vie de ML de bout en bout robuste, automatisé et reproductible qui implique plusieurs étapes (comme le traitement, l'entraînement, l'évaluation, le déploiement ou la surveillance des données), l'approche recommandée est Vertex AI Pipelines, car elle est conçue pour l'orchestration des workflows.

Avant de créer un pipeline

Avant de créer un pipeline d'entraînement sur Vertex AI, vous devez créer une application d'entraînement Python ou un conteneur personnalisé pour définir le code d'entraînement et les dépendances que vous voulez exécuter dans Vertex AI. Si vous créez une application d'entraînement Python avec PyTorch, TensorFlow, scikit-learn ou XGBoost, vous pouvez exécuter votre code à l'aide de nos conteneurs prédéfinis. Si vous ne savez pas quelle option choisir, reportez-vous aux exigences concernant le code d'entraînement pour en savoir plus.

Options de pipeline d'entraînement

Un pipeline d'entraînement encapsule des jobs d'entraînement avec des étapes supplémentaires. Ce guide explique deux pipelines d'entraînement différents :

Lancer un CustomJob et importer le modèle obtenu dans Vertex AI
Lancer un job de réglage d'hyperparamètres et importer le modèle obtenu dans Vertex AI

Vous pouvez également utiliser des ensembles de données gérés dans votre pipeline d'entraînement. Découvrez comment configurer votre pipeline d'entraînement pour qu'il utilise un ensemble de données géré.

Éléments inclus dans un `CustomJob`

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

Un pool de nœuds de calcul pour l'entraînement à nœud unique (WorkerPoolSpec) ou plusieurs pools de nœuds de calcul pour l'entraînement distribué
Des paramètres facultatifs pour configurer la planification des jobs (Scheduling), définir certaines variables d'environnement pour votre code d'entraînement, utiliser un compte de service personnalisé et utiliser l'appairage de réseaux VPC<

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

Types de machines et accélérateurs
Configuration du type de code d'entraînement exécuté par le pool de nœuds de calcul : une application d'entraînement Python (PythonPackageSpec) ou un conteneur personnalisé (ContainerSpec)

Si vous souhaitez créer un job personnalisé autonome en dehors d'un pipeline Vertex AI Training, reportez-vous au guide sur les jobs personnalisés.

Configurer votre pipeline pour utiliser un ensemble de données géré

Dans votre pipeline d'entraînement, vous pouvez configurer votre job d'entraînement personnalisé ou votre job de réglage d'hyperparamètres pour utiliser un ensemble de données géré. Les ensembles de données gérés vous permettent de gérer vos ensembles de données avec vos applications et modèles d'entraînement.

Pour utiliser un ensemble de données géré dans votre pipeline d'entraînement :

Créez votre ensemble de données.
Modifiez votre application d'entraînement afin d'utiliser un ensemble de données géré. Pour en savoir plus, découvrez comment Vertex AI transmet votre ensemble de données à votre application d'entraînement.
Spécifiez un ensemble de données géré lorsque vous créez votre pipeline d'entraînement. Par exemple, si vous créez votre pipeline d'entraînement à l'aide de l'API REST, spécifiez les paramètres de l'ensemble de données dans la section inputDataConfig.

Vous devez créer le pipeline d'entraînement dans la même région que celle où vous avez créé l'ensemble de données.

Pour en savoir plus, consultez la documentation de référence de l'API sur TrainingPipeline.

Configurer l'entraînement distribué

Dans votre pipeline d'entraînement, vous pouvez configurer votre job d'entraînement personnalisé ou votre job de réglage d'hyperparamètres pour l'entraînement distribué en spécifiant plusieurs pools de nœuds de calcul.

Tous les exemples de cette page montrent des jobs d'entraînement à instance répliquée unique avec un seul pool de nœuds de calcul. Pour les modifier pour un entraînement distribué :

Utilisez votre premier pool de nœuds de calcul pour configurer votre instance répliquée principale, puis définissez le nombre d'instances répliquées sur 1.
Ajoutez ensuite d'autres pools de nœuds de calcul pour configurer des instances répliquées de nœuds de calcul, des instances répliquées de serveurs de paramètres ou des instances répliqué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é.

Importer des objets CustomJob et des modèles

Ce pipeline d'entraînement encapsule un job personnalisé avec une étape supplémentaire pratique qui vise à faciliter le déploiement de votre modèle sur Vertex AI après l'entraînement. Ce pipeline d'entraînement remplit deux fonctions principales :

Le pipeline d'entraînement crée une ressource CustomJob. Le job personnalisé exécute l'application d'entraînement en utilisant les ressources de calcul que vous spécifiez.
Une fois le job personnalisé terminé, le pipeline d'entraînement recherche les artefacts de modèle créés par votre application d'entraînement dans le répertoire de sortie que vous avez spécifié pour votre bucket Cloud Storage. Il utilise ces artefacts pour créer une ressource de modèle qui vous permet de configurer le déploiement du modèle.

Il existe deux façons différentes de définir l'emplacement de vos artefacts de modèle :

Si vous définissez un baseOutputDirectory pour votre job d'entraînement, assurez-vous que votre code d'entraînement enregistre vos artefacts de modèle à cet emplacement à l'aide de la variable d'environnement $AIP_MODEL_DIR définie par Vertex AI. Une fois le job d'entraînement terminé, Vertex AI recherche les artefacts de modèle obtenus dans gs://BASE_OUTPUT_DIRECTORY/model.
Remarque : Si vous utilisez le SDK Vertex AI pour Python, vous pouvez omettre l'attribut base_output_dir. Dans ce cas, Vertex AI génère les artefacts de votre modèle dans un répertoire avec code temporel, dans le répertoire de préproduction. Pour plus d'informations, consultez :
Si vous définissez le champ modelToUpload.artifactUri, le pipeline d'entraînement importe les artefacts de modèle à partir de cet URI. Vous devez définir ce champ si vous n'avez pas défini baseOutputDirectory.

Si vous spécifiez à la fois baseOutputDirectory et modelToUpload.artifactUri, Vertex AI utilise modelToUpload.artifactUri.

Pour créer ce type de pipeline d'entraînement :

Console

Dans la section Vertex AI de la console Google Cloud , accédez à la page Pipelines d'entraînement.

Accéder à la page "Pipelines d'entraînement"
Cliquez sur Créer pour ouvrir le volet Entraîner le nouveau modèle.
À l'étape Méthode d'entraînement, spécifiez les paramètres suivants :
1. Si vous souhaitez utiliser un ensemble de données géré pour l'entraînement, spécifiez un ensemble de données et un ensemble d'annotations.
  
  Dans le cas contraire, 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.
À 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.
À 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 :
  - Si vous souhaitez utiliser un conteneur prédéfini pour l'entraînement, fournissez à Vertex AI les informations nécessaires à l'utilisation du package d'entraînement que vous avez importé dans Cloud Storage :
    1. Utilisez les listes déroulantes Framework de modèle et Version du framework de modèle pour spécifier le conteneur prédéfini que vous souhaitez utiliser.
    2. Dans le champ Emplacement du package, spécifiez l'URI Cloud Storage de l'application d'entraînement Python que vous avez créée et importée. Ce fichier se termine généralement par .tar.gz.
    3. Dans le champ Module Python, saisissez le nom de module du point d'entrée de votre application d'entraînement.
  - Si vous souhaitez utiliser un conteneur personnalisé pour l'entraînement, spécifiez dans le champ Image du conteneur l'URI Artifact Registry ou Docker Hub de votre image de conteneur.
3. Dans le champ Répertoire de sortie du modèle, spécifiez l'URI Cloud Storage du 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.
  
  À la fin de l'entraînement, Vertex AI recherche des artefacts de modèle dans un sous-répertoire de cet URI afin de créer un Model. (Ce sous-répertoire est disponible pour votre code d'entraînement en tant que variable d'environnement AIP_MODEL_DIR.)
  
  Lorsque vous n'utilisez pas le réglage d'hyperparamètres, Vertex AI s'attend à trouver des artefacts de modèle dans BASE_OUTPUT_DIRECTORY/model/.
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 :
  - Si vous utilisez un conteneur prédéfini, Vertex AI transmet les arguments à votre module Python en tant qu'options de ligne de commande.
  - Si vous utilisez un conteneur personnalisé, Vertex AI remplace l'instruction CMD de votre conteneur par les arguments.
Cliquez sur Continuer.
À 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.
À 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.
À l'étape Conteneur de prédiction, spécifiez les paramètres suivants :
1. Indiquez si vous souhaitez utiliser un conteneur prédéfini ou un conteneur personnalisé pour livrer les prédictions de votre modèle entraîné.
2. Selon votre choix, effectuez l'une des opérations suivantes :
  - Si vous souhaitez utiliser un conteneur prédéfini pour livrer des prédictions, utilisez les champs Framework de modèle, Version du framework de modèle et Type d'accélérateur pour sélectionner le conteneur de prédiction prédéfini à utiliser pour la prédiction.
    
    Faites correspondre le framework de modèle et la version du framework de modèle au framework de machine learning que vous avez utilisé pour l'entraînement. Ne spécifiez un type d'accélérateur que si vous souhaitez par la suite utiliser des GPU pour les prédictions en ligne ou par lots.
  - Si vous souhaitez utiliser un conteneur personnalisé pour livrer des prédictions, procédez comme suit :
    1. Dans le champ Image du conteneur, spécifiez l'URI Artifact Registry de votre image de conteneur.
    2. Vous pouvez éventuellement spécifier une commande pour remplacer l'instruction ENTRYPOINT du conteneur.
3. Le champ Répertoire du modèle contient la valeur que vous avez définie précédemment dans le champ Répertoire de sortie du modèle de l'étape Conteneur d'entraînement. La modification de l'un de ces champs a le même effet. Pour en savoir plus sur ce champ, consultez l'instruction précédente.
4. Laissez vides les champs de la section Schémas de prédiction.
Cliquez sur Démarrer l'entraînement pour démarrer le pipeline d'entraînement personnalisé.

REST

Utilisez l'exemple de code suivant pour créer un pipeline d'entraînement à l'aide de la méthode create de la ressource trainingPipeline.

Remarque : Si vous souhaitez définir ce pipeline pour créer une nouvelle version de modèle, vous pouvez éventuellement ajouter le PARENT_MODEL dans le champ trainingPipeline.

Pour en savoir plus, consultez Gérer les versions de modèles avec Vertex AI Model Registry.

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

LOCATION_ID : région où le code d'entraînement est exécuté et où Model est stocké.
PROJECT_ID : ID de votre projet.
TRAINING_PIPELINE_NAME (valeur obligatoire) : nom à afficher du pipeline d'entraînement.
Si votre application d'entraînement utilise un ensemble de données Vertex AI, spécifiez les éléments suivants :
- DATASET_ID : ID de l'ensemble de données.
- ANNOTATIONS_FILTER : filtre l'ensemble de données sur la base des annotations que vous spécifiez.
- ANNOTATION_SCHEMA_URI : filtre l'ensemble de données sur la base de l'URI de schéma d'annotation spécifié.
- Utilisez l'une des options suivantes pour spécifier la manière dont les éléments de données sont répartis entre les ensembles d'entraînement, de validation et de test.
  - Pour diviser l'ensemble de données sur la base de fractions définissant la taille de chaque ensemble, spécifiez les éléments suivants :
    - TRAINING_FRACTION : fraction de l'ensemble de données à utiliser pour entraîner votre modèle.
    - VALIDATION_FRACTION : fraction de l'ensemble de données à utiliser pour valider votre modèle.
    - TEST_FRACTION : fraction de l'ensemble de données à utiliser pour évaluer votre modèle.
  - Pour diviser l'ensemble de données en utilisant des filtres, spécifiez les éléments suivants :
    - TRAINING_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour entraîner votre modèle.
    - VALIDATION_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour valider votre modèle.
    - TEST_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour évaluer votre modèle.
  - Pour utiliser une répartition prédéfinie, spécifiez les éléments suivants :
    - PREDEFINED_SPLIT_KEY : nom de la colonne à utiliser pour diviser l'ensemble de données. Les valeurs autorisées dans cette colonne sont "training", "validation" et "test".
  - Pour diviser l'ensemble de données sur la base de l'horodatage des éléments de données, spécifiez les éléments suivants :
    - TIMESTAMP_TRAINING_FRACTION : fraction de l'ensemble de données à utiliser pour entraîner votre modèle.
    - TIMESTAMP_VALIDATION_FRACTION : fraction de l'ensemble de données à utiliser pour valider votre modèle.
    - TIMESTAMP_TEST_FRACTION : fraction de l'ensemble de données à utiliser pour évaluer votre modèle.
    - TIMESTAMP_SPLIT_KEY : nom de la colonne de code temporel à utiliser pour diviser l'ensemble de données.
- OUTPUT_URI_PREFIX : emplacement Cloud Storage où Vertex AI exporte votre ensemble de données d'entraînement une fois qu'il a été divisé en ensembles d'entraînement, de validation et de test.
Définissez le job d'entraînement personnalisé :
- MACHINE_TYPE : type de la machine. Reportez-vous aux types de machines disponibles pour l'entraînement.
- ACCELERATOR_TYPE (facultatif) : type d'accélérateur à associer à chaque essai.
- ACCELERATOR_COUNT (facultatif) : nombre d'accélérateurs à associer à chaque essai.
- REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser pour chaque essai.
- 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 ou Docker Hub à exécuter sur chaque instance répliqué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. La longueur maximale de l'ensemble des arguments combinés est de 100 000 caractères.
- 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 :
  - PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez la liste des conteneurs prédéfinis disponibles pour l'entraînement.
  - PYTHON_PACKAGE_URIS : emplacement Cloud Storage des fichiers de package Python, qui sont le programme d'entraînement et ses packages dépendants. La limite est de 100 URI de package.
  - 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. La longueur maximale de l'ensemble des arguments combinés est de 100 000 caractères.
- TIMEOUT (facultatif) : durée d'exécution maximale pour le job.
MODEL_NAME : nom à afficher du modèle importé (créé) par le pipeline d'entraînement.
MODEL_DESCRIPTION : description du modèle.
IMAGE_URI : URI de l'image de conteneur à utiliser pour exécuter les prédictions. Par exemple : us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilisez des conteneurs prédéfinis ou des conteneurs personnalisés.
modelToUpload.labels : tout ensemble de paires clé/valeur pour organiser vos modèles. Par exemple :
- "env" : "prod"
- "tier" : "backend"
Spécifiez LABEL_NAME et LABEL_VALUE pour toutes les étiquettes que vous souhaitez appliquer à ce pipeline d'entraînement.

Méthode HTTP et URL :

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corps JSON de la requête :

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // 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": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    }
  },
  "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

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

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

Réponse


{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://BUCKET_NAME/training/hello-custom-training-1.0.tar.gz"
          ],
          "pythonModule": "trainer.task",
          "args": [
            "--model-dir=gs://BUCKET_NAME/output/"
          ]
        }
      }
    ]
  },
  "trainingTaskMetadata": {
    "backingCustomJob": "projects/PROJECT_ID/locations/LOCATION_ID/customJobs/CUSTOM_JOB_ID"
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest"
    }
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

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.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.PipelineServiceClient;
import com.google.cloud.aiplatform.v1.PipelineServiceSettings;
import com.google.cloud.aiplatform.v1.TrainingPipeline;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateTrainingPipelineCustomJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelDisplayName = "MODEL_DISPLAY_NAME";
    String containerImageUri = "CONTAINER_IMAGE_URI";
    String baseOutputDirectoryPrefix = "BASE_OUTPUT_DIRECTORY_PREFIX";
    createTrainingPipelineCustomJobSample(
        project, displayName, modelDisplayName, containerImageUri, baseOutputDirectoryPrefix);
  }

  static void createTrainingPipelineCustomJobSample(
      String project,
      String displayName,
      String modelDisplayName,
      String containerImageUri,
      String baseOutputDirectoryPrefix)
      throws IOException {
    PipelineServiceSettings settings =
        PipelineServiceSettings.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. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PipelineServiceClient client = PipelineServiceClient.create(settings)) {
      JsonObject jsonMachineSpec = new JsonObject();
      jsonMachineSpec.addProperty("machineType", "n1-standard-4");

      // A working docker image can be found at
      // gs://cloud-samples-data/ai-platform/mnist_tfrecord/custom_job
      // This sample image accepts a set of arguments including model_dir.
      JsonObject jsonContainerSpec = new JsonObject();
      jsonContainerSpec.addProperty("imageUri", containerImageUri);
      JsonArray jsonArgs = new JsonArray();
      jsonArgs.add("--model_dir=$(AIP_MODEL_DIR)");
      jsonContainerSpec.add("args", jsonArgs);

      JsonObject jsonJsonWorkerPoolSpec0 = new JsonObject();
      jsonJsonWorkerPoolSpec0.addProperty("replicaCount", 1);
      jsonJsonWorkerPoolSpec0.add("machineSpec", jsonMachineSpec);
      jsonJsonWorkerPoolSpec0.add("containerSpec", jsonContainerSpec);

      JsonArray jsonWorkerPoolSpecs = new JsonArray();
      jsonWorkerPoolSpecs.add(jsonJsonWorkerPoolSpec0);

      JsonObject jsonBaseOutputDirectory = new JsonObject();
      // The GCS location for outputs must be accessible by the project's AI Platform
      // service account.
      jsonBaseOutputDirectory.addProperty("output_uri_prefix", baseOutputDirectoryPrefix);

      JsonObject jsonTrainingTaskInputs = new JsonObject();
      jsonTrainingTaskInputs.add("workerPoolSpecs", jsonWorkerPoolSpecs);
      jsonTrainingTaskInputs.add("baseOutputDirectory", jsonBaseOutputDirectory);

      Value.Builder trainingTaskInputsBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonTrainingTaskInputs.toString(), trainingTaskInputsBuilder);
      Value trainingTaskInputs = trainingTaskInputsBuilder.build();
      String trainingTaskDefinition =
          "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
      String imageUri = "gcr.io/cloud-aiplatform/prediction/tf-cpu.1-15:latest";
      ModelContainerSpec containerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();
      Model modelToUpload =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setContainerSpec(containerSpec)
              .build();
      TrainingPipeline trainingPipeline =
          TrainingPipeline.newBuilder()
              .setDisplayName(displayName)
              .setTrainingTaskDefinition(trainingTaskDefinition)
              .setTrainingTaskInputs(trainingTaskInputs)
              .setModelToUpload(modelToUpload)
              .build();
      LocationName parent = LocationName.of(project, location);
      TrainingPipeline response = client.createTrainingPipeline(parent, trainingPipeline);
      System.out.format("response: %s\n", response);
      System.out.format("Name: %s\n", response.getName());
    }
  }
}

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.

Les exemples suivants montrent comment créer un pipeline d'entraînement personnalisé à l'aide du SDK Vertex AI pour Python. Choisissez si vous prévoyez d'utiliser un conteneur personnalisé ou un conteneur prédéfini pour l'entraînement :

Conteneur prédéfini

Lorsque vous utilisez le SDK Vertex AI pour Python afin de créer un pipeline d'entraînement qui exécute votre code Python dans un conteneur prédéfini, vous pouvez fournir votre code d'entraînement de l'une des manières suivantes :

Spécifiez l'URI d'un package de distribution source Python dans Cloud Storage

(cette option est également disponible lorsque vous créez un pipeline d'entraînement sans utiliser le SDK Vertex AI pour Python).
Spécifiez le chemin d'accès à un script Python sur votre machine locale. Avant de créer un pipeline d'entraînement, le SDK Vertex AI pour Python crée un package de votre script en tant que distribution source et l'importe dans le bucket Cloud Storage de votre choix

(cette option n'est disponible que si vous utilisez le SDK Vertex AI pour Python).

Pour afficher un exemple de code pour chacune de ces options, sélectionnez l'onglet correspondant :

Package

L'exemple suivant utilise la classe CustomPythonPackageTrainingJob.

def create_training_pipeline_custom_package_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    python_package_gcs_uri: str,
    python_module_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomPythonPackageTrainingJob(
        display_name=display_name,
        python_package_gcs_uri=python_package_gcs_uri,
        python_module_name=python_module_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Script

L'exemple suivant utilise la classe CustomTrainingJob.

def create_training_pipeline_custom_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    script_path: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 0,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomTrainingJob(
        display_name=display_name,
        script_path=script_path,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Conteneur personnalisé

L'exemple suivant utilise la classe CustomContainerTrainingJob.

def create_training_pipeline_custom_container_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
    model_serving_container_image_uri: str,
    dataset_id: Optional[str] = None,
    model_display_name: Optional[str] = None,
    args: Optional[List[Union[str, float, int]]] = None,
    replica_count: int = 1,
    machine_type: str = "n1-standard-4",
    accelerator_type: str = "ACCELERATOR_TYPE_UNSPECIFIED",
    accelerator_count: int = 0,
    training_fraction_split: float = 0.8,
    validation_fraction_split: float = 0.1,
    test_fraction_split: float = 0.1,
    sync: bool = True,
    tensorboard_resource_name: Optional[str] = None,
    service_account: Optional[str] = None,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    job = aiplatform.CustomContainerTrainingJob(
        display_name=display_name,
        container_uri=container_uri,
        model_serving_container_image_uri=model_serving_container_image_uri,
    )

    # This example uses an ImageDataset, but you can use another type
    dataset = aiplatform.ImageDataset(dataset_id) if dataset_id else None

    model = job.run(
        dataset=dataset,
        model_display_name=model_display_name,
        args=args,
        replica_count=replica_count,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        training_fraction_split=training_fraction_split,
        validation_fraction_split=validation_fraction_split,
        test_fraction_split=test_fraction_split,
        sync=sync,
        tensorboard=tensorboard_resource_name,
        service_account=service_account,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    print(model.uri)
    return model

Job de réglage d'hyperparamètres et importation de modèle

Ce pipeline d'entraînement encapsule un job de réglage d'hyperparamètres avec une étape supplémentaire pratique qui vise à faciliter le déploiement de votre modèle sur Vertex AI après l'entraînement. Ce pipeline d'entraînement remplit deux fonctions principales :

Le pipeline d'entraînement crée une ressource de job de réglage d'hyperparamètres. Le job de réglage d'hyperparamètres crée plusieurs essais. Pour chaque essai, un job personnalisé exécute votre application d'entraînement à l'aide des ressources de calcul et des hyperparamètres que vous spécifiez.
Une fois le job de réglage d'hyperparamètres terminé, le pipeline d'entraînement trouve les artefacts de modèle du meilleur essai dans le répertoire de sortie (baseOutputDirectory) que vous avez spécifié pour votre bucket Cloud Storage. Le pipeline d'entraînement utilise ces artefacts pour créer une ressource de modèle qui vous permet de procéder au déploiement du modèle.

Pour ce pipeline d'entraînement, vous devez spécifier un baseOutputDirectory dans lequel Vertex AI recherche les artefacts de modèle du meilleur essai.

Les jobs de réglage d'hyperparamètres possèdent des paramètres supplémentaires à configurer. Découvrez plus en détail les paramètres d'un HyperparameterTuningJob.

REST

Utilisez l'exemple de code suivant pour créer un pipeline d'entraînement à l'aide de la méthode create de la ressource trainingPipeline.

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

LOCATION_ID : région de votre projet.
PROJECT_ID : ID de votre projet.
TRAINING_PIPELINE_NAME (valeur obligatoire) : nom à afficher du pipeline d'entraînement.
Si votre application d'entraînement utilise un ensemble de données Vertex AI, spécifiez les éléments suivants :
- DATASET_ID : ID de l'ensemble de données.
- ANNOTATIONS_FILTER : filtre l'ensemble de données sur la base des annotations que vous spécifiez.
- ANNOTATION_SCHEMA_URI : filtre l'ensemble de données sur la base de l'URI de schéma d'annotation spécifié.
- Utilisez l'une des options suivantes pour spécifier la manière dont les éléments de données sont répartis entre les ensembles d'entraînement, de validation et de test.
  - Pour diviser l'ensemble de données sur la base de fractions définissant la taille de chaque ensemble, spécifiez les éléments suivants :
    - TRAINING_FRACTION : fraction de l'ensemble de données à utiliser pour entraîner votre modèle.
    - VALIDATION_FRACTION : fraction de l'ensemble de données à utiliser pour valider votre modèle.
    - TEST_FRACTION : fraction de l'ensemble de données à utiliser pour évaluer votre modèle.
  - Pour diviser l'ensemble de données en utilisant des filtres, spécifiez les éléments suivants :
    - TRAINING_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour entraîner votre modèle.
    - VALIDATION_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour valider votre modèle.
    - TEST_FILTER : filtre l'ensemble de données sur les éléments de données à utiliser pour évaluer votre modèle.
  - Pour utiliser une répartition prédéfinie, spécifiez les éléments suivants :
    - PREDEFINED_SPLIT_KEY : nom de la colonne à utiliser pour diviser l'ensemble de données. Les valeurs autorisées dans cette colonne sont "training", "validation" et "test".
  - Pour diviser l'ensemble de données sur la base de l'horodatage des éléments de données, spécifiez les éléments suivants :
    - TIMESTAMP_TRAINING_FRACTION : fraction de l'ensemble de données à utiliser pour entraîner votre modèle.
    - TIMESTAMP_VALIDATION_FRACTION : fraction de l'ensemble de données à utiliser pour valider votre modèle.
    - TIMESTAMP_TEST_FRACTION : fraction de l'ensemble de données à utiliser pour évaluer votre modèle.
    - TIMESTAMP_SPLIT_KEY : nom de la colonne de code temporel à utiliser pour diviser l'ensemble de données.
- OUTPUT_URI_PREFIX : emplacement Cloud Storage où Vertex AI exporte votre ensemble de données d'entraînement une fois qu'il a été divisé en ensembles d'entraînement, de validation et de test.
Spécifiez votre job de réglage d'hyperparamètres :
- Spécifiez vos métriques :
  - METRIC_ID : nom de cette métrique.
  - METRIC_GOAL : objectif de cette métrique. Il peut s'agir de MAXIMIZE ou MINIMIZE.
- Spécifiez vos hyperparamètres :
  - PARAMETER_ID : nom de cet hyperparamètre.
  - PARAMETER_SCALE (facultatif) : méthode de mise à l'échelle du paramètre. Ne pas renseigner les paramètres de type CATÉGORIEL. Il peut s'agir de UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE ou SCALE_TYPE_UNSPECIFIED.
  - Si ce type d'hyperparamètre est DOUBLE, spécifiez les valeurs minimale (DOUBLE_MIN_VALUE) et maximale (DOUBLE_MAX_VALUE) pour cet hyperparamètre.
  - Si le type de cet hyperparamètre est ENTIER, spécifiez les valeurs minimale (INTEGER_MIN_VALUE) et maximale (INTEGER_MAX_VALUE) pour cet hyperparamètre.
  - Si ce type d'hyperparamètre est CATÉGORIEL, spécifiez les valeurs acceptables (CATEGORICAL_VALUES) sous la forme d'un tableau de chaînes.
  - Si ce type d'hyperparamètre est DISCRET, spécifiez les valeurs acceptables (DISCRETE_VALUES) sous la forme d'un tableau de nombres.
- ALGORITHM (facultatif) : algorithme de recherche à utiliser dans ce job de réglage d'hyperparamètres. Il peut s'agir de ALGORITHM_UNSPECIFIED, GRID_SEARCH ou RANDOM_SEARCH.
- MAX_TRIAL_COUNT : nombre maximal d'essais à exécuter dans ce job.
- PARALLEL_TRIAL_COUNT : nombre maximal d'essais pouvant être exécutés en parallèle.
- MAX_FAILED_TRIAL_COUNT : nombre de jobs pouvant échouer avant l'échec du job de réglage d'hyperparamètres.
- Définissez le job d'entraînement personnalisé de l'essai :
  - MACHINE_TYPE : type de la machine. Reportez-vous aux types de machines disponibles pour l'entraînement.
  - ACCELERATOR_TYPE (facultatif) : type d'accélérateur à associer à chaque essai.
  - ACCELERATOR_COUNT (facultatif) : nombre d'accélérateurs à associer à chaque essai.
  - REPLICA_COUNT : nombre d'instances dupliquées de nœuds de calcul à utiliser pour chaque essai.
  - 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 ou Docker Hub à exécuter sur chaque instance répliqué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 :
    - PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez la liste des conteneurs prédéfinis disponibles pour l'entraînement.
    - PYTHON_PACKAGE_URIS : emplacement Cloud Storage des fichiers de package Python, qui sont le programme d'entraînement et ses packages dépendants. La limite est de 100 URI de package.
    - 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 jobs.
- TIMEOUT (facultatif) : temps d'exécution maximal pour chaque essai.
- Spécifiez les valeurs LABEL_NAME et LABEL_VALUE pour toutes les étiquettes que vous souhaitez appliquer à ce job de réglage d'hyperparamètres.
MODEL_NAME : nom à afficher du modèle importé (créé) par le pipeline d'entraînement.
MODEL_DESCRIPTION (facultatif) : description du modèle.
PREDICTION_IMAGE_URI (valeur obligatoire) : spécifiez l'une des deux options suivantes :
- URI d'image de conteneur prédéfini à utiliser pour la prédiction, par exemple "tf2-cpu.2-1:latest".
- URI d'image de votre propre conteneur personnalisé à utiliser pour la prédiction.
modelToUpload.labels (facultatif) : tout ensemble de paires clé/valeur pour organiser vos modèles. Par exemple :
- "env" : "prod"
- "tier" : "backend"
Spécifiez LABEL_NAME et LABEL_VALUE pour toutes les étiquettes que vous souhaitez appliquer à ce pipeline d'entraînement.

Méthode HTTP et URL :

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines

Corps JSON de la requête :

{
  "displayName": "TRAINING_PIPELINE_NAME",
  "inputDataConfig": {
    "datasetId": DATASET_ID,
    "annotationsFilter": ANNOTATIONS_FILTER,
    "annotationSchemaUri": ANNOTATION_SCHEMA_URI,

    // Union field split can be only one of the following:
    "fractionSplit": {
      "trainingFraction": TRAINING_FRACTION,
      "validationFraction": VALIDATION_FRACTION,
      "testFraction": TEST_FRACTION
    },
    "filterSplit": {
      "trainingFilter": TRAINING_FILTER,
      "validationFilter": VALIDATION_FILTER,
      "testFilter": TEST_FILTER
    },
    "predefinedSplit": {
      "key": PREDEFINED_SPLIT_KEY
    },
    "timestampSplit": {
      "trainingFraction": TIMESTAMP_TRAINING_FRACTION,
      "validationFraction": TIMESTAMP_VALIDATION_FRACTION,
      "testFraction": TIMESTAMP_TEST_FRACTION,
      "key": TIMESTAMP_SPLIT_KEY
    }
    // End of list of possible types for union field split.
    "gcsDestination": {
      "outputUriPrefix": OUTPUT_URI_PREFIX
    }
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/hyperparameter_tuning_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "studySpec": {
    "metrics": [
      {
        "metricId": METRIC_ID,
        "goal": METRIC_GOAL
      }
    ],
    "parameters": [
      {
        "parameterId": PARAMETER_ID,
        "scaleType": PARAMETER_SCALE,

        // Union field parameter_value_spec can be only one of the following:
        "doubleValueSpec": {
            "minValue": DOUBLE_MIN_VALUE,
            "maxValue": DOUBLE_MAX_VALUE
        },
        "integerValueSpec": {
            "minValue": INTEGER_MIN_VALUE,
            "maxValue": INTEGER_MAX_VALUE
        },
        "categoricalValueSpec": {
            "values": [
              CATEGORICAL_VALUES
            ]
        },
        "discreteValueSpec": {
            "values": [
              DISCRETE_VALUES
            ]
        }
        // End of list of possible types for union field parameter_value_spec.
      }
    ],
    "ALGORITHM": ALGORITHM
  },
  "maxTrialCount": MAX_TRIAL_COUNT,
  "parallelTrialCount": PARALLEL_TRIAL_COUNT,
  "maxFailedTrialCount": MAX_FAILED_TRIAL_COUNT,
  "trialJobSpec": {
      "workerPoolSpecs": [
        {
          "machineSpec": {
            "machineType": MACHINE_TYPE,
            "acceleratorType": ACCELERATOR_TYPE,
            "acceleratorCount": ACCELERATOR_COUNT
          },
          "replicaCount": REPLICA_COUNT,

          // 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": PYTHON_PACKAGE_EXECUTOR_IMAGE_URI,
            "packageUris": [
              PYTHON_PACKAGE_URIS
            ],
            "pythonModule": PYTHON_MODULE,
            "args": [
              PYTHON_PACKAGE_ARGS
            ]
          }
          // End of list of possible types for union field task.
        }
      ],
      "scheduling": {
        "TIMEOUT": TIMEOUT
      }
    },
    "labels": {
      LABEL_NAME_1": LABEL_VALUE_1,
      LABEL_NAME_2": LABEL_VALUE_2
    }
  },
  "modelToUpload": {
    "displayName": "MODEL_NAME",
    "description": "MODEL_DESCRIPTION",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "PREDICTION_IMAGE_URI"
    }
  },
  "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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

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_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines" | Select-Object -Expand Content

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

Réponse


{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/trainingPipelines/TRAININGPIPELINE_ID",
  "displayName": "TRAINING_PIPELINE_NAME",
  "input_data_config" {
    "dataset_id": "1234567891011121314"
    "gcs_destination" {
      "output_uri_prefix": "gs://BUCKET_NAME/data/20200915191342"
    }
    "annotation_schema_uri": "gs://google-cloud-aiplatform/schema/dataset/annotation/image_classification_1.0.0.yaml"
  },
  "trainingTaskDefinition": "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml",
  "trainingTaskInputs": {
    "name": "projects/12345/locations/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "myHyperparameterTuningJob",
  "studySpec": {
    "metrics": [
      {
        "metricId": "myMetric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "myParameter1",
        "integerValueSpec": {
          "minValue": "1",
          "maxValue": "128"
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      },
      {
        "parameterId": "myParameter2",
        "doubleValueSpec": {
          "minValue": 1e-07,
          "maxValue": 1
        },
        "scaleType": "UNIT_LINEAR_SCALE"
      }
    ],
    "ALGORITHM": "RANDOM_SEARCH"
  },
  "maxTrialCount": 20,
  "parallelTrialCount": 1,
  "trialJobSpec": {
    "workerPoolSpecs": [
      {
        "machineSpec": {
          "machineType": "n1-standard-4"
        },
        "replicaCount": "1",
        "pythonPackageSpec": {
          "executorImageUri": "us-docker.pkg.dev/vertex-ai/training/training-tf-cpu.2-1:latest",
          "packageUris": [
            "gs://my-bucket/my-training-application/trainer.tar.bz2"
          ],
          "pythonModule": "my-trainer.trainer"
        }
      }
    ]
  },
  "state": "PIPELINE_STATE_PENDING",
  "createTime": "2020-09-15T19:09:54.342080Z",
  "startTime": "2020-09-15T19:13:42.991045Z",
}

Surveiller l'entraînement

Pour afficher les journaux d'entraînement, procédez comme suit :

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

Accéder à la page "Entraînement"
Cliquez sur le nom de votre job pour accéder à la page des jobs personnalisés.
Cliquez sur Afficher les journaux.

Vous pouvez également utiliser un shell interactif pour inspecter vos conteneurs d'entraînement pendant l'exécution du pipeline d'entraînement.

Afficher le modèle entraîné

Une fois le pipeline d'entraînement personnalisé terminé, vous pouvez rechercher le modèle entraîné dans la console Google Cloud , dans la section Vertex AI de la page Modèles.

Accéder à la page "Modèles"

Étapes suivantes

Découvrez comment identifier les goulots d'étranglement qui nuisent aux performances d'entraînement afin d'entraîner les modèles plus rapidement et à moindre coût à l'aide de Cloud Profiler.
Déployez votre modèle sur un point de terminaison.
Créez un job de réglage d'hyperparamètres.
Découvrez comment planifier des jobs d'entraînement personnalisés en fonction de la disponibilité des ressources.

Créer des pipelines d'entraînement Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de créer un pipeline

Options de pipeline d'entraînement

Éléments inclus dans un CustomJob

Configurer votre pipeline pour utiliser un ensemble de données géré

Configurer l'entraînement distribué

Importer des objets CustomJob et des modèles

Console

REST

curl

PowerShell

Réponse

Java

Python

Conteneur prédéfini

Package

Script

Conteneur personnalisé

Job de réglage d'hyperparamètres et importation de modèle

REST

curl

PowerShell

Réponse

Surveiller l'entraînement

Afficher le modèle entraîné

Étapes suivantes

Créer des pipelines d'entraînement

Éléments inclus dans un `CustomJob`