Distribuerad finjustering av en BERT Large-modell för en frågesvarsuppgift med Hugging Face Transformers på Amazon SageMaker

Från att träna nya modeller till att använda dem i produktionen, Amazon SageMaker erbjuder den mest kompletta uppsättningen verktyg för nystartade företag och företag för att utnyttja kraften i maskininlärning (ML) och Deep Learning.

Med sitt Transformers-bibliotek med öppen källkod och ML-plattform gör Hugging Face överföringsinlärning och de senaste ML-modellerna tillgängliga för den globala AI-gemenskapen, vilket minskar tiden som behövs för datavetare och ML-ingenjörer i företag runt om i världen att dra nytta av varje ny vetenskaplig befordran.

Att tillämpa Transformers på nya NLP-uppgifter eller -domäner kräver finjustering av stora språkmodeller, en teknik som utnyttjar den samlade kunskapen om förutbildade modeller för att anpassa dem till en ny uppgift eller specifik typ av dokument i en ytterligare, effektiv utbildningsprocess.

Att finjustera modellen för att producera korrekta förutsägelser för det aktuella affärsproblemet kräver träning av stora Transformers-modeller, till exempel BERT, BART, RoBERTa, T5, vilket kan vara utmanande att utföra på ett skalbart sätt.

Hugging Face har ett nära samarbete med SageMaker för att leverera färdiga att använda Deep Learning Containers (DLC) som gör utbildning och driftsättning av de senaste Transformers-modellerna enklare och snabbare än någonsin. Eftersom funktioner som SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), S3 pipe mode, är integrerade i behållaren, minskar användningen av dessa drastiskt tiden för företag att skapa Transformers-baserade ML-lösningar såsom frågesvar, generering text och bilder, optimerar sökresultat och förbättrar kundsupportautomation, konversationsgränssnitt, semantisk sökning, dokumentanalyser och många fler applikationer.

I det här inlägget fokuserar vi på den djupa integrationen av SageMakers distribuerade bibliotek med Hugging Face, vilket gör det möjligt för datavetare att påskynda träning och finjustering av Transformers-modeller från dagar till timmar, allt i SageMaker.

Översikt över distribuerad utbildning

ML-utövare och datavetare står inför två skalningsutmaningar när de tränar modeller: skalning av modellstorlek (antal parametrar och lager) och skalning av träningsdata. Skalning av antingen modellstorleken eller träningsdata kan resultera i bättre noggrannhet, men det kan finnas fall vid djupinlärning där mängden minne på acceleratorn (CPU eller GPU) begränsar kombinationen av storleken på träningsdatan och storleken på modell. Till exempel, när man tränar en stor språkmodell, är batchstorleken ofta begränsad till ett litet antal prover, vilket kan resultera i en mindre exakt modell.

Distribuerad utbildning kan dela upp arbetsbelastningen för att träna modellen mellan flera processorer, kallad arbetare. Dessa arbetare arbetar parallellt för att påskynda modellutbildningen.

Baserat på vad vi vill skala (modell eller data) finns det två tillvägagångssätt för distribuerad utbildning: dataparallell och modellparallell.

Dataparallell är den vanligaste metoden för distribuerad utbildning. Dataparallellism innebär att skapa en kopia av modellarkitekturen och vikter på olika acceleratorer. Sedan, istället för att skicka in hela träningssetet till en enda accelerator, kan vi dela upp träningssetet över de olika acceleratorerna och ta oss igenom träningssetet snabbare. Även om detta lägger till steget för acceleratorerna som behöver kommunicera sin gradientinformation tillbaka till en parameterserver, kompenseras denna tid mer än väl av hastighetsökningen med att iterera över en bråkdel av hela datasetet per accelerator. På grund av detta kan dataparallellism avsevärt bidra till att minska träningstiderna. Att träna en enskild modell utan parallellisering tar till exempel 4 timmar. Att använda distribuerad träning kan minska det till 24 minuter. SageMaker distribuerad utbildning implementerar också banbrytande tekniker i gradientuppdateringar.

