Utiliser les réglages d'hyperparamètres

Cette page vous explique comment utiliser le réglage des hyperparamètres de AI Platform Training lors de l'entraînement de votre modèle. Les réglages d'hyperparamètres optimisent une variable cible que vous spécifiez. Celle-ci est appelée métrique d'hyperparamètres. Lorsque vous démarrez une tâche avec des réglages d'hyperparamètres, vous devez définir le nom de votre métrique d'hyperparamètres. Il s'agit du nom que vous attribuez au résumé scalaire que vous ajoutez à votre application d'entraînement.

Les étapes à suivre pour les réglages d'hyperparamètres

Pour inclure les réglages d'hyperparamètres dans votre tâche d'entraînement, procédez comme suit :

  1. Spécifiez la configuration des réglages d'hyperparamètres pour votre tâche d'entraînement en incluant un objet HyperparameterSpec dans votre objet TrainingInput.

  2. Incluez le code suivant dans votre application d'entraînement :

    • Analysez les arguments de ligne de commande représentant les hyperparamètres à régler et utilisez ces valeurs afin de définir les hyperparamètres pour votre essai d'entraînement.
    • Ajoutez votre métrique d'hyperparamètres au résumé de votre graphique.

Ces étapes sont détaillées ci-dessous.

Spécifier la configuration des réglages d'hyperparamètres pour votre tâche d'entraînement

Créez un objet HyperparameterSpec pour conserver la configuration de réglage des hyperparamètres pour votre tâche d'entraînement et ajoutez l'objet HyperparameterSpec en tant qu'objet hyperparameters dans votre objet TrainingInput.

Dans votre objet HyperparameterSpec, définissez le paramètre hyperparameterMetricTag sur une valeur représentant la métrique que vous avez choisie. Si vous ne spécifiez pas de hyperparameterMetricTag, AI Platform Training recherche une métrique portant le nom training/hptuning/metric. L'exemple suivant montre comment créer une configuration pour une métrique nommée metric1 :

gcloud

Ajoutez les informations de configuration de vos hyperparamètres à votre fichier de configuration YAML. Vous trouverez un exemple ci-dessous. Pour utiliser un fichier de configuration opérationnel, consultez hptuning_config.yaml dans l'exemple d'Estimator sur le recensement.

trainingInput:
  scaleTier: CUSTOM
  masterType: complex_model_m
  workerType: complex_model_m
  parameterServerType: large_model
  workerCount: 9
  parameterServerCount: 3
  hyperparameters:
    goal: MAXIMIZE
    hyperparameterMetricTag: metric1
    maxTrials: 30
    maxParallelTrials: 1
    enableTrialEarlyStopping: True
    params:
    - parameterName: hidden1
      type: INTEGER
      minValue: 40
      maxValue: 400
      scaleType: UNIT_LINEAR_SCALE
    - parameterName: numRnnCells
      type: DISCRETE
      discreteValues:
      - 1
      - 2
      - 3
      - 4
    - parameterName: rnnCellType
      type: CATEGORICAL
      categoricalValues:
      - BasicLSTMCell
      - BasicRNNCell
      - GRUCell
      - LSTMCell
      - LayerNormBasicLSTMCell

Python

Créez un dictionnaire représentant votre objet HyperparameterSpec et ajoutez-le à vos données d'entrée d'entraînement. L'exemple suivant suppose que vous avez déjà créé un dictionnaire TrainingInput (dans ce cas nommé training_inputs) comme indiqué dans le guide de configuration des tâches d'entraînement.

# Add hyperparameter tuning to the job config.
hyperparams = {
    'goal': 'MAXIMIZE',
    'hyperparameterMetricTag': 'metric1',
    'maxTrials': 30,
    'maxParallelTrials': 1,
    'enableTrialEarlyStopping': True,
    'params': []}

hyperparams['params'].append({
    'parameterName':'hidden1',
    'type':'INTEGER',
    'minValue': 40,
    'maxValue': 400,
    'scaleType': 'UNIT_LINEAR_SCALE'})

hyperparams['params'].append({
    'parameterName':'numRnnCells',
    'type':'DISCRETE',
    'discreteValues': [1, 2, 3, 4]})

