Composants d'une tâche de réglage Exemple de tâche de réglage HPO

Créer une tâche de réglage d'optimisation d'hyperparamètres pour un ou plusieurs algorithmes (console)

Ce guide explique comment créer une nouvelle tâche de réglage d'optimisation des hyperparamètres (HPO) pour un ou plusieurs algorithmes. Pour créer une tâche HPO, définissez les paramètres de la tâche de réglage et créez des définitions de tâches d'entraînement pour chaque algorithme à régler. Configurez ensuite les ressources pour la tâche de réglage et créez-la. Les sections suivantes fournissent des informations sur la manière de réaliser chaque étape. Nous fournissons un exemple de réglage de plusieurs algorithmes à l'aide du Python client SageMaker SDK for à la fin de ce guide.

Composants d'une tâche de réglage

Une tâche de réglage HPO contient les trois composants suivants :

Paramètres de la tâche de réglage
Définitions de la tâche de réglage
Configuration de la tâche de réglage

La manière dont ces composants sont inclus dans votre tâche de réglage HPO dépend de si celle-ci contient un ou plusieurs algorithmes d'entraînement. Le guide suivant décrit chacun des composants et donne un exemple des deux types de tâches de réglage.

Les paramètres de votre tâche de réglage sont appliqués à tous les algorithmes figurant dans la tâche de réglage HPO. Le démarrage à chaud et l'arrêt anticipé ne sont disponibles que lorsque vous réglez un algorithme unique. Après avoir défini les paramètres de la tâche, vous pouvez créer des définitions d'entraînement individuelles pour chaque algorithme ou variation que vous souhaitez régler.

Démarrage à chaud

Si vous avez cloné cette tâche, vous pouvez utiliser les résultats d'une tâche de réglage précédente pour améliorer les performances de cette nouvelle tâche de réglage. Il s'agit de la fonctionnalité de démarrage à chaud et elle n'est disponible que lors du réglage d'un algorithme unique. Avec le démarrage à chaud, vous pouvez choisir jusqu'à cinq tâches de réglage des hyperparamètres précédentes à utiliser. Vous pouvez également utiliser l'entraînement de transfert pour ajouter des données supplémentaires à la tâche de réglage parent. Lorsque vous sélectionnez cette option, vous choisissez une tâche de réglage précédente comme parent.

Note

Le démarrage à chaud est uniquement compatible avec les tâches de réglage créées après le 1er octobre 2018. Pour de plus amples informations, veuillez consulter Exécution d'une tâche de démarrage à chaud.

Arrêt anticipé

L'arrêt précoce de tâches d'entraînement peut vous aider à réduire les temps de calcul et vous permet d'éviter un réglage excessif de votre modèle. L'arrêt anticipé est utile lorsqu'il est peu probable que la tâche d'entraînement améliore la meilleure métrique d'objectif actuelle de la tâche de réglage d'hyperparamètres. Comme le démarrage à chaud, cette fonctionnalité n'est disponible que lors du réglage d'un algorithme unique. Il s'agit d'une fonctionnalité automatique sans options de configuration et elle est désactivée par défaut. Pour plus d'informations sur le fonctionnement de l'arrêt anticipé, les algorithmes qui le prennent en charge et la manière de l'utiliser avec vos propres algorithmes, consultez Arrêter de manière précoce des tâches d'entraînement.

Stratégie d'ajustement

La stratégie de réglage peut être aléatoire, bayésienne ou Hyperband. Ces sélections indiquent la manière dont les algorithmes de réglage automatique effectuent des recherches sur les plages d'hyperparamètres spécifiées qui sont sélectionnées dans une étape ultérieure. La recherche aléatoire choisit des combinaisons aléatoires de valeurs dans les plages spécifiées et peut être exécutée de façon séquentielle ou en parallèle. L'optimisation bayésienne choisit les valeurs en fonction de ce qui est susceptible d'obtenir le meilleur résultat en fonction de l'historique connu des sélections précédentes. Hyperband utilise une stratégie de multifidélité qui alloue de manière dynamique les ressources aux tâches les mieux utilisées et arrête automatiquement celles qui sont sous-performantes. La nouvelle configuration qui démarre après l'arrêt des autres configurations est choisie de manière aléatoire.

