Explorez les techniques avancées d'optimisation des hyperparamètres avec le réglage automatique du modèle Amazon SageMaker | Services Web Amazon

La création de solutions d'apprentissage automatique (ML) hautes performances repose sur l'exploration et l'optimisation des paramètres d'entraînement, également appelés hyperparamètres. Les hyperparamètres sont les boutons et leviers que nous utilisons pour ajuster le processus de formation, tels que le taux d'apprentissage, la taille du lot, la force de régularisation, etc., en fonction du modèle spécifique et de la tâche à accomplir. L'exploration des hyperparamètres implique de faire varier systématiquement les valeurs de chaque paramètre et d'observer l'impact sur les performances du modèle. Bien que ce processus nécessite des efforts supplémentaires, les avantages sont significatifs. L'optimisation des hyperparamètres (HPO) peut conduire à des temps de formation plus rapides, à une précision améliorée du modèle et à une meilleure généralisation aux nouvelles données.

Nous continuons notre voyage depuis la poste Optimisez les hyperparamètres avec Amazon SageMaker Automatic Model Tuning. Nous avons précédemment exploré une optimisation de tâche unique, visualisé les résultats de l'algorithme intégré de SageMaker et découvert l'impact de valeurs d'hyperparamètres particulières. En plus d'utiliser HPO comme optimisation ponctuelle à la fin du cycle de création de modèle, nous pouvons également l'utiliser en plusieurs étapes de manière conversationnelle. Chaque tâche de réglage nous aide à nous rapprocher d'une bonne performance, mais nous apprenons également à quel point le modèle est sensible à certains hyperparamètres et pouvons utiliser cette compréhension pour éclairer la prochaine tâche de réglage. Nous pouvons réviser les hyperparamètres et leurs plages de valeurs en fonction de ce que nous avons appris et donc transformer cet effort d'optimisation en conversation. Et de la même manière que nous, en tant que praticiens du ML, accumulons des connaissances au fil de ces exécutions, Réglage automatique du modèle Amazon SageMaker (AMT) avec des démarrages à chaud, vous pouvez également conserver les connaissances acquises lors des tâches de réglage précédentes pour la tâche de réglage suivante.

Dans cet article, nous exécutons plusieurs tâches HPO avec un algorithme de formation personnalisé et différentes stratégies HPO telles que l'optimisation bayésienne et la recherche aléatoire. Nous mettons également en œuvre des démarrages à chaud et comparons visuellement nos essais pour affiner l’exploration spatiale hyperparamétrique.

Concepts avancés de SageMaker AMT

Dans les sections suivantes, nous examinerons de plus près chacun des sujets suivants et montrerons comment SageMaker AMT peut vous aider à les mettre en œuvre dans vos projets ML :

• Utilisez du code de formation personnalisé et le framework ML populaire Scikit-learn dans SageMaker Training
• Définir des métriques d'évaluation personnalisées basées sur les journaux pour l'évaluation et l'optimisation
• Effectuer du HPO en utilisant une stratégie appropriée
• Utilisez des démarrages à chaud pour transformer une recherche d'hyperparamètre unique en un dialogue avec notre modèle
• Utilisez des techniques de visualisation avancées à l'aide de notre bibliothèque de solutions pour comparer deux stratégies HPO et les résultats des tâches de réglage.

Que vous utilisiez les algorithmes intégrés utilisés dans notre premier article ou votre propre code de formation, SageMaker AMT offre une expérience utilisateur transparente pour optimiser les modèles ML. Il fournit des fonctionnalités clés qui vous permettent de vous concentrer sur le problème de ML en question tout en gardant automatiquement une trace des essais et des résultats. Dans le même temps, il gère automatiquement l’infrastructure sous-jacente pour vous.

Dans cet article, nous nous éloignons d'un algorithme intégré à SageMaker et utilisons du code personnalisé. Nous utilisons une forêt aléatoire de SkApprendre. Mais nous nous en tenons à la même tâche ML et au même ensemble de données que dans notre premier message, qui détecte les chiffres manuscrits. Nous couvrons le contenu du notebook Jupyter 2_advanced_tuning_with_custom_training_and_visualizing.ipynb et vous invite à invoquer le code côte à côte pour poursuivre la lecture.

Approfondissons et découvrons comment nous pouvons utiliser du code de formation personnalisé, le déployer et l'exécuter, tout en explorant l'espace de recherche d'hyperparamètres pour optimiser nos résultats.

Comment créer un modèle ML et effectuer une optimisation des hyperparamètres

À quoi ressemble un processus typique de création d’une solution ML ? Bien qu'il existe de nombreux cas d'utilisation possibles et une grande variété de tâches de ML, nous suggérons le modèle mental suivant pour une approche par étapes :

