Réglage fin distribué d'un grand modèle BERT pour une tâche de question-réponse à l'aide de transformateurs de visage étreignant sur Amazon SageMaker

Republié par Platon

Suiveurs: 0

De la formation de nouveaux modèles à leur déploiement en production, Amazon Sage Maker offre l'ensemble d'outils le plus complet pour les startups et les entreprises afin d'exploiter la puissance de l'apprentissage automatique (ML) et de l'apprentissage en profondeur.

Avec sa bibliothèque open source Transformers et sa plate-forme ML, Hugging Face rend l'apprentissage par transfert et les derniers modèles ML accessibles à la communauté mondiale de l'IA, réduisant ainsi le temps nécessaire aux scientifiques des données et aux ingénieurs ML dans les entreprises du monde entier pour tirer parti de chaque nouvelle science avancement.

L'application de Transformers à de nouvelles tâches ou à de nouveaux domaines de PNL nécessite un réglage fin de grands modèles de langage, une technique tirant parti des connaissances accumulées de modèles pré-formés pour les adapter à une nouvelle tâche ou à un type spécifique de documents dans un processus de formation supplémentaire et efficace.

Le réglage fin du modèle pour produire des prédictions précises pour le problème métier en question nécessite la formation de grands modèles Transformers, par exemple, BERT, BART, RoBERTa, T5, qui peuvent être difficiles à réaliser de manière évolutive.

Hugging Face a travaillé en étroite collaboration avec SageMaker pour livrer Conteneurs de Deep Learning prêts à l'emploi (DLC) qui rendent la formation et le déploiement des derniers modèles Transformers plus faciles et plus rapides que jamais. Étant donné que des fonctionnalités telles que SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), le mode canal S3, sont intégrées dans le conteneur, leur utilisation réduit considérablement le temps nécessaire aux entreprises pour créer des solutions ML basées sur Transformers telles que la réponse aux questions, la génération texte et images, optimisant les résultats de recherche et améliorant l'automatisation du support client, les interfaces conversationnelles, la recherche sémantique, les analyses de documents et bien d'autres applications.

Dans cet article, nous nous concentrons sur l'intégration profonde des bibliothèques distribuées SageMaker avec Hugging Face, qui permet aux scientifiques des données d'accélérer la formation et le réglage fin des modèles Transformers de quelques jours à quelques heures, le tout dans SageMaker.

Présentation de la formation distribuée

Les praticiens du ML et les scientifiques des données sont confrontés à deux défis de mise à l'échelle lors de la formation des modèles : la mise à l'échelle de la taille du modèle (nombre de paramètres et de couches) et la mise à l'échelle des données de formation. La mise à l'échelle de la taille du modèle ou des données de formation peut entraîner une meilleure précision, mais il peut y avoir des cas dans l'apprentissage en profondeur où la quantité de mémoire sur l'accélérateur (CPU ou GPU) limite la combinaison de la taille des données de formation et de la taille du maquette. Par exemple, lors de la formation d'un grand modèle de langage, la taille du lot est souvent limitée à un petit nombre d'échantillons, ce qui peut entraîner un modèle moins précis.

La formation distribuée peut diviser la charge de travail pour former le modèle entre plusieurs processeurs, appelés ouvriers. Ces ouvriers opèrent en parallèle pour accélérer la formation des modèles.

En fonction de ce que nous voulons mettre à l'échelle (modèle ou données), il existe deux approches de la formation distribuée : données parallèles et modèle parallèle.

Le parallèle de données est l'approche la plus courante de la formation distribuée. Le parallélisme des données consiste à créer une copie de l'architecture du modèle et des pondérations sur différents accélérateurs. Ensuite, plutôt que de transmettre l'intégralité de l'ensemble d'apprentissage à un seul accélérateur, nous pouvons répartir l'ensemble d'apprentissage entre les différents accélérateurs et parcourir l'ensemble d'apprentissage plus rapidement. Bien que cela ajoute l'étape des accélérateurs qui doivent communiquer leurs informations de gradient à un serveur de paramètres, ce temps est plus que compensé par l'accélération de la vitesse d'itération sur une fraction de l'ensemble de données par accélérateur. Pour cette raison, le parallélisme des données peut considérablement aider à réduire les temps de formation. Par exemple, la formation d'un seul modèle sans parallélisation prend 4 heures. L'utilisation de la formation distribuée peut réduire cela à 24 minutes. La formation distribuée SageMaker met également en œuvre des techniques de pointe dans les mises à jour de gradient.

Une approche parallèle de modèles est utilisée avec de grands modèles trop volumineux pour tenir sur un seul accélérateur (GPU). Cette approche met en œuvre une stratégie de parallélisation où l'architecture du modèle est divisée en fragments et placée sur différents accélérateurs. La configuration de chacun de ces fragments dépend de l'architecture du réseau neuronal et comprend généralement plusieurs couches. La communication entre les accélérateurs se produit chaque fois que les données d'apprentissage passent d'une des partitions à la suivante.