Hyperband ne peut être utilisé qu'avec des algorithmes itératifs ou des algorithmes qui exécutent des étapes par itérations, tels que XGBoost ou Random Cut Forest. Hyperband ne peut pas être utilisé avec des algorithmes non itératifs, tels que les arbres de décision ou l'algorithme des k plus proches voisins. Pour plus d'informations sur les stratégies de recherche, consultez Mode de fonctionnement du réglage d'hyperparamètres.

Note

Hyperband utilise un mécanisme interne avancé pour appliquer un arrêt anticipé. Par conséquent, lorsque vous utilisez la fonctionnalité d'arrêt anticipé Hyperband interne, le paramètre TrainingJobEarlyStoppingType de l'API HyperParameterTuningJobConfig doit être défini sur OFF.

Balises

Vous pouvez entrer des balises en tant que paires clé-valeur pour affecter des métadonnées à des tâches de réglage afin de vous aider à les gérer. Les valeurs de la paire clé-valeur ne sont pas obligatoires. Vous pouvez utiliser la clé sans valeurs. Pour afficher les clés associées à une tâche, choisissez l'onglet Tags (Balises) dans la page de détails de la tâche de réglage. Pour plus d'informations sur l'utilisation des balises pour les tâches de réglage, consultez Gérer les tâches de réglage et d'entraînement des hyperparamètres.

Pour créer une définition de tâche d'entraînement, vous devez configurer l'algorithme et les paramètres, définir l'entrée et la sortie des données, puis configurer les ressources. Fournissez au moins une TrainingJobDefinition pour chaque tâche de réglage HPO. Chaque définition d'entraînement spécifie la configuration d'un algorithme.

Pour créer plusieurs définitions pour votre tâche d'entraînement, vous pouvez cloner une définition de tâche. Le clonage d'une tâche peut permettre de gagner du temps, car il copie tous les paramètres de la tâche, y compris les canaux de données et les emplacements de stockage Amazon S3 pour les artefacts de sortie. Vous pouvez modifier une tâche clonée pour modifier ce dont vous avez besoin pour votre cas d'utilisation.

Rubriques

Configurer l'algorithme et les paramètres
Définition de l'entrée et de la sortie des données
Configuration des ressources de tâche d'entraînement
Ajout ou clonage d'une tâche d'entraînement

Configurer l'algorithme et les paramètres

La liste suivante décrit ce dont vous avez besoin pour configurer l'ensemble des valeurs d'hyperparamètres pour chaque tâche d'entraînement.

Un nom pour votre tâche de réglage
Autorisation d'accès aux services
Paramètres pour toutes les options d'algorithme
Une métrique d'objectif
La plage de valeurs d'hyperparamètres, le cas échéant

Nom

Fournissez un nom unique pour la définition d'entraînement.

Autorisations

Amazon a SageMaker besoin d'autorisations pour appeler d'autres services en votre nom. Choisissez un rôle AWS Identity and Access Management (IAM) ou laissez AWS créer un rôle auquel la politique IAM AmazonSageMakerFullAccess est attachée.

Paramètres de sécurité facultatifs

Le paramètre d'isolation réseau empêche le conteneur d'effectuer des appels réseau sortants. Ceci est requis pour les offres de machine learning d'AWS Marketplace.

Vous pouvez également choisir d'utiliser un cloud privé virtuel (VPC).

Note

Le chiffrement inter-conteneur n'est disponible que lorsque vous créez une définition de tâches à partir de l'API.

Options d'algorithme

Vous pouvez choisir des algorithmes intégrés, votre propre algorithme, votre propre conteneur avec un algorithme, ou vous pouvez vous abonner à un algorithme depuis AWS Marketplace.

Si vous choisissez un algorithme intégré, les informations d'image Amazon Elastic Container Registry (Amazon ECR) sont préremplies.
Si vous choisissez votre propre conteneur, vous devez spécifier les informations d'image (Amazon ECR). Vous pouvez sélectionner le mode d'entrée de l'algorithme en tant que fichier ou canal.
Si vous prévoyez de fournir vos données à l'aide d'un fichier CSV à partir d'Amazon S3, vous devez sélectionner le fichier.

Métriques

Lorsque vous choisissez un algorithme intégré, des métriques vous sont fournies. Si vous choisissez votre propre algorithme, vous devez définir vos métriques. Vous pouvez définir jusqu'à 20 métriques qui seront surveillées par votre tâche de réglage. Vous devez choisir une métrique comme métrique d'objectif. Pour plus d'informations sur la définition d'une métrique pour une tâche de réglage, consultez Définition de métriques.

