Formation distribuée sur Amazon SageMaker - Amazon SageMaker
Avant de commencerCommencez par une formation distribuée sur Amazon SageMakerConcepts de base de l'entraînement distribuéConcepts avancésStratégies Optimisation de l'entraînement distribuéScénarios

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 de deep learning à l'aide du SDK SageMaker Python.

Astuce

Pour découvrir les bonnes pratiques en matière de calcul distribué pour l'entraînement au machine learning (ML) et les tâches de traitement en général, consultez Informatique distribuée avec les SageMaker meilleures pratiques.

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 le SDK SageMaker Python, 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 configure une infrastructure de formation distribuée, exécute l'CreateTrainingJobAPI dans le backend, trouve la région dans laquelle s'exécute 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 fichiers FSx sur les instances d'entraînement, vous devez transmettre votre sous-réseau de VPC et votre ID 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 d'entraînement de parallélisme de données distribué, un certain nombre de facteurs, tels que la communication entre les nœuds d'un cluster de calcul pour exécuter l'opération AllReduce et le transfert de données entre les nœuds et le stockage de données dans Amazon Simple Storage Service ou Amazon FSx pour Lustre, jouent un rôle crucial pour optimiser l'utilisation des ressources de calcul et accélérer la vitesse d'entraînement. Pour réduire les frais de communication, assurez-vous de configurer les instances, le sous-réseau VPC et le stockage des données dans la même Région AWS zone de disponibilité.

Instances de GPU avec réseau plus rapide et 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 linguistiques (LLM) et les modèles de diffusion, qui nécessitent une commutation inter-nœuds plus rapide, nous recommandons les instances GPU compatibles EFA prises en charge par. SageMaker En particulier, pour réaliser le travail d'entraînement distribué le plus performant possible SageMaker, nous recommandons les instances P4d et P4de équipées de GPU NVIDIA A100. 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 de données, nous recommandons Amazon FSx pour Lustre, qui fournit un débit élevé pour le stockage des jeux de données d'entraînement 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 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 bibliothèque SMDDP 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 bibliothèque SMDDP comme backend de modules de formation distribués PyTorch basés sur : distributed PyTorch data parallel (DDP), PyTorch fully sharded data parallelism (FSDP) et Megatron-. DeepSpeedDeepSpeed 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 des SageMaker modèles (SMP)