1. Comprenez votre scénario ML actuel et sélectionnez un algorithme en fonction des exigences. Par exemple, vous souhaiterez peut-être résoudre une tâche de reconnaissance d’images à l’aide d’un algorithme d’apprentissage supervisé. Dans cet article, nous continuons à utiliser le scénario de reconnaissance d'images manuscrites et le même ensemble de données que dans notre premier article.
2. Décidez quelle implémentation de l'algorithme dans SageMaker Training vous souhaitez utiliser. Il existe différentes options, internes à SageMaker ou externes. De plus, vous devez définir la métrique sous-jacente qui correspond le mieux à votre tâche et que vous souhaitez optimiser (comme la précision, le score F1 ou le ROC). SageMaker prend en charge quatre options en fonction de vos besoins et de vos ressources :
   • Utilisez un modèle pré-entraîné via Amazon SageMaker JumpStart, que vous pouvez utiliser directement ou simplement le peaufiner.
   • Utilisez l'un des algorithmes intégrés pour l'entraînement et le réglage, comme XGBoost, comme nous l'avons fait dans notre article précédent.
   • Entraînez et ajustez un modèle personnalisé basé sur l'un des principaux frameworks tels que Scikit-learn, TensorFlow ou PyTorch. AWS propose une sélection d'images Docker prédéfinies à cet effet. Pour cet article, nous utilisons cette option, qui vous permet d'expérimenter rapidement en exécutant votre propre code sur une image de conteneur prédéfinie.
   • Apportez votre propre image Docker personnalisée au cas où vous souhaiteriez utiliser un framework ou un logiciel qui ne serait pas autrement pris en charge. Cette option nécessite le plus d’efforts, mais offre également le plus haut degré de flexibilité et de contrôle.
3. Entraînez le modèle avec vos données. En fonction de la mise en œuvre de l'algorithme de l'étape précédente, cela peut être aussi simple que de référencer vos données d'entraînement et d'exécuter la tâche d'entraînement ou de fournir en plus un code personnalisé pour l'entraînement. Dans notre cas, nous utilisons du code de formation personnalisé en Python basé sur Scikit-learn.
4. Appliquez l'optimisation des hyperparamètres (sous forme de « conversation » avec votre modèle ML). Après la formation, vous souhaitez généralement optimiser les performances de votre modèle en trouvant la combinaison de valeurs la plus prometteuse pour les hyperparamètres de votre algorithme.

En fonction de votre algorithme ML et de la taille de votre modèle, la dernière étape de l'optimisation des hyperparamètres peut s'avérer être un défi plus important que prévu. Les questions suivantes sont typiques des praticiens du ML à ce stade et peuvent vous sembler familières :

• Quels types d'hyperparamètres ont un impact sur mon problème de ML ?
• Comment puis-je rechercher efficacement un vaste espace d'hyperparamètres pour trouver les valeurs les plus performantes ?
• Comment la combinaison de certaines valeurs d’hyperparamètres influence-t-elle mes mesures de performances ?
• Les coûts comptent ; comment puis-je utiliser mes ressources de manière efficace ?
• Quels types d’expériences de réglage valent la peine et comment puis-je les comparer ?

Il n’est pas facile de répondre à ces questions, mais il y a de bonnes nouvelles. SageMaker AMT vous décharge du gros du travail et vous permet de vous concentrer sur le choix de la bonne stratégie HPO et des plages de valeurs que vous souhaitez explorer. De plus, notre solution de visualisation facilite le processus itératif d'analyse et d'expérimentation pour trouver efficacement des valeurs d'hyperparamètres performantes.

Dans les sections suivantes, nous construisons un modèle de reconnaissance de chiffres à partir de zéro à l'aide de Scikit-learn et montrons tous ces concepts en action.

Vue d'ensemble de la solution

SageMaker offre des fonctionnalités très pratiques pour former, évaluer et affiner notre modèle. Il couvre toutes les fonctionnalités d'un cycle de vie ML de bout en bout, nous n'avons donc même pas besoin de quitter notre notebook Jupyter.

Dans notre premier article, nous avons utilisé l'algorithme intégré XGBoost de SageMaker. À des fins de démonstration, nous passons cette fois à un classificateur Random Forest car nous pouvons alors montrer comment fournir votre propre code de formation. Nous avons choisi de fournir notre propre script Python et d'utiliser Scikit-learn comme framework. Maintenant, comment exprimer que nous souhaitons utiliser un framework ML spécifique ? Comme nous le verrons, SageMaker utilise un autre service AWS en arrière-plan pour récupérer une image de conteneur Docker prédéfinie à des fins de formation :Registre des conteneurs élastiques Amazon (AmazonECR).

Nous couvrons les étapes suivantes en détail, y compris des extraits de code et des diagrammes pour relier les points. Comme mentionné précédemment, si vous en avez l'occasion, ouvrez le bloc-notes et exécutez les cellules de code étape par étape pour créer les artefacts dans votre environnement AWS. Il n’y a pas de meilleure façon d’apprendre activement.

