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.

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 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 tâches d'entraînement avec des étapes supplémentaires. Ce guide explique deux pipelines d'entraînement différents :

  • Lancer un objet CustomJob et importer le modèle obtenu dans Vertex AI
  • Lancer une tâche de réglages 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 une tâche personnalisée (CustomJob)

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 :

Si vous souhaitez créer une tâche personnalisée autonome en dehors d'un pipeline d'entraînement Vertex AI, reportez-vous au guide sur les tâches personnalisées.

Configurer votre pipeline pour qu'il utilise un ensemble de données géré

Dans votre pipeline d'entraînement, vous pouvez configurer votre tâche d'entraînement personnalisé ou votre tâche 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, procédez comme suit :

  1. Créez votre ensemble de données.
  2. Mettez à jour 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.

  3. 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 tâche d'entraînement personnalisé ou votre tâche 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 tâches d'entraînement à instance dupliquée unique avec un seul 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é.

Importer des objets CustomJob et des modèles

Ce pipeline d'entraînement encapsule une tâche personnalisée 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 :

  1. Le pipeline d'entraînement crée une ressource CustomJob. La tâche personnalisée exécute l'application d'entraînement en utilisant les ressources de calcul que vous spécifiez.

  2. Une fois la tâche personnalisée terminée, 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 tâche 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.

  • 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, procédez comme suit :

Console

  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. 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.

  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.

      À 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 les réglages 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 :

    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 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 diffuser les prédictions de votre modèle entraîné.

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

    3. Le champ Modèle de répertoire 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 les champs de la section Schémas de prédiction vides.

  9. 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 la page Gestion des versions de modèles avec Vertex AI Model Registry.

Avant d'utiliser les données de requête ci-dessous, 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 pour le trainingPipeline.
  • Si votre application d'entraînement utilise un ensemble de données de 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 d'horodatage à 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 la tâche d'entraînement personnalisée :
    • MACHINE_TYPE : type de la machine. Pour plus d'informations, 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, 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. 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 les 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. 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. 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 la tâche.
  • MODEL_NAME : nom à afficher pour le modèle importé (créé) par le TrainingPipeline.
  • MODEL_DESCRIPTION : description du modèle.
  • IMAGE_URI : URI de l'image de conteneur à utiliser pour exécuter les prédictions. 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. Exemple :
    • "env" : "prod"
    • "tier" : "backend"
  • Spécifiez les éléments 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

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

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.

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

Tâche de réglage d'hyperparamètres et importation de modèle

Ce pipeline d'entraînement intègre une tâche 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 :

  1. Le pipeline d'entraînement crée une ressource de tâche de réglage d'hyperparamètres. La tâche de réglage d'hyperparamètres crée plusieurs essais. Pour chaque essai, une tâche personnalisée exécute votre application d'entraînement à l'aide des ressources de calcul et des hyperparamètres que vous spécifiez.

  2. Une fois la tâche de réglage d'hyperparamètres terminée, 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 objet baseOutputDirectory dans lequel Vertex AI recherche les artefacts de modèle du meilleur essai.

Les tâches 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 ci-dessous, effectuez les remplacements suivants :

  • LOCATION_ID : région de votre projet.
  • PROJECT_ID : ID de votre projet
  • TRAINING_PIPELINE_NAME : valeur obligatoire. Nom à afficher pour le trainingPipeline.
  • Si votre application d'entraînement utilise un ensemble de données de 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 d'horodatage à 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, après que celui-ci a été divisé en ensembles d'entraînement, de validation et de test.
  • Spécifiez votre tâche 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 CATEGORICAL (catégoriel). Il peut s'agir de UNIT_LINEAR_SCALE, UNIT_LOG_SCALE, UNIT_REVERSE_LOG_SCALE ou SCALE_TYPE_UNSPECIFIED.
      • Si le type de cet 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 INTEGER, spécifiez les valeurs minimales(INTEGER_MIN_VALUE) et maximales(INTEGER_MAX_VALUE) pour cet hyperparamètre.
      • Si le type de cet hyperparamètre est CATEGORICAL, spécifiez les valeurs acceptables (CATEGORICAL_VALUES) sous la forme d'un tableau de chaînes.
      • Si le type de cet hyperparamètre est DISCRETE, spécifiez les valeurs acceptables (DISCRETE_VALUES) sous la forme d'un tableau de nombres.
    • ALGORITHM : (Facultatif) algorithme de recherche à utiliser dans cette tâche 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 cette tâche.
    • PARALLEL_TRIAL_COUNT : nombre maximal d'essais pouvant être exécutés en parallèle.
    • MAX_FAILED_TRIAL_COUNT : nombre de tâches pouvant échouer avant l'échec de la tâche de réglage d'hyperparamètres.
    • Définissez la tâche d'entraînement personnalisée :
      • 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, 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 :
        • PYTHON_PACKAGE_EXECUTOR_IMAGE_URI : URI de l'image de conteneur qui exécute le package Python fourni. Pour en savoir plus, consultez les conteneurs prédéfinis disponibles pour l'entraînement.
        • PYTHON_PACKAGE_URIS : emplacement Cloud Storage des fichiers de package Python qui regroupent le programme d'entraînement et ses dépendances. 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) 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 à cette tâche de réglage d'hyperparamètres.
  • MODEL_NAME : nom à afficher pour le modèle importé (créé) par le TrainingPipeline.
  • MODEL_DESCRIPTION : facultatif. Description du modèle.
  • PREDICTION_IMAGE_URI : valeur obligatoire. Spécifiez l'une des deux options suivantes :
  • modelToUpload.labels : facultatif. Tout ensemble de paires clé/valeur pour organiser vos modèles. Exemple :
    • "env" : "prod"
    • "tier" : "backend"
  • Spécifiez les éléments LABEL_NAME et LABEL_VALUE pour tous les libellés 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

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.

Surveiller l'entraînement

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

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

    Accéder à la page Entraînement

  2. Cliquez sur le nom de votre tâche pour accéder à la page des tâches personnalisées.

  3. Cliquez sur Afficher les journaux.

Vous pouvez également utiliser une interface système interactive 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 des modèles

Étapes suivantes