PyTorch Training met Meerdere GPU's: Een Complete Gids

PyTorch is uitgegroeid tot een van de populairste deep learning frameworks, geliefd bij onderzoekers en practitioners vanwege zijn dynamische rekengrafieken en gebruiksgemak. Naarmate deep learning modellen groter en complexer worden, vereist het efficiënt trainen ervan het benutten van de kracht van meerdere GPU's. In dit artikel duiken we in de wereld van multi-GPU training met PyTorch, waarbij we technieken als DataParallel en DistributedDataParallel verkennen om uw trainingsworkflows aanzienlijk te versnellen.

De Behoefte aan Snelheid: Waarom Multi-GPU Belangrijk Is

Het trainen van state-of-the-art deep learning modellen kost vaak dagen of zelfs weken op één GPU. Dit langzame tempo van iteratie kan de onderzoeksvoortgang belemmeren en het in productie brengen van modellen vertragen. Door de training over meerdere GPU's te verdelen, kunnen we de tijd die nodig is om deze grote modellen te trainen aanzienlijk verminderen.

Er zijn twee primaire benaderingen om training te parallelliseren in PyTorch:

Data Parallellisme: Het model wordt gerepliceerd op elke GPU, en een subset van de data wordt verwerkt op elke replica. Gradiënten worden na elke doorgang over de GPU's geaccumuleerd.
Model Parallellisme: Verschillende delen van het model worden over de GPU's verdeeld, waarbij elke GPU verantwoordelijk is voor een deel van de forward- en backwardpass. Dit is minder gebruikelijk en complexer om te implementeren.

In dit artikel zullen we ons concentreren op data parallellisme, aangezien dit de meest gebruikte benadering is en goed wordt ondersteund door PyTorch's ingebouwde modules.

Aan de Slag met DataParallel

PyTorch's DataParallel module biedt een eenvoudige manier om meerdere GPU's te benutten met minimale codewijzigingen. Het splitst de invoergegevens automatisch over de beschikbare GPU's en accumuleert de gradiënten tijdens de backwardpass.

Hier is een basic voorbeeld van het gebruik van DataParallel om een model in te pakken:

import torch
import torch.nn as nn
 
# Definieer uw model
model = nn.Sequential(
    nn.Li.
near(10, 20),
    nn.ReLU(),
    nn.Linear(20, 5)
)
 
# Verplaats het model naar de GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
 
# Verpak het model met DataParallel
parallel_model = nn.DataParallel(model)

Nu, wanneer je een invoer naar parallel_model doorgeeft, wordt deze automatisch over de beschikbare GPU's verdeeld. De module behandelt het verzamelen van de uitvoer en gradiënten, waardoor het transparant is voor de rest van je trainingsscode.

inputs = torch.randn(100, 10).to(device)
outputs = parallel_model(inputs)

Voordelen en beperkingen

DataParallel is eenvoudig te gebruiken en kan goede snelheidsverbeteringen opleveren wanneer je een paar GPU's op één machine hebt. Het heeft echter enkele beperkingen:

Het ondersteunt alleen single-process multi-GPU-training, dus het schaalt niet goed op naar grotere clusters.
Het model moet volledig in het geheugen van elke GPU passen, wat de maximale modelgrootte beperkt.
Er kan aanzienlijke overhead zijn door het kopiëren van gegevens tussen GPU's, vooral bij veel kleine bewerkingen.

Ondanks deze beperkingen is DataParallel een goede keuze voor veel gangbare gebruiksgevallen en is het een geweldige manier om te beginnen met multi-GPU-training in PyTorch.

Opschalen met DistributedDataParallel

Voor grotere modellen en clusters biedt PyTorch's DistributedDataParallel (DDP) module een flexibelere en efficiëntere aanpak voor multi-GPU-training. DDP gebruikt meerdere processen, elk met zijn eigen GPU, om de training te parallelliseren.

De belangrijkste kenmerken van DDP zijn:

Ondersteuning voor meerdere processen: DDP kan schalen naar honderden GPU's over meerdere nodes, waardoor het trainen van zeer grote modellen mogelijk wordt.
Efficiënte communicatie: Het gebruikt de NCCL-backend voor snelle GPU-naar-GPU-communicatie, waardoor de overhead wordt geminimaliseerd.
Gradiënt-synchronisatie: DDP synchroniseert automatisch de gradiënten tussen processen tijdens de backward-doorgang.

Hier is een voorbeeld van het instellen van DDP in je trainingsscript:

