Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Formation distribuée sur Amazon SageMaker

SageMaker fournit des bibliothèques de formation distribuées et prend en charge diverses options de formation distribuées pour les tâches d'apprentissage profond telles que la vision par ordinateur (CV) et le traitement du langage naturel (NLP). Grâce à SageMaker ses bibliothèques de formation distribuées, vous pouvez exécuter des tâches de formation personnalisées hautement évolutives et économiques en parallèle avec les données et modéliser le deep learning en parallèle. Vous pouvez également utiliser d'autres frameworks et packages de formation distribués tels que PyTorch DistributedDataParallel (DDP)torchrun, MPI (mpirun) et un serveur de paramètres. Tout au long de la documentation, des instructions et des exemples se concentrent sur la façon de configurer les options de formation distribuées pour les tâches d'apprentissage profond à l'aide de SageMaker PythonSDK.

Avant de commencer

SageMaker La formation prend en charge la formation distribuée sur une seule instance ainsi que sur plusieurs instances, afin que vous puissiez exécuter des formations de toutes tailles à grande échelle. Nous vous recommandons d'utiliser les classes d'estimateur du framework telles que PyTorchet TensorFlowdans SageMaker PythonSDK, qui sont des lanceurs de tâches de formation proposant diverses options de formation distribuées. Lorsque vous créez un objet estimateur, celui-ci met en place une infrastructure de formation distribuée, l'exécute CreateTrainingJob API dans le backend, trouve la région dans laquelle se déroule votre session en cours et extrait l'un des conteneurs d'apprentissage AWS profond prédéfinis, préemballés avec un certain nombre de bibliothèques, notamment des cadres d'apprentissage profond, des cadres de formation distribués et le pilote. EFA Si vous souhaitez monter un système de FSx fichiers sur les instances de formation, vous devez transmettre votre identifiant de VPC sous-réseau et de groupe de sécurité à l'estimateur. Avant d'exécuter votre tâche de formation distribuée dans SageMaker, lisez les instructions générales suivantes sur la configuration de base de l'infrastructure.

Zones de disponibilité et fond de panier réseau

Lorsque vous utilisez plusieurs instances (également appelées nœuds), il est important de comprendre le réseau qui connecte les instances, comment elles lisent les données d'entraînement et comment elles partagent les informations entre elles. Par exemple, lorsque vous exécutez une tâche de formation parallèle aux données distribuée, un certain nombre de facteurs, tels que la communication entre les nœuds d'un cluster de calcul pour exécuter l'AllReduceopération et le transfert de données entre les nœuds et le stockage des données dans Amazon Simple Storage Service ou Amazon FSx for Lustre, jouent un rôle crucial pour optimiser l'utilisation des ressources informatiques et accélérer la vitesse d'entraînement. Pour réduire les frais de communication, assurez-vous de configurer les instances, le VPC sous-réseau et le stockage des données dans la même Région AWS zone de disponibilité.

GPUinstances dotées d'un réseau plus rapide et d'un stockage à haut débit

Techniquement, vous pouvez utiliser n'importe quelle instance pour un entraînement distribué. Dans les cas où vous devez exécuter des tâches d'entraînement distribuées sur plusieurs nœuds pour entraîner de grands modèles, tels que les grands modèles de langage (LLMs) et les modèles de diffusion, qui nécessitent une commutation inter-nœuds plus rapide, nous vous recommandons d'utiliser des GPUinstances EFA compatibles prises en charge par. SageMaker En particulier, pour obtenir la tâche de formation distribuée la plus performante qui soit SageMaker, nous recommandons les instances P4d et P4de équipées de l'A100. NVIDIA GPUs Elles sont également équipées d'un stockage d'instance local à haut débit et à faible latence et d'un réseau intra-nœud plus rapide. Pour le stockage des données, nous recommandons Amazon FSx for Lustre, qui fournit un débit élevé pour le stockage des ensembles de données de formation et des points de contrôle des modèles.

Commencez par une formation distribuée sur Amazon SageMaker

