Créer une tâche de réglage d'hyperparamètres

Les hyperparamètres sont des variables qui régissent le processus d'entraînement d'un modèle, par exemple la taille du lot ou le nombre de couches cachées dans un réseau de neurones profond. Les réglages d'hyperparamètres recherchent la meilleure combinaison de valeurs d'hyperparamètres en optimisant les valeurs des métriques à l'aide d'une série de tests. Les métriques sont des résumés scalaires que vous ajoutez à votre application d'entraînement, telles que la justesse du modèle.

Obtenez plus d'informations sur les réglages d'hyperparamètres dans Vertex AI. Pour obtenir un exemple détaillé, consultez l'atelier de programmation Vertex AI : réglages d'hyperparamètres.

Cette page vous explique comment :

Préparer l'application d'entraînement

Dans une tâche de réglage d'hyperparamètres, Vertex AI crée des essais de votre tâche d'entraînement avec différents ensembles d'hyperparamètres et évalue l'efficacité d'un essai à l'aide des métriques spécifiées. Vertex AI transmet les valeurs d'hyperparamètres à votre application d'entraînement en tant qu'arguments de ligne de commande. Pour permettre à Vertex AI d'évaluer l'efficacité d'un essai, votre application d'entraînement doit transmettre vos métriques à Vertex AI.

Les sections suivantes décrivent :

  • Comment Vertex AI transmet les hyperparamètres à votre application d'entraînement.
  • Options permettant de transférer les métriques de votre application d'entraînement vers Vertex AI.

Pour en savoir plus sur les exigences des applications d'entraînement personnalisées qui s'exécutent sur Vertex AI, consultez la section Exigences du code d'entraînement.

Gérer les arguments de ligne de commande pour les hyperparamètres à régler

Vertex AI définit les arguments de ligne de commande lorsqu'il appelle votre application d'entraînement. Utilisez les arguments de ligne de commande dans votre code de la manière suivante :

  1. Définissez un nom pour chaque argument d'hyperparamètres et analysez-le à l'aide de l'analyseur d'arguments de votre choix, tel que argparse. Utilisez les mêmes noms d'arguments lorsque vous configurez votre tâche d'entraînement d'hyperparamètres.

    Par exemple, si votre application d'entraînement est un module Python nommé my_trainer et que vous réglez un hyperparamètre nommé learning_rate, Vertex AI lance chaque essai avec une commande semblable à celle-ci :

    python3 -m my_trainer --learning_rate learning-rate-in-this-trial

    Vertex AI détermine l'argument learning-rate-in-this-trial et le transmet à l'aide de l'argument learning_rate.

  2. Attribuez les valeurs des arguments de ligne de commande aux hyperparamètres dans votre code d'entraînement.

En savoir plus sur les exigences applicables à l'analyse des arguments de ligne de commande

Transmettre des métriques à Vertex AI

Pour signaler vos métriques à Vertex AI, utilisez le package Python cloudml-hypertune. Cette bibliothèque fournit des fonctions d'assistance pour la génération de rapports de métriques à Vertex AI.

En savoir plus sur la création de rapports sur les métriques d'hyperparamètres

Créer une tâche de réglage d'hyperparamètres

En fonction de l'outil que vous souhaitez utiliser pour créer un HyperparameterTuningJob, sélectionnez l'un des onglets suivants :