hyperparams['params'].append({
    'parameterName':'rnnCellType',
    'type': 'CATEGORICAL',
    'categoricalValues': [
        'BasicLSTMCell',
        'BasicRNNCell',
        'GRUCell',
        'LSTMCell',
        'LayerNormBasicLSTMCell'
    ]
})

# Add hyperparameter specification to the training inputs dictionary.
training_inputs['hyperparameters'] = hyperparams

# Build the job spec.
job_spec = {'jobId': my_job_name, 'trainingInput': training_inputs}

Vérifier le code dans votre application d'entraînement

Dans votre application, gérez les arguments de ligne de commande des hyperparamètres et signalez votre métrique d'hyperparamètres à AI Platform Training.

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

AI Platform Training définit des arguments de ligne de commande lors de l'appel de 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 (généralement argparse). Les noms des arguments doivent correspondre aux noms des paramètres que vous avez spécifiés dans la configuration de la tâche, comme décrit ci-dessus.

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

Signaler votre métrique d'hyperparamètres à AI Platform Training

La façon de signaler votre métrique d'hyperparamètres au service AI Platform Training varie selon que vous utilisez TensorFlow pour l'entraînement ou non. Cela dépend également du fait que vous utilisiez une version d'exécution ou un conteneur personnalisé pour l'entraînement.

Nous recommandons que votre code d'entraînement signale fréquemment votre métrique d'hyperparamètres à AI Platform Training afin de pouvoir bénéficier d'un arrêt prématuré.

TensorFlow avec une version d'exécution

Si vous utilisez une version d'exécution AI Platform Training et que vous effectuez un entraînement avec TensorFlow, vous pouvez signaler votre métrique d'hyperparamètres à AI Platform Training en écrivant la métrique dans un résumé TensorFlow. Utilisez l'une des fonctions suivantes :

L'utilisation d'une API TensorFlow différente qui appelle l'une des fonctions précédentes, comme dans l'exemple de l'API Estimator ci-dessous, permet également de signaler la métrique d'hyperparamètres à AI Platform Training.

Les exemples suivants présentent les principes de base de deux méthodes différentes pour écrire votre métrique d'hyperparamètres dans un résumé. Les deux exemples supposent que vous entraînez un modèle de régression. Ils écrivent la racine carrée de l'erreur quadratique moyenne entre les étiquettes de vérité terrain et les prédictions d'évaluation sous la forme d'une métrique d'hyperparamètres nommée metric1.

Keras

L'exemple suivant utilise un rappel Keras personnalisé pour écrire un résumé scalaire à la fin de chaque époque d'entraînement :

class MyMetricCallback(tf.keras.callbacks.Callback):

    def on_epoch_end(self, epoch, logs=None):
        tf.summary.scalar('metric1', logs['RootMeanSquaredError'], epoch)

logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

model = tf.keras.Sequential(
    tf.keras.layers.Dense(1, activation='linear', input_dim=784))
model.compile(
    optimizer='rmsprop',
    loss='mean_squared_error',
    metrics=['RootMeanSquaredError'])

model.fit(
    x_train,
    y_train,
    batch_size=64,
    epochs=10,
    steps_per_epoch=5,
    verbose=0,
    callbacks=[MyMetricCallback()])

Estimator

L'exemple suivant utilise tf.estimator.add_metrics pour ajouter votre métrique d'hyperparamètres au résumé de votre graphe.

Notez que l'API Estimator écrit un résumé de graphe chaque fois que sa méthode evaluate est exécutée. Cet exemple utilise tf.estimator.EvalSpec avec tf.estimator.train_and_evaluate pour configurer Estimator afin qu'il évalue et écrive des résumés toutes les 300 secondes pendant l'entraînement.

# Create metric for hyperparameter tuning
def my_metric(labels, predictions):
    # Note that different types of estimator provide different different
    # keys on the predictions Tensor. predictions['predictions'] is for
    # regression output.
    pred_values = predictions['predictions']
    return {'metric1': tf.compat.v1.metrics.root_mean_squared_error(labels, pred_values)}

# Create estimator to train and evaluate
def train_and_evaluate(output_dir):

    estimator = tf.estimator.DNNLinearCombinedRegressor(...)

    estimator = tf.estimator.add_metrics(estimator, my_metric)

    train_spec = ...
    eval_spec = tf.estimator.EvalSpec(
        start_delay_secs = 60, # start evaluating after 60 seconds
        throttle_secs = 300,  # evaluate every 300 seconds
        ...)
    tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)

