Accélérez l’apprentissage en profondeur des modèles jusqu’à 35% avec le tri intelligent Amazon SageMaker

Boostez l'apprentissage en profondeur de vos modèles jusqu'à 35% grâce à la puissante fonction de tri d'Amazon SageMaker

Dans le paysage en constante évolution de l’intelligence artificielle, les modèles d’apprentissage profond se retrouvent à l’avant-garde de l’innovation, avec des applications couvrant la vision par ordinateur (CV), le traitement du langage naturel (NLP) et les systèmes de recommandation. Cependant, le coût croissant associé à la formation et au raffinement de ces modèles pose un défi pour les entreprises. Ce coût est principalement lié au volume important de données utilisées dans la formation des modèles d’apprentissage profond. Aujourd’hui, les grands modèles sont souvent formés sur des téraoctets de données et peuvent prendre des semaines à se former, même avec des GPU puissants ou du matériel basé sur AWS Trainium. En général, les clients s’appuient sur des techniques et des optimisations qui améliorent l’efficacité de la boucle d’apprentissage d’un modèle, telles que les noyaux ou couches optimisés, l’apprentissage en précision mixte ou encore les bibliothèques d’apprentissage distribué de Amazon SageMaker. Cependant, il y a aujourd’hui moins d’attention portée sur l’efficacité des données d’entraînement elles-mêmes. Toutes les données ne contribuent pas également au processus d’apprentissage lors de la formation du modèle : une proportion significative des ressources informatiques peut être consacrée au traitement d’exemples simples qui ne contribuent pas de manière substantielle à l’exactitude globale du modèle.

Les clients ont traditionnellement utilisé des techniques de prétraitement telles que la suréchantillonnage ou la sous-échantillonnage et la déduplication pour affiner et améliorer la qualité de l’information de leurs données. Ces techniques peuvent être utiles, mais elles prennent souvent du temps, nécessitent une expérience spécialisée en science des données et peuvent parfois relever davantage de l’art que de la science. Les clients s’appuient également souvent sur des ensembles de données sélectionnés, tels que RefinedWeb, pour améliorer les performances de leurs modèles ; cependant, ces ensembles de données ne sont pas toujours entièrement open source et sont souvent plus généralistes et sans rapport direct avec votre cas d’utilisation spécifique.

Comment pouvez-vous donc surmonter cette inefficacité liée aux échantillons de données à faible valeur informative lors de la formation du modèle ?

Nous sommes heureux d’annoncer un aperçu public de smart sifting, une nouvelle fonctionnalité de SageMaker qui peut réduire le coût de la formation des modèles d’apprentissage profond jusqu’à 35 %. Smart sifting est une nouvelle technique d’efficacité des données qui analyse activement vos échantillons de données lors de la formation et filtre les échantillons moins informatifs pour le modèle. En s’entraînant sur un sous-ensemble plus petit de données contenant uniquement les échantillons qui contribuent le plus à la convergence du modèle, la formation et le coût totaux diminuent avec un impact minimal voire nul sur l’exactitude. De plus, comme la fonctionnalité fonctionne en ligne pendant la formation du modèle, smart sifting ne nécessite aucun changement dans vos données amont ou dans votre pipeline de formation aval.

Dans cet article, nous abordons les sujets suivants :

  • La nouvelle fonctionnalité smart sifting dans SageMaker et son fonctionnement
  • Comment utiliser smart sifting avec les charges de travail d’apprentissage PyTorch

Vous pouvez également consulter notre documentation et nos notebooks d’exemples pour des ressources supplémentaires sur la façon de commencer avec smart sifting.

Comment fonctionne SageMaker Smart Sifting

Nous commençons cet article par une présentation de la façon dont la fonctionnalité smart sifting peut accélérer la formation de votre modèle sur SageMaker.

La tâche de smart sifting consiste à passer en revue vos données d’entraînement pendant le processus de formation et à ne transmettre au modèle que les échantillons les plus informatifs. Lors d’une formation typique avec PyTorch, les données sont envoyées de manière itérative en lots à la boucle d’entraînement et aux périphériques accélérés (par exemple, les GPU ou les puces Trainium) via le chargeur de données PyTorch. Smart sifting est mis en œuvre à ce stade du chargement des données et est donc indépendant de tout prétraitement des données amont dans votre pipeline de formation.

Smart sifting utilise votre modèle et une fonction de perte spécifiée par l’utilisateur pour effectuer un passage en avant évaluatif de chaque échantillon de données lors de son chargement. Les échantillons à perte élevée auront un impact significatif sur la formation du modèle et sont donc utilisés dans la formation ; les échantillons de données à perte relativement faible sont mis de côté et exclus de la formation.

