Antrenați modele gigantice cu scalare aproape liniară folosind paralelismul de date fragmentat pe Amazon SageMaker

În căutarea unei acuratețe superioare, modelele de învățare profundă în domenii precum procesarea limbajului natural și viziunea pe computer au crescut semnificativ în dimensiuni în ultimii câțiva ani, numărate frecvent în zeci până la sute de miliarde de parametri. Antrenarea acestor modele gigantice este o provocare și necesită strategii complexe de distribuție. Oamenii de știință de date și inginerii de învățare automată caută în mod constant cea mai bună modalitate de a-și optimiza calculul de antrenament, dar se confruntă cu cheltuielile generale de comunicare care pot crește odată cu dimensiunea globală a clusterului.

Acesta este motivul pentru care ne-am lansat recent sparalelism de date harded on Amazon SageMaker, o nouă tehnică de antrenament distribuită pentru salvarea memoriei în Biblioteca SageMaker model paralel (SMP).. Paralelismul de date fragmentate este conceput special pentru modele la scară extremă și utilizează Amazon intern MiCS tehnologia sub capotă, un efort științific de a minimiza scara de comunicare prin reducerea cheltuielilor de comunicare costisitoare bazate pe colectarea parametrilor și sincronizarea gradientului. Cu un model GPT-30 cu parametri 2B cu lungimea secvenței 2048, această nouă caracteristică a atins 141 TFLOP, o viteză de 39.7% în comparație cu DeepSpeed ​​ZeRO-3. Pentru un model 10B GPT-2 cu lungimea secvenței 512, această nouă caracteristică a atins și 564 de eșantioane pe secundă, o viteză de 13.9% în comparație cu Fully Sharded Data Parallel (FSDP) de la PyTorch. Amintiți-vă că în antrenamentele gigantice pentru modele, fiecare procent de accelerare se traduce în dolari economisiți și în productivitate câștigată în echipa dvs.

În această postare de blog, vom arunca mai întâi o privire mai atentă asupra principalelor diferențieri ai paralelismului de date fragmentate și când să-l folosim. Apoi, veți învăța cum să antrenați cu ușurință un model GPT-30 cu parametri 2B pe SageMaker cu această nouă caracteristică. În cele din urmă, vom compara performanța cu alte opțiuni open source, în special depășind DeepSpeed ​​ZeRO cu până la 39.7% pe 256 de GPU-uri.

Cum funcționează paralelismul de date fragmentate și când să îl utilizați

Înainte de a introduce paralelismul de date fragmentate, să ne uităm la familia sa mai largă de tehnici. Abordările recente de instruire distribuită pentru modele mari s-au mutat la o paradigmă în care parametrii modelului, gradienții și stările de optimizare sunt partajate între nodurile paralele de date. Spre deosebire de Pipeline Parallelism, care are complexitatea înnăscută de a alege straturi de partiționat între dispozitive, mai ales atunci când cadrul dvs. nu acceptă împărțirea automată a modelelor, această paradigmă păstrează în mod elegant simplitatea paralelismului de date, îndepărtând în același timp constrângerea paralelismului de date în care un model trebuie să se potrivească într-un singur GPU.

În cadrele existente care se încadrează în această paradigmă, în special DeepSpeed ​​ZeRO-3 și FSDP PyTorch upstream de la FairScale, stările modelului sunt împărțite peste tot. toate GPU-uri, o strategie care reduce consumul de memorie pe fiecare GPU cu prețul suportării unei sarcini mari de comunicare, care crește odată cu dimensiunea clusterului și, prin urmare, face ca scalabilitatea să scadă semnificativ la scară. În contrast, paralelismul de date fragmentat în modelul de partiții de bibliotecă SMP afirmă în a conștient de scară mod prin partiționarea fiecărei replică a stărilor modelului numai în interior un subset a GPU-urilor.