Autres frameworks de machine learning ou conteneurs personnalisés

Si vous utilisez un conteneur personnalisé pour l'entraînement ou si vous souhaitez effectuer un réglage d'hyperparamètres avec un framework autre que TensorFlow, vous devez utiliser le package Python cloudml-hypertune pour signaler votre métrique d'hyperparamètres à AI Platform Training.

Consultez un exemple d'utilisation de cloudml-hypertune.

Obtenir des détails sur une tâche de réglages d'hyperparamètres en cours d'exécution

Vous pouvez surveiller les réglages d'hyperparamètres en obtenant le statut détaillé de votre tâche d'entraînement en cours d'exécution.

Dans la ressource "Job" de la réponse, les valeurs suivantes sont définies pour l'objet TrainingOutput lors d'une tâche d'entraînement avec réglages d'hyperparamètres :

  • La valeur de isHyperparameterTuningJob est True.

  • trials est présent et contient une liste d'objets HyperparameterOutput, un par essai.

Vous pouvez également récupérer l'ID d'essai à partir de la variable d'environnement TF_CONFIG. Consultez le guide pour obtenir des informations sur TF_CONFIG.

Obtenir les résultats des réglages d'hyperparamètres

Une fois les sessions d'entraînement terminées, vous pouvez afficher les résultats de chaque essai dans Cloud Console. Vous pouvez également appeler projects.jobs.get pour obtenir les résultats. L'objet TrainingOutput inclus dans la ressource de la tâche contient les métriques pour tous les entraînements, ainsi que celles de l'entraînement identifié comme possédant les meilleurs réglages.

Pour obtenir ces informations, effectuez une nouvelle fois la requête de statut détaillé que vous avez utilisée pour surveiller la tâche pendant le traitement.

Vous pouvez afficher les résultats de chaque essai dans la description de la tâche. Dans Cloud Console, vous pouvez filtrer les essais par rmse, learning_rate et training steps. Trouvez l'essai ayant renvoyé la valeur la plus souhaitable pour votre métrique d'hyperparamètres. Si l'essai répond à vos critères de réussite pour le modèle, vous pouvez utiliser les valeurs d'hyperparamètres indiquées par cet essai pour les exécutions ultérieures de votre modèle.

Parfois, plusieurs essais peuvent donner des résultats identiques pour les métriques de vos réglages. Dans ce cas, vous devez déterminer quelles valeurs d'hyperparamètres sont les plus avantageuses en utilisant d'autres mesures. Par exemple, si vous réglez le nombre de nœuds dans une couche cachée et que vous obtenez des résultats identiques pour une valeur définie sur 8 ou sur 20, vous devez utiliser la valeur 8. En pareil cas, un nombre supérieur de nœuds implique plus de traitement et des coûts plus importants, mais n'offre aucune amélioration de votre modèle.

L'état de l'essai FAILED dans HyperparameterOutput peut signifier que l'entraînement a échoué pour cet essai ou que celui-ci n'a pas signalé la métrique de réglage d'hyperparamètres. Dans ce dernier cas, la tâche parente peut réussir même si l'essai échoue. Vous pouvez consulter le journal d'essai pour savoir si l'entraînement a échoué pour l'essai.

Limiter le nombre d'essais

Vous devez déterminer le nombre d'essais à autoriser pour l'exécution du service et définir la valeur maxTrials dans l'objet HyperparameterSpec.

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

  • Le temps (et par conséquent, le coût)
  • La précision

L'augmentation du nombre d'essais donne généralement de meilleurs résultats, mais ce n'est pas toujours le cas. Dans la plupart des cas, il y a un risque de diminution des rendements, après quoi les essais supplémentaires n'ont que peu ou pas d'effet sur la précision. Il est préférable de commencer par un petit nombre d'essais pour évaluer l'effet de vos hyperparamètres sur la précision de votre modèle avant de démarrer une tâche avec un grand nombre d'essais.

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.

