Optimisation des hyperparamètres d’un modèle (v2)

APPLIES TO :Extension Azure ML CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (préversion)

Dans cet article, vous allez apprendre à automatiser l’optimisation efficace des hyperparamètres avec le Kit de développement logiciel (SDK) Azure Machine Learning v2 et CLI v2 à l’aide de la classe SweepJob .

• Définir l’espace de recherche de paramètre
• Choisir un algorithme d’échantillonnage
• Définir l’objectif d’optimisation
• Configurer une stratégie d’arrêt anticipé
• Définir les limites de la tâche de balayage
• Envoyer l’expérience
• Visualiser les tâches de formation
• Sélectionner la meilleure configuration

Qu’est-ce que l’optimisation des hyperparamètres ?

Les hyperparamètres sont des paramètres réglables qui contrôlent l’entraînement du modèle. Pour les réseaux neuronaux, par exemple, vous choisissez le nombre de couches masquées et le nombre de nœuds par couche. Les performances du modèle dépendent fortement de ces valeurs.

Le réglage des hyperparamètres (ou optimisation des hyperparamètres) est le processus de recherche de la configuration des hyperparamètres qui génère les meilleures performances. Ce processus est souvent coûteux et manuel.

Azure Machine Learning vous permet d’automatiser l’optimisation des hyperparamètres et d’exécuter des expérimentations parallèles pour optimiser efficacement les hyperparamètres.

Définir l’espace de recherche

Optimisez les hyperparamètres en explorant la plage de valeurs définie pour chaque hyperparamètre.

Les hyperparamètres peuvent être discrets ou continus et peuvent avoir une distribution de valeurs exprimée avec une expression de paramètre.

Hyperparamètres discrets

Les hyperparamètres discrets sont spécifiés en tant que Choice parmi des valeurs discrètes. Voici à quoi Choice peut correspondre :

• une ou plusieurs valeurs séparées par une virgule
• un objet range
• un objet list arbitraire

from azure.ai.ml.sweep import Choice

command_job_for_sweep = command_job(
    batch_size=Choice(values=[16, 32, 64, 128]),
    number_of_hidden_layers=Choice(values=range(1,5)),
)

Références :

• Choix

Dans ce cas, batch_size prend l’un des [16, 32, 64, 128] et number_of_hidden_layers prend l’un des [1, 2, 3, 4].

Les hyperparamètres discrets avancés suivants peuvent également être spécifiés en utilisant une distribution.

• QUniform(min_value, max_value, q) - Retourne une valeur telle que round(Uniform(min_value, max_value) / q) * q
• QLogUniform(min_value, max_value, q) - Retourne une valeur telle que round(exp(Uniform(min_value, max_value)) / q) * q
• QNormal(mu, sigma, q) - Retourne une valeur telle que round(Normal(mu, sigma) / q) * q
• QLogNormal(mu, sigma, q) - Retourne une valeur telle que round(exp(Normal(mu, sigma)) / q) * q

Hyperparamètres continus

Les hyperparamètres continus sont spécifiés comme une distribution sur une plage continue de valeurs :

• Uniform(min_value, max_value) - Retourne une valeur répartie uniformément entre min_value et max_value
• LogUniform(min_value, max_value) - Retourne une valeur calculée en fonction de exp(uniform(min_value, max_value)), de sorte que le logarithme de la valeur de retour présente une distribution uniforme.
• Normal(mu, sigma) : retourne une valeur réelle qui est normalement distribuée avec la moyenne mu et l’écart type sigma
• LogNormal(mu, sigma) : retourne une valeur calculée en fonction de exp(normal(mu, sigma)), de sorte que le logarithme de la valeur de retour est normalement distribué

Voici un exemple de définition d’espace de paramètres :

from azure.ai.ml.sweep import Normal, Uniform

command_job_for_sweep = command_job(   
    learning_rate=Normal(mu=10, sigma=3),
    keep_probability=Uniform(min_value=0.05, max_value=0.1),
)

Références :

• Normale
• Uniforme