Console

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

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

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

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

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

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

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

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

    Cliquez sur Continuer.

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

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

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

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

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

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

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

    Cliquez sur Continuer.

  6. À l'étape réglage des hyperparamètres, cochez la case Activer le réglage d'hyperparamètres et spécifiez les paramètres suivants :

    1. Dans la section Nouvel hyperparamètre, indiquez le nom du paramètre et le type d'un hyperparamètre à régler. Selon le type spécifié, configurez les paramètres d'hyperparamètres supplémentaires qui s'affichent.

      En savoir plus sur les types d'hyperparamètres et leurs configurations

    2. Si vous souhaitez régler plusieurs hyperparamètres, cliquez sur Ajouter un paramètre et répétez l'étape précédente dans la nouvelle section qui s'affiche.

      Répétez cette opération pour chaque hyperparamètre à régler.

    3. Dans le champ Métrique à optimiser et dans la liste déroulante Objectif, spécifiez le nom et l'objectif de la métrique que vous souhaitez optimiser.

    4. Dans le champ Nombre maximal d'essais, spécifiez le nombre maximal d'essais que vous souhaitez que Vertex AI exécute pour votre tâche de réglage d'hyperparamètres.

    5. Dans le champ Nombre maximal d'essais parallèles, spécifiez le nombre maximal d'essais que Vertex AI peut exécuter simultanément.

    6. Dans la liste déroulante Algorithme de recherche, spécifiez un algorithme de recherche que Vertex AI doit utiliser.

    7. Ignorez l'option Activer l'arrêt prématuré, qui est sans effet.

    Cliquez sur Continuer.

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

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

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

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

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

    Cliquez sur Continuer.

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

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

gcloud

Les étapes suivantes montrent comment utiliser Google Cloud CLI pour créer un HyperparameterTuningJob avec une configuration relativement minimale. Pour en savoir plus sur toutes les options de configuration que vous pouvez utiliser pour cette tâche, consultez la documentation de référence sur la commande gcloud ai hp-tuning-jobs create et la ressource API HyperparameterTuningJob.

  1. Créez un fichier YAML nommé config.yaml contenant les champs d'API que vous souhaitez spécifier pour votre nouveau fichier HyerparameterTuningJob :

    config.yaml
    studySpec:
  metrics:
  - metricId: METRIC_ID
    goal: METRIC_GOAL
  parameters:
  - parameterId: HYPERPARAMETER_ID
    doubleValueSpec:
      minValue: DOUBLE_MIN_VALUE
      maxValue: DOUBLE_MAX_VALUE
trialJobSpec:
  workerPoolSpecs:
    - machineSpec:
        machineType: MACHINE_TYPE
      replicaCount: 1
      containerSpec:
        imageUri: CUSTOM_CONTAINER_IMAGE_URI

    Remplacez les éléments suivants :

  2. Dans le même répertoire que votre fichier config.yaml, exécutez la commande shell suivante :

    gcloud ai hp-tuning-jobs create \
    --region=LOCATION \
    --display-name=DISPLAY_NAME \
    --max-trial-count=MAX_TRIAL_COUNT \
    --parallel-trial-count=PARALLEL_TRIAL_COUNT \
    --config=config.yaml

    Remplacez les éléments suivants :

REST

