Distribuert finjustering av en BERT Large-modell for en oppgave som besvarer spørsmål ved hjelp av Hugging Face Transformers på Amazon SageMaker

Fra opplæring av nye modeller til å distribuere dem i produksjon, Amazon SageMaker tilbyr det mest komplette settet med verktøy for startups og bedrifter for å utnytte kraften til maskinlæring (ML) og Deep Learning.

Med Transformers åpen kildekode-bibliotek og ML-plattform, gjør Hugging Face overføringslæring og de nyeste ML-modellene tilgjengelige for det globale AI-fellesskapet, noe som reduserer tiden som trengs for datavitere og ML-ingeniører i selskaper over hele verden for å dra nytte av alle nye vitenskapelige forfremmelse.

Å bruke Transformers på nye NLP-oppgaver eller -domener krever finjustering av store språkmodeller, en teknikk som utnytter den akkumulerte kunnskapen om forhåndstrente modeller for å tilpasse dem til en ny oppgave eller spesifikk type dokumenter i en ekstra, effektiv opplæringsprosess.

Å finjustere modellen for å produsere nøyaktige spådommer for forretningsproblemet krever opplæring av store Transformers-modeller, for eksempel BERT, BART, RoBERTa, T5, som kan være utfordrende å utføre på en skalerbar måte.

Hugging Face har jobbet tett med SageMaker for å levere klare til bruk Deep Learning-beholdere (DLC-er) som gjør opplæring og distribusjon av de nyeste Transformers-modellene enklere og raskere enn noen gang. Fordi funksjoner som SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), S3 pipe-modus, er integrert i containeren, reduserer bruken av disse drastisk tiden for bedrifter å lage transformatorbaserte ML-løsninger som svar på spørsmål, generering tekst og bilder, optimaliserer søkeresultater og forbedrer kundestøtteautomatisering, samtalegrensesnitt, semantisk søk, dokumentanalyser og mange flere applikasjoner.

I dette innlegget fokuserer vi på den dype integrasjonen av SageMaker-distribuerte biblioteker med Hugging Face, som gjør det mulig for dataforskere å akselerere trening og finjustering av Transformers-modeller fra dager til timer, alt i SageMaker.

Oversikt over distribuert opplæring

ML-utøvere og dataforskere møter to skaleringsutfordringer når de trener modeller: skalering av modellstørrelse (antall parametere og lag) og skalering av treningsdata. Skalering av enten modellstørrelsen eller treningsdata kan resultere i bedre nøyaktighet, men det kan være tilfeller i dyp læring hvor mengden minne på akseleratoren (CPU eller GPU) begrenser kombinasjonen av størrelsen på treningsdataene og størrelsen på modell. For eksempel, når du trener en stor språkmodell, er batchstørrelsen ofte begrenset til et lite antall prøver, noe som kan resultere i en mindre nøyaktig modell.

Distribuert opplæring kan dele opp arbeidsmengden for å trene modellen blant flere prosessorer, kalt arbeidere. Disse arbeiderne opererer parallelt for å få fart på modellopplæringen.

Basert på hva vi ønsker å skalere (modell eller data) er det to tilnærminger til distribuert opplæring: dataparallell og modellparallell.

Dataparallell er den vanligste tilnærmingen til distribuert opplæring. Dataparallellisme innebærer å lage en kopi av modellarkitekturen og vekter på forskjellige akseleratorer. Så, i stedet for å overføre hele treningssettet til en enkelt akselerator, kan vi dele treningssettet på de forskjellige akseleratorene og komme raskere gjennom treningssettet. Selv om dette legger til trinnet for akseleratorene som trenger å kommunisere gradientinformasjonen tilbake til en parameterserver, blir denne tiden mer enn oppveid av hastighetsøkningen ved å iterere over en brøkdel av hele datasettet per akselerator. På grunn av dette kan dataparallellisme i betydelig grad bidra til å redusere treningstiden. For eksempel tar det 4 timer å trene en enkelt modell uten parallellisering. Bruk av distribuert trening kan redusere det til 24 minutter. SageMaker distribuert opplæring implementerer også banebrytende teknikker i gradientoppdateringer.

