Gedistribueerde fijnafstemming van een BERT Large-model voor een vraagbeantwoordingstaak met behulp van Hugging Face Transformers op Amazon SageMaker

Van het trainen van nieuwe modellen tot het inzetten ervan in productie, Amazon Sage Maker biedt de meest complete set tools voor startups en ondernemingen om de kracht van machine learning (ML) en Deep Learning te benutten.

Met zijn Transformers open-sourcebibliotheek en ML-platform maakt Hugging Face overdrachtsleren en de nieuwste ML-modellen toegankelijk voor de wereldwijde AI-gemeenschap, waardoor datawetenschappers en ML-ingenieurs in bedrijven over de hele wereld minder tijd nodig hebben om te profiteren van elke nieuwe wetenschappelijke vooruitgang.

Het toepassen van Transformers op nieuwe NLP-taken of -domeinen vereist fijnafstemming van grote taalmodellen, een techniek die gebruikmaakt van de opgebouwde kennis van vooraf getrainde modellen om ze aan te passen aan een nieuwe taak of specifiek type documenten in een aanvullend, efficiënt trainingsproces.

Het verfijnen van het model om nauwkeurige voorspellingen te produceren voor het betreffende zakelijke probleem vereist de training van grote Transformers-modellen, bijvoorbeeld BERT, BART, RoBERTa, T5, die een uitdaging kunnen zijn om op een schaalbare manier te presteren.