Utilisez l'exemple de code suivant pour créer une tâche de réglage d'hyperparamètres à l'aide de la méthode create de la ressource hyperparameterTuningJob.

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

  • LOCATION : région dans laquelle vous souhaitez créer HyperparameterTuningJob. Utilisez une région compatible avec l'entraînement personnalisé.
  • PROJECT : l'ID de votre projet.
  • DISPLAY_NAME : nom à afficher de votre choix pour le paramètre HyperparameterTuningJob. Découvrez les exigences concernant les noms de ressources.
  • Spécifiez vos métriques :
  • Spécifiez vos hyperparamètres :
    • HYPERPARAMETER_ID : nom d'un hyperparamètre à régler. Votre code d'entraînement doit analyser une option de ligne de commande portant ce nom.
    • 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 minimales (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 minimales (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.
    • Spécifiez des hyperparamètres conditionnels. Les hyperparamètres conditionnels sont ajoutés à un essai lorsque la valeur de l'hyperparamètres parent correspond à la condition spécifiée. En savoir plus sur les hyperparamètres conditionnels
      • CONDITIONAL_PARAMETER : ParameterSpec du paramètre conditionnel. Cette spécification comprend le nom du paramètre, l'échelle, la plage de valeurs et les paramètres conditionnels qui dépendent de cet hyperparamètre.
      • Si le type de l'hyperparamètre parent est ENTIER, spécifiez une liste d'entiers en tant que INTEGERS_TO_MATCH. Si la valeur de l'hyperparamètre parent correspond à l'une des valeurs spécifiées, ce paramètre conditionnel est ajouté à l'essai.
      • Si le type d'hyperparamètre parent est CATÉGORIEL, spécifiez une liste de catégories comme CATEGORIES_TO_MATCH. Si la valeur de l'hyperparamètre parent correspond à l'une des valeurs spécifiées, ce paramètre conditionnel est ajouté à l'essai.
      • Si le type de l'hyperparamètre parent est DISCRET, spécifiez une liste d'entiers en tant que DISCRETE_VALUES_TO_MATCH. Si la valeur de l'hyperparamètre parent correspond à l'une des valeurs spécifiées, ce paramètre conditionnel est ajouté à l'essai.
  • 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.
  • PARALLEL_TRIAL_COUNT : nombre maximal d'essais à exécuter 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 VM à utiliser 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 Docker avec votre code d'entraînement. Apprenez à créer une image de conteneur personnalisé.
      • 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. Apprenez-en plus sur les conteneurs prédéfinis 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.
    • SERVICE_ACCOUNT : (Facultatif) Compte de service utilisé par Vertex AI pour exécuter le code. Apprenez-en plus sur l'association d'un compte de service personnalisé.
    • 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.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/hyperparameterTuningJobs

Corps JSON de la requête :

{
  "displayName": DISPLAY_NAME,
  "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.

        "conditionalParameterSpecs": [
            "parameterSpec": {
              CONDITIONAL_PARAMETER
            }

            // Union field parent_value_condition can be only one of the following:
            "parentIntValues": {
                "values": [INTEGERS_TO_MATCH]
            }
            "parentCategoricalValues": {
                "values": [CATEGORIES_TO_MATCH]
            }
            "parentDiscreteValues": {
                "values": [DISCRETE_VALUES_TO_MATCH]
            }
            // End of list of possible types for union field parent_value_condition.
        ]
      }
    ],
    "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
      },
      "serviceAccount": SERVICE_ACCOUNT
  },
  "labels": {
    LABEL_NAME_1": LABEL_VALUE_1,
    LABEL_NAME_2": LABEL_VALUE_2
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
        }
      }
    ]
  }
}

Java

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

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

import com.google.cloud.aiplatform.v1.AcceleratorType;
import com.google.cloud.aiplatform.v1.CustomJobSpec;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.PythonPackageSpec;
import com.google.cloud.aiplatform.v1.StudySpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec;
import com.google.cloud.aiplatform.v1.StudySpec.MetricSpec.GoalType;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ConditionalParameterSpec.DiscreteValueCondition;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DiscreteValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.DoubleValueSpec;
import com.google.cloud.aiplatform.v1.StudySpec.ParameterSpec.ScaleType;
import com.google.cloud.aiplatform.v1.WorkerPoolSpec;
import java.io.IOException;
import java.util.Arrays;

