Train gigantische modellen met bijna-lineaire schaling met behulp van shard-gegevensparallellisme op Amazon SageMaker

In het streven naar superieure nauwkeurigheid zijn deep learning-modellen op gebieden zoals natuurlijke taalverwerking en computervisie de afgelopen jaren aanzienlijk in omvang gegroeid, vaak geteld in tientallen tot honderden miljarden parameters. Het trainen van deze gigantische modellen is een uitdaging en vereist complexe distributiestrategieën. Datawetenschappers en machine learning-engineers zijn voortdurend op zoek naar de beste manier om hun trainingscomputer te optimaliseren, maar worstelen met de communicatie-overhead die kan toenemen met de totale clustergrootte.

Dit is waarom we onlangs lanceerden sharde data parallellisme on Amazon Sage Maker, een nieuwe geheugenbesparende gedistribueerde trainingstechniek in de SageMaker model parallelle (SMP) bibliotheek. Sharded data parallellisme is speciaal gebouwd voor extreme schaalmodellen en maakt gebruik van Amazon in-house Microfoons technologie onder de motorkap, een wetenschappelijke inspanning om de communicatieschaal te minimaliseren door dure communicatie-overhead te verminderen die is geworteld in het verzamelen van parameters en gradiëntsynchronisatie. Met een 30B-parameter GPT-2-model met een sequentielengte van 2048, behaalde deze nieuwe functie 141 TFLOP's, een snelheid van 39.7% vergeleken met DeepSpeed ​​ZeRO-3. Voor een 10B GPT-2-model met een sequentielengte van 512, behaalde deze nieuwe functie ook 564 samples per seconde, een snelheid van 13.9% vergeleken met PyTorch's Fully Sharded Data Parallel (FSDP). Onthoud dat bij gigantische modeltraining elk percentage van de versnelling zich vertaalt in bespaarde dollars en hogere productiviteit in uw team.

In deze blogpost gaan we eerst dieper in op de belangrijkste onderscheidende factoren van sharded-gegevensparallellisme en wanneer u het moet gebruiken. Vervolgens leert u hoe u met deze nieuwe functie gemakkelijk een 30B-parameter GPT-2-model op SageMaker kunt trainen. Ten slotte zullen we de prestaties vergelijken met andere open source-opties, met name beter dan DeepSpeed ​​ZeRO tot 39.7% op 256 GPU's.

Hoe shard-gegevensparallellisme werkt en wanneer het te gebruiken?

Laten we, voordat we sharded data-parallellisme introduceren, eens kijken naar de bredere techniekfamilie. Recente gedistribueerde trainingsbenaderingen voor grote modellen zijn verschoven naar een paradigma waarin modelparameters, gradiënten en optimalisatiestatussen worden gedeeld over dataparallelle knooppunten. In tegenstelling tot Pipeline Parallelism, dat de aangeboren complexiteit heeft van het kiezen van lagen om over verschillende apparaten te verdelen, vooral wanneer uw framework dit niet ondersteunt geautomatiseerde modelsplitsing, behoudt dit paradigma op elegante wijze de eenvoud van gegevensparallellisme, terwijl het de beperking van gegevensparalllisme wegneemt waarbij een model in een enkele GPU moet passen.

In bestaande kaders die onder dit paradigma vallen, met name DeepSpeed ​​ZeRO-3 en PyTorch's FSDP stroomopwaarts van FairScale, zijn modelstaten verdeeld over allen GPU's, een strategie die het geheugenverbruik op elke GPU verlaagt ten koste van grote communicatie-overhead die toeneemt met de clustergrootte en er daarom voor zorgt dat de schaalbaarheid op schaal aanzienlijk afneemt. Daarentegen sharded data parallellisme in de SMP bibliotheek partities model staten in a schaalbewust manier door elke replica van modelstatussen alleen te partitioneren binnen een deelverzameling van GPU's.

Laten we eens nader kijken naar de schaalbewuste modelpartitionering in MiCS, de kerntechnologie achter sharded data parallel. De intuïtie achter dit ontwerp is dat het misschien niet nodig is om trainingsstatussen te verdelen over de hele dataparallelle groep om een ​​model met tientallen miljarden parameters te trainen. 8 V100 GPU's (elk 32 GB) zijn bijvoorbeeld voldoende om de modelstatusreplica van een 10B-parametermodel te bevatten dat ongeveer 200 GB geheugen nodig heeft bij het trainen met Adam Optimizer met gemengde precisie. Door een volledige replica van modelstatussen te beperken in de kleinste subset van GPU's, kunnen we de omvang van de communicatie-overhead effectief verminderen in vergelijking met DeepSpeed ​​en PyTorch FSDP. Sharded data parallel maakt ook gebruik van andere technieken in MiCS, zoals hiërarchische communicatie en 2-hop gradiëntsynchronisatie. Kijk voor meer informatie op Bijna-lineaire schaal van training met gigantische modellen op AWS or MiCS: bijna-lineaire schaling voor het trainen van een gigantisch model op de openbare cloud.