SageMaker fournit la bibliothèque SMP 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 ce que la bibliothèque SMP propose, consultez Principales 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 les API d'entraînement distribuées dans la documentation du SDK 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.

  • Pour utiliser PyTorch DistributedDataParallel (DDP) SageMaker avec le mpirun backend, ajoutez-le distribution={"pytorchddp": {"enabled": True}} à votre PyTorch estimateur. Pour plus d'informations, consultez également l'entraînement PyTorch distribué et l'distributionargument de l'SageMaker PyTorch estimateur dans la documentation du SDK SageMaker Python.

    Note

    Cette option est disponible pour les versions PyTorch 1.12.0 et ultérieures.

    from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    distribution={"pytorchddp": {"enabled": True}}  # runs mpirun in the backend
)

  • SageMaker prend en charge le PyTorch torchrunlanceur pour la formation distribuée sur des instances Amazon EC2 basées sur un GPU, telles que P3 et P4, ainsi que sur Trn1 alimenté par le périphérique Trainium.AWS

    Pour utiliser PyTorch DistributedDataParallel (DDP) SageMaker avec le torchrun backend, ajoutez-le distribution={"torch_distributed": {"enabled": True}} à l' PyTorch estimateur.

    Note

    Cette option est disponible pour les versions PyTorch 1.13.0 et ultérieures.

    L'extrait de code suivant montre un exemple de création d'un SageMaker PyTorch estimateur pour exécuter un entraînement distribué sur deux ml.p4d.24xlarge instances avec l'option de distribution. torch_distributed

    from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    distribution={"torch_distributed": {"enabled": True}}   # runs torchrun in the backend
)

    Pour plus d'informations, consultez la section PyTorch Formation distribuée et distribution argument de l'SageMaker PyTorch estimateur dans la documentation du SDK SageMaker Python.

    Notes pour l'entrainement distribué sur Trn1

    Une instance Trn1 comprend jusqu'à 16 appareils Trainium, et chaque appareil Trainium en comprend deux. NeuronCores Pour les spécifications des appareils AWS Trainium, voir Architecture Trainium dans la documentation AWS Neuron.

    Pour vous entraîner sur les instances alimentées par Trainium, il vous suffit de spécifier le code d'instance Trn1ml.trn1.*, sous forme de chaîne de caractères à côté de l'instance_typeargument de la classe d'estimateur. SageMaker PyTorch Pour trouver les types d'instances Trn1 disponibles, consultez Architecture AWS Trn1 dans la Documentation AWS Neuron (langue française non garantie).

    Note

    SageMaker La formation sur les instances Amazon EC2 Trn1 est actuellement disponible uniquement pour le PyTorch framework AWS Deep Learning Containers for PyTorch Neuron à partir de la version 1.11.0. Pour obtenir la liste complète des versions prises en charge de PyTorch Neuron, consultez Neuron Containers dans le référentiel AWS Deep Learning Containers GitHub .

    Lorsque vous lancez une tâche de formation sur des instances Trn1 à l'aide du SDK SageMaker Python, il sélectionne et exécute SageMaker automatiquement le conteneur approprié à partir des conteneurs Neuron fournis par AWS Deep Learning Containers. Les conteneurs Neuron sont préemballés avec les paramètres et les dépendances de l'environnement de formation pour faciliter l'adaptation de votre tâche de formation à la plateforme de SageMaker formation et aux instances Amazon EC2 Trn1.

    Note

    Pour exécuter votre tâche de PyTorch formation sur des instances Trn1 avec SageMaker, vous devez modifier votre script d'entraînement pour initialiser les groupes de processus avec le xla backend et utiliser /XLA. PyTorch Pour soutenir le processus d'adoption de XLA, le SDK AWS Neuron fournit PyTorch Neuron qui utilise XLA pour convertir les opérations en instructions Trainium. PyTorch Pour savoir comment modifier votre script d'entraînement, consultez le guide du développeur pour l'entraînement avec PyTorch Neuron (torch-neuronx) dans la documentation de AWS Neuron.

    Pour plus d'informations, consultez la section Entraînement distribué avec PyTorch Neuron sur les instances Trn1 et l'argument de l'SageMaker PyTorch estimateur distribution dans la documentation du SDK PythonSageMaker .

  • Pour utiliser MPI SageMaker, ajoutez-le distribution={"mpi": {"enabled": True}} à votre estimateur. L'option de distribution MPI est disponible pour les frameworks suivants : MXnet PyTorch, et. TensorFlow

  • Pour utiliser un serveur de paramètres dans SageMaker, ajoutez-le distribution={"parameter_server": {"enabled": True}} à votre estimateur. L'option de serveur de paramètres est disponible pour les frameworks suivants : MXnet PyTorch, et. TensorFlow

    Astuce

    Pour plus d'informations sur l'utilisation du MPI et des options du serveur de paramètres par framework, utilisez les liens suivants vers la documentation du SDK SageMaker Python.

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

  • Jeu de données d'entraînement : toutes les données que vous utilisez pour entraîner le modèle.

  • Taille de lot globale : le nombre d'enregistrements sélectionnés dans le jeu de données d'entraînement dans chaque itération à envoyer aux GPU du cluster. Il s'agit du nombre d'enregistrements sur lesquels le gradient est calculé à chaque itération. Lorsque le parallélisme des données est utilisé, ce nombre est égal au nombre total de réplicas de modèle multiplié par la taille du lot par réplica : global batch size = (the number of model replicas) * (per-replica batch size). La littérature de machine learning utilise souvent le terme de mini-lot pour désigner un lot unique de taille de lot globale.

  • Taille de lot par réplica : lorsque le parallélisme des données est utilisé, ce terme désigne le nombre d'enregistrements envoyés à chaque réplica de modèle. Chaque réplica de modèle effectue une transmission vers l'avant et vers l'arrière avec ce lot pour calculer les mises à jour de poids. Les mises à jour de poids ainsi obtenues sont synchronisées (moyennées) sur tous les réplicas avant le traitement de l'ensemble suivant de lots par réplica.

  • Micro-lot : un sous-ensemble du mini-lot ou, si le modèle hybride et le parallélisme des données sont utilisés, un sous-ensemble du lot dimensionné par réplica. Lorsque vous utilisez SageMaker la bibliothèque de parallélisme de modèles distribués, chaque microlot est introduit dans le pipeline de formation one-by-one et suit un calendrier d'exécution défini par le moteur d'exécution de la bibliothèque.