Ce code définit un espace de recherche avec deux paramètres : learning_rate et keep_probability. learning_rate présente une distribution normale avec une valeur moyenne de 10 et un écart type de 3. keep_probability présente une distribution uniforme avec une valeur minimale de 0,05 et une valeur maximale de 0,1.

Pour l’interface en ligne de commande, utilisez le schéma YAML pour la tâche de balayage pour définir l’espace de recherche :

    search_space:
        conv_size:
            type: choice
            values: [2, 5, 7]
        dropout_rate:
            type: uniform
            min_value: 0.1
            max_value: 0.2

Échantillonnage de l’espace des hyperparamètres

Spécifiez la méthode d’échantillonnage pour l’espace hyperparamètre. Azure Machine Learning prend en charge :

• Échantillonnage aléatoire
• Échantillonnage par grille
• Échantillonnage bayésien

Échantillonnage aléatoire

L’échantillonnage aléatoire prend en charge les hyperparamètres discrets et continus, et prend en charge l’arrêt anticipé des travaux peu performants. De nombreux utilisateurs commencent par un échantillonnage aléatoire pour identifier les régions prometteuses, puis affiner.

Dans l’échantillonnage aléatoire, les valeurs sont dessinées uniformément (ou via la règle aléatoire spécifiée) à partir de l’espace de recherche défini. Après avoir créé votre travail de commande, utilisez cette option sweep pour définir l’algorithme d’échantillonnage.

from azure.ai.ml.entities import CommandJob
from azure.ai.ml.sweep import RandomSamplingAlgorithm, SweepJob, SweepJobLimits

   command_job = CommandJob(
       inputs=dict(kernel="linear", penalty=1.0),
       compute=cpu_cluster,
       environment=f"{job_env.name}:{job_env.version}",
       code="./scripts",
       command="python scripts/train.py --kernel $kernel --penalty $penalty",
       experiment_name="sklearn-iris-flowers",
   )

   sweep = SweepJob(
       sampling_algorithm=RandomSamplingAlgorithm(seed=999, rule="sobol", logbase="e"),
       trial=command_job,
       search_space={"ss": Choice(type="choice", values=[{"space1": True}, {"space2": True}])},
       inputs={"input1": {"file": "top_level.csv", "mode": "ro_mount"}},  # type:ignore
       compute="top_level",
       limits=SweepJobLimits(trial_timeout=600),
   )

Références :

• CommandJob
• RandomSamplingAlgorithm
• SweepJob
• SweepJobLimits
• Choix

Sobol

Sobol est une séquence quasi-aléatoire qui améliore le remplissage de l’espace et la reproductibilité. Fournissez une graine et définissez rule="sobol" sur RandomSamplingAlgorithm.

from azure.ai.ml.sweep import  RandomSamplingAlgorithm

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = RandomSamplingAlgorithm(seed=123, rule="sobol"),
    ...
)

Références : RandomSamplingAlgorithm

Échantillonnage par grille

L’échantillonnage de grille prend en charge les hyperparamètres discrets. Utilisez l’échantillonnage de grille si vous avez un budget pour effectuer une recherche exhaustive sur l’espace de recherche. Prend en charge l’arrêt précoce des travaux à faibles performances.

L’échantillonnage de grille effectue une recherche par grille simple sur toutes les valeurs possibles. L’échantillonnage de grille ne peut être utilisé qu’avec des hyperparamètres choice. Par exemple, l’espace suivant compte six échantillons :

from azure.ai.ml.sweep import Choice