Hugging Face heeft nauw samengewerkt met SageMaker om te leveren kant-en-klare deep learning-containers (DLC's) die het trainen en implementeren van de nieuwste Transformers-modellen eenvoudiger en sneller dan ooit maken. Omdat functies zoals SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), S3 pipe-modus in de container zijn geïntegreerd, verkort het gebruik hiervan drastisch de tijd voor bedrijven om op Transformers gebaseerde ML-oplossingen te creëren, zoals het beantwoorden van vragen, het genereren van tekst en afbeeldingen, het optimaliseren van zoekresultaten en het verbeteren van de automatisering van klantenondersteuning, conversatie-interfaces, semantisch zoeken, documentanalyses en nog veel meer toepassingen.

In dit bericht richten we ons op de diepe integratie van door SageMaker gedistribueerde bibliotheken met Hugging Face, waardoor datawetenschappers de training en fijnafstemming van Transformers-modellen van dagen tot uren kunnen versnellen, allemaal in SageMaker.

Overzicht van gedistribueerde training

ML-beoefenaars en datawetenschappers staan ​​voor twee schaaluitdagingen bij het trainen van modellen: schaalmodelgrootte (aantal parameters en lagen) en schaaltrainingsgegevens. Het schalen van de modelgrootte of trainingsgegevens kan resulteren in een betere nauwkeurigheid, maar er kunnen gevallen zijn bij diep leren waarbij de hoeveelheid geheugen op de accelerator (CPU of GPU) de combinatie van de grootte van de trainingsgegevens en de grootte van de model. Bij het trainen van een groot taalmodel is de batchgrootte bijvoorbeeld vaak beperkt tot een klein aantal voorbeelden, wat kan resulteren in een minder nauwkeurig model.

Gedistribueerde training kan de werklast verdelen om het model te trainen over meerdere processors, genaamd werknemers. Deze werknemers werken parallel om modeltraining te versnellen.

Op basis van wat we willen schalen (model of data) zijn er twee benaderingen voor gedistribueerde training: gegevensparallel en modelparallel.

Gegevensparallel is de meest gebruikelijke benadering van gedistribueerde training. Gegevensparallellisme houdt in dat er een kopie van de modelarchitectuur en gewichten op verschillende versnellers wordt gemaakt. Dan kunnen we, in plaats van de hele trainingsset door te geven aan een enkele accelerator, de trainingsset verdelen over de verschillende accelerators en sneller door de trainingsset heen komen. Hoewel dit de stap toevoegt van de versnellers die hun gradiëntinformatie terug moeten communiceren naar een parameterserver, wordt deze tijd ruimschoots gecompenseerd door de snelheidsboost van het itereren over een fractie van de volledige dataset per versneller. Hierdoor kan gegevensparallellisme de trainingstijd aanzienlijk helpen verkorten. Het trainen van een enkel model zonder parallellisatie duurt bijvoorbeeld 4 uur. Het gebruik van gedistribueerde training kan dat terugbrengen tot 24 minuten. SageMaker gedistribueerde training implementeert ook geavanceerde technieken in gradiëntupdates.

Een modelparallelle benadering wordt gebruikt bij grote modellen die te groot zijn om op één versneller (GPU) te passen. Deze benadering implementeert een parallellisatiestrategie waarbij de modelarchitectuur wordt verdeeld in scherven en op verschillende versnellers wordt geplaatst. De configuratie van elk van deze shards is afhankelijk van de architectuur van het neurale netwerk en omvat doorgaans meerdere lagen. De communicatie tussen de versnellers vindt plaats telkens wanneer de trainingsgegevens van een van de scherven naar de volgende gaan.

Samengevat: u moet gedistribueerde trainingsgegevens parallellisme gebruiken voor tijdintensieve taken als gevolg van grote datasets of wanneer u uw trainingsexperimenten wilt versnellen. U moet modelparallelisme gebruiken wanneer uw model niet op één versneller past.

Voorwaarden

Om gedistribueerde training van Hugging Face Transformers-modellen in SageMaker uit te voeren, moet u aan de volgende vereisten voldoen:

Implementeer gedistribueerde training

De Hugging Face Transformers-bibliotheek biedt een Trainer-API die is geoptimaliseerd voor het trainen of verfijnen van de modellen die de bibliotheek biedt. Je kunt het ook op je eigen modellen gebruiken als ze op dezelfde manier werken als Transformers-modellen; zien Trainer voor meer details. Deze API wordt gebruikt in onze voorbeeld scripts, die laten zien hoe de gegevens voor verschillende NLP-taken moeten worden voorbewerkt, die u als model kunt gebruiken om een ​​script te schrijven dat uw eigen aangepaste probleem oplost. De belofte van de Trainer API is dat dit script direct werkt op elke gedistribueerde setup, inclusief SageMaker.

De Trainer API neemt alles wat nodig is voor de training. Dit omvat uw datasets, uw model (of een functie die uw model retourneert), a compute_metrics functie die de metrische gegevens retourneert die u wilt volgen uit de arrays van voorspellingen en labels, uw optimalisatie en leersnelheidsplanner (goede standaardwaarden zijn aanwezig), evenals alle hyperparameters die u kunt afstemmen voor uw training gegroepeerd in een gegevensklasse genaamd TrainingArguments. Met dat alles legt het drie methoden bloot - trainen, evalueren en voorspellen - om uw model te trainen, de metrische resultaten voor elke dataset te krijgen of de voorspellingen voor elke dataset te krijgen. Raadpleeg voor meer informatie over het Trainer-object Een model verfijnen met de Trainer API en de video De Trainer-API, die u door een eenvoudig voorbeeld leidt.

Achter de schermen begint de Trainer API met het analyseren van de omgeving waarin u uw script start wanneer u de TrainingArguments. Als je bijvoorbeeld je training met SageMaker hebt gelanceerd, kijkt het naar de SM_FRAMEWORK_PARAMS variabele in de omgeving om te detecteren of u SageMaker-gegevensparallelisme of modelparallellisme hebt ingeschakeld. Vervolgens haalt het de relevante variabelen (zoals de rang van het proces of de wereldomvang) uit de omgeving voordat het de noodzakelijke initialisatiestappen uitvoert (zoals smdistributed.dataparallel.torch.distributed.init_process_group()).

De Trainer bevat de hele trainingslus, zodat hij de nodige stappen kan aanpassen om ervoor te zorgen dat de smdistributed.dataparallel backend wordt indien nodig gebruikt zonder dat u een regel code in uw script hoeft te wijzigen. Het kan nog steeds worden uitgevoerd (zij het veel langzamer) op uw lokale computer voor foutopsporing. Het zorgt voor het sharden van uw dataset zodat elk proces automatisch verschillende samples ziet, met een herschikking bij elk tijdvak, het synchroniseren van uw gradiënten vóór de optimalisatiestap, gemengde precisietraining als u het activeert, gradiëntaccumulatie als u geen grote batchgrootte op kunt passen uw GPU's en nog veel meer optimalisaties.

Als je model parallellisme hebt geactiveerd, zorgt het ervoor dat de processen die dezelfde gegevens moeten zien (als hun dp_rank is hetzelfde) krijgen dezelfde batches, en dat verwerkt met verschillende dp_rank zie niet dezelfde voorbeelden, opnieuw met een herschikking bij elk tijdvak. Het zorgt ervoor dat de toestandswoordenboeken van het model of de optimalisatieprogramma's correct worden gesynchroniseerd bij het checkpointen, en verwerkt opnieuw alle optimalisaties, zoals gemengde precisie en gradiëntaccumulatie.

Bij gebruik van de evaluatie- en voorspellingsmethoden voert de Trainer een gedistribueerde evaluatie uit om te profiteren van al uw GPU's. Het zorgt ervoor dat uw gegevens voor elk proces correct worden gesplitst (proces van hetzelfde dp_rank als model parallellisme is geactiveerd) en zorgt ervoor dat de voorspellingen correct worden verzameld in dezelfde volgorde als de dataset die u gebruikt voordat ze naar de compute_metrics functie of net terug. Het gebruik van de Trainer API is niet verplicht. Gebruikers kunnen Keras of PyTorch nog steeds gebruiken binnen Hugging Face. De Trainer API kan echter een nuttige abstractielaag bieden.

Train een model met SageMaker Hugging Face Estimators

Een Estimator is een interface op hoog niveau voor SageMaker-training en voert end-to-end SageMaker-trainings- en implementatietaken uit. De training van uw script wordt aangeroepen wanneer u belt fit een HuggingFace schatter. In de Estimator definieert u als welk finetuningscript u wilt gebruiken entry_point, welke instance_type te gebruiken en welke hyperparameters worden doorgegeven. Voor meer informatie over HuggingFace parameters, zie Knuffelende Gezichtsschatter.

Gedistribueerde training: Gegevensparallel

In dit voorbeeld gebruiken we de nieuwe Hugging Face DLC's en SageMaker SDK om een ​​gedistribueerd Seq2Seq-transformatormodel te trainen op de vraag- en antwoordtaak met behulp van de Transformers- en datasets-bibliotheken. De bert-grote-uncased-hele-woord-maskering model is verfijnd op de squad gegevensset.

De volgende codevoorbeelden tonen u de stappen voor het maken van een HuggingFace schatter voor gedistribueerde training met gegevensparallellisme.

1. Kies een Hugging Face Transformers-script:

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

Wanneer u een HuggingFace Estimator kunt u een trainingsscript opgeven dat is opgeslagen in een GitHub-repository als toegangspunt voor de Estimator, zodat u de scripts niet lokaal hoeft te downloaden. Je kunt gebruiken git_config om de Hugging Face Transformers-voorbeeldscripts uit te voeren en rechts 'branch' als je transformers_version moet worden geconfigureerd. Als u bijvoorbeeld gebruikt transformers_version 4.6.1, je moet 'branch':'v4.6.1'.

2. Configureer trainingshyperparameters die worden doorgegeven aan de trainingstaak:

   # 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'
   }

