Démonstrations et visualisation avancées de Debugger - Amazon SageMaker

Démonstrations et visualisation avancées de Debugger

Les démonstrations suivantes vous guident dans les cas d'utilisation et les scripts de visualisation avancés à l'aide de Debugger.

Entraînez et ajustez vos modèles avec Amazon SageMaker Experiments et Debugger

Nathalie Rauschmayr, AWS Applied Scientist | Durée : 49 minutes et 26 secondes

Découvrez comment Amazon SageMaker Experiments et Debugger peuvent simplifier la gestion de vos tâches d'entraînement. Amazon SageMaker Debugger offre une visibilité transparente sur les tâches d'entraînement et enregistre les métriques d'entraînement dans votre compartiment Amazon S3. SageMaker Experiments vous permet d'appeler les informations d'entraînement en tant qu'essais via SageMaker Studio et prend en charge la visualisation de la tâche d'entraînement. Cela contribue à préserver la qualité élevée du modèle tout en réduisant les paramètres moins importants en fonction du niveau d'importance.

Cette vidéo montre une technique de réduction des modèles qui rend les modèles préentraînés ResNet50 et AlexNet plus légers et abordables tout en respectant des normes élevées pour la précision du modèle.

SageMaker Estimator entraîne les algorithmes fournis à partir de PyTorch Model Zoo dans des conteneurs AWS Deep Learning Containers avec le cadre PyTorch, et Debugger extrait les métriques d'entraînement du processus d'entraînement.

La vidéo montre également comment configurer une règle personnalisée pour contrôler la précision d'un modèle réduit, déclencher un événement Amazon CloudWatch et une fonction AWS Lambda lorsque la précision atteint un seuil, et arrêter automatiquement le processus de réduction pour éviter les itérations redondantes.

Les objectifs d'apprentissage sont les suivants :

  • Apprendre à utiliser SageMaker pour accélérer l'entraînement du modèle de ML et améliorer la qualité du modèle.

  • Découvrir comment gérer les itérations d'entraînement avec SageMaker Experiments en capturant automatiquement les paramètres d'entrée, les configurations et les résultats.

  • Découvrir comment Debugger rend le processus d'entraînement transparent en capturant automatiquement les données des tenseurs en temps réel à partir de métriques telles que les pondérations, les gradients et les sorties d'activation des réseaux de neurones convolutifs.

  • Utiliser CloudWatch pour déclencher Lambda lorsque Debugger détecte des problèmes.

  • Maîtriser le processus d'entraînement SageMaker à l'aide de SageMaker Experiments et Debugger.

Pour consulter les blocs-notes et les scripts d'entraînement utilisés dans cette vidéo, rendez-vous sur la page SageMaker Debugger PyTorch Iterative Model Pruning.

L'image suivante montre comment le processus de réduction du modèle itératif réduit la taille d'AlexNet en éliminant les 100 filtres les moins significatifs en fonction du niveau d'importance évalué par les sorties d'activation et les gradients.

Le processus de réduction a réduit le nombre initial de 50 millions de paramètres à 18 millions. Il a également réduit la taille estimée du modèle de 201 Mo à 73 Mo.


                Image contenant des visualisations du résultat de la réduction du modèle

Vous devez également suivre la précision du modèle. L'image suivante montre comment tracer le processus de réduction du modèle pour visualiser les modifications au niveau de la précision du modèle en fonction du nombre de paramètres dans SageMaker Studio.


                Image de visualisation des tenseurs avec Debugger dans SageMaker Studio

Dans l'onglet Experiments (Expérimentations) de l'interface SageMaker Studio, sélectionnez une liste des tenseurs enregistrés par Debugger dans le processus de réduction et composez un panneau Trial Component List (Liste des composants d'essai). Sélectionnez les dix itérations et choisissez Add chart (Ajouter un graphique) pour créer un Trial Component Chart (Graphique de composants d'essai). Une fois que vous avez choisi le modèle à déployer, choisissez le composant d'essai et un menu permettant d'effectuer une action ou choisissez Deploy model (Déployer le modèle).

Note

Pour déployer un modèle via SageMaker Studio à l'aide de cet exemple de bloc-notes, ajoutez une ligne à la fin de la fonction train dans le script train.py.

# In the train.py script, look for the train function in line 58. def train(epochs, batch_size, learning_rate): ... print('acc:{:.4f}'.format(correct/total)) hook.save_scalar("accuracy", correct/total, sm_metric=True) # Add the following code to line 128 of the train.py script to save the pruned models # under the current SageMaker Studio model directory torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')

Utilisation de SageMaker Debugger pour surveiller l'entraînement du modèle auto-encodeur convolutif

Ce bloc-notes montre comment SageMaker Debugger visualise les tenseurs à partir d'un processus d'apprentissage non supervisé (ou auto-supervisé) sur un jeu de données d'images MNIST de nombres manuscrits.

Le modèle d'entraînement de ce bloc-notes est un auto-encodeur convolutif avec le framework MxNet. L'auto-encodeur convolutif a un réseau de neurones convolutif en forme de goulot d'étranglement qui se compose d'une partie encodeur et d'une partie décodeur.