En modellparallell tilnærming brukes med store modeller som er for store til å passe på én akselerator (GPU). Denne tilnærmingen implementerer en parallelliseringsstrategi der modellarkitekturen deles inn i shards og plasseres på forskjellige akseleratorer. Konfigurasjonen av hver av disse skårene er avhengig av nevrale nettverksarkitektur, og inkluderer vanligvis flere lag. Kommunikasjonen mellom akseleratorene skjer hver gang treningsdataene går fra et av skårene til det neste.

For å oppsummere bør du bruke distribuert treningsdataparallellisme for tidkrevende oppgaver på grunn av store datasett eller når du vil akselerere treningseksperimentene dine. Du bør bruke modellparallellisme når modellen din ikke får plass på én gasspedal.

Forutsetninger

For å utføre distribuert opplæring av Hugging Face Transformers-modeller i SageMaker, må du fullføre følgende forutsetninger:

Gjennomføre distribuert opplæring

Hugging Face Transformers-biblioteket gir en Trainer API som er optimalisert for å trene eller finjustere modellene biblioteket tilbyr. Du kan også bruke den på dine egne modeller hvis de fungerer på samme måte som Transformers-modeller; se Trener for flere detaljer. Denne API-en brukes i vår eksempel skript, som viser hvordan du forhåndsbehandler dataene for ulike NLP-oppgaver, som du kan ta som modeller for å skrive et skript som løser ditt eget tilpassede problem. Løftet til Trainer API er at dette skriptet fungerer ut av esken på alle distribuerte oppsett, inkludert SageMaker.

Trainer API tar alt som trengs for opplæringen. Dette inkluderer datasettene dine, modellen din (eller en funksjon som returnerer modellen), en compute_metrics funksjon som returnerer metrikkene du vil spore fra serien med prediksjoner og etiketter, optimerings- og læringshastighetsplanleggeren (god standard er gitt), samt alle hyperparametrene du kan stille inn for treningen, gruppert i en dataklasse kalt TrainingArguments. Med alt dette avslører den tre metoder – trene, evaluere og forutsi – for å trene modellen din, få metriske resultater på ethvert datasett eller få spådommene på et hvilket som helst datasett. For å lære mer om Trener-objektet, se Finjustere en modell med Trainer API og videoen Trainer API, som leder deg gjennom et enkelt eksempel.

Bak kulissene starter Trainer API med å analysere miljøet der du starter skriptet når du oppretter TrainingArguments. Hvis du for eksempel startet treningen med SageMaker, ser den på SM_FRAMEWORK_PARAMS variabel i miljøet for å oppdage om du har aktivert SageMaker dataparallellisme eller modellparallellisme. Deretter henter den de relevante variablene (som prosessens rangering eller verdensstørrelsen) fra miljøet før den utfører nødvendige initialiseringstrinn (som f.eks. smdistributed.dataparallel.torch.distributed.init_process_group()).

Treneren inneholder hele treningsløkken, slik at den kan justere de nødvendige trinnene for å sikre at smdistributed.dataparallel backend brukes når det er nødvendig uten at du trenger å endre en kodelinje i skriptet ditt. Den kan fortsatt kjøre (om enn mye tregere) på din lokale maskin for feilsøking. Den håndterer sønderdeling av datasettet ditt slik at hver prosess ser forskjellige prøver automatisk, med en omstokking ved hver epoke, synkroniserer gradientene dine før optimaliseringstrinnet, blandet presisjonstrening hvis du har aktivert det, gradientakkumulering hvis du ikke får plass til en stor batchstørrelse på dine GPU-er, og mange flere optimaliseringer.

Hvis du aktiverte modellparallellisme, sørger det for at prosessene som må se de samme dataene (hvis deres dp_rank er det samme) får de samme partiene, og som behandler med forskjellige dp_rank ser ikke de samme prøvene, igjen med en stokking for hver epoke. Den sørger for at tilstandsordbøkene til modellen eller optimererne er riktig synkronisert ved sjekkpunkt, og håndterer igjen alle optimaliseringer som blandet presisjon og gradientakkumulering.

Når du bruker evaluerings- og forutsigmetodene, utfører treneren en distribuert evaluering for å dra nytte av alle dine GPU-er. Den håndterer delingen av dataene dine på riktig måte for hver prosess (prosess av samme dp_rank hvis modellparallellisme er aktivert) og sørger for at prediksjonene er riktig samlet i samme rekkefølge som datasettet du bruker før de sendes til compute_metrics funksjon eller nettopp returnert. Bruk av Trainer API er ikke obligatorisk. Brukere kan fortsatt bruke Keras eller PyTorch i Hugging Face. Trainer API kan imidlertid gi et nyttig abstraksjonslag.