Als hyperparameter kunnen we elke definiëren Seq2SeqTrainingargumenten en degene die zijn gedefinieerd in het trainingsscript.

3. Definieer de distributieparameters in de HuggingFace Schatter:

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

U kunt gebruik maken van de SageMaker-gegevensparallellisme-bibliotheek uit de doos voor gedistribueerde training. We hebben de functionaliteit van gegevensparallelisme rechtstreeks in de Trainer toegevoegd. Om gegevensparallellisme mogelijk te maken, kunt u eenvoudig een enkele parameter toevoegen aan uw HuggingFace Estimator om uw op Trainer gebaseerde code deze automatisch te laten gebruiken.

4. Maak een HuggingFace Estimator inclusief parameters gedefinieerd in vorige stappen en start training:

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()

De Hugging Face Transformers-repository bevat verschillende voorbeelden en scripts voor het verfijnen van modellen voor taken van taalmodellering tot tokenclassificatie. In ons geval gebruiken we run_qa.py van het examples/pytorch/question-answering voorbeelden.

smdistributed.dataparallel ondersteunt modeltraining op SageMaker met alleen de volgende instantietypen. Voor de beste prestaties raden we aan een instantietype te gebruiken dat ondersteuning biedt Elastische stofadapter (EFA):

• ml.p3.16xgroot
• ml.p3dn.24xlarge (aanbevolen)
• ml.p4d.24xlarge (aanbevolen)

Om de beste prestaties en het maximale eruit te halen SMDataParallel, moet u ten minste twee instanties gebruiken, maar u kunt er ook een gebruiken om dit voorbeeld te testen.

De volgende voorbeeld notebook biedt meer gedetailleerde stapsgewijze begeleiding.

Gedistribueerde training: parallel modelleren

Voor gedistribueerde training met modelparallellisme gebruiken we de Hugging Face Transformers en datasets-bibliotheek samen met de SageMaker SDK voor sequentieclassificatie op de Algemene taalbegripevaluatie (LIJM) benchmark op een cluster met meerdere knooppunten en meerdere GPU's met behulp van de SageMaker-modelparallelismebibliotheek.

Net als bij gegevensparallellisme, stellen we eerst de git-configuratie, trainingshyperparameters en distributieparameters in de HuggingFace Schatter:

# 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
}

De modelparallelismebibliotheek gebruikt intern MPI, dus om modelparallelisme te gebruiken, moet MPI worden ingeschakeld met behulp van de distributieparameter. “processes_per_host” in de voorgaande code specificeert het aantal processen dat MPI op elke host moet starten. We raden deze aan voor ontwikkeling en testen. Tijdens de productie kunt u contact opnemen met AWS Support als u uitgebreide GPU-capaciteit aanvraagt. Voor meer informatie, zie Voer een SageMaker gedistribueerde model parallelle trainingstaak uit.