command_job_for_sweep = command_job(
    batch_size=Choice(values=[16, 32]),
    number_of_hidden_layers=Choice(values=[1,2,3]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "grid",
    ...
)

Références : Choix

Échantillonnage bayésien

L’échantillonnage bayésien (optimisation bayésienne) sélectionne de nouveaux échantillons en fonction des résultats précédents pour améliorer efficacement la métrique principale.

L’échantillonnage bayésien est recommandé si vous disposez d’un budget suffisant pour explorer l’espace hyperparamétrique. Pour de meilleurs résultats, nous recommandons un nombre maximal de travaux supérieur ou égal à 20 fois le nombre d’hyperparamètres configurés.

Le nombre de travaux simultanés a un impact sur l’efficacité du processus d’optimisation. Un nombre inférieur de travaux simultanés peut déboucher sur une meilleure convergence d’échantillonnage, car le plus faible degré de parallélisme accroît le nombre de travaux qui bénéficient des travaux ayant abouti précédemment.

L’échantillonnage bayésien prend en charge choice, uniformet quniform les distributions.

from azure.ai.ml.sweep import Uniform, Choice

command_job_for_sweep = command_job(   
    learning_rate=Uniform(min_value=0.05, max_value=0.1),
    batch_size=Choice(values=[16, 32, 64, 128]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "bayesian",
    ...
)

Références :

• Uniforme
• Choix

Spécifier l’objectif du balayage

Définissez l’objectif de votre travail de balayage en spécifiant la métrique principale et l’objectif pour lesquels vous souhaitez optimiser le réglage des hyperparamètres. Chaque travail d’entraînement est évalué par rapport à la métrique principale. La stratégie d’arrêt anticipé utilise la métrique principale pour identifier les travaux aux faibles performances.

• primary_metric : le nom de la métrique principale doit correspondre exactement au nom de la métrique journalisée par le script d’entraînement
• goal : il peut s’agir de Maximize ou Minimize et détermine si la métrique principale est maximisée ou minimisée lors de l’évaluation des travaux.

from azure.ai.ml.sweep import Uniform, Choice

command_job_for_sweep = command_job(   
    learning_rate=Uniform(min_value=0.05, max_value=0.1),
    batch_size=Choice(values=[16, 32, 64, 128]),
)

sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm = "bayesian",
    primary_metric="accuracy",
    goal="Maximize",
)

Références :

• Uniforme
• Choix

Cet exemple maximise la « précision ».

Journaliser des métriques pour l’optimisation des hyperparamètres

Votre script d’apprentissage doit journaliser la métrique principale avec le nom exact attendu par le travail de balayage.

Journalisez la métrique principale dans votre script d’entraînement avec l’extrait de code suivant :

import mlflow
mlflow.log_metric("accuracy", float(val_accuracy))

Références : mlflow.log_metric

Le script d’entraînement calcule la valeur de val_accuracy et la journalise comme valeur de précision de la métrique principale. Chaque fois que la métrique est journalisée, elle est reçue par le service d’optimisation des hyperparamètres. C’est à vous de déterminer la fréquence des rapports.

Pour plus d’informations sur les valeurs de journalisation pour les travaux d’entraînement, consultez Activer la journalisation dans les travaux d’entraînement Azure Machine Learning.

Spécifier une stratégie d’arrêt anticipé

Mettre fin à des travaux médiocres tôt pour améliorer l’efficacité.

Vous pouvez configurer les paramètres suivants pour contrôler à quel moment une stratégie s’applique :

• evaluation_interval : fréquence d’application de la stratégie. Chaque journalisation de la métrique principale par le script d’entraînement compte pour un intervalle. Une valeur de 1 pour evaluation_interval applique la stratégie chaque fois que le script d’entraînement signale la métrique principale. Une valeur de 2 pour evaluation_interval applique la stratégie à chaque fois. La valeur par défaut de evaluation_interval est 0 si ce paramètre n’est pas spécifié.
• delay_evaluation : retarde la première évaluation de la stratégie pour un nombre d’intervalles spécifié. Il s’agit d’un paramètre facultatif qui évite un arrêt prématuré des travaux d’entraînement en permettant à toutes les configurations de s’exécuter pour un nombre minimal d’intervalles. S’il est spécifié, la stratégie s’applique à chaque multiple de evaluation_interval qui est supérieur ou égal à delay_evaluation. La valeur par défaut de delay_evaluation est 0 si ce paramètre n’est pas spécifié.

Azure Machine Learning prend en charge les stratégies d’arrêt anticipé suivantes :

• Stratégie Bandit
• Stratégie d’arrêt médian
• Stratégie de sélection de troncation
• Stratégie sans arrêt

Stratégie Bandit

La stratégie bandit utilise un facteur de marge ou une quantité plus un intervalle d’évaluation. Elle met fin à un travail lorsque sa métrique principale se trouve en dehors de la marge autorisée du meilleur travail.

Spécifiez les paramètres de configuration suivants :

• slack_factor ou slack_amount: différence autorisée par rapport au meilleur travail. slack_factor est un ratio ; slack_amount est une valeur absolue.

  Par exemple, considérez une stratégie Bandit appliquée avec un intervalle de 10. Supposez que le travail le plus performant à l’intervalle 10 a signalé une métrique principale de 0,8 avec l’objectif de maximiser la métrique principale. Si la stratégie spécifie avec un slack_factor de 0,2, les travaux d’entraînement, dont la meilleure mesure à l’intervalle 10 est inférieure à 0,66 (0,8/(1+slack_factor)) seront arrêtés.

• evaluation_interval : (facultatif) fréquence d’application de la stratégie

• delay_evaluation : (facultatif) retarde la première évaluation de la stratégie pour un nombre d’intervalles spécifié

from azure.ai.ml.sweep import BanditPolicy
sweep_job.early_termination = BanditPolicy(slack_factor = 0.1, delay_evaluation = 5, evaluation_interval = 1)

Références : BanditPolicy

Dans cet exemple, la stratégie d’arrêt anticipé est appliquée à chaque intervalle quand des métriques sont signalées, en commençant à l’intervalle d’évaluation 5. Tout travail dont la meilleure métrique est inférieure à (1/(1+0,1) ou 91 % du meilleur travail sera arrêté.

Stratégie d’arrêt médiane

La stratégie d’arrêt médiane est une stratégie d’arrêt anticipé basée sur les moyennes mobiles des métriques principales rapportées par les travaux. Cette stratégie calcule les moyennes mobiles pour tous les travaux d’apprentissage et arrête les travaux dont les valeurs de la métrique principale sont moins bonnes que la valeur médiane des moyennes.

Cette stratégie prend les paramètres de configuration suivants :

• evaluation_interval : fréquence d’application de la stratégie (paramètre facultatif).
• delay_evaluation : retarde la première évaluation de la stratégie pour un nombre d’intervalles spécifié (paramètre facultatif).

from azure.ai.ml.sweep import MedianStoppingPolicy
sweep_job.early_termination = MedianStoppingPolicy(delay_evaluation = 5, evaluation_interval = 1)

Références : MedianStoppingPolicy

Dans cet exemple, la stratégie d’arrêt anticipé est appliquée à chaque intervalle, en commençant à l’intervalle d’évaluation 5. Un travail est interrompu à l’intervalle 5 si sa meilleure métrique principale est moins bonne que la valeur médiane des moyennes mobiles sur les intervalles 1 à 5 pour tous les travaux d’apprentissage.

Stratégie de sélection de troncation

La stratégie de sélection de troncation annule un pourcentage des travaux les moins performants à chaque intervalle d’évaluation. Les travaux sont comparés à l’aide de la métrique principale.

Cette stratégie prend les paramètres de configuration suivants :

• truncation_percentage : le pourcentage des travaux avec les performances les moins bonnes à arrêter à chaque intervalle d’évaluation. Nombre entier compris entre 1 et 99.
• evaluation_interval : (facultatif) fréquence d’application de la stratégie
• delay_evaluation : (facultatif) retarde la première évaluation de la stratégie pour un nombre d’intervalles spécifié
• exclude_finished_jobs : spécifie s’il faut exclure les travaux terminés lors de l’application de la stratégie

from azure.ai.ml.sweep import TruncationSelectionPolicy
sweep_job.early_termination = TruncationSelectionPolicy(evaluation_interval=1, truncation_percentage=20, delay_evaluation=5, exclude_finished_jobs=true)

Références : TruncationSelectionPolicy

Dans cet exemple, la stratégie d’arrêt anticipé est appliquée à chaque intervalle, en commençant à l’intervalle d’évaluation 5. Un travail se termine à l’intervalle 5 si ses performances à l’intervalle 5 se situent dans les 20 % les plus bas des performances de tous les travaux à l’intervalle 5 et exclura les travaux terminés lors de l’application de la stratégie.

Aucune stratégie de fin (par défaut)

Si aucune stratégie n’est spécifiée, le service d’optimisation des hyperparamètres permet à tous les travaux d’entraînement d’arriver à leur terme.

sweep_job.early_termination = None

Références : SweepJob

Sélection d’une stratégie d’arrêt anticipé

• Si vous cherchez une stratégie classique qui permet de réaliser des économies, sans arrêter les tâches prometteuses, vous pouvez utiliser une stratégie d’arrêt à la médiane avec un evaluation_interval de 1 et un delay_evaluation de 5. Il s’agit de valeurs prudentes, qui peuvent fournir approximativement 25 à 35 % d’économies sans perte sur la métrique principale (d’après nos évaluations).
• Pour des économies plus importantes, utilisez une stratégie Bandit avec une plus petite marge autorisée ou une stratégie de sélection de troncation avec un pourcentage de troncation plus élevé.

Définir des limites pour votre travail de balayage

Contrôlez votre budget de ressources en définissant des limites pour votre travail de balayage.

• max_total_trials : nombre maximal de travaux d’évaluation. Doit être un entier compris entre 1 et 1000.
• max_concurrent_trials : (facultatif) nombre maximal de travaux d’évaluation qui peuvent s’exécuter simultanément. S’il n’est pas spécifié, max_total_trials nombre de travaux sont lancés en parallèle. En cas de spécification, doit être un entier compris entre 1 et 1000.
• timeout : Durée maximale, en secondes, pendant laquelle l’exécution du travail de balayage est autorisée. Une fois cette limite atteinte, le système annule le travail de rangement, y compris toutes ses évaluations.
• trial_timeout : durée maximale, en minutes, pendant laquelle l’exécution de chaque travail d’évaluation est autorisée. Une fois cette limite atteinte, le système annule l’évaluation.

sweep_job.set_limits(max_total_trials=20, max_concurrent_trials=4, timeout=1200)

Références : SweepJob.set_limits

Ce code configure l’expérience d’optimisation des hyperparamètres pour qu’elle utilise un maximum de 20 travaux d’évaluation au total, exécutant quatre travaux d’évaluation à la fois avec un délai d’expiration de 1 200 secondes pour l’ensemble du travail de rangement.

Configurer l’expérience d’optimisation des hyperparamètres

Pour configurer votre expérience de réglage des hyperparamètres, fournissez les informations suivantes :

• Espace de recherche des hyperparamètres défini
• Votre algorithme d’échantillonnage
• Votre stratégie d’arrêt anticipé
• Votre objectif
• Limites des ressources
• CommandJob ou CommandComponent
• SweepJob

SweepJob peut exécuter un balayage d’hyperparamètres sur Command ou Command Component.

Configurez votre expérience d’optimisation des hyperparamètres :

from azure.ai.ml import MLClient
from azure.ai.ml import command, Input
from azure.ai.ml.sweep import Choice, Uniform, MedianStoppingPolicy
from azure.identity import DefaultAzureCredential

# Create your base command job
command_job = command(
    code="./src",
    command="python main.py --iris-csv ${{inputs.iris_csv}} --learning-rate ${{inputs.learning_rate}} --boosting ${{inputs.boosting}}",
    environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
    inputs={
        "iris_csv": Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/iris.csv",
        ),
        "learning_rate": 0.9,
        "boosting": "gbdt",
    },
    compute="cpu-cluster",
)

# Override your inputs with parameter expressions
command_job_for_sweep = command_job(
    learning_rate=Uniform(min_value=0.01, max_value=0.9),
    boosting=Choice(values=["gbdt", "dart"]),
)

# Call sweep() on your command job to sweep over your parameter expressions
sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm="random",
    primary_metric="test-multi_logloss",
    goal="Minimize",
)

