A BERT Large modell elosztott finomhangolása egy kérdés-megválaszoló feladathoz Hugging Face Transformers segítségével az Amazon SageMakeren

Az új modellek betanításától a termelésben való bevezetésig, Amazon SageMaker a legteljesebb eszközkészletet kínálja startupoknak és vállalkozásoknak a gépi tanulás (ML) és a Deep Learning erejének kihasználásához.

Transformers nyílt forráskódú könyvtárával és ML platformjával a Hugging Face elérhetővé teszi az átviteli tanulást és a legújabb ML-modelleket a globális mesterségesintelligencia-közösség számára, csökkentve ezzel az időt arra, hogy az adattudósok és az ML-mérnökök a világ különböző részein működő vállalatoknál minden új tudományos előnyt kihasználjanak. haladás.

A Transformers új NLP-feladatokra vagy tartományokra történő alkalmazása megköveteli a nagy nyelvi modellek finomhangolását, egy olyan technikát, amely felhasználja az előre betanított modellek felhalmozott tudását, hogy egy további, hatékony képzési folyamat során hozzáigazítsa őket egy új feladathoz vagy meghatározott típusú dokumentumokhoz.

A modell finomhangolása a szóban forgó üzleti probléma pontos előrejelzéseinek előállításához nagy Transformers-modellek (például BERT, BART, RoBERTa, T5) betanítását igényli, amelyek méretezhető módon történő végrehajtása kihívást jelenthet.

Hugging Face szorosan együttműködik a SageMakerrel a szállítás érdekében használatra kész mélytanulási tárolók (DLC-k), amelyek minden eddiginél egyszerűbbé és gyorsabbá teszik a legújabb Transformers modellek betanítását és üzembe helyezését. Mivel az olyan funkciók, mint a SageMaker Data Parallel (SMDP), a SageMaker Model Parallel (SMMP), az S3 pipe mode, be vannak építve a konténerbe, ezek használata drasztikusan csökkenti a Transformers alapú ML megoldások létrehozásának idejét, például a kérdések megválaszolását, generálását. szöveget és képeket, optimalizálja a keresési eredményeket, és javítja az ügyfélszolgálat automatizálását, a párbeszédes felületeket, a szemantikus keresést, a dokumentumelemzést és még sok más alkalmazást.

Ebben a bejegyzésben a SageMaker elosztott könyvtárak Hugging Face-szel való mélyreható integrációjára összpontosítunk, amely lehetővé teszi az adatkutatók számára, hogy napokról órákra felgyorsítsák a Transformers modellek képzését és finomhangolását, mindezt a SageMakerben.

Az elosztott képzés áttekintése

Az ML gyakorlói és adattudósai két skálázási kihívással néznek szembe a modellek betanítása során: a modell méretének (paraméterek és rétegek száma) és a betanítási adatok skálázásával. A modell méretének vagy a betanítási adatoknak a skálázása nagyobb pontosságot eredményezhet, de a mély tanulásban előfordulhatnak olyan esetek, amikor a gyorsítón lévő memória mennyisége (CPU vagy GPU) korlátozza a betanítási adatok méretének és a képzési adatok méretének kombinációját. modell. Például egy nagy nyelvi modell betanításakor a köteg mérete gyakran csak kis számú mintára korlátozódik, ami kevésbé pontos modellt eredményezhet.

Az elosztott képzés feloszthatja a munkaterhelést, hogy a modellt több processzor között képezze, ún dolgozók. Ezek a dolgozók párhuzamosan dolgoznak a modellképzés felgyorsítása érdekében.

Attól függően, hogy mit akarunk skálázni (modell vagy adatok), az elosztott képzésnek két megközelítése van: párhuzamos adatok és párhuzamos modellek.

