Distribueret finjustering af en BERT Large-model til en spørgsmål-besvarende opgave ved hjælp af Hugging Face Transformers på Amazon SageMaker

Fra træning af nye modeller til implementering af dem i produktionen, Amazon SageMaker tilbyder det mest komplette sæt værktøjer til startups og virksomheder til at udnytte kraften i maskinlæring (ML) og Deep Learning.

Med sit Transformers open source-bibliotek og ML-platform gør Hugging Face overførselslæring og de nyeste ML-modeller tilgængelige for det globale AI-fællesskab, hvilket reducerer den tid, det tager for dataforskere og ML-ingeniører i virksomheder rundt om i verden at drage fordel af alle nye videnskabelige fremgang.

Anvendelse af Transformers til nye NLP-opgaver eller -domæner kræver finjustering af store sprogmodeller, en teknik, der udnytter den akkumulerede viden om præ-trænede modeller til at tilpasse dem til en ny opgave eller specifik type dokumenter i en yderligere, effektiv træningsproces.

Finjustering af modellen til at producere nøjagtige forudsigelser for det aktuelle forretningsproblem kræver træning af store Transformers-modeller, for eksempel BERT, BART, RoBERTa, T5, som kan være udfordrende at udføre på en skalerbar måde.

Hugging Face har arbejdet tæt sammen med SageMaker for at levere klar til brug Deep Learning Containers (DLC'er), der gør træning og implementering af de nyeste Transformers-modeller nemmere og hurtigere end nogensinde. Fordi funktioner som SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), S3 pipe mode, er integreret i containeren, reducerer brugen af ​​disse drastisk tid for virksomheder til at skabe Transformers-baserede ML-løsninger såsom besvarelse af spørgsmål, generering tekst og billeder, optimering af søgeresultater og forbedrer kundesupportautomatisering, samtalegrænseflader, semantisk søgning, dokumentanalyser og mange flere applikationer.

I dette indlæg fokuserer vi på den dybe integration af SageMaker distribuerede biblioteker med Hugging Face, som gør det muligt for dataforskere at accelerere træning og finjustering af Transformers-modeller fra dage til timer, alt sammen i SageMaker.

Oversigt over distribueret træning

ML-praktikere og dataforskere står over for to skaleringsudfordringer, når de træner modeller: skalering af modelstørrelse (antal parametre og lag) og skalering af træningsdata. Skalering af enten modelstørrelsen eller træningsdata kan resultere i bedre nøjagtighed, men der kan være tilfælde i deep learning, hvor mængden af ​​hukommelse på acceleratoren (CPU eller GPU) begrænser kombinationen af ​​størrelsen af ​​træningsdataene og størrelsen af model. For eksempel, når du træner en stor sprogmodel, er batchstørrelsen ofte begrænset til et lille antal prøver, hvilket kan resultere i en mindre nøjagtig model.

Distribueret træning kan opdele arbejdsbyrden for at træne modellen blandt flere processorer, kaldet arbejdere. Disse arbejdere arbejder parallelt for at fremskynde modeluddannelsen.

Baseret på hvad vi ønsker at skalere (model eller data) er der to tilgange til distribueret træning: data parallel og model parallel.

Dataparallel er den mest almindelige tilgang til distribueret træning. Dataparallelisme indebærer at skabe en kopi af modelarkitekturen og vægte på forskellige acceleratorer. Så i stedet for at overføre hele træningssættet til en enkelt accelerator, kan vi opdele træningssættet på tværs af de forskellige acceleratorer og komme hurtigere igennem træningssættet. Selvom dette tilføjer det trin, hvor acceleratorerne skal kommunikere deres gradientinformation tilbage til en parameterserver, bliver denne gang mere end opvejet af hastighedsforøgelsen ved at iterere over en brøkdel af hele datasættet pr. accelerator. På grund af dette kan dataparallelisme bidrage væsentligt til at reducere træningstiden. For eksempel tager træning af en enkelt model uden parallelisering 4 timer. Brug af distribueret træning kan reducere det til 24 minutter. SageMaker distribueret træning implementerer også banebrydende teknikker i gradientopdateringer.

En model parallel tilgang bruges med store modeller for store til at passe på én accelerator (GPU). Denne tilgang implementerer en paralleliseringsstrategi, hvor modelarkitekturen er opdelt i shards og placeret på forskellige acceleratorer. Konfigurationen af ​​hver af disse shards er afhængig af neural netværksarkitektur og omfatter typisk flere lag. Kommunikationen mellem acceleratorerne sker, hver gang træningsdataene går fra et af skårene til det næste.

For at opsummere bør du bruge distribueret træningsdataparallelisme til tidskrævende opgaver på grund af store datasæt, eller når du vil accelerere dine træningseksperimenter. Du bør bruge modelparallelisme, når din model ikke kan passe på én speeder.

Forudsætninger

For at udføre distribueret træning af Hugging Face Transformers-modeller i SageMaker skal du opfylde følgende forudsætninger:

Gennemføre distribueret træning

Hugging Face Transformers-biblioteket giver et Trainer API, der er optimeret til at træne eller finjustere de modeller, biblioteket leverer. Du kan også bruge det på dine egne modeller, hvis de fungerer på samme måde som Transformers-modeller; se Træner for flere detaljer. Denne API bruges i vores eksempel scripts, som viser, hvordan du forbehandler dataene til forskellige NLP-opgaver, som du kan tage som modeller for at skrive et script, der løser dit eget tilpassede problem. Løftet med Trainer API er, at dette script fungerer ud af boksen på enhver distribueret opsætning, inklusive SageMaker.

Trainer API'et tager alt det nødvendige til træningen. Dette inkluderer dine datasæt, din model (eller en funktion, der returnerer din model), en compute_metrics funktion, der returnerer de metrics, du vil spore fra rækkerne af forudsigelser og etiketter, din optimerings- og læringshastighedsplanlægger (god standard er angivet), samt alle de hyperparametre, du kan indstille til din træning, grupperet i en dataklasse kaldet TrainingArguments. Med alt dette afslører den tre metoder - træne, evaluere og forudsige - til at træne din model, få metriske resultater på ethvert datasæt eller få forudsigelserne på ethvert datasæt. For at lære mere om Træner-objektet, se Finjustering af en model med Trainer API og videoen Træner API, som leder dig gennem et simpelt eksempel.

Bag kulisserne starter Trainer API med at analysere det miljø, hvor du starter dit script, når du opretter TrainingArguments. For eksempel, hvis du startede din træning med SageMaker, ser den på SM_FRAMEWORK_PARAMS variabel i miljøet for at opdage, om du aktiverede SageMaker-dataparallelisme eller modelparallelisme. Derefter får den de relevante variabler (såsom processens rang eller verdensstørrelsen) fra miljøet, før den udfører de nødvendige initialiseringstrin (som f.eks. smdistributed.dataparallel.torch.distributed.init_process_group()).

Træneren indeholder hele træningsløkken, så den kan justere de nødvendige trin for at sikre smdistributed.dataparallel backend bruges når det er nødvendigt, uden at du skal ændre en kodelinje i dit script. Det kan stadig køre (omend meget langsommere) på din lokale maskine til fejlretning. Den håndterer sønderdeling af dit datasæt, således at hver proces automatisk ser forskellige prøver med en omfordeling ved hver epoke, synkronisering af dine gradienter før optimeringstrinnet, blandet præcisionstræning, hvis du aktiverede det, gradientakkumulering, hvis du ikke kan passe en stor batchstørrelse på dine GPU'er og mange flere optimeringer.

Hvis du aktiverede modelparallelisme, sørger det for, at de processer, der skal se de samme data (hvis deres dp_rank er det samme) får de samme batches, og det behandler med forskellige dp_rank kan du ikke se de samme prøver, igen med en omfordeling ved hver epoke. Den sørger for, at modellens eller optimerernes tilstandsordbøger er korrekt synkroniserede ved kontrol, og håndterer igen alle optimeringer såsom blandet præcision og gradientakkumulering.

Når du bruger evaluerings- og forudsigelsesmetoderne, udfører træneren en distribueret evaluering for at drage fordel af alle dine GPU'er. Det håndterer korrekt opdeling af dine data for hver proces (proces af samme dp_rank hvis modelparallelisme er aktiveret) og sørger for, at forudsigelserne er korrekt samlet i samme rækkefølge som det datasæt, du bruger, før de sendes til compute_metrics funktion eller lige returneret. Brug af Trainer API er ikke obligatorisk. Brugere kan stadig bruge Keras eller PyTorch i Hugging Face. Trainer API kan dog give et nyttigt abstraktionslag.

Træn en model ved hjælp af SageMaker Hugging Face Estimators

En Estimator er en grænseflade på højt niveau til SageMaker-træning og håndterer ende-til-ende SageMaker-trænings- og implementeringsopgaver. Træningen af ​​dit script påkaldes, når du ringer fit på en HuggingFace Estimator. I Estimator definerer du, hvilket finjusteringsscript du skal bruge som entry_point, Hvilket instance_type at bruge, og hvilke hyperparametre der sendes i. For mere information om HuggingFace parametre, se Knusende ansigtsvurdering.

Distribueret træning: Dataparallel

I dette eksempel bruger vi de nye Hugging Face DLC'er og SageMaker SDK til at træne en distribueret Seq2Seq-transformermodel i spørgsmål og svaropgaven ved hjælp af Transformers og datasætbiblioteker. Det bert-stor-uindfattet-hel-ord-maskering modellen er finjusteret på hold datasæt.

Følgende kodeeksempler viser dig trin til oprettelse af en HuggingFace estimator for distribueret træning med dataparallelisme.

1. Vælg et Hugging Face Transformers-manuskript:

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

Når du opretter en HuggingFace Estimator, du kan angive et træningsscript, der er gemt i et GitHub-lager som indgangspunktet for Estimator, så du ikke behøver at downloade scripts lokalt. Du kan bruge git_config at køre Hugging Face Transformers eksempler scripts og højre 'gren' hvis din transformers_version skal konfigureres. Hvis du f.eks. bruger transformers_version 4.6.1, du skal bruge 'branch':'v4.6.1«.

2. Konfigurer træningshyperparametre, der overføres til 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 hyperparameter kan vi definere enhver Seq2SeqTrainingArguments og dem, der er defineret i træningsscriptet.

3. Definer fordelingsparametrene i HuggingFace Estimator:

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

Du kan bruge SageMaker data parallelisme bibliotek ud af kassen til distribueret træning. Vi tilføjede dataparallelismens funktionalitet direkte i træneren. For at aktivere dataparallelisme kan du blot tilføje en enkelt parameter til din HuggingFace Estimator til at lade din træner-baserede kode bruge den automatisk.

4. Opret en HuggingFace Estimator inklusive parametre defineret i tidligere trin og start træning:

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

Hugging Face Transformers repository indeholder flere eksempler og scripts til finjustering af modeller på opgaver fra sprogmodellering til tokenklassificering. I vores tilfælde bruger vi run_qa.py fra examples/pytorch/question-answering eksempler.

smdistributed.dataparallel understøtter modeltræning på SageMaker med kun følgende instanstyper. For den bedste ydeevne anbefaler vi at bruge en instanstype, der understøtter Elastisk stofadapter (EFA):

• ml.p3.16xlarge
• ml.p3dn.24xlarge (anbefales)
• ml.p4d.24xlarge (anbefales)

For at få den bedste ydeevne og mest muligt ud af SMDataParallel, bør du bruge mindst to forekomster, men du kan også bruge en til at teste dette eksempel.

Følgende eksempel notesbog giver mere detaljeret trin-for-trin vejledning.

Distribueret træning: Model parallel

Til distribueret træning med modelparallelisme bruger vi Hugging Face Transformers og datasætbiblioteket sammen med SageMaker SDK til sekvensklassificering på General Language Understanding Evaluation (GLUE) benchmark på en multi-node, multi-GPU klynge ved hjælp af SageMaker model parallelisme bibliotek.

Som med dataparallelisme indstillede vi først git-konfigurationen, træningshyperparametre og distributionsparametre i HuggingFace Estimator:

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

Modelparallelismebiblioteket bruger internt MPI, så for at bruge modelparallelisme skal MPI aktiveres ved hjælp af distributionsparameteren. “processes_per_host” i den foregående kode angiver antallet af processer MPI skal starte på hver vært. Vi foreslår disse til udvikling og test. På produktionstidspunktet kan du kontakte AWS Support, hvis du anmoder om omfattende GPU-kapacitet. For mere information, se Kør et SageMaker Distributed Model Parallel Training Job.

Følgende eksempel notesbog indeholder de komplette kodescripts.

Spot-forekomster

Med Hugging Face framework-udvidelsen til SageMaker Python SDK kan vi også drage fordel af fuldt administreret Amazon Elastic Compute Cloud (Amazon EC2) Spot-forekomster og spar op til 90 % af vores uddannelsesomkostninger.

Medmindre dit træningsjob afsluttes hurtigt, anbefaler vi, at du bruger kontrolpunkt med managed spot træning, derfor skal du definere checkpoint_s3_uri.

For at bruge Spot Instances med HuggingFace Estimator, vi skal indstille use_spot_instances parameter til Sand og definer din max_wait , max_run tid. For mere information om den administrerede spottræningslivscyklus, se Managed Spot Training i Amazon SageMaker.

Følgende er et kodestykke til opsætning af en spottræningsestimator:

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ølgende notesbog indeholder de komplette kodescripts.

Konklusion

I dette indlæg diskuterede vi distribueret træning af Hugging Face Transformers ved hjælp af SageMaker. Vi gennemgik først use cases for dataparallelisme vs. modelparallelisme. Dataparallelisme er typisk mere passende, men er ikke nødvendigvis begrænset til, når træning er flaskehalsede af computer, hvorimod du kan bruge modelparallelisme, når en model ikke kan passe ind i hukommelsen på en enkelt accelerator. Vi viste derefter, hvordan man træner med begge metoder.

I den dataparallelismebrug, vi diskuterede, tager træning af en model på en enkelt p3.2xlarge-instans (med en enkelt GPU) 4 timer og koster omkring $15 på tidspunktet for dette skrivende. Med dataparallelisme kan vi træne den samme model på 24 minutter til en pris af $28. Selvom omkostningerne er fordoblet, har dette reduceret træningstiden med en faktor 10. I en situation, hvor du skal træne mange modeller inden for en kort periode, kan dataparallelisme muliggøre dette med en relativt lav omkostningsstigning. Hvad angår modelparallelisme, tilføjer det muligheden for at træne modeller, der slet ikke kunne have været trænet tidligere på grund af hardwarebegrænsninger. Begge funktioner muliggør nye arbejdsgange for ML-udøvere og er let tilgængelige via HuggingFace Estimator som en del af SageMaker Python SDK. Implementering af disse modeller til hostede slutpunkter følger samme procedure som for andre estimatorer.

Denne integration muliggør andre funktioner, der er en del af SageMaker-økosystemet. For eksempel kan du bruge Spot Instances ved at tilføje et simpelt flag til Estimator for yderligere omkostningsoptimering. Som et næste trin kan du finde og køre træningsdemo , eksempel notesbog.

Om forfatterne

Archis Joglekar er en AI/ML Partner Solutions Architect i Emerging Technologies-teamet. Han er interesseret i performant, skalerbar deep learning og videnskabelig computing ved hjælp af byggestenene hos AWS. Hans tidligere erfaringer spænder fra beregningsfysisk forskning til udvikling af maskinlæringsplatforme i den akademiske verden, nationale laboratorier og startups. Hans tid væk fra computeren går med til at spille fodbold og med venner og familie.

James Yi er en Sr. AI/ML Partner Solutions Architect i Emerging Technologies-teamet hos Amazon Web Services. Han brænder for at arbejde med virksomhedskunder og partnere for at designe, implementere og skalere AI/ML-applikationer for at udlede deres forretningsværdier. Uden for arbejdet nyder han at spille fodbold, rejse og tilbringe tid med sin familie.

Philipp Schmid er Machine Learning Engineer og Tech Lead hos Hugging Face, hvor han leder samarbejdet med Amazon SageMaker-teamet. Han brænder for at demokratisere, optimere og producere banebrydende NLP-modeller og forbedre brugervenligheden til Deep Learning.

Sylvain Gugger er forskningsingeniør hos Hugging Face og en af ​​de vigtigste vedligeholdere af Transformers-biblioteket. Han elsker open source-software og hjælper samfundet med at bruge det.

Jeff Boudier bygger produkter hos Hugging Face, skaberen af ​​Transformers, det førende open source ML-bibliotek. Tidligere var Jeff medstifter af Stupeflix, erhvervet af GoPro, hvor han fungerede som direktør for Product Management, Product Marketing, Business Development og Corporate Development.

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