Ett modellparallellt tillvägagångssätt används med stora modeller för stora för att passa på en accelerator (GPU). Detta tillvägagångssätt implementerar en parallelliseringsstrategi där modellarkitekturen delas upp i skärvor och placeras på olika acceleratorer. Konfigurationen av var och en av dessa skärvor är beroende av neurala nätverksarkitektur och inkluderar vanligtvis flera lager. Kommunikationen mellan acceleratorerna sker varje gång träningsdatan går från en av skärvorna till nästa.

För att sammanfatta bör du använda distribuerad träningsdataparallellism för tidskrävande uppgifter på grund av stora datamängder eller när du vill accelerera dina träningsexperiment. Du bör använda modellparallellism när din modell inte får plats på en gaspedalen.

Förutsättningar

För att utföra distribuerad utbildning av Hugging Face Transformers-modeller i SageMaker måste du uppfylla följande förutsättningar:

Genomföra distribuerad utbildning

Hugging Face Transformers-biblioteket tillhandahåller ett Trainer API som är optimerat för att träna eller finjustera de modeller som biblioteket tillhandahåller. Du kan också använda den på dina egna modeller om de fungerar på samma sätt som Transformers-modeller; ser Tränare för mer detaljer. Detta API används i vår exempelskript, som visar hur man förbearbetar data för olika NLP-uppgifter, som du kan ta som modeller för att skriva ett skript som löser ditt eget anpassade problem. Löftet med Trainer API är att det här skriptet fungerar direkt på alla distribuerade inställningar, inklusive SageMaker.

Trainer API tar allt som behövs för utbildningen. Detta inkluderar dina datauppsättningar, din modell (eller en funktion som returnerar din modell), en compute_metrics funktion som returnerar mätvärdena du vill spåra från matriserna av predikationer och etiketter, din optimerare och inlärningshastighetsschemaläggare (bra standardvärden tillhandahålls), såväl som alla hyperparametrar du kan ställa in för din träning grupperade i en dataklass som heter TrainingArguments. Med allt detta avslöjar den tre metoder – träna, utvärdera och förutsäga – för att träna din modell, få metriska resultat på vilken datauppsättning som helst eller få förutsägelser på vilken datauppsättning som helst. För att lära dig mer om Trainer-objektet, se Finjustera en modell med Trainer API och videon Trainer API, som leder dig genom ett enkelt exempel.

Bakom kulisserna börjar Trainer API med att analysera miljön där du startar ditt skript när du skapar TrainingArguments. Till exempel, om du startade din träning med SageMaker, tittar den på SM_FRAMEWORK_PARAMS variabel i miljön för att upptäcka om du aktiverade SageMaker dataparallellism eller modellparallellism. Sedan hämtar den de relevanta variablerna (som processens rangordning eller världsstorleken) från miljön innan den utför de nödvändiga initieringsstegen (som t.ex. smdistributed.dataparallel.torch.distributed.init_process_group()).

Trainern innehåller hela träningsslingan, så den kan justera de nödvändiga stegen för att säkerställa att smdistributed.dataparallel backend används vid behov utan att du behöver ändra en kodrad i ditt skript. Det kan fortfarande köras (om än mycket långsammare) på din lokala dator för felsökning. Den hanterar skärning av din datauppsättning så att varje process ser olika prover automatiskt, med en omblandning vid varje epok, synkronisering av dina gradienter före optimeringssteget, blandad precisionsträning om du aktiverat den, gradientackumulering om du inte kan få plats med en stor batchstorlek på dina GPU:er och många fler optimeringar.

Om du aktiverade modellparallellism ser det till att processerna som måste se samma data (om deras dp_rank är samma) får samma partier, och som bearbetar med olika dp_rank ser inte samma prover, igen med en omblandning vid varje epok. Den ser till att modellens eller optimerarnas tillståndslexikon är korrekt synkroniserade vid kontroll och återigen hanterar alla optimeringar som blandad precision och gradientackumulering.

När du använder utvärderings- och förutsägelsemetoderna utför Trainern en distribuerad utvärdering för att dra fördel av alla dina GPU:er. Den hanterar korrekt uppdelning av dina data för varje process (process av samma dp_rank om modellparallellism är aktiverad) och ser till att förutsägelserna är korrekt samlade i samma ordning som datauppsättningen du använder innan de skickas till compute_metrics funktion eller just återvänt. Att använda Trainer API är inte obligatoriskt. Användare kan fortfarande använda Keras eller PyTorch inom Hugging Face. Trainer API kan dock tillhandahålla ett användbart abstraktionslager.