public class CreateHyperparameterTuningJobPythonPackageSample {

  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 executorImageUri = "EXECUTOR_IMAGE_URI";
    String packageUri = "PACKAGE_URI";
    String pythonModule = "PYTHON_MODULE";
    createHyperparameterTuningJobPythonPackageSample(
        project, displayName, executorImageUri, packageUri, pythonModule);
  }

  static void createHyperparameterTuningJobPythonPackageSample(
      String project,
      String displayName,
      String executorImageUri,
      String packageUri,
      String pythonModule)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      // study spec
      MetricSpec metric =
          MetricSpec.newBuilder().setMetricId("val_rmse").setGoal(GoalType.MINIMIZE).build();

      // decay
      DoubleValueSpec doubleValueSpec =
          DoubleValueSpec.newBuilder().setMinValue(1e-07).setMaxValue(1).build();
      ParameterSpec parameterDecaySpec =
          ParameterSpec.newBuilder()
              .setParameterId("decay")
              .setDoubleValueSpec(doubleValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();
      Double[] decayValues = {32.0, 64.0};
      DiscreteValueCondition discreteValueDecay =
          DiscreteValueCondition.newBuilder().addAllValues(Arrays.asList(decayValues)).build();
      ConditionalParameterSpec conditionalParameterDecay =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterDecaySpec)
              .setParentDiscreteValues(discreteValueDecay)
              .build();

      // learning rate
      ParameterSpec parameterLearningSpec =
          ParameterSpec.newBuilder()
              .setParameterId("learning_rate")
              .setDoubleValueSpec(doubleValueSpec) // Use the same min/max as for decay
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .build();

      Double[] learningRateValues = {4.0, 8.0, 16.0};
      DiscreteValueCondition discreteValueLearning =
          DiscreteValueCondition.newBuilder()
              .addAllValues(Arrays.asList(learningRateValues))
              .build();
      ConditionalParameterSpec conditionalParameterLearning =
          ConditionalParameterSpec.newBuilder()
              .setParameterSpec(parameterLearningSpec)
              .setParentDiscreteValues(discreteValueLearning)
              .build();

      // batch size
      Double[] batchSizeValues = {4.0, 8.0, 16.0, 32.0, 64.0, 128.0};

      DiscreteValueSpec discreteValueSpec =
          DiscreteValueSpec.newBuilder().addAllValues(Arrays.asList(batchSizeValues)).build();
      ParameterSpec parameter =
          ParameterSpec.newBuilder()
              .setParameterId("batch_size")
              .setDiscreteValueSpec(discreteValueSpec)
              .setScaleType(ScaleType.UNIT_LINEAR_SCALE)
              .addConditionalParameterSpecs(conditionalParameterDecay)
              .addConditionalParameterSpecs(conditionalParameterLearning)
              .build();

      // trial_job_spec
      MachineSpec machineSpec =
          MachineSpec.newBuilder()
              .setMachineType("n1-standard-4")
              .setAcceleratorType(AcceleratorType.NVIDIA_TESLA_T4)
              .setAcceleratorCount(1)
              .build();

      PythonPackageSpec pythonPackageSpec =
          PythonPackageSpec.newBuilder()
              .setExecutorImageUri(executorImageUri)
              .addPackageUris(packageUri)
              .setPythonModule(pythonModule)
              .build();

      WorkerPoolSpec workerPoolSpec =
          WorkerPoolSpec.newBuilder()
              .setMachineSpec(machineSpec)
              .setReplicaCount(1)
              .setPythonPackageSpec(pythonPackageSpec)
              .build();

      StudySpec studySpec =
          StudySpec.newBuilder()
              .addMetrics(metric)
              .addParameters(parameter)
              .setAlgorithm(StudySpec.Algorithm.RANDOM_SEARCH)
              .build();
      CustomJobSpec trialJobSpec =
          CustomJobSpec.newBuilder().addWorkerPoolSpecs(workerPoolSpec).build();
      // hyperparameter_tuning_job
      HyperparameterTuningJob hyperparameterTuningJob =
          HyperparameterTuningJob.newBuilder()
              .setDisplayName(displayName)
              .setMaxTrialCount(4)
              .setParallelTrialCount(2)
              .setStudySpec(studySpec)
              .setTrialJobSpec(trialJobSpec)
              .build();
      LocationName parent = LocationName.of(project, location);
      HyperparameterTuningJob response =
          client.createHyperparameterTuningJob(parent, hyperparameterTuningJob);
      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. 

from google.cloud import aiplatform

from google.cloud.aiplatform import hyperparameter_tuning as hpt