# Specify your experiment details
sweep_job.display_name = "lightgbm-iris-sweep-example"
sweep_job.experiment_name = "lightgbm-iris-sweep-example"
sweep_job.description = "Run a hyperparameter sweep job for LightGBM on Iris dataset."

# Define the limits for this sweep
sweep_job.set_limits(max_total_trials=20, max_concurrent_trials=10, timeout=7200)

# Set early stopping on this one
sweep_job.early_termination = MedianStoppingPolicy(
    delay_evaluation=5, evaluation_interval=2
)

Références :

• MLClient
• command
• Input
• Choix
• Uniforme
• MedianStoppingPolicy
• DefaultAzureCredential

L’objet command_job est appelé en tant que fonction pour que vous puissiez appliquer des expressions de paramètre. La sweep fonction est configurée avec triall’algorithme d’échantillonnage, l’objectif, les limites et le calcul. L’extrait de code ci-dessus provient de l’exemple de notebook Exécuter le balayage d’hyperparamètre sur Command ou CommandComponent. Dans cet exemple, learning_rate et boosting sont réglés. L’arrêt anticipé est piloté par un MedianStoppingPolicy, qui arrête un travail dont la métrique principale est inférieure à la médiane des moyennes d’exécution sur tous les travaux (voir la référence MedianStoppingPolicy).