Pour résumer, vous devez utiliser le parallélisme des données de formation distribuées pour les tâches chronophages en raison de grands ensembles de données ou lorsque vous souhaitez accélérer vos expériences de formation. Vous devez utiliser le parallélisme des modèles lorsque votre modèle ne peut pas tenir sur un seul accélérateur.

Pré-requis

Pour effectuer une formation distribuée des modèles Hugging Face Transformers dans SageMaker, vous devez remplir les conditions préalables suivantes :

Mettre en œuvre une formation distribuée

La bibliothèque Hugging Face Transformers fournit une API Trainer optimisée pour former ou affiner les modèles fournis par la bibliothèque. Vous pouvez également l'utiliser sur vos propres modèles s'ils fonctionnent de la même manière que les modèles Transformers ; voir Entraîneur pour plus de détails. Cette API est utilisée dans notre exemples de scripts, qui montrent comment prétraiter les données pour diverses tâches NLP, que vous pouvez prendre comme modèles pour écrire un script résolvant votre propre problème personnalisé. La promesse de l'API Trainer est que ce script fonctionne immédiatement sur n'importe quelle configuration distribuée, y compris SageMaker.

L'API Trainer prend tout le nécessaire pour la formation. Cela inclut vos ensembles de données, votre modèle (ou une fonction qui renvoie votre modèle), un compute_metrics fonction qui renvoie les métriques que vous souhaitez suivre à partir des tableaux de prédications et d'étiquettes, votre optimiseur et votre planificateur de taux d'apprentissage (de bons paramètres par défaut sont fournis), ainsi que tous les hyperparamètres que vous pouvez régler pour votre formation regroupés dans une classe de données appelée TrainingArguments. Avec tout cela, il expose trois méthodes - former, évaluer et prédire - pour former votre modèle, obtenir les résultats métriques sur n'importe quel ensemble de données ou obtenir les prédictions sur n'importe quel ensemble de données. Pour en savoir plus sur l'objet Trainer, reportez-vous à Affiner un modèle avec l'API Trainer et la vidéo L'API du formateur, qui vous guide à travers un exemple simple.

Dans les coulisses, l'API Trainer commence par analyser l'environnement dans lequel vous lancez votre script lorsque vous créez le TrainingArguments. Par exemple, si vous avez lancé votre formation avec SageMaker, il examine les SM_FRAMEWORK_PARAMS variable dans l'environnement pour détecter si vous avez activé le parallélisme des données SageMaker ou le parallélisme des modèles. Ensuite, il obtient les variables pertinentes (telles que le rang du processus ou la taille du monde) de l'environnement avant d'effectuer les étapes d'initialisation nécessaires (telles que smdistributed.dataparallel.torch.distributed.init_process_group()).

Le formateur contient toute la boucle de formation, il peut donc ajuster les étapes nécessaires pour s'assurer que le smdistributed.dataparallel backend est utilisé lorsque cela est nécessaire sans que vous ayez à modifier une ligne de code dans votre script. Il peut toujours s'exécuter (bien que beaucoup plus lentement) sur votre machine locale pour le débogage. Il gère le partage de votre ensemble de données de sorte que chaque processus voit automatiquement différents échantillons, avec un remaniement à chaque époque, la synchronisation de vos gradients avant l'étape d'optimisation, l'entraînement de précision mixte si vous l'avez activé, l'accumulation de gradient si vous ne pouvez pas adapter une grande taille de lot sur vos GPU, et bien d'autres optimisations.

Si vous avez activé le parallélisme des modèles, il s'assure que les processus qui doivent voir les mêmes données (si leurs dp_rank est le même) obtenir les mêmes lots, et qui traite avec différents dp_rank ne voyez pas les mêmes échantillons, encore une fois avec un remaniement à chaque époque. Il s'assure que les dictionnaires d'état du modèle ou des optimiseurs sont correctement synchronisés lors du point de contrôle, et gère à nouveau toutes les optimisations telles que la précision mixte et l'accumulation de gradient.

Lors de l'utilisation des méthodes d'évaluation et de prédiction, le formateur effectue une évaluation distribuée, pour tirer parti de tous vos GPU. Il gère correctement le fractionnement de vos données pour chaque processus (processus du même dp_rank si le parallélisme des modèles est activé) et s'assure que les prédictions sont correctement rassemblées dans le même ordre que l'ensemble de données que vous utilisez avant qu'elles ne soient envoyées au compute_metrics fonction ou vient de revenir. L'utilisation de l'API Trainer n'est pas obligatoire. Les utilisateurs peuvent toujours utiliser Keras ou PyTorch dans Hugging Face. Cependant, l'API Trainer peut fournir une couche d'abstraction utile.