Traiter les essais infructueux

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. Dans l'objet HyperparameterSpec, définissez le champ maxFailedTrials sur le nombre d'essais en échec que vous souhaitez autoriser. Une fois ce nombre d'essais en échec atteint, AI Platform Training met fin à l'entraînement. La valeur maxFailedTrials doit être inférieure ou égale à maxTrials.

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

  • Si le premier essai de votre tâche échoue, AI Platform Training met immédiatement fin à la tâche. 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 avez la possibilité de diagnostiquer le problème sans attendre les résultats d'autres essais qui engendreraient des coûts supplémentaires.
  • Si le premier essai aboutit, AI Platform Training peut mettre fin à la tâche en cas d'échec des essais ultérieurs, en fonction 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 seuils internes sont susceptibles de changer. Pour garantir un comportement spécifique, définissez vous-même la valeur du champ maxFailedTrials.

Effectuer des essais parallèles

Vous pouvez spécifier un nombre d'essais à exécuter en parallèle en définissant maxParallelTrials dans l'objet HyperparameterSpec.

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 d'entraînement 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). Le niveau d'évolutivité défini pour votre tâche est utilisé pour chaque cluster d'entraînement.

Arrêter les essais prématurément

Vous pouvez programmer AI Platform Training pour arrêter automatiquement les essais qui sont voués à l'échec. Vous économisez ainsi le coût de la poursuite d'un essai qui ne sera probablement pas utile.

Pour permettre l'arrêt anticipé d'un essai, définissez la valeur enableTrialEarlyStopping dans l'objet HyperparameterSpec sur TRUE.

Relancer une tâche de réglages d'hyperparamètres terminée

Vous pouvez poursuivre l'exécution d'une tâche de réglages d'hyperparamètres terminée, et ainsi commencer à partir d'un état partiellement optimisé. Cette pratique vous permet de réutiliser les connaissances acquises au cours de la précédente tâche de réglage d'hyperparamètres.

Pour relancer une tâche de réglage d'hyperparamètres, envoyez une nouvelle tâche de réglage d'hyperparamètres avec la configuration suivante :

  • Dans l'objet HyperparameterSpec, définissez la valeur resumePreviousJobId sur l'ID de la tâche de l'essai précédent.
  • Spécifiez les valeurs pour maxTrials et maxParallelTrials.

AI Platform Training utilise l'ID de tâche précédent pour rechercher et réutiliser les mêmes valeurs goal, params et hyperparameterMetricTag pour poursuivre la tâche de réglage des hyperparamètres.

Utilisez des noms cohérents pour hyperparameterMetricTag et params pour les tâches similaires, même lorsque les tâches ont des paramètres différents. Cette pratique permet à AI Platform Training d'améliorer l'optimisation au fil du temps.

Les exemples suivants illustrent l'utilisation de la configuration resumePreviousJobId :

gcloud

trainingInput:
  scaleTier: CUSTOM
  masterType: complex_model_m
  workerType: complex_model_m
  parameterServerType: large_model
  workerCount: 9
  parameterServerCount: 3
  hyperparameters:
    enableTrialEarlyStopping: TRUE
    maxTrials: 30
    maxParallelTrials: 1
    resumePreviousJobId: [PREVIOUS_JOB_IDENTIFIER]

Python

# Add hyperparameter tuning to the job config.
hyperparams = {
    'enableTrialEarlyStopping': True,
    'maxTrials': 30,
    'maxParallelTrials': 1,
    'resumePreviousJobId': [PREVIOUS_JOB_IDENTIFIER]}

# Add the hyperparameter specification to the training inputs dictionary.
training_inputs['hyperparameters'] = hyperparams

# Build the job spec.
job_spec = {'jobId': my_job_name, 'trainingInput': training_inputs}

Effectuer des réglages d'hyperparamètres avec Cloud TPU

Si vous exécutez votre tâche de réglage d'hyperparamètres avec Cloud TPU sur AI Platform Training, il est conseillé d'utiliser la propriété eval_metrics dans TPUEstimatorSpec.

Consultez l'exemple de réglage d'hyperparamètres TPU à l'aide du modèle ResNet-50 pour en savoir plus les réglages d'hyperparamètres avec Cloud TPU.

Au lieu d'utiliser la propriété eval_metrics pour utiliser le service de réglage des hyperparamètres, vous pouvez également appeler tf.summary dans host_call. Pour plus d'informations, consultez TPUEstimatorSpec.

Étapes suivantes