Träna en modell med SageMaker Hugging Face Estimators

En Estimator är ett gränssnitt på hög nivå för SageMaker-utbildning och hanterar end-to-end SageMaker-utbildning och implementeringsuppgifter. Träningen av ditt manus åberopas när du ringer fit på en HuggingFace Uppskattare. I Estimatorn definierar du vilket finjusteringsskript du ska använda som entry_point, Vilket instance_type att använda, och vilka hyperparametrar som skickas in. För mer information om HuggingFace parametrar, se Kramar Face Estimator.

Distribuerad utbildning: Dataparallell

I det här exemplet använder vi de nya Hugging Face DLC:erna och SageMaker SDK för att träna en distribuerad Seq2Seq-transformatormodell på fråge- och svarsuppgiften med hjälp av biblioteken Transformers och dataset. De bert-large-uncased-helord-maskering modellen är finjusterad på trupp datasätt.

Följande kodexempel visar stegen för att skapa en HuggingFace estimator för distribuerad utbildning med dataparallellism.

1. Välj ett Hugging Face Transformers-manus:

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

När du skapar en HuggingFace Estimator, du kan ange ett träningsskript som är lagrat i ett GitHub-förråd som ingångspunkt för Estimator, så att du inte behöver ladda ner skripten lokalt. Du kan använda git_config att köra Hugging Face Transformers exempel skript och rätt "gren" om din transformers_version måste konfigureras. Till exempel om du använder transformers_version 4.6.1, du måste använda 'branch':'v4.6.1".

2. Konfigurera träningshyperparametrar som skickas till träningsjobbet:

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

Som en hyperparameter kan vi definiera vilken som helst Seq2SeqTrainingArguments och de som definieras i träningsmanuset.

3. Definiera fördelningsparametrarna i HuggingFace Uppskattare:

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

Du kan använda SageMaker dataparallellbibliotek ur lådan för distribuerad utbildning. Vi lade till funktionaliteten för dataparallellism direkt i Trainern. För att möjliggöra dataparallellism kan du helt enkelt lägga till en enda parameter till din HuggingFace Estimator för att låta din Trainer-baserade kod använda den automatiskt.

4. Skapa en HuggingFace Estimator inklusive parametrar definierade i tidigare steg och börja träna:

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

Smakämnen Kramande Face Transformers-förråd innehåller flera exempel och skript för att finjustera modeller för uppgifter från språkmodellering till tokenklassificering. I vårt fall använder vi run_qa.py från examples/pytorch/question-answering exempel.

smdistributed.dataparallel stödjer modellträning på SageMaker med endast följande instanstyper. För bästa prestanda rekommenderar vi att du använder en instanstyp som stöder Elastisk tygadapter (EFA):

• ml. mp3.16xstor
• ml.p3dn.24xlarge (rekommenderas)
• ml.p4d.24xlarge (rekommenderas)

För att få den bästa prestandan och det mesta av SMDataParallel, bör du använda minst två instanser, men du kan också använda en för att testa det här exemplet.

Följande exempel anteckningsbok ger mer detaljerad steg-för-steg-vägledning.

Distribuerad utbildning: Modellparallell

För distribuerad träning med modellparallellism använder vi Hugging Face Transformers och datauppsättningsbiblioteket tillsammans med SageMaker SDK för sekvensklassificering på Allmän utvärdering av språkförståelse (GLUE) benchmark på ett multi-nod, multi-GPU-kluster med hjälp av SageMaker modell parallellism bibliotek.

Som med dataparallellism ställer vi först in git-konfigurationen, träningshyperparametrar och distributionsparametrar i HuggingFace Uppskattare:

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

Modellparallellismbiblioteket använder internt MPI, så för att använda modellparallellism måste MPI aktiveras med fördelningsparametern. "processes_per_host” i den föregående koden anger antalet processer som MPI ska starta på varje värd. Vi föreslår dessa för utveckling och testning. Vid produktionstid kan du kontakta AWS Support om du begär omfattande GPU-kapacitet. För mer information, se Kör ett SageMaker Distributed Model Parallell Training Job.

Följande exempel anteckningsbok innehåller de fullständiga kodskripten.

Spotinstanser