Métrique d'objectif

Afin de trouver la meilleure tâche d'entraînement, définissez une métrique d'objectif et s'il faut la maximiser ou la minimiser. Une fois la tâche d'entraînement terminée, vous pouvez consulter la page détaillée de la tâche de réglage. La page détaillée fournit un résumé de la meilleure tâche d'entraînement trouvée à l'aide de cette métrique d'objectif.

Configuration des hyperparamètres

Lorsque vous choisissez un algorithme intégré, les valeurs par défaut de ses hyperparamètres sont définies pour vous à l'aide de plages optimisées pour l'algorithme à régler. Vous pouvez modifier ces valeurs comme bon vous semble. Par exemple, à la place d'une plage, vous pouvez définir une valeur fixe pour un hyperparamètre en définissant le type du paramètre sur statique. Chaque algorithme a des paramètres obligatoires et facultatifs différents. Pour de plus amples informations, veuillez consulter Bonnes pratiques pour le réglage des hyperparamètres et Définition des plages d'hyperparamètres.

Définition de l'entrée et de la sortie des données

Chaque définition de tâche d'entraînement pour une tâche de réglage doit configurer les canaux pour les entrées de données, les emplacements de sortie de données et éventuellement tous les emplacements de stockage de points de contrôle pour chaque tâche d'entraînement.

Configuration des données d'entrée

Les données d'entrée sont définies par canaux. Chaque canal avec son propre emplacement source (Amazon S3 ou Amazon Elastic File System), sa compression et ses options de format. Vous pouvez définir jusqu'à 20 canaux de sources d'entrée. Si l'algorithme que vous avez choisi prend en charge plusieurs canaux d'entrée, vous pouvez les spécifier également. Par exemple, lorsque vous utilisez le bloc-notes de prédiction de désabonnement XGBoost, vous pouvez ajouter deux canaux : un d'entraînement et un de validation.

Configuration des points de contrôle

Des points de contrôle sont générés périodiquement pendant l'entraînement. Vous devez choisir un emplacement Amazon S3 pour que les points de contrôle soient enregistrés. Les points de contrôle sont utilisés dans les rapports de métriques et sont également utilisés pour reprendre les tâches d'entraînement Spot géré. Pour plus d’informations, consultez Utilisation des points de contrôle dans Amazon SageMaker.

Configuration des données de sortie

Définissez un emplacement Amazon S3 pour que les artefacts de la tâche d'entraînement soient stockés. Vous avez la possibilité d'ajouter un chiffrement à la sortie à l'aide d'une clé AWS Key Management Service (AWS KMS).

Configuration des ressources de tâche d'entraînement

Chaque définition de tâche d'entraînement pour une tâche de réglage doit configurer les ressources à déployer, y compris les types et le nombre d'instances, l'entraînement Spot géré et les conditions d'arrêt.

Configuration des ressources

Chaque définition d'entraînement peut avoir une configuration de ressources différente. Vous choisissez le type d'instance et le nombre de nœuds.

Entraînement Spot géré

Vous pouvez réduire les coûts informatiques liés aux tâches si vous disposez de flexibilité dans les heures de début et de fin en autorisant l'utilisation SageMaker de la capacité inutilisée pour exécuter les tâches. Pour plus d’informations, consultez Utilisez Managed Spot Training sur Amazon SageMaker.

Condition d'arrêt

La condition d'arrêt spécifie la durée maximale autorisée par tâche d'entraînement.

Ajout ou clonage d'une tâche d'entraînement

Une fois que vous avez créé une définition de tâche d'entraînement pour une tâche de réglage, vous revenez au panneau Définition(s) de tâche d'entraînement. Ce panneau vous permet de créer des définitions de tâches d'entraînement supplémentaires pour entraîner des algorithmes supplémentaires. Vous pouvez sélectionner l'option Ajouter une définition de tâche d'entraînement et suivre les étapes pour définir à nouveau une tâche d'entraînement.

Sinon, pour reproduire une définition de tâche d'entraînement existante et la modifier pour le nouvel algorithme, choisissez Cloner dans le menu Action. L'option de clonage peut vous faire gagner du temps, car elle copie tous les paramètres de la tâche, y compris les canaux de données et les emplacements de stockage Amazon S3. Pour plus d'informations sur le clonage, consultez Gérer les tâches de réglage et d'entraînement des hyperparamètres.