Să ne uităm mai atent la partiționarea modelului la scară în MiCS, tehnologia de bază din spatele paralelei de date fragmentate. Intuiția din spatele acestui design este că partiționarea stărilor de antrenament în întregul grup de date paralele poate să nu fie necesară pentru a antrena un model cu zeci de miliarde de parametri. De exemplu, 8 GPU-uri V100 (32 GB fiecare) sunt suficiente pentru a păstra replica stărilor modelului unui model cu parametri 10B care necesită aproximativ 200 GB de memorie atunci când se antrenează cu optimizatorul Adam folosind precizie mixtă. Prin limitarea unei replici complete a stărilor modelului în cel mai mic subsetul de GPU-uri, putem reduce în mod eficient amploarea supraîncărcării de comunicare în comparație cu DeepSpeed ​​și PyTorch FSDP. Paralelul de date partajate folosește și alte tehnici în MiCS, cum ar fi Comunicarea ierarhică și Sincronizarea gradientului cu 2 hop. Pentru mai multe informații, verificați Scalare aproape liniară a antrenamentului pe model gigantic pe AWS or MiCS: Scalare aproape liniară pentru antrenarea modelului gigantic pe Public Cloud.

Acum, de unde știi când să alegi date fragmentate în paralel față de alte tehnici de antrenament distribuite? Regula generală este că, dacă modelul tău are mai puțin de 1 miliard de parametri și poate încadra în memoria GPU, Biblioteca paralelă de date SageMaker or Compilatorul de instruire SageMaker poate fi suficient pentru tine. Dacă aveți modele mai mari de limbaj sau de viziune computerizată, sugestia noastră este să-l antrenați cu tehnica de paralelism a datelor fragmentate combinată cu punct de control de activare și descărcare de activare în biblioteca paralelă de modele SageMaker mai întâi, înainte de alte tehnici precum paralelism tensor sau paralelismul conductelor.

Utilizarea paralelismului de date fragmentate pentru a antrena GPT-2 pe Amazon SageMaker

Să învățăm acum cum să antrenăm un model GPT-2 cu date fragmentate în paralel, cu SMP care încapsulează complexitatea pentru tine. Acest caiet tutorial complet vă ghidează prin întregul proces, de la procesarea datelor, definirea și trimiterea joburilor de formare până la monitorizarea jurnalelor de instruire. Ceea ce urmează este o scurtă prezentare generală care evidențiază pașii cheie pentru utilizarea acestei funcții.

1. Începeți

Paralelismul de date partajate este disponibil în PyTorch v1.12.0+ și funcționează atât cu FP16, cât și cu BF16. Cel mai simplu mod de a utiliza biblioteca SMP este printr-un container AWS Deep Learning pentru PyTorch predefinit. Cu toate acestea, dacă doriți să vă aduceți propriul container Docker, vă puteți referi la Creați-vă propriul container Docker cu SageMaker Distributed Model Parallel Library. Pentru a începe, urmează Modificați un script de antrenament PyTorch pentru a adapta API-urile SMP-urilor în scriptul de antrenament. În această secțiune, menționăm doar câțiva pași principali cu fragmente de cod din scriptul de instruire gata de utilizat train_gpt_simple.py. Puteți urmări comentariile din scenariu și Document API pentru a afla mai multe despre unde sunt utilizate API-urile SMP.

Mai întâi, importați și inițializați biblioteca apelând smdistributed.modelparallel.torch.init() la începutul scenariului de antrenament:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

În al doilea rând, înfășurați modelul cu care urmează să fie partiționat smdistributed.modelparallel.torch.DistributedModel și folosiți cea returnată DistributedModel obiect înainte:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_config(model_config)
model = smp.DistributedModel(model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation)

Înfășurați optimizatorul cu smdistributed.modelparallel.torch.DistributedOptimizer pentru salvarea și încărcarea stărilor optimizatorului.

from torch import optim

optimizer = optim.Adam(
    param_groups, betas=(args.beta1, args.beta2), lr=args.lr, weight_decay=args.weight_decay
)

optimizer = smp.DistributedOptimizer(
        optimizer, 
        static_loss_scale=None, 
        dynamic_loss_scale=True,
        dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
        )

Puneți logica înainte și înapoi într-o funcție de pas și decorați-o cu smdistributed.modelparallel.torch.step.  Orice calcul definit în interiorul smp.step-decorated funcția este executată într-o manieră distribuită.