De volgende voorbeeld notebook bevat de volledige codescripts.

Spotinstanties

Met de Hugging Face-frameworkextensie voor de SageMaker Python SDK kunnen we ook profiteren van volledig beheerd Amazon Elastic Compute-cloud (Amazone EC2) Spotinstanties en bespaar tot 90% op onze trainingskosten.

Tenzij uw trainingstaak snel zal worden voltooid, raden we u aan om te gebruiken controlepunt met beheerde spottraining, daarom moet u definiëren checkpoint_s3_uri.

Om Spot-exemplaren te gebruiken met de HuggingFace Schatter, we moeten de use_spot_instances parameter naar True en definieer uw max_wait en max_run tijd. Zie voor meer informatie over de levenscyclus van beheerde spottraining Managed Spot-training in Amazon SageMaker.

Het volgende is een codefragment voor het opzetten van een Spot Training Estimator:

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)

De volgende notitieboekje bevat de volledige codescripts.

Conclusie

In dit bericht hebben we de gedistribueerde training van Hugging Face Transformers met SageMaker besproken. We hebben eerst de use-cases voor gegevensparallelisme versus modelparallellisme bekeken. Gegevensparallellisme is doorgaans geschikter, maar niet noodzakelijkerwijs beperkt tot wanneer training wordt gehinderd door rekenkracht, terwijl u modelparallellisme kunt gebruiken wanneer een model niet past in het geheugen van een enkele accelerator. We hebben toen laten zien hoe je met beide methoden kunt trainen.

In de use case van gegevensparallelisme die we hebben besproken, duurt het trainen van een model op een enkele p3.2xlarge-instantie (met een enkele GPU) 4 uur en kost ongeveer $ 15 op het moment van schrijven. Met gegevensparallellisme kunnen we hetzelfde model in 24 minuten trainen voor $ 28. Hoewel de kosten zijn verdubbeld, heeft dit de trainingstijd met een factor 10 verkort. Voor een situatie waarin u in korte tijd veel modellen moet trainen, kan dataparallellisme dit mogelijk maken tegen een relatief lage kostenstijging. Wat betreft de use case van modelparallelisme, het voegt de mogelijkheid toe om modellen te trainen die eerder helemaal niet getraind konden worden vanwege hardwarebeperkingen. Beide functies maken nieuwe workflows mogelijk voor ML-beoefenaars en zijn gemakkelijk toegankelijk via de HuggingFace Estimator als onderdeel van de SageMaker Python SDK. Het implementeren van deze modellen op gehoste eindpunten volgt dezelfde procedure als voor andere Estimators.

Deze integratie maakt andere functies mogelijk die deel uitmaken van het SageMaker-ecosysteem. U kunt bijvoorbeeld Spot-exemplaren gebruiken door een eenvoudige vlag toe te voegen aan de Estimator voor extra kostenoptimalisatie. Als volgende stap kunt u het trainingsdemo en voorbeeld notebook.

Over de auteurs

Archis Joglekar is een AI/ML Partner Solutions Architect in het Emerging Technologies-team. Hij is geïnteresseerd in performant, schaalbaar deep learning en wetenschappelijk computergebruik met behulp van de bouwstenen van AWS. Zijn eerdere ervaringen variëren van computationeel natuurkundig onderzoek tot de ontwikkeling van machine learning-platforms in de academische wereld, nationale laboratoria en startups. Zijn tijd buiten de computer brengt hij door met voetballen en met vrienden en familie.

James Yi is Sr. AI/ML Partner Solutions Architect in het Emerging Technologies-team bij Amazon Web Services. Hij is gepassioneerd door het werken met zakelijke klanten en partners om AI/ML-applicaties te ontwerpen, implementeren en schalen om hun zakelijke waarden te ontlenen. Naast zijn werk houdt hij van voetballen, reizen en tijd doorbrengen met zijn gezin.

Philippe Schmid is Machine Learning Engineer en Tech Lead bij Hugging Face, waar hij de samenwerking met het Amazon SageMaker-team leidt. Hij heeft een passie voor het democratiseren, optimaliseren en produceren van geavanceerde NLP-modellen en het verbeteren van het gebruiksgemak voor Deep Learning.

Sylvain Gugger is Research Engineer bij Hugging Face en een van de hoofdbeheerders van de Transformers-bibliotheek. Hij houdt van open source software en helpt de gemeenschap deze te gebruiken.

Jef Boudier bouwt producten bij Hugging Face, maker van Transformers, de toonaangevende open-source ML-bibliotheek. Voorheen was Jeff mede-oprichter van Stupeflix, overgenomen door GoPro, waar hij directeur was van Product Management, Product Marketing, Business Development en Corporate Development.

Bron: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- transformatoren-op-amazon-sagemaker/