Tren en modell ved å bruke SageMaker Hugging Face Estimators

An Estimator er et grensesnitt på høyt nivå for SageMaker-trening og håndterer ende-til-ende SageMaker-opplæring og distribusjonsoppgaver. Opplæringen av skriptet ditt påkalles når du ringer fit på en HuggingFace Estimator. I estimatoren definerer du hvilket finjusteringsskript du skal bruke som entry_point, Som instance_type å bruke, og hvilke hyperparametre som sendes inn. For mer informasjon om HuggingFace parametere, se Hugging Face Estimator.

Distribuert opplæring: Dataparallell

I dette eksemplet bruker vi de nye Hugging Face DLC-ene og SageMaker SDK for å trene en distribuert Seq2Seq-transformatormodell på spørsmåls- og svaroppgaven ved å bruke Transformers og datasettbibliotekene. De bert-large-ukapslet-helord-maskering modellen er finjustert på troppen datasett.

Følgende kodeeksempler viser deg trinnene for å lage en HuggingFace estimator for distribuert opplæring med dataparallellisme.

1. Velg et 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 oppretter en HuggingFace Estimator, du kan spesifisere et treningsskript som er lagret i et GitHub-depot som inngangspunkt for Estimator, slik at du ikke trenger å laste ned skriptene lokalt. Du kan bruke git_config å kjøre Hugging Face Transformers eksempler skript og høyre "gren" hvis din transformers_version må konfigureres. For eksempel hvis du bruker transformers_version 4.6.1, du må bruke 'branch':'v4.6.1'.

2. Konfigurer treningshyperparametere som sendes inn i treningsjobben:

   # 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 definere hvilken som helst Seq2SeqTrainingArguments og de som er definert i treningsskriptet.

3. Definer distribusjonsparametrene i HuggingFace Estimator:

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

Du kan også bruke det SageMaker dataparallellismebibliotek ut av esken for distribuert trening. Vi la til funksjonaliteten til dataparallellisme direkte i treneren. For å aktivere dataparallellisme kan du ganske enkelt legge til en enkelt parameter til din HuggingFace Estimator for å la den trenerbaserte koden din bruke den automatisk.

4. Lag en HuggingFace Estimator inkludert parametere definert i tidligere trinn og start trening:

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 inneholder flere eksempler og skript for finjustering av modeller på oppgaver fra språkmodellering til tokenklassifisering. I vårt tilfelle bruker vi run_qa.py fra examples/pytorch/question-answering eksempler.

smdistributed.dataparallel støtter modelltrening på SageMaker med bare følgende forekomsttyper. For best ytelse anbefaler vi å bruke en forekomsttype som støtter Elastisk stoffadapter (EFA):

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

For å få den beste ytelsen og mest mulig ut av SMDataParallel, bør du bruke minst to forekomster, men du kan også bruke en for å teste dette eksemplet.

Følgende eksempel notisbok gir mer detaljert steg-for-steg veiledning.

Distribuert opplæring: Modellparallell

For distribuert trening med modellparallellisme bruker vi Hugging Face Transformers og datasettbiblioteket sammen med SageMaker SDK for sekvensklassifisering på Evaluering av generell språkforståelse (GLUE) benchmark på en multi-node, multi-GPU-klynge ved hjelp av SageMaker modell parallellisme bibliotek.

Som med dataparallellisme, satte vi først git-konfigurasjonen, treningshyperparametere og distribusjonsparametere 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
}

Modellparallellismebiblioteket bruker MPI internt, så for å bruke modellparallellisme må MPI aktiveres ved hjelp av distribusjonsparameteren. "processes_per_host” i den foregående koden spesifiserer antall prosesser MPI skal starte på hver vert. Vi foreslår disse for utvikling og testing. På produksjonstidspunktet kan du kontakte AWS Support hvis du ber om omfattende GPU-kapasitet. For mer informasjon, se Kjør en SageMaker Distribuert Model Parallell Training Job.

Følgende eksempel notisbok inneholder de komplette kodeskriptene.

Spotforekomster