1. Tout d’abord, chargez et préparez les données. Nous utilisons Service de stockage simple Amazon (Amazon S3) pour télécharger un fichier contenant nos données de chiffres manuscrits.
2. Ensuite, préparez le script de formation et les dépendances du framework. Nous fournissons le code de formation personnalisé en Python, référençons certaines bibliothèques dépendantes et effectuons un test.
3. Pour définir les métriques d'objectif personnalisées, SageMaker nous permet de définir une expression régulière pour extraire les métriques dont nous avons besoin des fichiers journaux du conteneur.
4. Entraînez le modèle à l'aide du framework scikit-learn. En référençant une image de conteneur prédéfinie, nous créons un objet Estimator correspondant et transmettons notre script de formation personnalisé.
5. AMT nous permet d'essayer diverses stratégies HPO. Nous nous concentrons sur deux d'entre elles pour cet article : la recherche aléatoire et la recherche bayésienne.
6. Choisissez entre les stratégies SageMaker HPO.
7. Visualisez, analysez et comparez les résultats de réglage. Notre package de visualisation nous permet de découvrir quelle stratégie est la plus performante et quelles valeurs d'hyperparamètres offrent les meilleures performances en fonction de nos métriques.
8. Continuez l’exploration de l’espace des hyperparamètres et démarrez à chaud les tâches HPO.

AMT s'occupe de la mise à l'échelle et de la gestion de l'infrastructure de calcul sous-jacente pour exécuter les différentes tâches de réglage sur Cloud de calcul élastique Amazon (Amazon EC2). De cette façon, vous n'avez pas besoin de vous charger du provisionnement des instances, de gérer les problèmes de système d'exploitation et de matériel ou de regrouper vous-même les fichiers journaux. L'image du framework ML est récupérée d'Amazon ECR et les artefacts du modèle, y compris les résultats de réglage, sont stockés dans Amazon S3. Tous les journaux et métriques sont collectés dans Amazon Cloud Watch pour un accès pratique et une analyse plus approfondie si nécessaire.

Pré-requis

Puisqu'il s'agit de la suite d'une série, il est recommandé, mais pas nécessairement obligatoire, de lire notre premier article sur SageMaker AMT et HPO. En dehors de cela, une connaissance de base des concepts ML et de la programmation Python est utile. Nous vous recommandons également de suivre chaque étape du carnet d'accompagnement depuis notre référentiel GitHub en lisant cet article. Le notebook peut être exécuté indépendamment du premier, mais nécessite du code provenant de sous-dossiers. Assurez-vous de cloner le référentiel complet dans votre environnement comme décrit dans le fichier README.

Expérimenter le code et utiliser les options de visualisation interactive améliore considérablement votre expérience d'apprentissage. Alors, s'il vous plaît, vérifiez-le.

Charger et préparer les données

Dans un premier temps, nous nous assurons que le fichier téléchargé données numériques dont nous avons besoin pour la formation est accessible à SageMaker. Amazon S3 nous permet de le faire de manière sûre et évolutive. Référez-vous au notebook pour le code source complet et n'hésitez pas à l'adapter avec vos propres données.

sm_sess = sagemaker.session.Session(boto_session=boto_sess, sagemaker_client=sm)
BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
s3_data_url = f's3://{BUCKET}/{PREFIX}/data'
digits = datasets.load_digits()
digits_df = pd.DataFrame(digits.data)
digits_df['y'] = digits.target
digits_df.to_csv('data/digits.csv', index=False)
!aws s3 sync data/ {s3_data_url} —exclude '*' —include 'digits.csv'

Les digits.csv Le fichier contient des données de fonctionnalités et des étiquettes. Chaque chiffre est représenté par des valeurs de pixels dans une image 8 × 8, comme le montre l'image suivante pour le chiffre 4.

Préparer le script de formation et les dépendances du framework

Maintenant que les données sont stockées dans notre bucket S3, nous pouvons définir notre script de formation personnalisé basé sur Scikit-apprendre en Python. SageMaker nous offre la possibilité de simplement référencer le fichier Python plus tard pour la formation. Toutes les dépendances telles que les bibliothèques Scikit-learn ou pandas peuvent être fournies de deux manières :

• Ils peuvent être spécifiés explicitement dans un requirements.txt filet
• Ils sont préinstallés dans l'image du conteneur ML sous-jacent, qui est soit fournie par SageMaker, soit créée sur mesure.

Les deux options sont généralement considérées comme des méthodes standard de gestion des dépendances, vous les connaissez donc peut-être déjà. SageMaker prend en charge une variété de frameworks ML dans un environnement géré prêt à l’emploi. Cela inclut bon nombre des frameworks de science des données et de ML les plus populaires tels que PyTorch, TensorFlow ou Scikit-learn, comme dans notre cas. Nous n'utilisons pas de supplément requirements.txt fichier, mais n'hésitez pas à ajouter quelques bibliothèques pour l'essayer.

Le code de notre implémentation contient une méthode appelée fit(), qui crée un nouveau classificateur pour la tâche de reconnaissance des chiffres et l'entraîne. Contrairement à notre premier article dans lequel nous utilisions l'algorithme XGBoost intégré à SageMaker, nous utilisons maintenant un RandomForestClassifier fourni par la bibliothèque ML sklearn. L'appel du fit() La méthode sur l'objet classificateur démarre le processus de formation en utilisant un sous-ensemble (80 %) de nos données CSV :