Si vous connaissez déjà l'entraînement distribué, choisissez l'option, parmi les suivantes, qui correspond à votre stratégie ou votre framework préférés pour commencer. Si vous souhaitez en savoir plus sur l'entraînement distribué en général, consultez Concepts de base de l'entraînement distribué.

Les bibliothèques de formation SageMaker distribuées sont optimisées pour l'environnement de SageMaker formation, aident à adapter vos tâches de formation distribuées et améliorent la vitesse et le débit de formation. SageMaker Les offrent des stratégies d'entraînement parallèle de données et de modèles. Ils combinent des technologies logicielles et matérielles pour améliorer les communications entre nœuds GPU et entre nœuds, et étendent les capacités SageMaker de formation grâce à des options intégrées qui nécessitent des modifications de code minimales dans vos scripts d'entraînement. 

Utiliser la bibliothèque de parallélisme de données SageMaker distribué () SMDDP

La SMDDP bibliothèque améliore la communication entre les nœuds grâce à des implémentations AllReduce et à des opérations de communication AllGather collective optimisées pour l'infrastructure AWS réseau et la topologie des instances Amazon SageMaker ML. Vous pouvez utiliser la SMDDPbibliothèque en tant que backend de modules de formation distribués PyTorch basés sur des modules : PyTorch distributed data parallel (DDP), PyTorch fully sharded data parallelism (FSDP) et Megatron- DeepSpeed. DeepSpeed L'exemple de code suivant montre comment définir un PyTorch estimateur pour lancer une tâche de formation distribuée sur deux ml.p4d.24xlarge instances.

from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

Pour savoir comment préparer votre script de formation et lancer une tâche de formation parallèle aux données distribuées sur SageMaker, consultezOrganisez une formation distribuée avec la bibliothèque de parallélisme de données SageMaker distribué.

Utiliser la bibliothèque de parallélisme du SageMaker modèle () SMP

SageMaker fournit la SMP bibliothèque et prend en charge diverses techniques de formation distribuées, telles que le parallélisme des données fragmentées, le pipeline, le parallélisme des tenseurs, le partitionnement de l'état de l'optimiseur, etc. Pour en savoir plus sur les offres de la SMP bibliothèque, consultezPrincipales fonctionnalités de la bibliothèque de parallélisme des SageMaker modèles.

Pour utiliser SageMaker la bibliothèque de parallélisme du modèle, configurez le distribution paramètre des estimateurs du SageMaker framework. Les estimateurs de cadre pris en charge sont PyTorchet. TensorFlow L'exemple de code suivant montre comment construire un estimateur de cadre pour l'entraînement distribué à l'aide de la bibliothèque de parallélisme de modèles sur deux instances ml.p4d.24xlarge.

from sagemaker.framework import Framework

distribution={
    "smdistributed": {
        "modelparallel": {
            "enabled":True,
            "parameters": {
                ...   # enter parameter key-value pairs here
            }
        },
    },
    "mpi": {
        "enabled" : True,
        ...           # enter parameter key-value pairs here
    }
}

estimator = Framework(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    distribution=distribution
)

Pour savoir comment adapter votre script d'entraînement, configurer les paramètres de distribution dans la estimator classe et lancer une tâche de formation distribuée, consultez la bibliothèque SageMaker de modèles de parallélisme (voir également Formation distribuée APIs dans la SDKdocumentation SageMaker Python).

Utilisation des frameworks d'entraînement distribué open source

SageMaker prend également en charge les options suivantes pour fonctionner mpirun et torchrun dans le backend.

Concepts de base de l'entraînement distribué

SageMakerles bibliothèques de formation distribuées utilisent les termes et fonctionnalités de formation distribuée suivants.

Jeux de données et lots

Entrainement

Instances et GPUs

Solutions d'entraînement distribué

Concepts avancés

Les professionnels du Machine Learning (ML) sont généralement confrontés à deux défis de mise à l'échelle lorsqu'ils forment des modèles : la mise à l'échelle de la taille du modèle et la mise à l'échelle des données de formation. Bien que la taille et la complexité du modèle puissent améliorer la précision, il existe une limite à la taille du modèle que vous pouvez intégrer dans un seul CPU ouGPU. En outre, la mise à l'échelle de la taille du modèle peut augmenter le volume de calculs et allonger les durées d'entraînement.