Entrainement

  • Époque : un cycle d'entraînement sur la totalité du jeu de données. Il est fréquent que chaque époque comprenne plusieurs itérations. Le nombre d'époques que vous utilisez dans l'entraînement est unique pour votre modèle et votre cas d'utilisation.

  • Itération : une seule transmission vers l'avant et vers l'arrière effectuée à l'aide d'un lot dimensionné par rapport à la taille de lot globale (un mini-lot) de données d'entraînement. Le nombre d'itérations effectuées pendant l'entraînement est déterminé par la taille de lot globale et le nombre d'époques utilisées pour l'entraînement. Par exemple, si un jeu de données comprend 5 000 échantillons et que vous utilisez une taille de lot globale de 500, 10 itérations seront nécessaires pour terminer une seule époque.

  • Taux d'apprentissage : une variable qui agit sur l'ampleur de changement des poids en réponse à l'erreur calculée du modèle. Le taux d'apprentissage joue un rôle important dans la capacité du modèle à converger, ainsi que dans la rapidité et l'optimalité de la convergence.

Instances et GPU

  • Instances : une instance de calcul basée sur le AWS machine learning. Les instances sont également appelées nœuds.

  • Taille du cluster : lorsque vous utilisez SageMaker la bibliothèque de formation distribuée, il s'agit du nombre d'instances multiplié par le nombre de GPU dans chaque instance. Par exemple, si vous utilisez deux instances ml.p3.8xlarge dans une tâche d'entraînement, de 4 GPU chacune, la taille du cluster est 8. Bien que l'augmentation de la taille du cluster puisse réduire les durées d'entraînement, il est nécessaire d'optimiser la communication entre les instances afin d'éviter que la communication entre les nœuds n'ajoute un surdébit et n'allonge les durées d'entraînement. La bibliothèque de formation SageMaker distribuée est conçue pour optimiser la communication entre les instances de calcul Amazon EC2 ML, afin d'augmenter l'utilisation des appareils et d'accélérer les temps de formation.

Solutions d'entraînement distribué

  • Parallélisme de données : stratégie d'entraînement distribué dans le cadre de laquelle un jeu de données d'entraînement est réparti sur plusieurs GPU au sein d'un cluster de calcul composé de plusieurs instances de machine learning Amazon EC2. Chaque GPU contient un réplica du modèle, reçoit différents lots de données d'entraînement, effectue une transmission vers l'avant et vers l'arrière, et partage les mises à jour de poids avec les autres nœuds à des fins de synchronisation, avant de passer au lot suivant et finalement à une autre époque.

  • Parallélisme de modèles : stratégie d'entraînement distribué dans le cadre de laquelle le modèle est partitionné sur plusieurs GPU au sein d'un cluster de calcul composé de plusieurs instances de machine learning Amazon EC2. La complexité et le grand nombre de couches et de poids cachés du modèle peuvent l'empêcher de tenir dans la mémoire d'une seule instance. Chaque GPU contient un sous-ensemble du modèle, à travers lequel les flux de données et les transformations sont partagés et compilés. L'efficacité du parallélisme des modèles, en termes d'utilisation du GPU et de durée d'entraînement, dépend fortement de la façon dont le modèle est partitionné, ainsi que du calendrier d'exécution utilisé pour effectuer des transmissions vers l'avant et vers l'arrière.

  • Calendrier d'exécution du pipeline (Pipelining) : le calendrier d'exécution du pipeline détermine l'ordre dans lequel les calculs (micro-lots) sont effectués et les données sont traitées entre les périphériques pendant l'entraînement du modèle. Le Pipelining est une technique employée pour obtenir une véritable parallélisation des modèles grâce aux calculs simultanés effectués par les GPU sur différents échantillons de données, et surmonter la baisse de performance due au calcul séquentiel. Pour en savoir plus, consultez Calendrier d'exécution du pipeline.

Concepts avancés

Les professionnels du machine learning (ML) sont régulièrement confrontés à deux défis de mise à l'échelle lorsqu'ils entraînent des modèles : la mise à l'échelle de la taille du modèle et la mise à l'échelle des données d'entraînement. Bien que la taille et la complexité du modèle puissent améliorer la précision, il y a une limite à la taille du modèle que vous pouvez faire tenir dans un seul CPU ou GPU. 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 est la méthode SGD (Stochastic Gradient Descent) par mini-lots. Dans la méthode SGD par mini-lots, le modèle est entraîné en effectuant de petits changements itératifs de ses coefficients dans la direction qui réduit 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. La méthode SGD par mini-lots présente plusieurs avantages : d'abord, sa conception itérative rend la durée d'entraînement théoriquement linéaire de 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'entraînement SGD via la distribution des enregistrements d'un mini-lot sur différents périphériques informatiques est appelée entraînement distribué pour le parallélisme des données. C'est le 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. 