def create_hyperparameter_tuning_job_sample(
    project: str,
    location: str,
    staging_bucket: str,
    display_name: str,
    container_uri: str,
):
    aiplatform.init(project=project, location=location, staging_bucket=staging_bucket)

    worker_pool_specs = [
        {
            "machine_spec": {
                "machine_type": "n1-standard-4",
                "accelerator_type": "NVIDIA_TESLA_K80",
                "accelerator_count": 1,
            },
            "replica_count": 1,
            "container_spec": {
                "image_uri": container_uri,
                "command": [],
                "args": [],
            },
        }
    ]

    custom_job = aiplatform.CustomJob(
        display_name='custom_job',
        worker_pool_specs=worker_pool_specs,
    )

    hpt_job = aiplatform.HyperparameterTuningJob(
        display_name=display_name,
        custom_job=custom_job,
        metric_spec={
            'loss': 'minimize',
        },
        parameter_spec={
            'lr': hpt.DoubleParameterSpec(min=0.001, max=0.1, scale='log'),
            'units': hpt.IntegerParameterSpec(min=4, max=128, scale='linear'),
            'activation': hpt.CategoricalParameterSpec(values=['relu', 'selu']),
            'batch_size': hpt.DiscreteParameterSpec(values=[128, 256], scale='linear')
        },
        max_trial_count=128,
        parallel_trial_count=8,
        labels={'my_key': 'my_value'},
    )

    hpt_job.run()

    print(hpt_job.resource_name)
    return hpt_job

Configuration du job d'entraînement d'hyperparamètres

Les tâches de réglages d'hyperparamètres recherchent la meilleure combinaison d'hyperparamètres pour optimiser vos métriques. Pour ce faire, les tâches de réglage des hyperparamètres effectuent plusieurs essais de votre application d'entraînement avec différents ensembles d'hyperparamètres.

Lorsque vous configurez une tâche de réglage d'hyperparamètres, vous devez spécifier les informations suivantes :

Limiter le nombre d'essais

Déterminez le nombre d'essais dont vous souhaitez autoriser l'exécution par le service et définissez la valeur maxTrialCount dans l'objet HyperparameterTuningJob.

Les deux enjeux contradictoires suivants sont à prendre en compte au moment de déterminer le nombre d'essais à autoriser :

  • temps (et par conséquent, coût)
  • accuracy

L'augmentation du nombre d'essais donne généralement de meilleurs résultats, mais ce n'est pas toujours le cas. Il y a souvent un moment où les rendements diminuent au-delà duquel les essais supplémentaires n'ont que peu ou pas d'effet sur la précision. Avant de démarrer une tâche avec un grand nombre d'essais, vous pouvez commencer par un petit nombre d'essais pour évaluer l'effet de vos hyperparamètres sur la précision de votre modèle.

Pour tirer le meilleur parti des réglages d'hyperparamètres : définissez une valeur maximale au moins égale à 10 fois le nombre d'hyperparamètres utilisés.

Essais parallèles

Vous pouvez spécifier le nombre d'essais pouvant être exécutés en parallèle en définissant parallelTrialCount dans l'objet HyperparameterTuningJob.

L'exécution d'essais parallèles permet de réduire le délai de la tâche d'entraînement (temps réel : le temps de traitement total nécessaire n'est généralement pas modifié). Notez toutefois que l'exécution en parallèle peut réduire l'efficacité globale de la tâche de réglage. Cela est imputable au fait que les réglages d'hyperparamètres utilisent les résultats des essais précédents pour déterminer les valeurs à attribuer aux hyperparamètres des essais suivants. Lors de l'exécution en parallèle, certains essais sont lancés sans bénéficier des résultats des essais qui sont toujours en cours d'exécution.

Si vous utilisez des essais parallèles, le service de réglage d'hyperparamètres provisionne plusieurs clusters de traitement pour l'entraînement (ou plusieurs machines individuelles dans le cas d'une application d'entraînement à un seul processus). La spécification de pool de travail que vous définissez pour votre tâche est utilisée pour chaque cluster d'entraînement.

Gérer les essais ayant échoué

Si vos essais de réglage d'hyperparamètres se terminent avec des erreurs, vous souhaiterez peut-être mettre fin à la tâche d'entraînement prématurément. Définissez le champ maxFailedTrialCount dans HyperparameterTuningJob sur le nombre d'essais en échec que vous souhaitez autoriser. Une fois ce nombre d'essais échoués atteint, Vertex AI met fin à la tâche d'entraînement. La valeur maxFailedTrialCount doit être inférieure ou égale à maxTrialCount.