Med Hugging Face-ramverkstillägget för SageMaker Python SDK kan vi också dra nytta av fullt hanterade Amazon Elastic Compute Cloud (Amazon EC2) Spotinstanser och spara upp till 90 % av vår utbildningskostnad.

Om inte ditt träningsjobb kommer att slutföras snabbt, rekommenderar vi att du använder kontrollpunkt med hanterad punktträning, därför måste du definiera checkpoint_s3_uri.

För att använda Spot Instances med HuggingFace Estimator, vi måste ställa in use_spot_instances parameter till True och definiera din max_wait och max_run tid. För mer information om livscykeln för hanterad punktträning, se Managed Spot Training i Amazon SageMaker.

Följande är ett kodavsnitt för att ställa in en punktträningsuppskattning:

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)

Följande anteckningsbok innehåller de fullständiga kodskripten.

Slutsats

I det här inlägget diskuterade vi distribuerad träning av Hugging Face Transformers med SageMaker. Vi granskade först användningsfallen för dataparallellism kontra modellparallellism. Dataparallellism är vanligtvis mer lämplig men inte nödvändigtvis begränsad till när träningen är flaskhalsad av datorer, medan du kan använda modellparallellism när en modell inte får plats i minnet som tillhandahålls på en enskild accelerator. Vi visade sedan hur man tränar med båda metoderna.

I användningsfallet för dataparallellism som vi diskuterade tar träning av en modell på en enda p3.2xlarge-instans (med en enda GPU) 4 timmar och kostar ungefär $15 när detta skrivs. Med dataparallellism kan vi träna samma modell på 24 minuter till en kostnad av $28. Även om kostnaden har fördubblats har detta minskat träningstiden med en faktor 10. För en situation där du behöver träna många modeller inom en kort tidsperiod kan dataparallellism möjliggöra detta till en relativt låg kostnadsökning. När det gäller användningsfallet för modellparallellism, lägger det till möjligheten att träna modeller som inte alls kunde ha tränats tidigare på grund av hårdvarubegränsningar. Båda funktionerna möjliggör nya arbetsflöden för ML-utövare och är lättillgängliga via HuggingFace Estimator som en del av SageMaker Python SDK. Att distribuera dessa modeller till värdbaserade slutpunkter följer samma procedur som för andra skattare.

Denna integration möjliggör andra funktioner som är en del av SageMakers ekosystem. Du kan till exempel använda Spot Instances genom att lägga till en enkel flagga i Estimatorn för ytterligare kostnadsoptimering. Som nästa steg kan du hitta och köra träningsdemo och exempel anteckningsbok.

Om författarna

Archis Joglekar är en AI/ML Partner Solutions Architect i Emerging Technologies-teamet. Han är intresserad av prestanda, skalbar djupinlärning och vetenskaplig beräkning med hjälp av byggstenarna på AWS. Hans tidigare erfarenheter sträcker sig från beräkningsfysikforskning till utveckling av maskininlärningsplattformar i akademin, nationella labb och nystartade företag. Hans tid borta från datorn går åt till att spela fotboll och med vänner och familj.

James Yi är Sr. AI/ML Partner Solutions Architect i Emerging Technologies-teamet på Amazon Web Services. Han brinner för att arbeta med företagskunder och partners för att designa, distribuera och skala AI/ML-applikationer för att få fram deras affärsvärden. Utanför jobbet tycker han om att spela fotboll, resa och umgås med sin familj.

Philipp Schmid är Machine Learning Engineer och Tech Lead på Hugging Face, där han leder samarbetet med Amazon SageMaker-teamet. Han brinner för att demokratisera, optimera och producera banbrytande NLP-modeller och förbättra användarvänligheten för Deep Learning.

Sylvain Gugger är forskningsingenjör på Hugging Face och en av de främsta underhållarna av Transformers-biblioteket. Han älskar programvara med öppen källkod och hjälpa samhället att använda den.

Jeff Boudier bygger produkter på Hugging Face, skaparen av Transformers, det ledande ML-biblioteket med öppen källkod. Tidigare var Jeff en av grundarna av Stupeflix, förvärvat av GoPro, där han tjänstgjorde som chef för produktledning, produktmarknadsföring, affärsutveckling och företagsutveckling.

Källa: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- transformatorer-på-amazon-sagemaker/