Limites des ressources

Vous pouvez spécifier le nombre maximum de tâches d'entraînement simultanées qu'une tâche de réglage d'hyperparamètres peut exécuter simultanément (10 au maximum). Vous pouvez également spécifier le nombre maximum de tâches d'entraînement que la tâche de réglage des hyperparamètres peut exécuter (500 au maximum). Le nombre de tâches parallèles ne doit pas dépasser le nombre de nœuds que vous avez demandés sur l'ensemble de vos définitions d'entraînement. Le nombre total de tâches ne peut pas dépasser le nombre de tâches que vos définitions sont censées exécuter.

Vérifiez les paramètres de tâche, les définitions de tâche d'entraînement et les limites de ressources. Choisissez Create hyperparameter tuning job (Créer une tâche de réglage des hyperparamètres).

Exemple de tâche de réglage HPO

Pour exécuter une tâche d'entraînement à l'optimisation des hyperparamètres (HPO), créez d'abord une définition de tâche d'entraînement pour chaque algorithme en cours de réglage. Définissez ensuite les paramètres de la tâche de réglage et configurez les ressources pour la tâche de réglage. Enfin, exécutez la tâche de réglage.

Si votre tâche de réglage HPO contient un seul algorithme d'entraînement, la fonction de SageMaker réglage appellera directement l'HyperparameterTunerAPI et transmettra vos paramètres. Si votre tâche de réglage HPO contient plusieurs algorithmes d'entraînement, votre fonction de réglage appellera la fonction create de l'API HyperparameterTuner. La fonction create indique à l'API de s'attendre à un dictionnaire contenant un ou plusieurs estimateurs.

Dans la section suivante, des exemples de code montrent comment régler une tâche contenant soit un seul algorithme d'apprentissage, soit plusieurs algorithmes à l'aide du SageMaker Python SDK.

Création de définitions de tâche d'entraînement

Lorsque vous créez une tâche de réglage qui inclut plusieurs algorithmes d'entraînement, la configuration de votre tâche de réglage inclut les estimateurs, les métriques et les autres paramètres de vos tâches d'entraînement. Par conséquent, vous devez d'abord créer la définition de la tâche d'entraînement, puis configurer votre tâche de réglage.

L'exemple de code suivant montre comment récupérer deux SageMaker conteneurs contenant les algorithmes intégrés XGBoostet Linear Learner. Si votre tâche de réglage ne contient qu'un seul algorithme d'entraînement, omettez l'un des conteneurs et l'un des estimateurs.


import sagemaker
from sagemaker import image_uris

from sagemaker.estimator import Estimator

sess = sagemaker.Session()
region = sess.boto_region_name
role = sagemaker.get_execution_role()

bucket = sess.default_bucket()
prefix = "sagemaker/multi-algo-hpo"

# Define the training containers and intialize the estimators
xgb_container = image_uris.retrieve("xgboost", region, "latest")
ll_container = image_uris.retrieve("linear-learner", region, "latest")

xgb_estimator = Estimator(
    xgb_container,
    role=role,
    instance_count=1,
    instance_type="ml.m4.xlarge",
    output_path='s3://{}/{}/xgb_output".format(bucket, prefix)',
    sagemaker_session=sess,
)

ll_estimator = Estimator(
    ll_container,
    role,
    instance_count=1,
    instance_type="ml.c4.xlarge",
    output_path="s3://{}/{}/ll_output".format(bucket, prefix),
    sagemaker_session=sess,
)

# Set static hyperparameters
ll_estimator.set_hyperparameters(predictor_type="binary_classifier")
xgb_estimator.set_hyperparameters(
    eval_metric="auc",
    objective="binary:logistic",
    num_round=100,
    rate_drop=0.3,
    tweedie_variance_power=1.4,
)

Définissez ensuite vos données d'entrée en spécifiant les jeux de données d'entraînement, de validation et de test, comme indiqué dans l'exemple de code suivant. Cet exemple montre comment régler plusieurs algorithmes d'entraînement.


