Dela via

Öka kontrollpunktshastigheten och minska kostnaden med nebulosa

  • Artikel

Lär dig hur du ökar kontrollpunktshastigheten och minskar kostnaderna för kontrollpunkter för stora Azure Machine Learning-träningsmodeller med nebulosa.

Översikt

Nebula är ett snabbt, enkelt, disklöst, modellmedveten kontrollpunktsverktyg i Azure Container for PyTorch (ACPT). Nebulosa erbjuder en enkel, snabb kontrollpunktslösning för distribuerade storskaliga modellträningsjobb med PyTorch. Genom att använda de senaste teknikerna för distribuerad databehandling kan Nebula minska kontrollpunktstiderna från timmar till sekunder , vilket kan spara 95 % till 99,9 % av tiden. Storskaliga träningsjobb kan dra stor nytta av Nebulos prestanda.

Om du vill göra Nebula tillgängligt för dina träningsjobb importerar du nebulaml Python-paketet i skriptet. Nebula har fullständig kompatibilitet med olika distribuerade PyTorch-träningsstrategier, inklusive PyTorch Lightning, DeepSpeed med mera. Nebula-API:et är ett enkelt sätt att övervaka och visa kontrollpunktslivscykler. API:erna stöder olika modelltyper och säkerställer kontrollpunktskonsekvens och tillförlitlighet.

Viktigt!

Paketet nebulaml är inte tillgängligt för det offentliga PyPI Python-paketindexet. Den är endast tillgänglig i den Azure Container for PyTorch-kurerade miljön (ACPT) i Azure Machine Learning.It is only available in the Azure Container for PyTorch (ACPT) curated environment on Azure Machine Learning. Undvik problem genom att inte försöka installera nebulaml från PyPI eller med kommandot pip .

I det här dokumentet får du lära dig hur du använder Nebula med ACPT i Azure Machine Learning för att snabbt kontrollera dina modellträningsjobb. Dessutom får du lära dig hur du visar och hanterar nebulosa-kontrollpunktsdata. Du får också lära dig hur du återupptar modellträningsjobben från den senaste tillgängliga kontrollpunkten om det uppstår avbrott, fel eller avslutning av Azure Machine Learning.

Varför kontrollpunktsoptimering för stor modellträning är viktigt

I takt med att datavolymerna växer och dataformaten blir mer komplexa har maskininlärningsmodeller också blivit mer avancerade. Det kan vara svårt att träna dessa komplexa modeller på grund av GPU-minneskapacitetsbegränsningar och långa träningstider. Därför används distribuerad träning ofta när du arbetar med stora datamängder och komplexa modeller. Distribuerade arkitekturer kan dock uppleva oväntade fel och nodfel, vilket kan bli allt mer problematiskt när antalet noder i en maskininlärningsmodell ökar.

Kontrollpunkter kan hjälpa dig att åtgärda dessa problem genom att regelbundet spara en ögonblicksbild av det fullständiga modelltillståndet vid en viss tidpunkt. I händelse av ett fel kan den här ögonblicksbilden användas för att återskapa modellen till dess tillstånd vid tidpunkten för ögonblicksbilden så att träningen kan återupptas från den tidpunkten.

När stora modellträningsåtgärder drabbas av fel eller uppsägningar kan dataforskare och forskare återställa träningsprocessen från en tidigare sparad kontrollpunkt. Alla framsteg som görs mellan kontrollpunkten och avslutningen går dock förlorade eftersom beräkningar måste köras igen för att återställa osparade mellanliggande resultat. Kortare kontrollpunktsintervall kan bidra till att minska den här förlusten. Diagrammet illustrerar den tid som slösats bort mellan träningsprocessen från kontrollpunkter och avslutning:

Skärmbild som visar tidskostnaden för att återställa en träningsprocess från kontrollpunkter.

Processen att spara kontrollpunkter i sig kan dock generera betydande omkostnader. Att spara en kontrollpunkt i TB-storlek kan ofta bli en flaskhals i träningsprocessen, där den synkroniserade kontrollpunktsprocessen blockerar träningen i timmar. I genomsnitt kan kontrollpunktsrelaterade omkostnader stå för 12 % av den totala träningstiden och kan stiga till så mycket som 43 % (Maeng et al., 2021).

Sammanfattnings taget innebär hantering av stora kontrollpunkter för modell tung lagring och omkostnader för jobbåterställningstid. Frekventa kontrollpunktssparningar i kombination med återupptaganden av träningsjobb från de senaste tillgängliga kontrollpunkterna blir en stor utmaning.