Tous les modèles ne gèrent pas la mise à l'échelle des données d'entraînement de la même façon, car ils doivent utiliser toutes les données d'entraînement dans la mémoire pour l'entraînement. La mise à l'échelle se fait verticalement seulement, et sur des types d'instances toujours plus grands. Dans la plupart des cas, la mise à l'échelle des données d'entraînement allonge les temps d'entraînement.

Le deep learning (DL) est une famille spécifique d'algorithmes ML composée de plusieurs couches de réseaux neuronaux artificiels. La méthode d'entraînement la plus courante consiste à utiliser la descente stochastique à gradient par mini-lots (). SGD En mini-batchSGD, le modèle est entraîné en effectuant de petites modifications itératives de ses coefficients dans le sens de la réduction de son erreur. Ces itérations sont effectuées sur des sous-échantillons de taille égale du jeu de données d'entraînement appelés mini-lots. Pour chaque mini-lot, le modèle est exécuté dans chaque enregistrement du mini-lot, son erreur est mesurée et le gradient de l'erreur est estimé. Ensuite, le gradient moyen est mesuré sur tous les enregistrements du mini-lot et fournit une direction de mise à jour pour chaque coefficient du modèle. Une transmission complète sur le jeu de données d'entraînement est appelée époque. Les entraînements de modèle comprennent généralement plusieurs dizaines à plusieurs centaines d'époques. Le mini-batch SGD présente plusieurs avantages : tout d'abord, sa conception itérative rend le temps d'apprentissage théoriquement linéaire par rapport à la taille du jeu de données. Ensuite, dans un mini-lot donné, chaque enregistrement est traité individuellement par le modèle, sans autre communication entre enregistrements que la moyenne finale du gradient. Le traitement d'un mini-lot est donc particulièrement adapté à la parallélisation et à la distribution. 

La parallélisation de l'SGDentraînement en distribuant les enregistrements d'un mini-lot sur différents appareils informatiques est appelée entraînement distribué en parallèle avec les données. Il s'agit du paradigme de distribution DL le plus couramment utilisé. L'entraînement parallèle des données est une stratégie de distribution pertinente pour mettre à l'échelle la taille du mini-lot et le traiter plus rapidement. Cependant, l'entraînement parallèle des données s'accompagne de la complexité supplémentaire de devoir calculer la moyenne de gradient de mini-lots avec des gradients provenant de tous les employés et de la communiquer à tous les employés, une étape appelée allreduce (tout réduire). Cela peut provoquer un surdébit, dû à la mise à l'échelle du cluster d'entraînement, et pénaliser considérablement la durée d'entraînement s'il est mal mis en œuvre ou mis en œuvre sur des soustractions matérielles inappropriées. 

Data parallel nécessite SGD toujours que les développeurs soient capables d'intégrer au moins le modèle et un seul enregistrement dans un appareil informatique, tel qu'un seul CPU ouGPU. Lorsque vous entraînez de très grands modèles tels que de grands transformateurs en traitement automatique du langage (NLP) ou des modèles de segmentation sur des images haute résolution, cela peut s'avérer impossible dans certaines situations. Une autre façon de décomposer l'application consiste à partitionner le modèle entre plusieurs périphériques informatiques, une approche appelée entraînement distribué pour le parallélisme des modèles.

Stratégies

L'entraînement distribué est généralement divisé en deux approches : le parallélisme des données et le parallélisme des modèles. Le data parallel est l'approche la plus courante en matière de formation distribuée : vous disposez d'un grand nombre de données, vous les regroupez et vous envoyez des blocs de données à plusieurs CPUs ou GPUs (nœuds) pour qu'ils soient traités par le réseau neuronal ou l'algorithme ML, puis vous combinez les résultats. Le réseau neuronal est le même sur chaque nœud. L'approche de parallélisme des modèles est utilisée avec de grands modèles qui ne tiennent pas d'un seul tenant dans la mémoire d'un nœud. Elle décompose le modèle et en place les différentes parties sur différents nœuds. Dans ce cas, vous devez envoyer vos lots de données vers chaque nœud afin que les données de toutes les parties du modèle soient traitées.