@smp.step
def train_step(model, optimizer, input_ids, attention_mask, args):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    model.backward(loss)

    return loss

@smp.step
def test_step(model, input_ids, attention_mask):
    loss = model(input_ids=input_ids, attention_mask=attention_mask, labels=input_ids)["loss"]
    
    return loss

2. Pregătiți setul de date

Noi folosim openwebtext este setul de date pe care îl folosim în acest exemplu. Caietul folosește scriptul data_prep_512.py pentru a descărca și preprocesa setul de date. De asemenea, vă puteți antrena cu alte seturi de date prin modificare data_pipeline.py. Când aveți de-a face cu un set de date și un model mare, puteți accelera munca de antrenament utilizând datele stocate în Amazon FSx pentru Luster, care oferă un sistem de fișiere de înaltă performanță integrat în mod nativ Serviciul Amazon de stocare simplă (S3). Vă rugăm să consultați instrucțiunile de la Configurați canalul de intrare a datelor pentru a utiliza Amazon FSx pentru Luster pentru îndrumări privind setarea unui sistem de fișiere FSx Luster ca canal de intrare a datelor.

3. Începeți lucrările de formare

Acest pas presupune că ați făcut-o deja a modificat scriptul de antrenament și a pregătit setul de date așa cum este menționat în secțiunile precedente. La activați paralelismul de date fragmentate, pur și simplu setați sharded_data_parallel_degree în Estimator PyTorch. În acest tutorial, setăm sharded_data_parallel_degree=128 și instace_count=32 pentru nodurile p4d.24xlarge, ceea ce indică faptul că stările modelului vor fi împărțite pe 128 de GPU-uri din totalul de 256 de GPU-uri. Pe baza acestei valori selectate, SMP va seta apoi automat gradul de paralelism al datelor la 2 (deoarece 256/128=2), ceea ce înseamnă că vom avea două replici pentru paralelismul datelor. O regulă generală pentru alegerea unei valori ideale pentru sharded_data_parallel_degree este de a adăuga încă un nod la grupul de partajare la fiecare 3B de parametri ai modelului. În acest tutorial, dimensiunea modelului nostru este de 30B, așa că ar trebui să folosim cel puțin 10 noduri pentru fragmentare. Și deoarece 16 noduri (128 GPU-uri) este cea mai mică putere de 2 peste prag, am stabilit sharded_data_parallel_degree=128.

Pentru puncte de control, oferim, de asemenea, un set de utilități pentru puncte de control sharded_data_parallel_checkpoint.py , inclusiv o utilitate pentru a reconstrui integral state_dict pentru cazuri de utilizare avansate. În cele din urmă, putem lansa un job de instruire distribuit apelând fit() pe Estimator.

smp_estimator = PyTorch(
    entry_point="train_gpt_simple.py",
    instance_type="ml.p4d.24xlarge",
    source_dir=os.getcwd(),
    volume_size=500,
    instance_count=32,
    distribution={
        "mpi": {
            "enabled": True,
            "processes_per_host": processes_per_host,
            "custom_mpi_options": mpioptions,
        },
        "smdistributed": {
            "modelparallel": {
                "enabled": True,
                "parameters": {
                    "ddp": True,
                    "skip_tracing": True,
                    "delayed_parameter_initialization": True,
                    "offload_activations": True,
                    "activation_loading_horizon": 4,
                    # To enable sharded data parallelism.
                    # Here we shard model states across 128 GPUs. 
                    "sharded_data_parallel_degree": 128, 
                    "fp16": False,
                    "bf16": True,
                    # This is to disable pipeline parallelism.
                    "partitions": 1,
                },
            }
        },
    },
    framework_version="1.12",
    py_version="py38",
    hyperparameters=hyperparameters,
    checkpoint_s3_uri=checkpoint_s3_uri if not use_fsx else None,
    checkpoint_local_path=hyperparameters["checkpoint-dir"] if use_fsx else None,
    ...
)

smp_estimator.fit(inputs=data_channels)

4. Monitorizați locurile de muncă de formare