Entraîner un modèle à l'aide des estimateurs de visage étreignant SageMaker

Un estimateur est une interface de haut niveau pour la formation SageMaker et gère les tâches de formation et de déploiement SageMaker de bout en bout. La formation de votre script est invoquée lorsque vous appelez fit sur un HuggingFace Estimateur. Dans l'estimateur, vous définissez le script de réglage fin à utiliser comme entry_point, Qui instance_type à utiliser et quels hyperparamètres sont transmis. Pour plus d'informations sur HuggingFace paramètres, voir Estimateur de visage étreignant.

Formation distribuée : données parallèles

Dans cet exemple, nous utilisons les nouveaux DLC Hugging Face et SageMaker SDK pour former un modèle Seq2Seq-transformer distribué sur la tâche de question et de réponse à l'aide des bibliothèques Transformers et d'ensembles de données. La bert-large-masquage-de-mots-entiers-sans-casque le modèle est affiné sur le équipe jeu de données.

Les exemples de code suivants vous montrent les étapes de création d'un HuggingFace estimateur pour l'apprentissage distribué avec parallélisme des données.

Choisissez un script Hugging Face Transformers :

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

Lorsque vous créez un HuggingFace Estimator, vous pouvez spécifier un script de formation qui est stocké dans un référentiel GitHub comme point d'entrée pour l'Estimator, de sorte que vous n'ayez pas à télécharger les scripts localement. Vous pouvez utiliser git_config pour exécuter les scripts d'exemples de Hugging Face Transformers et la "branche" droite si votre transformers_version doit être configuré. Par exemple, si vous utilisez transformers_version 4.6.1, vous devez utiliser 'branch':'v4.6.1'.

Configurez les hyperparamètres d'entraînement qui sont transmis à la tâche d'entraînement :

# hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
}

En tant qu'hyperparamètre, nous pouvons définir n'importe quel Seq2SeqTrainingArguments et ceux définis dans le script de formation.

Définissez les paramètres de distribution dans le HuggingFace Estimateur:

# configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

Vous pouvez utiliser le Bibliothèque de parallélisme de données SageMaker prêt à l'emploi pour une formation distribuée. Nous avons ajouté la fonctionnalité de parallélisme des données directement dans le Trainer. Pour activer le parallélisme des données, vous pouvez simplement ajouter un seul paramètre à votre HuggingFace Estimator pour permettre à votre code basé sur Trainer de l'utiliser automatiquement.

Créer un HuggingFace Estimateur incluant les paramètres définis dans les étapes précédentes et démarrage de l'entraînement :

from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

Les Référentiel Hugging Face Transformers contient plusieurs exemples et scripts pour affiner les modèles sur des tâches allant de la modélisation du langage à la classification des jetons. Dans notre cas, nous utilisons run_qa.py du examples/pytorch/question-answering exemples.

smdistributed.dataparallel prend en charge la formation de modèles sur SageMaker avec les types d'instance suivants uniquement. Pour de meilleures performances, nous vous recommandons d'utiliser un type d'instance qui prend en charge Adaptateur en tissu élastique (ALE):

ml.p3.16xlarge
ml.p3dn.24xlarge (recommandé)
ml.p4d.24xlarge (recommandé)

Pour obtenir les meilleures performances et tirer le meilleur parti de SMDataParallel, vous devez utiliser au moins deux instances, mais vous pouvez également en utiliser une pour tester cet exemple.

exemple de cahier fournit des conseils étape par étape plus détaillés.

Entraînement distribué : modèle parallèle

Pour la formation distribuée avec le parallélisme des modèles, nous utilisons la bibliothèque Hugging Face Transformers et les ensembles de données avec le SDK SageMaker pour la classification des séquences sur le Évaluation de la compréhension générale du langage (GLUE) benchmark sur un cluster multi-nœuds et multi-GPU en utilisant le bibliothèque de parallélisme de modèles SageMaker.

Comme pour le parallélisme des données, nous définissons d'abord la configuration de git, les hyperparamètres d'entraînement et les paramètres de distribution dans le HuggingFace Estimateur:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

La bibliothèque de parallélisme de modèle utilise en interne MPI, donc pour utiliser le parallélisme de modèle, MPI doit être activé à l'aide du paramètre de distribution. "processes_per_host” dans le code précédent spécifie le nombre de processus que MPI doit lancer sur chaque hôte. Nous les suggérons pour le développement et les tests. Au moment de la production, vous pouvez contacter AWS Support si vous demandez une capacité GPU étendue. Pour plus d'informations, voir Exécuter une tâche de formation parallèle de modèle distribué SageMaker.