Nebulosa till undsättning

För att effektivt träna stora distribuerade modeller är det viktigt att ha ett tillförlitligt och effektivt sätt att spara och återuppta träningsförloppet som minimerar dataförlust och slöseri med resurser. Nebula hjälper till att minska kontrollpunktsbesparingstider och GPU-timkrav för stora azure machine learning-träningsjobb genom att tillhandahålla snabbare och enklare kontrollpunktshantering.

Med nebulosa kan du:

  • Öka kontrollpunktshastigheten med upp till 1 000 gånger med ett enkelt API som fungerar asynkront med din träningsprocess. Nebulosa kan minska kontrollpunktstiderna från timmar till sekunder – en potentiell minskning på 95 % till 99 %.

    Skärmbild som visar tidsbesparingsförmånen för Nebula.

    Det här exemplet visar kontrollpunkten och minskning av träningstiden från slutpunkt till slutpunkt för fyra kontrollpunkter som sparar träningsjobben Hugging Face GPT2, GPT2-Large och GPT-XL. För den medelstora Hugging Face GPT2-XL-kontrollpunkten sparar (20,6 GB) uppnådde Nebula en tidsminskning på 96,9 % för en kontrollpunkt.

    Hastighetsökningen för kontrollpunkter kan fortfarande öka med modellstorlek och GPU-tal. Till exempel kan testning av en kontrollpunkt för träningspunkter spara 97 GB på 128 A100 NVIDIA GPU:er krympa från 20 minuter till 1 sekund.

  • Minska kostnaderna för träning från slutpunkt till slutpunkt för stora modeller genom att minimera kontrollpunktskostnaderna och minska antalet GPU-timmar som slösats bort vid jobbåterställning. Nebula sparar kontrollpunkter asynkront och avblocker träningsprocessen för att minska träningstiden från slutpunkt till slutpunkt. Det möjliggör också mer frekventa kontrollpunktssparningar. På så sätt kan du återuppta träningen från den senaste kontrollpunkten efter eventuella avbrott och spara tid och pengar som slösats bort på jobbåterställning och GPU-träningstimmar.

  • Ge fullständig kompatibilitet med PyTorch. Nebula erbjuder fullständig kompatibilitet med PyTorch och erbjuder fullständig integrering med distribuerade träningsramverk, inklusive DeepSpeed (>=0.7.3) och PyTorch Lightning (>=1.5.0). Du kan också använda den med olika Azure Machine Learning-beräkningsmål, till exempel Azure Machine Learning Compute eller AKS.

  • Hantera enkelt dina kontrollpunkter med ett Python-paket som hjälper dig att lista, hämta, spara och läsa in dina kontrollpunkter. För att visa kontrollpunktslivscykeln tillhandahåller Nebula även omfattande loggar på Azure Machine Learning-studio. Du kan välja att spara kontrollpunkterna på en lokal eller fjärransluten lagringsplats

    • Azure Blob Storage
    • Azure Data Lake Storage
    • NFS

    och få åtkomst till dem när som helst med några rader kod.

Förutsättningar

Använda nebulosa

Nebulosa ger en snabb och enkel kontrollpunktsupplevelse direkt i ditt befintliga träningsskript. Stegen för snabbstartsnebulosa är:

Använda ACPT-miljö

Azure Container for PyTorch (ACPT), en kuraterad miljö för PyTorch-modellträning, innehåller Nebula som ett förinstallerat, beroende Python-paket. Mer information om ACPT-avbildningen finns i Azure Container for PyTorch (ACPT) och Aktivera djupinlärning med Azure Container for PyTorch i Azure Machine Learning .

Initiera nebulosa

För att aktivera Nebula med ACPT-miljön behöver du bara ändra träningsskriptet för att importera nebulaml paketet och sedan anropa Nebula-API:erna på lämpliga platser. Du kan undvika ändringar i Azure Machine Learning SDK eller CLI. Du kan också undvika att ändra andra steg för att träna din stora modell på Azure Machine Learning Platform.

Nebulosa behöver initieras för att köras i träningsskriptet. I initieringsfasen anger du de variabler som bestämmer platsen och frekvensen för att spara kontrollpunkter, som du ser i det här kodfragmentet:

  import nebulaml as nm
  nm.init(persistent_storage_path=<YOUR STORAGE PATH>) # initialize Nebula