Pour voir comment les valeurs de paramètre sont reçues, analysées et passées au script d’entraînement à optimiser, reportez-vous à cet exemple de code.

Soumettre une expérience d’optimisation des hyperparamètres

Une fois que vous avez défini votre configuration d’optimisation des hyperparamètres, soumettez le travail :

# submit the sweep
returned_sweep_job = ml_client.create_or_update(sweep_job)
# get a URL for the status of the job
returned_sweep_job.services["Studio"].endpoint

Références :

• MLClient.create_or_update
• SweepJob

Visualiser les travaux d’optimisation des hyperparamètres

Visualiser les travaux de réglage des hyperparamètres dans Azure Machine Learning Studio. Pour découvrir plus d’informations, consultez Consulter les enregistrements de tâches dans le studio.

• Graphique des métriques : cette visualisation assure le suivi des métriques journalisées pour chaque travail enfant Hyperdrive pendant la durée de l’optimisation des hyperparamètres. Chaque ligne représente un travail enfant, tandis que chaque point mesure la valeur de métrique principale à cette itération d’exécution.

  

• Graphique des coordonnées parallèles : cette visualisation montre la corrélation entre les performances des métriques principales et les valeurs d’hyperparamètre individuelles. Le graphique est interactif via le déplacement des axes (sélectionnez et faites glisser l’étiquette d’un axe) et la mise en surbrillance des valeurs d’un axe spécifique (cliquez sur un axe et opérez un glissement vertical le long de ce dernier pour mettre en surbrillance une plage de valeurs souhaitées). Le graphe des coordonnées parallèles comprend sur la partie la plus à droite un axe qui représente la meilleure valeur métrique correspondant aux hyperparamètres définis pour cette instance de travail. Cet axe permet de projeter de façon plus lisible la légende de gradient du graphe sur les données.

  