def fit(train_dir, n_estimators, max_depth, min_samples_leaf, max_features, min_weight_fraction_leaf): digits = pd.read_csv(Path(train_dir)/'digits.csv') Xtrain, Xtest, ytrain, ytest = train_test_split(digits.iloc[:, :-1], digits.iloc[:, -1], test_size=.2) m = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, min_samples_leaf=min_samples_leaf, max_features=max_features, min_weight_fraction_leaf=min_weight_fraction_leaf) m.fit(Xtrain, ytrain) predicted = m.predict(Xtest) pre, rec, f1, _ = precision_recall_fscore_support(ytest, predicted, pos_label=1, average='weighted') print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}') return m

Voir le script complet dans notre notebook Jupyter sur GitHub.

Avant de lancer les ressources du conteneur pour le processus de formation complet, avez-vous essayé d'exécuter le script directement ? Il s'agit d'une bonne pratique pour garantir rapidement que le code ne contient pas d'erreurs de syntaxe, vérifier dès le début les dimensions correspondantes de vos structures de données et quelques autres erreurs.

Il existe deux façons d'exécuter votre code localement. Tout d'abord, vous pouvez l'exécuter immédiatement dans le notebook, ce qui vous permet également d'utiliser le débogueur Python. pdb:

# Running the code from within the notebook. It would then be possible to use the Python Debugger, pdb.
from train import fit
fit('data', 100, 10, 1, 'auto', 0.01)

Vous pouvez également exécuter le script train à partir de la ligne de commande de la même manière que vous souhaiterez peut-être l'utiliser dans un conteneur. Cela prend également en charge la définition de divers paramètres et l'écrasement des valeurs par défaut si nécessaire, par exemple :

!cd src && python train.py --train ../data/ --model-dir /tmp/ --n-estimators 100

En sortie, vous pouvez voir les premiers résultats des performances du modèle en fonction de la précision des métriques objectives, du rappel et du score F1. Par exemple, pre: 0.970 rec: 0.969 f1: 0.969.

Pas mal pour un entraînement aussi rapide. Mais d’où viennent ces chiffres et qu’en faisons-nous ?

Définir des métriques d'objectifs personnalisées

N'oubliez pas que notre objectif est de former et d'ajuster entièrement notre modèle en fonction des mesures objectives que nous considérons pertinentes pour notre tâche. Parce que nous utilisons un script de formation personnalisé, nous devons définir explicitement ces métriques pour SageMaker.

Notre script émet les métriques de précision, de rappel et de score F1 pendant l'entraînement simplement en utilisant le print fonction:

print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}')

La sortie standard est capturée par SageMaker et envoyée à CloudWatch sous forme de flux de journaux. Pour récupérer les valeurs des métriques et travailler avec elles ultérieurement dans SageMaker AMT, nous devons fournir des informations sur la façon d'analyser cette sortie. Nous pouvons y parvenir en définissant des instructions d'expression régulière (pour plus d'informations, reportez-vous à Surveiller et analyser les tâches de formation à l'aide des métriques Amazon CloudWatch):

metric_definitions = [ {'Name': 'valid-precision', 'Regex': r'pre:s+(-?[0-9.]+)'}, {'Name': 'valid-recall', 'Regex': r'rec:s+(-?[0-9.]+)'}, {'Name': 'valid-f1', 'Regex': r'f1:s+(-?[0-9.]+)'}] 

Examinons ensemble la première définition de métrique dans le code précédent. SageMaker recherchera la sortie dans le journal qui commence par pre: et est suivi d'un ou plusieurs espaces, puis d'un nombre que nous souhaitons extraire, c'est pourquoi nous utilisons la parenthèse ronde. Chaque fois que SageMaker trouve une valeur comme celle-là, il la transforme en une métrique CloudWatch portant le nom valid-precision.

Entraîner le modèle à l'aide du framework Scikit-learn