Si vous ne définissez pas maxFailedTrialCount, ou si vous définissez la valeur sur 0, Vertex AI utilise les règles suivantes pour gérer les essais en échec :

  • Si le premier essai de la tâche échoue, Vertex AI termine la tâche immédiatement. Un échec lors du premier essai suggère un problème dans votre code d'entraînement. Par conséquent, des essais ultérieurs risquent également d'échouer. En mettant fin à la tâche, vous pouvez diagnostiquer le problème sans attendre de nouveaux essais ni encourir des coûts plus élevés.
  • Si le premier essai réussit, Vertex AI peut mettre fin à la tâche après des échecs lors d'essais ultérieurs, sur la base de l'un des critères suivants :
    • Le nombre d'essais ayant échoué est devenu trop élevé.
    • Le ratio entre le nombre d'essais échoués et le nombre d'essais réussis est devenu trop élevé.

Ces règles sont susceptibles d'être modifiées. Pour garantir un comportement spécifique, définissez vous-même la valeur du champ maxFailedTrialCount.

Gérer les tâches de réglage d'hyperparamètres

Les sections suivantes expliquent comment gérer vos tâches de réglages d'hyperparamètres.

Récupérer des informations sur une tâche de réglage d'hyperparamètres

Les exemples de code suivants montrent comment récupérer une tâche de réglage d'hyperparamètres.

gcloud

Exécutez la commande gcloud ai hp-tuning-jobs describe :

gcloud ai hp-tuning-jobs describe ID_OR_NAME \
    --region=LOCATION

Remplacez les éléments suivants :

  • ID_OR_NAME : nom ou ID numérique du jeton HyperparameterTuningJob (l'ID correspond à la dernière partie du nom).

    Vous avez peut-être vu l'ID ou le nom lorsque vous avez créé l'objet HyperparameterTuningJob. Si vous ne connaissez pas l'ID ni le nom, vous pouvez exécuter la commande gcloud ai hp-tuning-jobs list et rechercher la ressource appropriée.

  • LOCATION : région dans laquelle HyperparameterTuningJob a été créé.

REST

Utilisez l'exemple de code suivant pour récupérer une tâche de réglage d'hyperparamètres à l'aide de la méthode get de la ressource hyperparameterTuningJob.

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

  • LOCATION : région dans laquelle HyperparameterTuningJob a été créé.
  • NAME : nom de la tâche de réglage d'hyperparamètres. Le nom de la tâche utilise le format projects/{project}/LOCATIONS/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Méthode HTTP et URL :

GET https://LOCATION-aiplatform.googleapis.com/v1/NAME

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/12345/LOCATIONs/us-central1/hyperparameterTuningJobs/6789",
  "displayName": "my-hyperparameter-tuning-job",
  "studySpec": {
    "metrics": [
      {
        "metricId": "my_metric",
        "goal": "MINIMIZE"
      }
    ],
    "parameters": [
      {
        "parameterId": "my_parameter",
        "doubleValueSpec": {
          "minValue": 1e-05,
          "maxValue": 1
        }
      }
    ]
  },
  "maxTrialCount": 3,
  "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"
        }
      }
    ]
  },
  "trials": [
    {
      "id": "2",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.71426874725564571
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30007445812225342
          }
        ]
      },
      "startTime": "2020-09-09T23:39:15.549112551Z",
      "endTime": "2020-09-09T23:47:08Z"
    },
    {
      "id": "3",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.3078893356622992
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30000102519989014
          }
        ]
      },
      "startTime": "2020-09-09T23:49:22.451699360Z",
      "endTime": "2020-09-09T23:57:15Z"
    },
    {
      "id": "1",
      "state": "SUCCEEDED",
      "parameters": [
        {
          "parameterId": "my_parameter",
          "value": 0.500005
        }
      ],
      "finalMeasurement": {
        "stepCount": "2",
        "metrics": [
          {
            "metricId": "my_metric",
            "value": 0.30005377531051636
          }
        ]
      },
      "startTime": "2020-09-09T23:23:12.283374629Z",
      "endTime": "2020-09-09T23:36:56Z"
    }
  ],
  "state": "JOB_STATE_SUCCEEDED",
  "createTime": "2020-09-09T23:22:31.777386Z",
  "startTime": "2020-09-09T23:22:34Z",
  "endTime": "2020-09-10T01:31:24.271307Z",
  "updateTime": "2020-09-10T01:31:24.271307Z"
}

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.HyperparameterTuningJob;
import com.google.cloud.aiplatform.v1.HyperparameterTuningJobName;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import java.io.IOException;

public class GetHyperparameterTuningJobSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String hyperparameterTuningJobId = "HYPERPARAMETER_TUNING_JOB_ID";
    getHyperparameterTuningJobSample(project, hyperparameterTuningJobId);
  }

  static void getHyperparameterTuningJobSample(String project, String hyperparameterTuningJobId)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (JobServiceClient client = JobServiceClient.create(settings)) {
      HyperparameterTuningJobName name =
          HyperparameterTuningJobName.of(project, location, hyperparameterTuningJobId);
      HyperparameterTuningJob response = client.getHyperparameterTuningJob(name);
      System.out.format("response: %s\n", response);
    }
  }
}

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. 

# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from google.cloud import aiplatform


def get_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    return hpt_job

Annuler une tâche de réglage d'hyperparamètres

Les exemples de code suivants montrent comment annuler une tâche de réglage d'hyperparamètres.

gcloud

Exécutez la commande gcloud ai hp-tuning-jobs cancel :

gcloud ai hp-tuning-jobs cancel ID_OR_NAME \
    --region=LOCATION

Remplacez les éléments suivants :

  • ID_OR_NAME : nom ou ID numérique du jeton HyperparameterTuningJob (l'ID correspond à la dernière partie du nom).

    Vous avez peut-être vu l'ID ou le nom lorsque vous avez créé l'objet HyperparameterTuningJob. Si vous ne connaissez pas l'ID ni le nom, vous pouvez exécuter la commande gcloud ai hp-tuning-jobs list et rechercher la ressource appropriée.

  • LOCATION : région dans laquelle HyperparameterTuningJob a été créé.

REST

Utilisez l'exemple de code suivant pour annuler une tâche de réglage d'hyperparamètres à l'aide de la méthode cancel de la ressource hyperparameterTuningJob.

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

  • LOCATION : région dans laquelle HyperparameterTuningJob a été créé.
  • NAME : nom de la tâche de réglage d'hyperparamètres. Le nom de la tâche utilise le format projects/{project}/locations/{location}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/NAME:cancel

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

from google.cloud import aiplatform


def cancel_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.cancel()

Supprimer une tâche de réglage d'hyperparamètres

Les exemples de code suivants montrent comment supprimer une tâche de réglage d'hyperparamètres à l'aide du SDK Vertex AI pour Python et l'API REST.

REST

Utilisez l'exemple de code suivant pour supprimer une tâche de réglage d'hyperparamètres à l'aide de la méthode delete de la ressource hyperparameterTuningJob.

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

  • LOCATION : votre région.
  • NAME : nom de la tâche de réglage d'hyperparamètres. Le nom de la tâche utilise le format projects/{project}/LOCATIONs/{LOCATION}/hyperparameterTuningJobs/{hyperparameterTuningJob}.

Méthode HTTP et URL :

DELETE https://LOCATION-aiplatform.googleapis.com/v1/NAME

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python. 

from google.cloud import aiplatform


def delete_hyperparameter_tuning_job_sample(
    project: str,
    hyperparameter_tuning_job_id: str,
    location: str = "us-central1",
):

    aiplatform.init(project=project, location=location)

    hpt_job = aiplatform.HyperparameterTuningJob.get(
        resource_name=hyperparameter_tuning_job_id,
    )

    hpt_job.delete()

Étapes suivantes