• Graphique à nuages de points bidimensionnel : cette visualisation montre la corrélation entre deux hyperparamètres individuels, ainsi que leur valeur de métrique principale associée.

  

• Graphique à nuages de points tridimensionnel : cette visualisation est identique à 2D, mais permet trois dimensions d’hyperparamètre de corrélation avec la valeur de métrique principale. Vous pouvez également sélectionner et faire glisser pour réorienter le graphique afin de voir différentes corrélations dans l’espace 3D.

  

Trouver le meilleur travail d’évaluation

Une fois tous les travaux de paramétrage terminés, récupérez les meilleures sorties d’évaluation :

# Download best trial model output
ml_client.jobs.download(returned_sweep_job.name, output_name="model")

Références :

• MLClient.jobs

Vous pouvez utiliser l’interface CLI pour télécharger toutes les sorties par défaut et nommées du meilleur travail d’évaluation et des journaux du travail de balayage.

az ml job download --name <sweep-job> --all

Si vous le souhaitez, téléchargez uniquement la meilleure sortie d’évaluation :

az ml job download --name <sweep-job> --output-name model

References

• Exemple d’optimisation des hyperparamètres
• Schéma YAML de la tâche de balayage CLI (v2)

Étapes suivantes

• Faire le suivi d’une expérience
• Déployer un modèle entraîné