exemple de cahier contient les scripts de code complets.

Instances ponctuelles

Avec l'extension de framework Hugging Face pour le SDK SageMaker Python, nous pouvons également profiter d'une gestion entièrement gérée Cloud de calcul élastique Amazon (Amazon EC2) Instances ponctuelles et économisez jusqu'à 90% de nos coûts de formation.

À moins que votre travail de formation ne se termine rapidement, nous vous recommandons d'utiliser point de contrôle avec une formation ponctuelle gérée, vous devez donc définir checkpoint_s3_uri.

Pour utiliser des instances ponctuelles avec le HuggingFace Estimateur, nous devons fixer le use_spot_instances paramètre sur True et définissez votre max_wait ainsi que max_run temps. Pour plus d'informations sur le cycle de vie de la formation ponctuelle gérée, consultez Formation ponctuelle gérée dans Amazon SageMaker.

Voici un extrait de code permettant de configurer un estimateur d'entraînement ponctuel :

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

cahier contient les scripts de code complets.

Conclusion

Dans cet article, nous avons discuté de la formation distribuée de Hugging Face Transformers à l'aide de SageMaker. Nous avons d'abord examiné les cas d'utilisation du parallélisme des données par rapport au parallélisme des modèles. Le parallélisme des données est généralement plus approprié, mais pas nécessairement limité, lorsque la formation est entravée par le calcul, tandis que vous pouvez utiliser le parallélisme des modèles lorsqu'un modèle ne peut pas tenir dans la mémoire fournie sur un seul accélérateur. Nous avons ensuite montré comment s'entraîner avec les deux méthodes.

Dans le cas d'utilisation du parallélisme des données dont nous avons discuté, la formation d'un modèle sur une seule instance p3.2xlarge (avec un seul GPU) prend 4 heures et coûte environ 15 $ au moment de la rédaction de cet article. Avec le parallélisme des données, nous pouvons former le même modèle en 24 minutes pour un coût de 28 $. Bien que le coût ait doublé, cela a réduit le temps de formation d'un facteur 10. Dans une situation où vous devez former de nombreux modèles dans un court laps de temps, le parallélisme des données peut permettre cela à une augmentation de coût relativement faible. Quant au cas d'utilisation du parallélisme de modèles, il ajoute la possibilité de former des modèles qui n'auraient pas pu être formés auparavant en raison de limitations matérielles. Les deux fonctionnalités permettent de nouveaux flux de travail pour les praticiens du ML et sont facilement accessibles via le HuggingFace Estimator dans le cadre du SDK SageMaker Python. Le déploiement de ces modèles sur des terminaux hébergés suit la même procédure que pour les autres estimateurs.

Cette intégration active d'autres fonctionnalités qui font partie de l'écosystème SageMaker. Par exemple, vous pouvez utiliser des instances ponctuelles en ajoutant un simple indicateur à l'estimateur pour une optimisation supplémentaire des coûts. Dans l'étape suivante, vous pouvez trouver et exécuter le démo de formation ainsi que exemple de cahier.

À propos des auteurs

Archis Joglekar est un architecte de solutions partenaires IA/ML au sein de l'équipe Technologies émergentes. Il s'intéresse à l'apprentissage en profondeur performant et évolutif et au calcul scientifique en utilisant les blocs de construction d'AWS. Ses expériences passées vont de la recherche en physique informatique au développement de plateformes d'apprentissage automatique dans les universités, les laboratoires nationaux et les startups. Il passe son temps loin de l'ordinateur à jouer au football, avec ses amis et sa famille.

James Yi est un architecte principal de solutions partenaires AI/ML au sein de l'équipe Emerging Technologies d'Amazon Web Services. Il est passionné par le fait de travailler avec des entreprises clientes et des partenaires pour concevoir, déployer et mettre à l'échelle des applications AI/ML afin de dériver leurs valeurs commerciales. En dehors du travail, il aime jouer au football, voyager et passer du temps avec sa famille.

Philippe Schmid est ingénieur en apprentissage automatique et responsable technique chez Hugging Face, où il dirige la collaboration avec l'équipe Amazon SageMaker. Il est passionné par la démocratisation, l'optimisation et la production de modèles NLP de pointe et l'amélioration de la facilité d'utilisation du Deep Learning.

Sylvain Guger est ingénieur de recherche chez Hugging Face et l'un des principaux mainteneurs de la bibliothèque Transformers. Il aime les logiciels open source et aide la communauté à les utiliser.

Jeff Boudier construit des produits chez Hugging Face, créateur de Transformers, la principale bibliothèque de ML open source. Auparavant, Jeff était co-fondateur de Stupeflix, acquis par GoPro, où il a occupé le poste de directeur de la gestion des produits, du marketing des produits, du développement commercial et du développement de l'entreprise.