Un élément clé de smart sifting est la proportion de données à exclure : par exemple, en définissant la proportion à 33 % (valeur beta_value=0.5), les échantillons situés approximativement dans le tiers inférieur de chaque lot seront exclus de la formation. Lorsque suffisamment d’échantillons à perte élevée ont été identifiés pour compléter un lot, les données sont envoyées dans la boucle d’entraînement complète et le modèle apprend et s’entraîne normalement. Vous n’avez pas besoin d’apporter de modifications à votre boucle d’entraînement lorsque smart sifting est activé.

Le diagramme suivant illustre ce flux de travail.

En incluant uniquement un sous-ensemble de vos données d’entraînement, le tri intelligent réduit le temps et la puissance de calcul nécessaires pour former le modèle. Dans nos tests, nous avons obtenu une réduction pouvant atteindre près de 40 % du temps total de formation et du coût. Grâce au tri intelligent des données, il peut y avoir un impact minimal ou nul sur l’exactitude du modèle, car les échantillons exclus étaient relativement peu significatifs pour le modèle. Dans le tableau suivant, nous présentons un ensemble de résultats expérimentaux démontrant l’amélioration des performances possibles avec le tri intelligent de SageMaker.

Dans le tableau, la colonne % Accepté indique la proportion de données qui est incluse et utilisée dans la boucle d’entraînement. Une augmentation de ce paramètre modifiable diminue le coût (comme le montre la colonne % Économies d’IMR), mais cela peut également avoir une incidence sur l’exactitude. Le réglage approprié pour % Accepté dépend de votre jeu de données et de votre modèle ; vous devez expérimenter et ajuster ce paramètre pour trouver le meilleur équilibre entre la réduction du coût et l’impact sur l’exactitude.

Aperçu de la solution

Dans les sections suivantes, nous vous guiderons à travers un exemple pratique d’activation du tri intelligent avec une tâche de formation PyTorch sur SageMaker. Si vous souhaitez commencer rapidement, vous pouvez passer aux exemples PyTorch ou PyTorch Lightning.

Prérequis

Nous supposons que vous savez déjà comment former un modèle avec PyTorch ou PyTorch Lightning en utilisant le kit SDK Python SageMaker et la classe Estimator en utilisant SageMaker Deep Learning Containers pour la formation. Sinon, consultez Utilisation du kit SDK Python SageMaker avant de continuer.

Démarrer avec SageMaker Smart Sifting

Dans une tâche de formation PyTorch classique, vous initialisez le DataLoader d’entraînement PyTorch avec votre ensemble de données et d’autres paramètres requis, qui fournit des lots d’entrée au fur et à mesure de la progression de l’entraînement. Pour activer le tri intelligent de vos données d’entraînement, vous utiliserez une nouvelle classe DataLoader : smart_sifting.dataloader.sift_dataloader.SiftingDataloader. Cette classe est utilisée comme une enveloppe par-dessus votre DataLoader PyTorch existant et le processus de formation utilisera plutôt SiftingDataloader pour obtenir des lots d’entrée. Le SiftingDataLoader récupère le lot d’entrée de votre DataLoader PyTorch d’origine, évalue l’importance des échantillons du lot et construit un lot trié avec des échantillons de perte élevée, qui sont ensuite transmis à l’étape d’entraînement. L’enveloppe ressemble au code suivant :

from smart_sifting.dataloader.sift_dataloader import SiftingDataloadertrain_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=BertLoss(),    model=self.model)

Le SiftingDataloader nécessite quelques paramètres supplémentaires pour analyser vos données d’entraînement, que vous pouvez spécifier via le paramètre sift_config. Tout d’abord, créez un objet smart_sifting.sift_config.sift_configs.RelativeProbabilisticSiftConfig. Cet objet contient les configurations configurables et requises beta_value et loss_history_length, qui définissent respectivement la proportion d’échantillons à conserver et la fenêtre d’échantillons à inclure lors de l’évaluation de la perte relative. Notez que, parce que le tri intelligent utilise votre modèle pour définir l’importance de l’échantillon, il peut y avoir des implications négatives si nous utilisons un modèle avec des poids complètement aléatoires. Au lieu de cela, vous pouvez utiliser loss_based_sift_config et un sift_delay pour retarder le processus de tri jusqu’à ce que les poids des paramètres du modèle soient mis à jour au-delà des valeurs aléatoires. (Pour plus de détails, consultez Appliquer le tri intelligent à votre script d’entraînement.) Dans le code suivant, nous définissons sift_config et spécifions beta_value et loss_history_length, ainsi que le retard du démarrage du tri à l’aide de loss_based_sift_config:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfigsift_config = RelativeProbabilisticSiftConfig(    beta_value=3,    loss_history_length=500,    loss_based_sift_config=LossConfig(         sift_config=SiftingBaseConfig(sift_delay=10)    ))