Les termes réseau et modèle sont souvent utilisés de façon interchangeable : un grand modèle est en fait un grand réseau comprenant une multitude de couches et de paramètres. L'entraînement avec un grand réseau produit un grand modèle, et le chargement du modèle sur le réseau avec tous vos paramètres préentraînés et leurs poids charge un grand modèle dans la mémoire. Lorsque vous décomposez un modèle pour le diviser entre les nœuds, vous décomposez également le réseau sous-jacent. Un réseau se compose de couches, et pour diviser le réseau, vous placez des couches sur différents périphériques de calcul.

Un écueil courant lié à la division naïve des couches entre les appareils est une grave sous-utilisation. GPU L'entraînement est intrinsèquement séquentiel dans les passes avant et arrière, et à un moment donné, un seul GPU peut calculer activement, tandis que les autres attendent que les activations soient envoyées. Les bibliothèques parallèles de modèles modernes résolvent ce problème en utilisant des calendriers d'exécution de pipeline pour améliorer l'utilisation des périphériques. Cependant, seule la bibliothèque SageMaker de modèles parallèles distribués d'Amazon inclut le fractionnement automatique des modèles. Les deux principales caractéristiques de la bibliothèque, la division automatique des modèles et le calendrier d'exécution du pipeline, simplifient le processus de mise en œuvre du parallélisme des modèles en prenant des décisions automatisées conduisant à une utilisation efficace des périphériques.

Entraînement avec le parallélisme de données et le parallélisme de modèles

Si vous entraînez avec un jeu de données volumineux, commencez par une approche de parallélisme des données. Si vous manquez de mémoire pendant l'entraînement, vous pouvez passer à une approche de parallélisme des modèles ou essayer un modèle hybride et un parallélisme des données. Vous pouvez également procéder comme suit pour améliorer vos performances avec le parallélisme des données :

Essayez la compression en dégradé (FP16,INT8) :

Essayez de réduire la taille d'entrée :

Vérifiez si vous utilisez la normalisation par lots, car cela peut affecter la convergence. Lorsque vous utilisez la formation distribuée, votre lot est divisé GPUs et une taille de lot beaucoup plus faible peut entraîner un taux d'erreur plus élevé, empêchant ainsi le modèle de converger. Par exemple, si vous avez prototypé votre réseau sur un seul lot GPU avec une taille de lot de 64, puis que vous l'avez étendu à quatre p3dn.24xlarge, vous en avez désormais 32 GPUs et votre taille par lot passe de 64 à 2. GPU Cela va probablement affecter la convergence qui était possible avec un seul nœud.

Commencez par un entraînement pour le parallélisme des modèles lorsque :

Pour en savoir plus sur les bibliothèques SageMaker distribuées, consultez les rubriques suivantes :

Optimisation de l'entraînement distribué

Personnalisez les hyperparamètres de votre cas d'utilisation et de vos données afin d'obtenir la meilleure efficacité de mise à l'échelle. Dans la discussion qui suit, nous mettons en évidence certaines des variables de formation les plus importantes et fournissons des références aux state-of-the-art implémentations afin que vous puissiez en savoir plus sur les options qui s'offrent à vous. En outre, nous vous recommandons de consulter la documentation d'entraînement distribué de votre cadre préféré.

Taille de lot

SageMaker les boîtes à outils distribuées vous permettent généralement de vous entraîner sur des lots plus importants. Par exemple, si un modèle tient dans un seul périphérique mais ne peut être entraîné qu'avec un lot de petite taille, un entraînement pour le parallélisme des modèles ou des données vous permet d'expérimenter des lots de plus grande taille.

N'oubliez pas que la taille du lot influe directement sur la précision du modèle en contrôlant la quantité de bruit dans la mise à jour du modèle à chaque itération. L'augmentation de la taille du lot réduit la quantité de bruit dans l'estimation du gradient, ce qui peut être avantageux en cas d'augmentation à partir de lots de très petite taille, mais peut entraîner une dégradation de la précision du modèle à mesure que la taille du lot augmente pour atteindre des valeurs élevées. 