Med Hugging Face-rammeutvidelsen for SageMaker Python SDK kan vi også dra nytte av fullt administrert Amazon Elastic Compute Cloud (Amazon EC2) Spotforekomster og spar opptil 90 % av treningskostnadene våre.

Med mindre treningsjobben vil fullføres raskt, anbefaler vi at du bruker sjekkpunkt med administrert punkttrening, derfor må du definere checkpoint_s3_uri.

For å bruke Spot Instances med HuggingFace Estimator, vi må stille inn use_spot_instances parameter til True og definer din max_wait og max_run tid. For mer informasjon om livssyklusen for administrert punkttrening, se Managed Spot Training i Amazon SageMaker.

Følgende er en kodebit for å sette opp en spottreningsestimator:

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 bærbare inneholder de komplette kodeskriptene.

konklusjonen

I dette innlegget diskuterte vi distribuert trening av Hugging Face Transformers ved hjelp av SageMaker. Vi gjennomgikk først brukstilfellene for dataparallellisme vs modellparallellisme. Dataparallellisme er vanligvis mer hensiktsmessig, men ikke nødvendigvis begrenset til når trening er flaskehalser av databehandling, mens du kan bruke modellparallellisme når en modell ikke får plass i minnet som er gitt på en enkelt akselerator. Vi viste deretter hvordan man trener med begge metodene.

I brukssaken for dataparallellisme vi diskuterte, tar opplæring av en modell på en enkelt p3.2xlarge-instans (med en enkelt GPU) 4 timer og koster omtrent $15 når dette skrives. Med dataparallellisme kan vi trene den samme modellen på 24 minutter til en pris av $28. Selv om kostnadene har doblet seg, har dette redusert treningstiden med en faktor 10. For en situasjon der du trenger å trene mange modeller innen kort tid, kan dataparallellisme muliggjøre dette til en relativt lav kostnadsøkning. Når det gjelder brukstilfellet for modellparallellisme, legger det til muligheten til å trene modeller som ikke kunne vært trent tidligere i det hele tatt på grunn av maskinvarebegrensninger. Begge funksjonene muliggjør nye arbeidsflyter for ML-utøvere, og er lett tilgjengelige gjennom HuggingFace Estimator som en del av SageMaker Python SDK. Å distribuere disse modellene til vertsbaserte endepunkter følger samme prosedyre som for andre estimatorer.

Denne integrasjonen muliggjør andre funksjoner som er en del av SageMaker-økosystemet. Du kan for eksempel bruke Spot-forekomster ved å legge til et enkelt flagg til Estimator for ytterligere kostnadsoptimalisering. Som et neste trinn kan du finne og kjøre treningsdemo og eksempel notisbok.

Om forfatterne

Archis Joglekar er en AI/ML Partner Solutions Architect i Emerging Technologies-teamet. Han er interessert i presterende, skalerbar dyp læring og vitenskapelig databehandling ved å bruke byggesteinene ved AWS. Hans tidligere erfaringer spenner fra beregningsfysikkforskning til utvikling av maskinlæringsplattformer i akademia, nasjonale laboratorier og startups. Tiden hans borte fra datamaskinen går med til å spille fotball og med venner og familie.

James Yi er Sr. AI/ML Partner Solutions Architect i Emerging Technologies-teamet hos Amazon Web Services. Han brenner for å jobbe med bedriftskunder og partnere for å designe, distribuere og skalere AI/ML-applikasjoner for å utlede deres forretningsverdier. Utenom jobben liker han å spille fotball, reise og tilbringe tid med familien.

Philipp Schmid er Machine Learning Engineer og Tech Lead hos Hugging Face, hvor han leder samarbeidet med Amazon SageMaker-teamet. Han er lidenskapelig opptatt av å demokratisere, optimalisere og produsere banebrytende NLP-modeller og forbedre brukervennligheten for Deep Learning.

Sylvain Gugger er en forskningsingeniør ved Hugging Face og en av de viktigste vedlikeholderne av Transformers-biblioteket. Han elsker åpen kildekode-programvare og hjelper samfunnet med å bruke den.

Jeff Boudier bygger produkter hos Hugging Face, skaperen av Transformers, det ledende ML-biblioteket med åpen kildekode. Tidligere var Jeff en av grunnleggerne av Stupeflix, kjøpt opp av GoPro, hvor han fungerte som direktør for produktledelse, produktmarkedsføring, forretningsutvikling og bedriftsutvikling.

Kilde: 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/