Hoe weet u nu wanneer u sharded-gegevens parallel moet kiezen boven andere gedistribueerde trainingstechnieken? De algemene regel is dat als uw model minder dan 1 miljard parameters heeft en in het GPU-geheugen past, SageMaker data parallelle bibliotheek or SageMaker-trainingscompiler voor u voldoende kan zijn. Als u grotere taal- of computervisiemodellen heeft, raden wij u aan deze te trainen met de sharded data parallellism-techniek in combinatie met activering checkpointing en activering ontladen eerst in de parallelle bibliotheek van het SageMaker-model, voordat andere technieken zoals: tensor parallellisme of pijplijn parallellisme.

Sharded data parallellisme gebruiken om GPT-2 te trainen op Amazon SageMaker

Laten we nu leren hoe u een GPT-2-model met parallelle sharded data kunt trainen, waarbij SMP de complexiteit voor u inkapselt. Deze volledig zelfstudie notitieboek begeleidt u door het hele proces, van gegevensverwerking, het definiëren en indienen van trainingstaken tot het bewaken van trainingslogboeken. Wat volgt is een kort overzicht met de belangrijkste stappen voor het gebruik van deze functie.

1. Begin

Sharded data parallellisme is beschikbaar in PyTorch v1.12.0+ en werkt met zowel FP16 als BF16. De eenvoudigste manier om de SMP-bibliotheek te gebruiken, is via een vooraf gebouwde AWS Deep Learning Container voor PyTorch. Als u echter uw eigen Docker-container wilt meenemen, kunt u verwijzen naar: Maak uw eigen Docker-container met de SageMaker Distributed Model Parallel Library. Om te beginnen, volg Een PyTorch-trainingsscript wijzigen om de API's van SMP's aan te passen in uw trainingsscript. In deze sectie noemen we slechts enkele hoofdstappen met codefragmenten uit het kant-en-klare trainingsscript train_gpt_simple.py. U kunt de opmerkingen in het script volgen en API-document voor meer informatie over waar SMP-API's worden gebruikt.

Importeer en initialiseer eerst de bibliotheek door te bellen met smdistributed.modelparallel.torch.init() aan het begin van het trainingsscript:

import smdistributed.modelparallel.torch as smp

smp.init(smp_config)

Ten tweede, wikkel het model waarmee gepartitioneerd moet worden smdistributed.modelparallel.toorts.DistributedModel en gebruik de geretourneerde DistributedModel voorwerp vooruit:

from transformers import AutoModelForCausalLM

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

Wikkel de optimizer met smdistributed.modelparallel.torch.DistributedOptimizer voor het opslaan en laden van optimalisatiestatussen.

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},
        )

Zet de voorwaartse en achterwaartse logica in een stapfunctie en versier deze met smdistributed.modelparallel.torch.step.  Elke berekening gedefinieerd binnen de smp.step-decorated functie wordt gedistribueerd uitgevoerd.

@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. Bereid de dataset voor

We maken gebruik van de openwebtekst is de dataset die we in dit voorbeeld gebruiken. De notebook gebruikt het script data_prep_512.py om de dataset te downloaden en voor te verwerken. U kunt ook met andere datasets trainen door te wijzigen data_pipeline.py. Als u te maken heeft met grote datasets en modellen, kunt u de trainingstaak versnellen door gegevens te gebruiken die zijn opgeslagen in Amazon FSx voor Luster, dat een krachtig bestandssysteem biedt dat native is geïntegreerd met Amazon eenvoudige opslagservice (S3). Zie de instructies van Configureer het gegevensinvoerkanaal om Amazon FSx te gebruiken voor glans voor begeleiding bij het instellen van een FSx Luster-bestandssysteem als gegevensinvoerkanaal.

3. Start de trainingstaken

Bij deze stap wordt ervan uitgegaan dat u al je trainingsscript aangepast en de dataset voorbereid zoals vermeld in de voorgaande paragrafen. Tot schakel shard-gegevensparallellisme in, stel eenvoudig de sharded_data_parallel_degree in de PyTorch-schatter. In deze zelfstudie stellen we sharded_data_parallel_degree=128 en instace_count=32 voor p4d.24xlarge nodes, wat aangeeft dat de modelstatussen zullen worden verdeeld over 128 GPU's van de in totaal 256 GPU's. Op basis van deze geselecteerde waarde stelt SMP dan automatisch de dataparallelgraad in op 2 (omdat 256/128=2), wat betekent dat we twee replica's hebben voor dataparallellisme. Een algemene regel voor het kiezen van een ideale waarde voor: sharded_data_parallel_degree is om een ​​extra knooppunt toe te voegen aan de deelgroep per elke 3B modelparameters. In deze zelfstudie is onze modelgrootte 30B, dus we moeten ten minste 10 knooppunten gebruiken voor sharding. En omdat 16 nodes (128 GPU's) de kleinste power-of-2 boven de drempel is, stellen we in sharded_data_parallel_degree=128.