Puteți accesa jurnalele de antrenament și puteți urmări utilizarea GPU-ului și a memoriei Amazon CloudWatch. Asigurați-vă că vă uitați la jurnalele „algo-1” deoarece acesta este nodul principal al cărui flux de ieșire are jurnalele de lucru de antrenament din toate instanțele.

Benchmarking performanță

Am evaluat paralelismul de date sharded în biblioteca SMP atât pe 16, cât și pe 32 de noduri p4d.24xlarge pentru lungimea secvenței 512 și, respectiv, 2048. Modelul GPT30 cu parametri 2B este configurat să utilizeze o lățime ascunsă de 7168, 48 de straturi și 64 de capete. Puteți adopta exact aceeași configurație în care lungimea secvenței este 2048 prin setare model_config = "gpt2-30b" în caietul tutorial. Cu această setare, SMP a atins 73.52 de mostre pe secundă, o viteză de 39.7% în comparație cu DeepSpeed ​​ZeRO-3. Dacă dimensiunea simbolului dvs. este de 500 de miliarde, această accelerare înseamnă aproape 367 de ore de economii pe nodurile p4d.24xlarge, un echivalent a unui buget de peste 12,000 USD economisit pe antrenament! Următorul tabel rezumă rezultatele noastre de referință.

1/ Pentru fiecare configurație de model, am testat diferite caracteristici, etape și configurații în DeepSpeed ​​ZeRO și am ales-o pe cea care oferă cel mai bun debit ca linie de bază DeepSpeed. Benchmark-ul a fost continuat Cloud Elastic de calcul Amazon (Amazon EC2). 2/ Aceste rezultate se bazează pe colective de comunicare îmbunătățite optimizate pentru AWS, care vor fi disponibile în curând. 3/ Timpul până la antrenament este proiectat din viteza pe baza numărului de jetoane procesate.

În rezumat, am observat în mod constant un debit mai mare cu paralelismul de date fragmentat în SMP în comparație cu DeepSpeed ​​într-o serie de modele și configurații. Această nouă caracteristică a demonstrat, de asemenea, o eficiență mai bună a memoriei în comparație cu DeepSpeed, permițând SMP să se potrivească cu o dimensiune mai mare a lotului și să reducă nivelul de acumulare de gradient necesar pentru a se potrivi cu o anumită dimensiune globală a lotului.

Concluzie

În această postare, am introdus o nouă tehnică de instruire distribuită - paralelismul de date fragmentat - și modul în care accelerează antrenamentul gigantic al modelului cu scalare aproape liniară pe Amazon SageMaker. De asemenea, am explicat cum să antrenăm un model GPT-2 cu noua tehnică care urmează exemplu complet. Puteți urmări Amazon SageMaker Exemple de depozit GitHub pentru a urmări toate exemplele paralele de modele SageMaker sau pentru a participa la următorul nostru ateliere de instruire distribuite. Pentru a afla mai multe despre paralelismul datelor fragmentate, consultați documentaţie.

Despre autori

Emily Webber sa alăturat AWS imediat după lansarea SageMaker și de atunci a încercat să spună lumii despre asta! În afară de a construi noi experiențe ML pentru clienți, lui Emily îi place să mediteze și să studieze budismul tibetan.

Can Karakus este cercetător senior aplicat la AWS, care optimizează învățarea profundă distribuită la scară largă pe AWS. Interesele sale de cercetare acoperă învățarea profundă, optimizarea distribuită, sistemele distribuite și teoria informației. În afara serviciului, îi place să meargă cu bicicleta, să călătorească, să citească și să învețe.

Rahul Huilgol este inginer software senior la AWS. Lucrează pe sisteme de deep learning distribuite, pentru a face mai ușoară și performantă antrenarea modelelor mari de deep learning în cloud. În timpul liber, îi place fotografia, ciclismul și grădinărit.

Suhit Kodgule este inginer de dezvoltare software cu grupul de inteligență artificială AWS care lucrează pe cadre de învățare profundă. În timpul liber, îi place drumețiile, călătoriile și gătitul.

Erin Ho este manager de produs pentru AWS Deep Learning. Lucrează la produse care facilitează pentru clienți antrenarea modelelor de deep learning pe AWS. Pentru distracție în aer liber, îi place drumeții și schi.