Après avoir créé notre script de formation train.py et instruisons SageMaker sur la façon de surveiller les métriques dans CloudWatch, nous définissons un Estimateur SageMaker objet. Il lance la tâche de formation et utilise le type d'instance que nous spécifions. Mais en quoi ce type d'instance peut-il être différent de celui sur lequel vous exécutez un Amazon SageMakerStudio ordinateur portable, et pourquoi ? SageMaker Studio exécute vos tâches de formation (et d'inférence) sur des instances de calcul distinctes de celles de votre bloc-notes. Cela vous permet de continuer à travailler dans votre bloc-notes pendant que les tâches s'exécutent en arrière-plan.

Le paramètre framework_version fait référence à la version Scikit-learn que nous utilisons pour notre travail de formation. Alternativement, nous pouvons passer image_uri à la estimator. Vous pouvez vérifier si votre framework ou bibliothèque ML préféré est disponible en tant que image Docker SageMaker prédéfinie et utilisez-le tel quel ou avec rallonges.

De plus, nous pouvons exécuter des tâches de formation SageMaker sur des instances Spot EC2 en définissant use_spot_instances à True. Ce sont des instances de capacité de réserve qui peuvent économisez jusqu'à 90% des coûts. Ces instances offrent une flexibilité quant au moment où les tâches de formation sont exécutées.

estimator = SKLearn( 'train.py', source_dir='src', role=get_execution_role(), instance_type= 'ml.m5.large', instance_count=1, framework_version='0.23-1', metric_definitions=metric_definitions, # Uncomment the following three lines to use Managed Spot Training # use_spot_instances= True, # max_run= 60 * 60 * 24, # max_wait= 60 * 60 * 24, hyperparameters = {'n-estimators': 100, 'max-depth': 10, 'min-samples-leaf': 1, 'max-features': 'auto', 'min-weight-fraction-leaf': 0.1}
)

Une fois l'objet Estimator configuré, nous commençons la formation en appelant le fit() fonction, fournissant le chemin d’accès à l’ensemble de données de formation sur Amazon S3. Nous pouvons utiliser cette même méthode pour fournir des données de validation et de test. Nous fixons le wait paramètre True nous pouvons donc utiliser le modèle entraîné dans les cellules de code suivantes.

estimator.fit({'train': s3_data_url}, wait=True)

Définir des hyperparamètres et exécuter des tâches de réglage

Jusqu'à présent, nous avons entraîné le modèle avec un ensemble de valeurs d'hyperparamètres. Mais ces valeurs étaient-elles bonnes ? Ou pourrions-nous en chercher de meilleurs ? Utilisons le Classe HyperparameterTuner pour exécuter une recherche systématique sur l’espace des hyperparamètres. Comment recherche-t-on cet espace avec le tuner ? Les paramètres nécessaires sont le nom de la métrique objective et le type d’objectif qui guideront l’optimisation. La stratégie d’optimisation est un autre argument clé pour le tuner car elle définit davantage l’espace de recherche. Voici quatre stratégies différentes parmi lesquelles choisir :

• Grille de recherche
• Recherche aléatoire
• Optimisation bayésienne (par défaut)
• Hyperbande

Nous décrivons plus en détail ces stratégies et vous donnons quelques conseils pour en choisir une plus loin dans cet article.

Avant de définir et d'exécuter notre objet tuner, récapitulons notre compréhension du point de vue de l'architecture. Nous avons couvert l'aperçu architectural de SageMaker AMT dans notre dernier post et reproduisez-en un extrait ici pour plus de commodité.

Nous pouvons choisir les hyperparamètres que nous voulons régler ou laisser statiques. Pour les hyperparamètres dynamiques, nous fournissons hyperparameter_ranges qui peut être utilisé pour optimiser les hyperparamètres réglables. Parce que nous utilisons un classificateur Random Forest, nous avons utilisé les hyperparamètres du Documentation Scikit-learn sur la forêt aléatoire.

Nous limitons également les ressources avec le nombre maximum de tâches de formation et de tâches de formation parallèles que le tuner peut utiliser. Nous verrons comment ces limites nous aident à comparer les résultats de différentes stratégies entre eux.

tuner_parameters = { 'estimator': estimator, 'base_tuning_job_name': 'random', 'metric_definitions': metric_definitions, 'objective_metric_name': 'valid-f1', 'objective_type': 'Maximize', 'hyperparameter_ranges': hpt_ranges, 'strategy': 'Random', 'max_jobs': n, # 50 'max_parallel_jobs': k # 2 } 

Semblable à celui de l'estimateur fit fonction, nous démarrons un travail de réglage appelant le tuner fit:

random_tuner = HyperparameterTuner(**tuner_parameters)
random_tuner.fit({'train': s3_data_url}, wait=False)

C'est tout ce que nous avons à faire pour laisser SageMaker exécuter les tâches de formation (n=50) en arrière-plan, chacun utilisant un ensemble différent d'hyperparamètres. Nous explorons les résultats plus loin dans cet article. Mais avant cela, commençons un autre travail de réglage, en appliquant cette fois la stratégie d'optimisation bayésienne. Nous comparerons visuellement les deux stratégies une fois terminées.

tuner_parameters['strategy'] = 'Bayesian'
tuner_parameters['base_tuning_job_name'] = 'bayesian'
bayesian_tuner = HyperparameterTuner(**tuner_parameters)
bayesian_tuner.fit({'train': s3_data_url}, wait=False)

Notez que les deux tâches de réglage peuvent s'exécuter en parallèle car SageMaker orchestre les instances de calcul requises indépendamment les unes des autres. C'est très utile pour les praticiens qui expérimentent différentes approches en même temps, comme nous le faisons ici.

Choisissez entre les stratégies SageMaker HPO

En ce qui concerne les stratégies de réglage, vous disposez de quelques options avec SageMaker AMT : recherche par grille, recherche aléatoire, optimisation bayésienne et Hyperband. Ces stratégies déterminent la manière dont les algorithmes de réglage automatique explorent les plages spécifiées d'hyperparamètres.

La recherche aléatoire est assez simple. Il sélectionne de manière aléatoire des combinaisons de valeurs dans les plages spécifiées et peut être exécuté de manière séquentielle ou parallèle. C'est comme lancer des fléchettes les yeux bandés, dans l'espoir d'atteindre la cible. Nous avons commencé avec cette stratégie, mais les résultats s’amélioreront-ils avec une autre ?

L'optimisation bayésienne adopte une approche différente de la recherche aléatoire. Il prend en compte l’historique des sélections précédentes et choisit les valeurs susceptibles de donner les meilleurs résultats. Si vous souhaitez apprendre des explorations précédentes, vous ne pouvez y parvenir qu'en exécutant une nouvelle tâche de réglage après les précédentes. C’est logique, non ? De cette manière, l’optimisation bayésienne dépend des exécutions précédentes. Mais voyez-vous quelle stratégie HPO permet une parallélisation plus élevée ?

Hyperbande c'est intéressant ! Il utilise une stratégie multi-fidélité, ce qui signifie qu'il alloue dynamiquement des ressources aux emplois de formation les plus prometteurs et arrête ceux qui sont sous-performants. Par conséquent, Hyperband est efficace sur le plan informatique avec les ressources, apprenant des tâches de formation précédentes. Après avoir arrêté les configurations sous-performantes, une nouvelle configuration démarre et ses valeurs sont choisies aléatoirement.

En fonction de vos besoins et de la nature de votre modèle, vous pouvez choisir entre la recherche aléatoire, l'optimisation bayésienne ou Hyperband comme stratégie de réglage. Chacun a sa propre approche et ses propres avantages, il est donc important de déterminer laquelle fonctionne le mieux pour votre exploration du ML. La bonne nouvelle pour les praticiens du ML est que vous pouvez sélectionner la meilleure stratégie HPO en comparant visuellement l'impact de chaque essai sur la métrique objective. Dans la section suivante, nous voyons comment identifier visuellement l’impact des différentes stratégies.

Visualisez, analysez et comparez les résultats de réglage

Lorsque nos travaux de réglage sont terminés, cela devient passionnant. Quels résultats apportent-ils ? À quel type d’amélioration pouvez-vous vous attendre sur notre métrique par rapport à votre modèle de base ? Quels sont les hyperparamètres les plus performants pour notre cas d’utilisation ?

Un moyen rapide et simple d'afficher les résultats HPO consiste à visiter la console SageMaker. Sous Tâches de réglage d'hyperparamètres, nous pouvons voir (par tâche de réglage) la combinaison de valeurs d'hyperparamètres qui ont été testées et ont fourni les meilleures performances mesurées par notre métrique objective (valid-f1).

Est-ce tout ce dont vous avez besoin ? En tant que praticien du ML, vous êtes peut-être non seulement intéressé par ces valeurs, mais vous souhaitez certainement en savoir plus sur le fonctionnement interne de votre modèle pour explorer tout son potentiel et renforcer votre intuition grâce à des commentaires empiriques.

Un bon outil de visualisation peut grandement vous aider à comprendre l'amélioration de HPO au fil du temps et à obtenir des commentaires empiriques sur les décisions de conception de votre modèle ML. Il montre l'impact de chaque hyperparamètre individuel sur votre métrique objective et fournit des conseils pour optimiser davantage vos résultats de réglage.

Nous utilisons les amtviz package de visualisation personnalisé pour visualiser et analyser les tâches de réglage. Il est simple à utiliser et offre des fonctionnalités utiles. Nous démontrons son avantage en interprétant certains graphiques individuels et enfin en comparant la recherche aléatoire côte à côte avec l'optimisation bayésienne.

Tout d’abord, créons une visualisation pour la recherche aléatoire. Nous pouvons le faire en appelant visualize_tuning_job() De amtviz et en passant notre premier objet tuner comme argument :

from amtviz import visualize_tuning_job
visualize_tuning_job(random_tuner, advanced=True, trials_only=True)

Vous verrez quelques graphiques, mais procédons étape par étape. Le premier nuage de points de la sortie ressemble à ceci et nous donne déjà des indices visuels que nous ne reconnaîtrions dans aucun tableau.

Chaque point représente la performance d'un travail de formation individuel (notre objectif valid-f1 sur l'axe des y) en fonction de son heure de début (axe des x), produite par un ensemble spécifique d'hyperparamètres. Par conséquent, nous examinons les performances de notre modèle au fur et à mesure de sa progression tout au long de la durée du travail de réglage.

La ligne pointillée met en évidence le meilleur résultat trouvé jusqu’à présent et indique une amélioration au fil du temps. Les deux meilleurs métiers de formation ont obtenu un score F1 d'environ 0.91.

Outre la ligne pointillée montrant la progression cumulée, voyez-vous une tendance dans le graphique ?

Probablement pas. Et c'est normal, car nous observons les résultats de la stratégie aléatoire HPO. Chaque tâche de formation a été exécutée à l’aide d’un ensemble d’hyperparamètres différent mais sélectionné de manière aléatoire. Si nous poursuivions notre travail de réglage (ou en exécutions un autre avec le même paramètre), nous verrions probablement de meilleurs résultats au fil du temps, mais nous ne pouvons pas en être sûrs. Le hasard est une chose délicate.

Les graphiques suivants vous aident à évaluer l'influence des hyperparamètres sur les performances globales. Tous les hyperparamètres sont visualisés, mais par souci de concision, nous nous concentrons sur deux d'entre eux : n-estimators ainsi que le max-depth.

Nos deux principaux emplois de formation utilisaient n-estimators d'environ 20 et 80, et max-depth d'environ 10 et 18 respectivement. Les valeurs exactes des hyperparamètres sont affichées via une info-bulle pour chaque point (tâche de formation). Ils sont même mis en évidence de manière dynamique sur tous les graphiques et vous offrent une vue multidimensionnelle ! As-tu vu ça? Chaque hyperparamètre est tracé par rapport à la métrique objective, sous forme de graphique distinct.

Maintenant, quel genre d'informations obtenons-nous n-estimators?

Sur la base du graphique de gauche, il semble que les plages de valeurs très faibles (inférieures à 10) donnent plus souvent de mauvais résultats que les valeurs plus élevées. Par conséquent, des valeurs plus élevées peuvent aider votre modèle à mieux fonctionner, ce qui est intéressant.

En revanche, la corrélation de max-depth L'hyperparamètre de notre métrique objective est plutôt faible. Nous ne pouvons pas déterminer clairement quelles plages de valeurs sont les plus performantes d’un point de vue général.

En résumé, la recherche aléatoire peut vous aider à trouver un ensemble d’hyperparamètres performants, même dans un laps de temps relativement court. De plus, il ne privilégie pas une bonne solution mais donne une vision équilibrée de l’espace de recherche. Cependant, votre utilisation des ressources pourrait ne pas être très efficace. Il continue d'exécuter des tâches de formation avec des hyperparamètres dans des plages de valeurs connues pour donner de mauvais résultats.

Examinons les résultats de notre deuxième travail de réglage utilisant l'optimisation bayésienne. On peut utiliser amtviz pour visualiser les résultats de la même manière que nous l'avons fait jusqu'à présent pour le tuner de recherche aléatoire. Ou, mieux encore, nous pouvons utiliser la capacité de la fonction pour comparer les deux tâches de réglage dans un seul ensemble de graphiques. Bien pratique !

visualize_tuning_job([random_tuner, bayesian_tuner], advanced=True, trials_only=True)

Il y a plus de points maintenant car nous visualisons les résultats de toutes les tâches de formation pour la recherche aléatoire (points orange) et l'optimisation bayésienne (points bleus). Sur le côté droit, vous pouvez voir un graphique de densité visualisant la distribution de tous les scores F1. Une majorité des emplois de formation obtiennent des résultats dans la partie haute de l'échelle F1 (supérieure à 0.6), c'est tant mieux !

Quel est le point clé à retenir ici ? Le nuage de points montre clairement l’avantage de l’optimisation bayésienne. Il donne de meilleurs résultats au fil du temps car il peut apprendre des exécutions précédentes. C'est pourquoi nous avons obtenu des résultats nettement meilleurs en utilisant le bayésien qu'en utilisant le random (0.967 contre 0.919) avec le même nombre de tâches de formation.

Vous pouvez faire encore plus avec amtviz. Allons-y.

Si vous donnez à SageMaker AMT l'instruction d'exécuter un plus grand nombre de tâches de réglage, voir plusieurs essais à la fois peut devenir compliqué. C'est l'une des raisons pour lesquelles nous avons rendu ces graphiques interactifs. Vous pouvez cliquer et faire glisser sur chaque nuage de points d'hyperparamètres pour zoomer sur certaines plages de valeurs et affiner votre interprétation visuelle des résultats. Tous les autres graphiques sont automatiquement mis à jour. C'est plutôt utile, n'est-ce pas ? Consultez les tableaux suivants à titre d'exemple et essayez-le par vous-même dans votre cahier !

En tant que maximaliste du réglage, vous pouvez également décider que l’exécution d’une autre tâche de réglage des hyperparamètres pourrait améliorer encore les performances de votre modèle. Mais cette fois, une plage plus spécifique de valeurs d’hyperparamètres peut être explorée car vous savez déjà (à peu près) où s’attendre à de meilleurs résultats. Par exemple, vous pouvez choisir de vous concentrer sur des valeurs comprises entre 100 et 200 pour n-estimators, comme le montre le graphique. Cela permet à AMT de se concentrer sur les tâches de formation les plus prometteuses et d'augmenter votre efficacité de réglage.

Résumer, amtviz vous offre un riche ensemble de fonctionnalités de visualisation qui vous permettent de mieux comprendre l'impact des hyperparamètres de votre modèle sur les performances et de prendre des décisions plus intelligentes dans vos activités de réglage.

Poursuivre l'exploration de l'espace des hyperparamètres et démarrer à chaud les tâches HPO

Nous avons vu qu'AMT nous aide à explorer efficacement l'espace de recherche des hyperparamètres. Mais que se passe-t-il si nous avons besoin de plusieurs cycles de réglage pour améliorer nos résultats de manière itérative ? Comme mentionné au début, nous souhaitons établir un cycle de retour d'optimisation : notre « conversation » avec le modèle. Devons-nous repartir de zéro à chaque fois ?

Examinons le concept de gestion d'un tâche de réglage des hyperparamètres à démarrage à chaud. Il ne lance pas de nouvelles tâches de réglage à partir de zéro, il réutilise ce qui a été appris lors des exécutions HPO précédentes. Cela nous aide à être plus efficaces avec notre temps de réglage et nos ressources de calcul. Nous pouvons continuer à itérer sur nos résultats précédents. Pour utiliser les démarrages à chaud, nous créons un WarmStartConfig et préciser warm_start_type as IDENTICAL_DATA_AND_ALGORITHM. Cela signifie que nous modifions les valeurs des hyperparamètres mais que nous ne modifions pas les données ou l'algorithme. Nous demandons à AMT de transférer les connaissances précédentes vers notre nouveau travail de réglage.

En faisant référence à nos précédentes tâches d'optimisation bayésienne et de réglage de recherche aléatoire comme parents, on peut les utiliser tous les deux pour le démarrage à chaud :

warm_start_config = WarmStartConfig(warm_start_type=WarmStartTypes.IDENTICAL_DATA_AND_ALGORITHM, parents=[bayesian_tuner_name, random_tuner_name])
tuner_parameters['warm_start_config'] = warm_start_config

Pour voir les avantages de l'utilisation des démarrages à chaud, reportez-vous aux tableaux suivants. Ceux-ci sont générés par amtviz de la même manière que nous l'avons fait précédemment, mais cette fois nous avons ajouté un autre travail de réglage basé sur un démarrage à chaud.

Dans le graphique de gauche, nous pouvons observer que les nouvelles tâches de réglage se trouvent principalement dans le coin supérieur droit du graphique des mesures de performances (voir les points marqués en orange). Le démarrage à chaud a en effet réutilisé les résultats précédents, c'est pourquoi ces points de données figurent parmi les meilleurs résultats pour le score F1. Cette amélioration se reflète également dans le tableau de densité à droite.

En d’autres termes, AMT sélectionne automatiquement des ensembles prometteurs de valeurs d’hyperparamètres sur la base de ses connaissances issues d’essais précédents. Ceci est illustré dans le graphique suivant. Par exemple, l'algorithme testerait une valeur faible pour n-estimators moins souvent car ceux-ci sont connus pour produire de mauvais scores en F1. Nous ne gaspillons aucune ressource là-dessus, grâce aux démarrages à chaud.

Nettoyer

Pour éviter d'encourir des coûts indésirables lorsque vous avez fini d'expérimenter avec HPO, vous devez supprimer tous les fichiers de votre compartiment S3 avec le préfixe amt-visualize-demo mais aussi arrêter les ressources de SageMaker Studio.

Exécutez le code suivant dans votre bloc-notes pour supprimer tous les fichiers S3 de ce message :

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Si vous souhaitez conserver les jeux de données ou les artefacts du modèle, vous pouvez modifier le préfixe dans le code pour amt-visualize-demo/data supprimer uniquement les données ou amt-visualize-demo/output pour supprimer uniquement les artefacts du modèle.

Conclusion

Nous avons appris comment l'art de créer des solutions ML implique l'exploration et l'optimisation des hyperparamètres. Le réglage de ces boutons et leviers est un processus exigeant mais gratifiant qui conduit à des temps de formation plus rapides, à une précision améliorée du modèle et à de meilleures solutions globales de ML. La fonctionnalité SageMaker AMT nous aide à exécuter plusieurs tâches de réglage et à les démarrer à chaud, et fournit des points de données pour un examen plus approfondi, une comparaison visuelle et une analyse.

Dans cet article, nous avons examiné les stratégies HPO que nous utilisons avec SageMaker AMT. Nous avons commencé avec la recherche aléatoire, une stratégie simple mais performante dans laquelle les hyperparamètres sont échantillonnés aléatoirement à partir d'un espace de recherche. Ensuite, nous avons comparé les résultats à l'optimisation bayésienne, qui utilise des modèles probabilistes pour guider la recherche d'hyperparamètres optimaux. Après avoir identifié une stratégie HPO appropriée et de bonnes plages de valeurs d'hyperparamètres grâce à des essais initiaux, nous avons montré comment utiliser les démarrages à chaud pour rationaliser les futurs travaux HPO.

Vous pouvez explorer l'espace de recherche d'hyperparamètres en comparant les résultats quantitatifs. Nous avons suggéré la comparaison visuelle côte à côte et fourni le package nécessaire pour une exploration interactive. Faites-nous savoir dans les commentaires à quel point cela vous a été utile dans votre parcours de réglage des hyperparamètres !

À propos des auteurs

Ümit Yoldas est un architecte de solutions senior chez Amazon Web Services. Il travaille avec des entreprises clientes de tous les secteurs en Allemagne. Il est déterminé à traduire les concepts de l'IA en solutions concrètes. En dehors du travail, il aime passer du temps en famille, savourer de bons plats et faire de la forme physique.

Elina Lesyk est un architecte de solutions basé à Munich. Elle se concentre sur les entreprises clientes du secteur des services financiers. Pendant son temps libre, Elina crée des applications avec l'IA générative lors de certaines rencontres informatiques, développe une nouvelle idée pour lutter rapidement contre le changement climatique ou court dans la forêt pour se préparer à un semi-marathon avec un écart typique par rapport au calendrier prévu.

Mariano Camp est architecte de solutions principal chez Amazon Web Services. Il travaille avec des banques et des compagnies d'assurance en Allemagne sur l'apprentissage automatique. Dans ses temps libres, Mariano aime faire de la randonnée avec sa femme.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/explore-advanced-techniques-for-hyperparameter-optimization-with-amazon-sagemaker-automatic-model-tuning/