Ensuite, vous devez également inclure un paramètre loss_impl dans l’objet SiftingDataloader. La sélection intelligente fonctionne au niveau de chaque échantillon individuel, et il est crucial d’avoir accès à une méthode de calcul de la perte pour déterminer l’importance de l’échantillon. Vous devez implémenter une méthode de perte de sélection qui renvoie un tenseur nx1, qui contient les valeurs de perte de n échantillons. En général, vous spécifiez la même méthode de perte utilisée par votre model lors de la formation. Enfin, incluez un pointeur vers votre modèle dans l’objet SiftingDataloader, qui est utilisé pour évaluer les échantillons avant qu’ils ne soient inclus dans la formation. Voici le code suivant:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig## Définition de la perte de sélectionclass SiftBertLoss(Loss):    # Vous devez ajouter la fonction d'initialisation suivante     # pour calculer la perte par échantillon, pas par lot.    def __init__(self):        self.celoss = torch.nn.CrossEntropyLoss(reduction='none')    def loss(            self,            model: torch.nn.Module,            transformed_batch: SiftingBatch,            original_batch: Any = None,    ) -> torch.Tensor:            device = next(model.parameters()).device        batch = [t.to(device) for t in original_batch]        # calculer la perte        outputs = model(batch)        return self.celoss(outputs.logits, batch[2])........train_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=SiftBertLoss(),    model=self.model)

Le code suivant montre un exemple complet d’activation de la sélection intelligente avec un travail d’entraînement BERT existant:

from smart_sifting.dataloader.sift_dataloader import SiftingDataloaderfrom smart_sifting.loss.abstract_sift_loss_module import Lossfrom smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig.........## Définition de la perte de sélectionclass SiftBertLoss(Loss):    # Vous devez ajouter la fonction d'initialisation suivante     # pour calculer la perte par échantillon, pas par lot.    def __init__(self):        self.celoss = torch.nn.CrossEntropyLoss(reduction='none')    def loss(            self,            model: torch.nn.Module,            transformed_batch: SiftingBatch,            original_batch: Any = None,    ) -> torch.Tensor:            device = next(model.parameters()).device        batch = [t.to(device) for t in original_batch]        # calculer la perte        outputs = model(batch)        return self.celoss(outputs.logits, batch[2])              .... .... ....  sift_config = RelativeProbabilisticSiftConfig(    beta_value=3,    loss_history_length=500,    loss_based_sift_config=LossConfig(        sift_config=SiftingBaseConfig(sift_delay=10)    ))train_dataloader =  SiftingDataloader(    sift_config = sift_config,    orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True),    loss_impl=SiftBertLoss(),    model=self.model)......# utiliser train_dataloader dans le reste de la logique d'entraînement.

Conclusion

Dans cet article, nous avons exploré la prévisualisation publique de la sélection intelligente, une nouvelle fonctionnalité de SageMaker qui peut réduire les coûts de formation des modèles d’apprentissage profond jusqu’à 35 %. Cette fonctionnalité améliore l’efficacité des données lors de la formation en filtrant les échantillons de données moins informatifs. En ne sélectionnant que les données les plus impactantes pour la convergence du modèle, vous pouvez réduire considérablement le temps et les coûts de formation, tout en maintenant la précision. De plus, il s’intègre parfaitement à vos processus existants sans nécessiter de modifications de vos données ou de votre pipeline de formation.

Pour approfondir la sélection intelligente de SageMaker, découvrir son fonctionnement et l’implémenter avec des charges de travail d’entraînement PyTorch, consultez notre documentation et nos notebooks d’exemples et commencez avec cette nouvelle fonctionnalité.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

AI

Apprentissage tout au long de la vie au niveau de l'Edge

Apprendre à ne pas oublier est une compétence cruciale.

Science des données

Les 4 meilleurs graphiques en apprentissage automatique.

Dans le monde dynamique de l'apprentissage automatique, les visualisations jouent un rôle essentiel. Ce sont les narr...

AI

Des chercheurs chinois présentent ImageBind-LLM une méthode d'ajustement d'instructions multi-modalités pour les modèles de langage larges (LLMs) via ImageBind.

Les chercheurs ont récemment observé des améliorations significatives dans l’ajustement des modèles de langage ...

AI

Entropie de l'IA Le cercle vicieux du contenu généré par l'IA

Imaginez si vous pouviez vous cloner pour être à plusieurs endroits à la fois, gérant toutes vos responsabilités sans...

AI

La création d'un ChatGPT spécifique à l'entreprise est composée d'un tiers de technologie et de deux tiers d'améliorations de processus.

Tout au long de 2023, nous avons développé un assistant virtuel basé sur le modèle GPT pour les employés d'Enefit (l'...