Az adatpárhuzam az elosztott képzés legelterjedtebb megközelítése. Az adatok párhuzamossága magában foglalja a modellarchitektúra és súlyok másolatának létrehozását a különböző gyorsítókon. Ezután ahelyett, hogy a teljes edzéskészletet egyetlen gyorsítóhoz adnánk át, feloszthatjuk az edzéskészletet a különböző gyorsítók között, és gyorsabban teljesíthetjük az edzéskészletet. Bár ez hozzáadja azt a lépést, hogy a gyorsítóknak vissza kell kommunikálniuk a gradiens információikat a paraméterkiszolgálóval, ezt az időt bőven ellensúlyozza a gyorsítónkénti teljes adatkészlet töredékén történő iteráció sebességének növelése. Emiatt az adatok párhuzamossága jelentősen csökkentheti az edzési időt. Például egyetlen modell betanítása párhuzamosítás nélkül 4 órát vesz igénybe. Az elosztott edzés használatával ez 24 percre csökkenthető. A SageMaker elosztott képzése a legkorszerűbb technikákat is megvalósítja a gradiens frissítésekben.

A modellpárhuzamos megközelítést olyan nagy modelleknél alkalmazzák, amelyek túl nagyok ahhoz, hogy elférjenek egy gyorsítón (GPU). Ez a megközelítés párhuzamosítási stratégiát valósít meg, ahol a modellarchitektúra szilánkokra van osztva, és különböző gyorsítókra helyezik. Ezen szilánkok mindegyikének konfigurációja neurális hálózati architektúra függő, és jellemzően több rétegből áll. A gyorsítók közötti kommunikáció minden alkalommal megtörténik, amikor a betanítási adatok az egyik szilánkról a másikra kerülnek.

Összefoglalva, az elosztott képzési adatok párhuzamosságát kell használnia a nagy adatkészletek miatti időigényes feladatokhoz, vagy ha fel akarja gyorsítani a képzési kísérleteket. Használjon modell párhuzamosságot, ha a modellje nem fér el egyetlen gyorsítón.

Előfeltételek

A Hugging Face Transformers modellek SageMakerben való elosztott képzéséhez a következő előfeltételeket kell teljesítenie:

Elosztott képzés végrehajtása

A Hugging Face Transformers könyvtár egy Trainer API-t biztosít, amely a könyvtár által biztosított modellek betanítására vagy finomhangolására van optimalizálva. Használhatja saját modelljein is, ha azok ugyanúgy működnek, mint a Transformers modellek; lát Edző további részletekért. Ezt az API-t használjuk példa szkriptek, amelyek bemutatják, hogyan kell elődolgozni az adatokat a különböző NLP-feladatokhoz, amelyeket modellként vehet fel a saját egyedi problémáját megoldó szkript írásához. A Trainer API ígérete az, hogy ez a szkript minden elosztott beállításon működik, beleértve a SageMaker-t is.

A Trainer API mindent tartalmaz, ami a képzéshez szükséges. Ez magában foglalja az adatkészleteket, a modellt (vagy a modellt visszaadó függvényt), a compute_metrics függvény, amely visszaadja a követni kívánt mérőszámokat a predikációk és címkék tömbjéből, az optimalizálóból és a tanulási ütemütemezőből (jó alapértelmezések vannak), valamint az összes olyan hiperparamétert, amelyet az edzéshez hangolhat, egy adatosztályba csoportosítva. TrainingArguments. Mindezek mellett három módszert tesz elérhetővé – a betanítást, az értékelést és az előrejelzést – a modell betanításához, a metrikaeredmények lekéréséhez bármely adatkészlethez vagy az előrejelzésekhez bármely adatkészlethez. Ha többet szeretne megtudni a Trainer objektumról, lásd: Modell finomhangolása a Trainer API-val és a videó A Trainer API, amely egy egyszerű példán végigvezeti Önt.

A színfalak mögött a Trainer API azzal kezdődik, hogy elemzi a környezetet, amelyben elindítja a szkriptet, amikor létrehozza a TrainingArguments. Például, ha elindította a képzést a SageMakerrel, az megnézi a SM_FRAMEWORK_PARAMS változót a környezetben annak észlelésére, hogy engedélyezte-e a SageMaker adatpárhuzamot vagy a modell párhuzamosságot. Ezután a szükséges inicializálási lépések (pl. smdistributed.dataparallel.torch.distributed.init_process_group()).