La méthode SGD avec entraînement parallèle des données exige des développeurs qu'ils puissent toujours faire tenir au moins le modèle et un seul enregistrement dans un seul périphérique informatique, tel qu'un CPU ou GPU. Lorsque de très grands modèles sont entraînés, comme de grands transformateurs dans le traitement du langage naturel (NLP) ou des modèles de segmentation sur des images haute résolution, cela n'est pas toujours possible. 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 parallélisme des données est l'approche la plus courante de l'entraînement distribué : vous avez beaucoup de données, vous les regroupez en lots, et vous envoyez des blocs de données à plusieurs CPU ou GPU (nœuds) pour un traitement 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.

Une erreur fréquente consiste à simplement diviser les couches entre les périphériques, ce qui conduit à une forte sous-utilisation du GPU. Comme l'entraînement est intrinsèquement séquentiel dans les transmissions vers l'avant et vers l'arrière, il arrive qu'à un moment donné, un seul GPU calcule de façon active, 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 :

  • Modifiez les hyperparamètres de votre modèle.

  • Réduisez la taille du lot.

  • Continuez à réduire la taille du lot jusqu'à ce qu'il tienne. Si vous réduisez la taille du lot à 1 et que vous manquez toujours de mémoire, essayez l'entraînement pour le parallélisme des modèles.

Essayez la compression de gradient (FP16, INT8) :

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

  • Réduisez la longueur de la séquence NLP si vous augmentez le lien de séquence, que vous devez réduire la taille du lot ou que vous devez augmenter les GPU pour répartir le lot.

  • Réduisez la résolution d'image.

Vérifiez si vous utilisez la normalisation par lots, car cela peut affecter la convergence. Lorsque vous utilisez l'entraînement distribué, votre lot est divisé entre les GPU, de sorte que la réduction significative de la taille de lot peut accroître le taux d'erreur et perturber ainsi la convergence du modèle. Par exemple, si vous avez prototypé votre réseau sur un seul GPU avec une taille de lot de 64, puis réalisé une augmentation d'échelle à l'aide de quatre p3dn.24xlarge, le nombre de GPU passe à 32 et la taille de lot par GPU passe de 64 à 2. 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 :

  • votre modèle ne tient pas dans un seul périphérique ;

  • les limitations dues à la taille de votre modèle vous conduisent à choisir des tailles de lot supérieures, par exemple si les poids de votre modèle occupent la majeure partie de votre mémoire GPU et que vous êtes obligé de choisir une taille de lot inférieure et sous-optimale. 

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. 

Astuce

Ajustez vos hyperparamètres pour vous assurer que l'entraînement de votre modèle tend vers une convergence satisfaisante à mesure que la taille du lot augmente.

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

Dans l'approche SGD, 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.

Mise à l'échelle d'un seul GPU à plusieurs GPU

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. Une solution consiste à augmenter le nombre de GPU que vous utilisez pour l'entraînement. Sur une instance avec plusieurs GPU, comme une instance p3.16xlarge avec huit GPU, les données et le traitement sont divisés entre les huit GPU. 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 légèrement plus de 1/8 du temps qu'il aurait fallu sur une instance p3.2xlarge avec un seul GPU.

Type d’instance GPU
p3.2xlarge 1
p3.8xlarge 4
p3.16xlarge 8
p3dn.24xlarge 8
Note

Les types d'instances ml utilisés par l' SageMaker entraînement ont le même nombre de GPU que les types d'instances p3 correspondants. Par exemple, une instance ml.p3.8xlarge a le même nombre de GPU qu'une instance p3.8xlarge - 4.

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 voir combien de GPU contient chaque type d'instance p3.

Si vous êtes passé d'un seul GPU sur une instance p3.2xlarge à quatre GPU sur une instance p3.8xlarge, mais que vous avez besoin de plus de puissance de traitement, il peut être avantageux du point de vue des performances et des coûts de choisir une instance p3.16xlarge avant 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 la estimator fonction du SDK SageMaker Python en définissant votreinstance_count. Vous pouvez, par exemple, définir instance_type = p3.16xlarge et instance_count = 2. Au lieu d'avoir huit GPU sur une seule instance p3.16xlarge, vous disposez de 16 GPU sur deux instances identiques. Le graphique suivant montre la mise à l'échelle et le débit en commençant par huit GPU sur une seule instance, puis le passage à 64 instances pour un total de 256 GPU.

Chart showing how throughput increases and time to train decreases with more GPUs.

Scripts d'entraînement personnalisés

Tout en SageMaker simplifiant le déploiement et la mise à l'échelle du nombre d'instances et de GPU, en fonction de l'infrastructure de votre choix, la gestion des données et des résultats peut s'avérer très difficile. 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.