L'encodeur de cet exemple comporte deux couches de convolution pour produire une représentation compressée (variables latentes) des images en entrée. Dans ce cas, l'encodeur produit une variable latente de taille (1, 20) à partir d'une image d'entrée d'origine de taille (28, 28) et réduit considérablement la taille des données pour l'entraînement, de l'ordre de 40 fois.

Le décodeur dispose de deux couches déconvolutives et garantit que les variables latentes conservent les informations clés en reconstruisant les images de sortie.

L'encodeur convolutif alimente les algorithmes de clustering avec une taille de données d'entrée plus petite, ainsi que les performances des algorithmes de clustering tels que k-moyennes (k-means), k-nn et T-SNE (Stochastic Neighbor Embedding) distribuée.

Cet exemple de bloc-notes montre comment visualiser les variables latentes à l'aide de Debugger, comme illustré dans l'animation suivante. Il montre également comment l'algorithme T-SNE classe les variables latentes en dix groupes et les projette dans un espace à deux dimensions. Le diagramme de points en couleur situé sur la droite de l'image reflète les vraies valeurs pour montrer l'efficacité de l'organisation des variables latentes dans les clusters par le modèle BERT et l'algorithme T-SNE.


                Image conceptuelle de l'auto-encodeur convolutif

Utilisation de SageMaker Debugger pour contrôler les attentions dans l'entraînement du modèle BERT

Le modèle BERT (Bidirectional Encode Representations from Transformers) est un modèle de représentation linguistique. Comme le reflète son nom, le modèle BERT s'appuie sur l'apprentissage par transfert et sur le modèle de transformateur pour le traitement du langage naturel.

Le modèle BERT est préentraîné pour des tâches non supervisées, comme la prédiction des mots manquants dans une phrase ou la prédiction de la phrase qui suit naturellement une phrase. Les données d'entraînement contiennent 3,3 milliards de mots (jetons) de texte anglais, provenant de sources telles que Wikipédia et des livres électroniques. Pour vous donner un exemple simple, le modèle BERT peut accorder une grande attention aux jetons de verbe appropriés ou aux jetons de pronom d'un jeton sujet.

Le modèle BERT préentraîné peut être affiné à l'aide d'une couche de sortie supplémentaire afin d'obtenir un entraînement du modèle de pointe dans les tâches de traitement du langage naturel, par exemple des réponses automatiques à des questions, la classification de textes, etc.

Debugger collecte les tenseurs du processus de réglage précis. Dans le contexte du traitement du langage naturel, la pondération des neurones est appelée attention.

Ce bloc-notes montre comment utiliser le modèle BERT préentraîné du GluonNLP Model Zoo sur le jeu de données des Questions et Réponses de Stanford et comment configurer SageMaker Debugger pour contrôler la tâche d'entraînement.

Le tracé des scores d'attention et des neurones individuels dans la requête et les vecteurs clés peut aider à identifier les causes de prédictions erronées du modèle. Avec SageMaker Debugger, vous pouvez facilement récupérer les tenseurs et tracer la vue de la tête de l'attention en temps réel pendant la progression de l'entraînement et comprendre ce que le modèle apprend.

L'animation suivante montre les scores d'attention des 20 premiers jetons d'entrée pour dix itérations dans la tâche d'entraînement fournie dans l'exemple de bloc-notes.


                Animation des scores d'attention

Utilisation de SageMaker Debugger pour visualiser les cartes d'activation des classes dans les réseaux neuronaux convolutifs

Ce bloc-notes montre comment utiliser SageMaker Debugger pour tracer des cartes d'activation des classes pour la détection et la classification des images dans les réseaux de neurones convolutifs. Dans le deep learning, un réseau neuronal convolutif (CNN ou ConvNet) est une classe de réseaux neuronaux profonds, le plus souvent appliquée à l'analyse de l'imagerie visuelle. Les voitures autonomes illustrent une application qui adopte les cartes d'activation de classes. En effet, elles nécessitent la détection instantanée et la classification des images telles que les panneaux de signalisation, les routes et les obstacles.

Dans ce bloc-notes, le modèle PyTorch ResNet est entraîné sur l'ensemble de données de signalisation allemand, qui contient plus de 40 classes d'objets liés à la circulation et plus de 50 000 images au total.


                Animation de carte d'activation des classes dans les réseaux de neurones convolutifs

Pendant le processus d'entraînement, SageMaker Debugger recueille des tenseurs pour tracer les cartes d'activation des classes en temps réel. Comme illustré dans l'image animée, la carte d'activation des classes (également appelée carte de saillance) met en évidence les régions à forte activation en rouge.

À l'aide des tenseurs capturés par Debugger, vous pouvez visualiser l'évolution de la carte d'activation au cours de l'entraînement du modèle. Le modèle commence par détecter le bord dans le coin inférieur gauche au début de la tâche d'entraînement. Au fur et à mesure de la progression de l'entraînement, l'attention se déplace vers le centre et détecte le panneau de limite de vitesse. Le modèle prédit à juste titre que la classe de l'image d'entrée est la classe 3, à savoir une classe pour les panneaux de limite de vitesse de 60 km/h, avec un niveau de confiance de 97 %.