A Trainer tartalmazza a teljes edzéshurkot, így be tudja állítani a szükséges lépéseket annak érdekében, hogy a smdistributed.dataparallel A backend szükség esetén használatos anélkül, hogy módosítania kellene egy kódsort a szkriptben. Továbbra is futhat (bár sokkal lassabban) a helyi gépen hibakeresés céljából. Kezeli az adatkészlet felosztását úgy, hogy minden folyamat automatikusan különböző mintákat lásson, minden korszakban újrakeveréssel, a gradiensek szinkronizálásával az optimalizálási lépés előtt, vegyes precíziós képzéssel, ha aktiválta, a gradiens felhalmozását, ha nem fér bele egy nagy tétel. a GPU-k és még sok más optimalizálás.

Ha aktiválta a modell párhuzamosságot, akkor gondoskodik arról, hogy a folyamatoknak ugyanazokat az adatokat kell látniuk (ha azok dp_rank ugyanaz) ugyanazokat a kötegeket kapja meg, és ez eltérő módon dolgozza fel dp_rank nem látni ugyanazokat a mintákat, minden korszakban újra kell rendezni. Gondoskodik arról, hogy a modell vagy az optimalizálók állapotszótárai megfelelően szinkronizálva legyenek az ellenőrzési pontozás során, és ismét kezeli az összes optimalizálást, például a vegyes pontosságot és a gradiens-gyűjtést.

Az értékelési és előrejelzési módszerek használatakor a Trainer elosztott kiértékelést végez, hogy kihasználja az összes GPU előnyeit. Megfelelően kezeli az adatok felosztását minden egyes folyamathoz (azonos folyamathoz dp_rank ha a modellpárhuzam be van kapcsolva), és győződjön meg arról, hogy az előrejelzések megfelelően összegyűjtésre kerülnek, ugyanabban a sorrendben, mint az Ön által használt adatkészlet, mielőtt elküldenék őket a compute_metrics függvényt, vagy éppen visszaadta. A Trainer API használata nem kötelező. A felhasználók továbbra is használhatják a Keras-t vagy a PyTorch-ot a Hugging Face-ben. A Trainer API azonban hasznos absztrakciós réteget biztosíthat.

Tanítson modellt a SageMaker Hugging Face Estimators segítségével

Az Estimator egy magas szintű interfész a SageMaker képzéshez, és a SageMaker teljes képzési és telepítési feladatait kezeli. Híváskor a program meghívja a szkript betanítását fit a HuggingFace Becslő. A Becslőben meghatározhatja, hogy melyik finomhangoló szkriptet használja entry_point, Amely instance_type használni, és mely hiperparaméterek kerülnek átadásra. További információkért HuggingFace paraméterek, lásd Ölelés Arc Becslő.

Elosztott képzés: Adatok párhuzamos

Ebben a példában az új Hugging Face DLC-ket és a SageMaker SDK-t használjuk arra, hogy egy elosztott Seq2Seq-transzformátor modellt tanítsunk a kérdés- és válaszfeladatra a Transformers and Datasets könyvtárak segítségével. A bert-nagy-betét nélküli-egészszó-maszkolás modell finomhangolása a osztag adatkészlet.

A következő kódpéldák az a létrehozásának lépéseit mutatják be HuggingFace becslő az elosztott képzéshez adatok párhuzamosságával.

1. Válassz egy Hugging Face Transformers szkriptet:

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

Amikor létrehoz egy HuggingFace Becslő, megadhat egy tanítási szkriptet, amely egy GitHub-tárolóban van tárolva a Becslő belépési pontjaként, így nem kell helyileg letöltenie a szkripteket. Te tudod használni git_config a Hugging Face Transformers példaszkriptek futtatásához és a jobb oldali „ághoz”, ha az Ön transformers_version konfigurálni kell. Például, ha használ transformers_version 4.6.1, a "branch':'v4.6.1".