import torch
import torch.distributed as dist
import torch.multiprocessing as m.
```Hier is de Nederlandse vertaling van het bestand:
 
def train(rank, world_size):
    # Initialiseer de procesgroep
    dist.init_process_group(backend='nccl', rank=rank, world_size=world_size)
    
    # Definieer je model
    model = nn.Sequential(...)
    
    # Wikkel het model in DDP
    model = nn.parallel.DistributedDataParallel(model, device_ids=[rank])
    
    # Je trainlus komt hier
    ...
 
def main():
    world_size = torch.cuda.device_count()
    mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)
 
if __name__ == '__main__':
    main()

In dit voorbeeld gebruiken we torch.multiprocessing om een proces te starten voor elke GPU. Elk proces initialiseert zijn eigen procesgroep met behulp van dist.init_process_group(), waarbij het zijn rang en de totale wereldgrootte opgeeft.

Het model wordt vervolgens ingepakt met DDP, waarbij de lijst met te gebruiken apparaat-ID's wordt doorgegeven. Binnen de trainlus kan het model op de normale manier worden gebruikt, waarbij DDP zorgt voor de verdeling van gegevens en gradiënten over de processen.

Prestatie vergelijking

Om de prestatievoordelen van multi-GPU-training te illustreren, vergelijken we de trainingstijden voor een eenvoudig model op één GPU, met DataParallel en met DDP:

Opstelling	Trainingstijd (s)	Versnelling
Enkele GPU	100	1x
DataParallel	55	1.8x
DDP (4 GPU's)	30	3.3x

Zoals we kunnen zien, bieden zowel DataParallel als DDP aanzienlijke versnellingen ten opzichte van training op één GPU. DDP schaalt beter met meer GPU's en kan in veel gevallen bijna lineaire schaling bereiken.

Best practices voor multi-GPU-training

Om het meeste uit multi-GPU-training in PyTorch te halen, houd je best rekening met de volgende best practices:

Kies de juiste parallellisatiestrategie: Gebruik DataParallel voor eenvoudige gevallen met een paar GPU's, en schakel over naar DDP voor grotere modellen en clusters.
Stem batchgroottes af: Grotere batchgroottes kunnen de GPU-benutting verbeteren en de communicatieoverhead verminderen. Experimenteer met verschillende batchgroottes. zes om het zoete punt voor uw model en hardware te vinden.
Gebruik Gemengde Precisie: PyTorch's torch.cuda.amp module maakt gemengde-precisie training mogelijk, wat het geheugengebruik aanzienlijk kan verminderen en de prestaties op moderne GPU's kan verbeteren.
Behandel Willekeurige Staten: Zorg ervoor dat u expliciet willekeurige zaden instelt voor reproduceerbaarheid, en gebruik torch.manual_seed() om ervoor te zorgen dat elke proces een unieke willekeurige staat heeft.
Profileren en Optimaliseren: Gebruik profileringshulpmiddelen zoals PyTorch Profiler of NVIDIA Nsight om prestatiebottlenecks te identificeren en uw code te optimaliseren.

Praktijkvoorbeelden

Multi-GPU training is gebruikt om state-of-the-art resultaten te behalen in een breed scala aan domeinen, van computervision tot natuurlijke taalverwerking. Hier zijn enkele opmerkelijke voorbeelden:

BigGAN: Onderzoekers bij DeepMind gebruikten PyTorch DDP om het BigGAN-model te trainen op 128 GPU's, waarbij ze hoogwaardige afbeeldingen genereerden met een ongekend niveau van detail en diversiteit.
OpenAI GPT-3: Het GPT-3 taalmodel, met 175 miljard parameters, werd getraind op een cluster van 10.000 GPU's met behulp van een combinatie van model- en dataparallelisme.
AlphaFold 2: DeepMind's AlphaFold 2 eiwoutvouwingsmodel werd getraind op 128 TPUv3-cores, wat de schaalbaarheid van multi-apparaat training voorbij alleen GPU's laat zien.

Deze voorbeelden tonen de kracht van multi-GPU training aan om de grenzen van wat mogelijk is met diepe lering te verleggen.

Conclusie

In dit artikel hebben we de wereld van multi-GPU training met PyTorch verkend, van de basisbeginselen van DataParallel tot de geavanceerde technieken van DistributedDataParallel. Door gebruik te maken van de kracht van meerdere GPU's, kunt u uw trainingsworkflows aanzienlijk versnellen en grotere, complexere modellen aanpakken.

Onthoud om de juiste parallellisatiestrategie voor uw use case te kiezen, uw hyperparameters af te stemmen en best practices te volgen voor optimale prestaties. Met de juiste aanpak kan multi-GPU training een game-changer zijn voor uw diepe leerprojecten.

Voor meer informatie over multi-GPU training. Voor meer informatie over parallelliseren in PyTorch, bekijk deze extra bronnen:

Veel succes met het trainen!

Parallelle Verwerking in Python: Een Beginnersgids Tensorflow Gpu