training_data = sagemaker.inputs.TrainingInput(
    s3_data="s3://{}/{}/train".format(bucket, prefix), content_type="csv"
)
validation_data = sagemaker.inputs.TrainingInput(
    s3_data="s3://{}/{}/validate".format(bucket, prefix), content_type="csv"
)
test_data = sagemaker.inputs.TrainingInput(
    s3_data="s3://{}/{}/test".format(bucket, prefix), content_type="csv"
)

train_inputs = {
    "estimator-1": {
        "train": training_data,
        "validation": validation_data,
        "test": test_data,
    },
    "estimator-2": {
        "train": training_data,
        "validation": validation_data,
        "test": test_data,
    },
}

Si votre algorithme de réglage ne contient qu'un seul algorithme d'entraînement, vos train_inputs ne doivent contenir qu'un seul estimateur.

Vous devez télécharger les entrées pour les jeux de données d'entraînement, de validation et d'entraînement dans votre compartiment Amazon S3 avant de les utiliser dans une tâche de réglage HPO.

Définition des ressources et des paramètres pour votre tâche de réglage

Cette section explique comment initialiser un régleur, définir les ressources et spécifier les paramètres de tâche pour votre tâche de réglage. Si votre tâche de réglage contient plusieurs algorithmes d'entraînement, ces paramètres sont appliqués à tous les algorithmes contenus dans votre tâche de réglage. Cette section fournit deux exemples de code pour définir un régleur. Les exemples de code vous montrent comment optimiser un algorithme d'entraînement unique, suivis d'un exemple de réglage de plusieurs algorithmes d'entraînement.

Réglage d'un seul algorithme d'entraînement

L'exemple de code suivant montre comment initialiser un tuner et définir des plages d'hyperparamètres pour un algorithme SageMaker intégré,. XGBoost


from sagemaker.tuner import HyperparameterTuner
from sagemaker.parameter import ContinuousParameter, IntegerParameter

hyperparameter_ranges = {
    "max_depth": IntegerParameter(1, 10),
    "eta": ContinuousParameter(0.1, 0.3),
}

objective_metric_name = "validation:accuracy"

tuner = HyperparameterTuner(
    xgb_estimator,
    objective_metric_name,
    hyperparameter_ranges,
    objective_type="Maximize",
    max_jobs=5,
    max_parallel_jobs=2,
)

Réglage de plusieurs algorithmes d'entraînement

Chaque tâche d'entraînement nécessite des configurations différentes, qui sont spécifiées à l'aide d'un dictionnaire. L'exemple de code suivant montre comment initialiser un tuner avec des configurations pour deux algorithmes SageMaker intégrés, etXGBoost. Linear Learner L'exemple de code montre également comment définir une stratégie de réglage et d'autres paramètres de tâche, tels que les ressources de calcul pour la tâche de réglage. L'exemple de code suivant utilise metric_definitions_dict, ce qui est facultatif.


from sagemaker.tuner import HyperparameterTuner
from sagemaker.parameter import ContinuousParameter, IntegerParameter

# Initialize your tuner
tuner = HyperparameterTuner.create(
    estimator_dict={
        "estimator-1": xgb_estimator,
        "estimator-2": ll_estimator,
    },
    objective_metric_name_dict={
        "estimator-1": "validation:auc",
        "estimator-2": "test:binary_classification_accuracy",
    },
    hyperparameter_ranges_dict={
        "estimator-1": {"eta": ContinuousParameter(0.1, 0.3)},
        "estimator-2": {"learning_rate": ContinuousParameter(0.1, 0.3)},
    },
    metric_definitions_dict={
        "estimator-1": [
            {"Name": "validation:auc", "Regex": "Overall test accuracy: (.*?);"}
        ],
        "estimator-2": [
            {
                "Name": "test:binary_classification_accuracy",
                "Regex": "Overall test accuracy: (.*?);",
            }
        ],
    },
    strategy="Bayesian",
    max_jobs=10,
    max_parallel_jobs=3,
)

Exécution de votre tâche de réglage HPO

Vous pouvez maintenant exécuter votre travail de réglage en transmettant vos données d'entraînement à la fonction fit de la classe HyperparameterTuner. L'exemple de code suivant montre comment transmettre le paramètre train_inputs défini dans un exemple de code précédent à votre régleur.


tuner.fit(inputs=train_inputs, include_cls_metadata ={}, estimator_kwargs ={})

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Réglage de plusieurs algorithmes

Gérer les tâches pour HPO