2. Konfigurálja a betanítási feladatba átadott képzési hiperparamétereket:

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

Hiperparaméterként bármelyiket meghatározhatjuk Seq2SeqTrainingArguments és a képzési forgatókönyvben meghatározottakat.

3. Határozza meg az eloszlási paramétereket a HuggingFace Becslő:

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

Használhatja a SageMaker adatpárhuzamossági könyvtár a dobozból az elosztott képzéshez. Az adatpárhuzamosság funkcióját közvetlenül a Trainerbe adtuk. Az adatok párhuzamosságának engedélyezéséhez egyszerűen hozzáadhat egyetlen paramétert az adathoz HuggingFace Becslő, amely lehetővé teszi a Trainer-alapú kód automatikus használatát.

4. Hozzon létre egy HuggingFace Becslő, amely tartalmazza az előző lépésekben meghatározott paramétereket, és indítsa el a képzést:

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

A Hugging Face Transformers adattár számos példát és szkriptet tartalmaz a feladatok modelljének finomhangolásához a nyelvi modellezéstől a token osztályozásig. A mi esetünkben használjuk run_qa.py tól examples/pytorch/question-answering példák.

smdistributed.dataparallel támogatja a SageMaker modell képzését csak a következő példánytípusok. A legjobb teljesítmény érdekében olyan példánytípus használatát javasoljuk, amely támogatja Elasztikus szövetadapter (EFA):

• ml.p3.16xnagy
• ml.p3dn.24xlarge (ajánlott)
• ml.p4d.24xlarge (ajánlott)

A legjobb teljesítmény és a legtöbbet kihozni SMDataParallel, akkor legalább két példányt kell használnia, de használhat egyet a példa teszteléséhez is.

A következő példafüzet részletesebb, lépésenkénti útmutatást nyújt.

Elosztott képzés: Modellpárhuzam

A modell-párhuzamot alkalmazó elosztott képzéshez a Hugging Face Transformers és adatkészlet-könyvtárat a SageMaker SDK-val együtt használjuk a szekvenciaosztályozáshoz a Általános nyelvértés értékelése (GLUE) benchmark egy többcsomópontos, több GPU-s klaszteren a SageMaker modell párhuzamossági könyvtár.

Az adatok párhuzamosságához hasonlóan először beállítjuk a git konfigurációt, a betanítási hiperparamétereket és az elosztási paramétereket a HuggingFace Becslő:

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

A modell-párhuzamossági könyvtár belsőleg MPI-t használ, ezért a modellpárhuzam használatához az MPI-t engedélyezni kell az elosztási paraméter használatával. "processes_per_host” az előző kódban megadja azon folyamatok számát, amelyeket az MPI-nek el kell indítania minden gazdagépen. Ezeket ajánljuk fejlesztésre és tesztelésre. A gyártás idején felveheti a kapcsolatot az AWS ügyfélszolgálatával, ha nagy GPU-kapacitást igényel. További információkért lásd Futtasson egy SageMaker elosztott modell párhuzamos képzési munkát.

A következő példafüzet tartalmazza a teljes kódszkripteket.

Helyszínpéldányok

A SageMaker Python SDK Hugging Face keretrendszer-kiterjesztésével a teljes mértékben felügyelt Amazon rugalmas számítási felhő (Amazon EC2) Helyszínpéldányok és akár a képzési költségünk 90%-át is megtakaríthatja.

Hacsak a képzési munkája nem fejeződik be gyorsan, javasoljuk, hogy használja ellenőrzőpont irányított helyszíni képzéssel, ezért meg kell határozni checkpoint_s3_uri.

A spot példányok használatához a HuggingFace Becslő, be kell állítanunk a use_spot_instances paramétert igazra állítsa, és adja meg a saját max_wait és a max_run idő. A felügyelt helyszíni képzési életciklussal kapcsolatos további információkért lásd: Menedzselt helyszíni képzés az Amazon SageMakerben.

A következő kódrészlet egy spot edzésbecslő beállításához:

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)

A következő jegyzetfüzet tartalmazza a teljes kódszkripteket.