Certaines techniques ont été développées afin d'assurer une bonne convergence des modèles lorsque la taille du lot augmente.

Taille du mini-lot

DansSGD, la taille du mini-lot quantifie la quantité de bruit présente dans l'estimation du gradient. Un mini-lot de petite taille produit un gradient de mini-lot très bruyant, ce qui n'est pas représentatif du gradient réel sur le jeu de données. Un mini-lot de grande taille produit un gradient de mini-lot proche du gradient réel sur le jeu de données et potentiellement pas assez bruyant, de sorte qu'il risque de rester verrouillé dans des minima non pertinents.

Pour en savoir plus sur ces techniques, consultez les articles suivants :

Scénarios

Les sections suivantes décrivent les scénarios dans lesquels vous souhaiterez peut-être étendre la formation, ainsi que la manière dont vous pouvez le faire en utilisant AWS les ressources.

Passer d'une solution unique GPU à plusieurs GPUs

La quantité de données ou la taille du modèle utilisé en machine learning peut créer des situations où le temps d'entraînement d'un modèle est supérieur au temps dont vous disposez. Parfois, le format du modèle ou le volume des données rend l'entraînement impossible. L'une des solutions consiste à augmenter le nombre GPUs que vous utilisez pour la formation. Sur une instance comportant plusieursGPUs, comme une instance p3.16xlarge qui en a huitGPUs, les données et le traitement sont répartis sur les huitGPUs. L'utilisation de bibliothèques d'entraînement distribué peut accélérer de façon quasi linéaire le temps nécessaire à l'entraînement de votre modèle. Cela prend un peu plus d'un huitième du temps que cela aurait pris p3.2xlarge avec unGPU.

Mise à l'échelle d'une seule instance à plusieurs instances

Pour augmenter la mise à l'échelle de votre entraînement, vous pouvez utiliser plus d'instances. Vous devrez toutefois choisir un type d'instance plus grand avant d'ajouter d'autres instances. Consultez le tableau précédent pour savoir combien il GPUs y en a dans chaque type d'instance p3.

Si vous êtes passé d'un simple GPU sur un p3.2xlarge à quatre GPUs sur unp3.8xlarge, mais que vous décidez que vous avez besoin de plus de puissance de traitement, vous pouvez obtenir de meilleures performances et réduire les coûts si vous en choisissez un p3.16xlarge avant d'essayer d'augmenter le nombre d'instances. Selon les bibliothèques que vous utilisez, en continuant votre entraînement sur une seule instance, vous améliorez les performances et réduisez les coûts par rapport à un scénario à plusieurs instances.

Lorsque vous êtes prêt à augmenter le nombre d'instances, vous pouvez le faire avec SDK estimator la fonction SageMaker Python en définissant votreinstance_count. Vous pouvez, par exemple, définir instance_type = p3.16xlarge et instance_count = 2. Au lieu de huit GPUs sur un seulp3.16xlarge, vous en avez 16 GPUs sur deux instances identiques. Le graphique suivant montre le dimensionnement et le débit, en commençant par huit GPUs sur une seule instance et en augmentant jusqu'à 64 instances pour un total de 256GPUs.

Scripts d'entraînement personnalisés

Tout en SageMaker simplifiant le déploiement et la mise à l'échelle du nombre d'instancesGPUs, la gestion des données et des résultats peut s'avérer très difficile, selon le framework de votre choix. C'est pourquoi des bibliothèques de support externes sont souvent utilisées. Cette forme la plus élémentaire de formation distribuée nécessite la modification de votre script d'entraînement pour gérer la distribution des données.

SageMaker prend également en charge Horovod et les implémentations de formations distribuées natives à chaque framework d'apprentissage profond majeur. Si vous choisissez d'utiliser des exemples issus de ces frameworks, vous pouvez suivre SageMaker le guide des conteneurs pour les Deep Learning Containers, ainsi que divers exemples de blocs-notes illustrant les implémentations.