Voor controlepunten bieden we ook een set hulpprogramma's voor controlepunten in sharded_data_parallel_checkpoint.py , inclusief een hulpprogramma om de volledige state_dict voor geavanceerde gebruikssituaties. Ten slotte kunnen we een gedistribueerde trainingstaak starten door fit() op de Estimator aan te roepen.

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. Bewaak de opleidingstaken

U kunt toegang krijgen tot de trainingslogboeken en GPU- en geheugengebruik volgen op Amazon Cloud Watch. Zorg ervoor dat u de logs van "algo-1" bekijkt omdat dat het hoofdknooppunt is waarvan de uitvoerstroom de trainingstaaklogboeken van alle instanties heeft.

Benchmarking prestaties

We hebben shard-gegevensparallellisme in de SMP-bibliotheek gebenchmarkt op zowel 16 als 32 p4d.24xlarge-knooppunten voor respectievelijk sequentielengte 512 en 2048. Het GPT30-model met 2B-parameter is geconfigureerd om een ​​verborgen breedte van 7168, 48 lagen en 64 koppen te gebruiken. U kunt exact dezelfde configuratie aannemen waarbij de sequentielengte 2048 is door in te stellen: model_config = "gpt2-30b" in het instructieboekje. Met deze instelling behaalde SMP 73.52 samples per seconde, een snelheid van 39.7% vergeleken met DeepSpeed ​​ZeRO-3. Als uw token 500 miljard is, betekent deze snelheidswinst bijna 367 uur besparing op p4d.24xlarge nodes, een equivalent van meer dan $12,000 bespaard budget per training! De volgende tabel vat onze benchmarkresultaten samen.

1/ Voor elke modelconfiguratie hebben we verschillende functies, fasen en configuraties in DeepSpeed ​​ZeRO getest en degene gekozen die de beste doorvoer biedt als de DeepSpeed-basislijn. De benchmark is uitgevoerd op Amazon Elastic Compute-cloud (Amazone EC2). 2/ Deze resultaten zijn gebaseerd op verbeterde communicatiecollectieven die zijn geoptimaliseerd voor AWS en die binnenkort beschikbaar zullen zijn. 3/ De tijd om te trainen wordt geprojecteerd op basis van snelheid op basis van het aantal verwerkte tokens.

Samenvattend hebben we een consistent hogere doorvoer waargenomen met parallellisme van shard-gegevens in SMP in vergelijking met DeepSpeed ​​voor een reeks modellen en configuraties. Deze nieuwe functie toonde ook een betere geheugenefficiëntie in vergelijking met DeepSpeed, waardoor SMP in een grotere batchgrootte kon passen en het niveau van gradiëntaccumulatie dat nodig is om te passen bij een bepaalde wereldwijde batchgrootte, te verminderen.

Conclusie

In dit bericht hebben we een nieuwe gedistribueerde trainingstechniek geïntroduceerd - sharded data parallellisme - en hoe het gigantische modeltraining versnelt met bijna lineaire schaling op Amazon SageMaker. We hebben ook uitgelegd hoe je een GPT-2-model kunt trainen met de nieuwe techniek die hierna volgt compleet voorbeeld. U kunt de . volgen Amazon SageMaker-voorbeelden GitHub-opslagplaats om alle parallelle voorbeelden van SageMaker-modellen te volgen of onze volgende bij te wonen gedistribueerde trainingsworkshops. Voor meer informatie over sharded-gegevensparallellisme, raadpleegt u de: documentatie.

Over de auteurs

Emily Webber kwam bij AWS net na de lancering van SageMaker en probeert sindsdien de wereld erover te vertellen! Naast het bouwen van nieuwe ML-ervaringen voor klanten, mediteert Emily graag en bestudeert ze het Tibetaans boeddhisme.

Kan Karakus is Senior Applied Scientist bij AWS en optimaliseert grootschalige gedistribueerde deep learning op AWS. Zijn onderzoeksinteresses omvatten deep learning, gedistribueerde optimalisatie, gedistribueerde systemen en informatietheorie. Naast zijn werk houdt hij van fietsen, reizen, lezen en leren.

Rahul Huilgol is Senior Software Engineer bij AWS. Hij werkt aan gedistribueerde deep learning-systemen om het gemakkelijk en performant te maken om grote deep learning-modellen in de cloud te trainen. In zijn vrije tijd houdt hij van fotografie, fietsen en tuinieren.

Suhit Kodgule is een Software Development Engineer bij de AWS Artificial Intelligence-groep die werkt aan deep learning-frameworks. In zijn vrije tijd houdt hij van wandelen, reizen en koken.

Erin Ho is een productmanager voor AWS Deep Learning. Ze werkt aan producten die het voor klanten gemakkelijker maken om deep learning-modellen op AWS te trainen. Voor de lol buiten haar werk houdt ze van wandelen en skiën.