Következtetés

Ebben a bejegyzésben megvitattuk a Hugging Face Transformers megosztott képzését a SageMaker segítségével. Először áttekintettük az adat-párhuzamosság és a modell-párhuzamosság használati eseteit. Az adatok párhuzamossága általában megfelelőbb, de nem feltétlenül korlátozódik arra az esetre, amikor a képzés szűk keresztmetszetet jelent a számítások miatt, míg a modellpárhuzamot akkor használhatja, ha a modell nem fér el az egyetlen gyorsítón biztosított memóriába. Ezután megmutattuk, hogyan kell edzeni mindkét módszerrel.

Az általunk tárgyalt adatpárhuzamossági esetnél a modell betanítása egyetlen p3.2xlarge példányon (egyetlen GPU-val) 4 órát vesz igénybe, és az írás idején nagyjából 15 dollárba kerül. Az adatok párhuzamosságával ugyanazt a modellt 24 perc alatt betaníthatjuk 28 dolláros költséggel. Bár a költségek megduplázódtak, ez 10-szeresére csökkentette a betanítási időt. Olyan helyzetekben, amikor sok modellt kell betanítani rövid időn belül, az adatok párhuzamossága viszonylag alacsony költségnövekedés mellett teszi lehetővé ezt. Ami a modellpárhuzamos használati esetet illeti, ez lehetőséget ad olyan modellek betanítására, amelyeket korábban a hardver korlátai miatt egyáltalán nem lehetett volna betanítani. Mindkét funkció új munkafolyamatokat tesz lehetővé az ML szakemberek számára, és könnyen elérhető a következőn keresztül HuggingFace Becslő a SageMaker Python SDK részeként. Ezeknek a modelleknek a hosztolt végpontokra történő telepítése ugyanazt az eljárást követi, mint a többi becslő esetében.

Ez az integráció más, a SageMaker ökoszisztéma részét képező funkciókat tesz lehetővé. Használhatja például az azonnali példányokat, ha egy egyszerű jelzőt ad a Becslőhöz a további költségoptimalizálás érdekében. Következő lépésként megkeresheti és futtathatja a képzési bemutató és a példafüzet.

A szerzőkről

Archis Joglekar AI/ML Partner Solutions Architect az Emerging Technologies csapatban. Az AWS építőelemeit használó, hatékony, méretezhető mély tanulás és tudományos számítástechnika érdekli. Korábbi tapasztalatai a számítási fizika kutatásától a gépi tanulási platform fejlesztéséig terjednek az egyetemeken, nemzeti laboratóriumokban és startupokban. A számítógéptől távol töltött idejét focizással, barátokkal és családdal tölti.

James Yi Sr. AI/ML Partner Solutions Architect az Amazon Web Services Emerging Technologies csapatában. Szenvedélyesen dolgozik a vállalati ügyfelekkel és partnerekkel az AI/ML alkalmazások tervezése, üzembe helyezése és méretezése érdekében, hogy üzleti értékeikből származtassanak. Munkán kívül szeret focizni, utazni és a családjával tölt időt.

Philipp Schmid gépi tanulási mérnök és műszaki vezető a Hugging Face-nél, ahol az Amazon SageMaker csapatával való együttműködést vezeti. Szenvedélye az élvonalbeli NLP-modellek demokratizálása, optimalizálása és gyártása, valamint a Deep Learning egyszerű használatának javítása.

Sylvain Gugger a Hugging Face kutatómérnöke és a Transformers könyvtár egyik fő karbantartója. Szereti a nyílt forráskódú szoftvereket, és segíti a közösséget a használatában.

Jeff Boudier termékeket épít a Hugging Face-nél, a Transformers, a vezető nyílt forráskódú ML-könyvtár megalkotójában. Korábban Jeff a GoPro által felvásárolt Stupeflix társalapítója volt, ahol a termékmenedzsment, termékmarketing, üzletfejlesztés és vállalatfejlesztés igazgatójaként dolgozott.

Forrás: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- transformers-on-amazon-sagemaker/