Nebulosa har integrerats i DeepSpeed och PyTorch Lightning. Därför blir initieringen enkel och enkel. De här exemplen visar hur du integrerar Nebula i dina träningsskript.

Viktigt!

För att spara kontrollpunkter med Nebula krävs lite minne för att lagra kontrollpunkter. Kontrollera att minnet är större än minst tre kopior av kontrollpunkterna.

Om minnet inte räcker för att lagra kontrollpunkter, rekommenderas du att konfigurera en miljövariabel NEBULA_MEMORY_BUFFER_SIZE i kommandot för att begränsa användningen av minnet per varje nod när du sparar kontrollpunkter. När du ställer in den här variabeln använder Nebula det här minnet som buffert för att spara kontrollpunkter. Om minnesanvändningen inte är begränsad använder Nebula minnet så mycket som möjligt för att lagra kontrollpunkterna.

Om flera processer körs på samma nod är det maximala minnet för att spara kontrollpunkter hälften av gränsen dividerat med antalet processer. Nebulosa använder den andra hälften för samordning av flera processer. Om du till exempel vill begränsa minnesanvändningen per nod till 200 MB kan du ange miljövariabeln som export NEBULA_MEMORY_BUFFER_SIZE=200000000 (i byte, cirka 200 MB) i kommandot. I det här fallet använder Nebula endast 200 MB minne för att lagra kontrollpunkterna i varje nod. Om det finns 4 processer som körs på samma nod använder Nebula 25 MB minne per varje process för att lagra kontrollpunkterna.

Anropa API:er för att spara och läsa in kontrollpunkter

Nebula tillhandahåller API:er för att hantera sparande av kontrollpunkter. Du kan använda dessa API:er i dina träningsskript, ungefär som PyTorch-API torch.save() :et. De här exemplen visar hur du använder Nebula i dina träningsskript.

Visa dina kontrollpunktshistorik

När ditt träningsjobb är klart går du till fönstret Jobb Name> Outputs + logs . I den vänstra panelen expanderar du mappen Nebula och väljer checkpointHistories.csv att se detaljerad information om sparande av Nebula-kontrollpunkter – varaktighet, dataflöde och kontrollpunktsstorlek.

Skärmbild som visar metadata om att kontrollpunkten sparas.

Exempel

De här exemplen visar hur du använder Nebula med olika ramverkstyper. Du kan välja det exempel som passar bäst för ditt träningsskript.

Om du vill aktivera fullständig Nebula-kompatibilitet med PyTorch-baserade träningsskript ändrar du träningsskriptet efter behov.

  1. Importera först det nödvändiga nebulaml paketet:

      # Import the Nebula package for fast-checkpointing 
  import nebulaml as nm

  2. Om du vill initiera Nebula anropar du nm.init() funktionen i main(), som du ser här:

      # Initialize Nebula with variables that helps Nebula to know where and how often to save your checkpoints
  persistent_storage_path="/tmp/test",
  nm.init(persistent_storage_path, persistent_time_interval=2)

  3. Om du vill spara kontrollpunkter ersätter du den ursprungliga torch.save() instruktionen för att spara kontrollpunkten med Nebula. Kontrollera att kontrollpunktsinstansen börjar med "global_step", till exempel "global_step500" eller "global_step1000":

    checkpoint = nm.Checkpoint('global_step500')  
checkpoint.save('<CKPT_NAME>', model)

    Kommentar

    <'CKPT_TAG_NAME'> är det unika ID:t för kontrollpunkten. En tagg är vanligtvis antalet steg, epoknumret eller ett användardefinierat namn. Den valfria <'NUM_OF_FILES'> valfria parametern anger det tillståndsnummer som du skulle spara för den här taggen.

  4. Läs in den senaste giltiga kontrollpunkten, som du ser här:

    latest_ckpt = nm.get_latest_checkpoint()
p0 = latest_ckpt.load(<'CKPT_NAME'>)

    Eftersom en kontrollpunkt eller ögonblicksbild kan innehålla många filer kan du läsa in en eller flera av dem med namnet. Med den senaste kontrollpunkten kan träningstillståndet återställas till det tillstånd som sparades av den senaste kontrollpunkten.

    Andra API:er kan hantera kontrollpunktshantering

    • visa en lista över alla kontrollpunkter
    • hämta de senaste kontrollpunkterna
    # Managing checkpoints
## List all checkpoints
ckpts = nm.list_checkpoints()
## Get Latest checkpoint path
latest_ckpt_path = nm.get_latest_checkpoint_path("checkpoint", persisted_storage_path)