AI & GPU
Pytorch Multi Gpu

Oto polski przekład pliku:

title: "Szkolenie PyTorch z wykorzystaniem wielu kart GPU"

Szkolenie PyTorch z wykorzystaniem wielu kart GPU: Kompletny przewodnik

PyTorch stał się jednym z najbardziej popularnych frameworków do uczenia głębokiego, kochanych przez badaczy i praktyków za ich dynamiczne grafy obliczeniowe i łatwość użycia. Ponieważ modele uczenia głębokiego stają się coraz większe i bardziej złożone, ich efektywne szkolenie wymaga wykorzystania mocy wielu kart GPU. W tym artykule zagłębimy się w świat szkolenia wielokartowego GPU z PyTorch, badając techniki takie jak DataParallel i DistributedDataParallel, aby znacznie przyspieszyć Twoje przepływy szkoleniowe.

Potrzeba szybkości: Dlaczego wielokartowe GPU ma znaczenie

Szkolenie najnowocześniejszych modeli uczenia głębokiego często trwa dni, a nawet tygodnie na pojedynczej karcie GPU. To powolne tempo iteracji może utrudniać postęp badań i opóźniać wprowadzanie modeli do produkcji. Poprzez rozdzielenie szkolenia na wiele kart GPU, możemy znacznie skrócić czas potrzebny do wytrenowania tych dużych modeli.

Istnieją dwa podstawowe podejścia do równoległego szkolenia w PyTorch:

  1. Równoległość danych: Model jest replikowany na każdej karcie GPU, a podzbiór danych jest przetwarzany na każdej replice. Gradienty są akumulowane na kartach GPU po każdym przebiegu.

  2. Równoległość modelu: Różne części modelu są podzielone między karty GPU, przy czym każda karta GPU odpowiada za część przejścia w przód i wstecz. Jest to mniej powszechne i bardziej złożone w implementacji.

W tym artykule skupimy się na równoległości danych, ponieważ jest to najbardziej powszechne podejście i jest dobrze obsługiwane przez wbudowane moduły PyTorch.

Rozpoczynanie pracy z DataParallel

Moduł DataParallel PyTorch zapewnia prosty sposób na wykorzystanie wielu kart GPU z minimalnymi zmianami w kodzie. Automatycznie dzieli dane wejściowe na dostępne karty GPU i akumuluje gradienty podczas przejścia wstecznego.

Oto podstawowy przykład użycia DataParallel do owinięcia modelu:

import torch
import torch.nn as nn
 
# Zdefiniuj swój model
model = nn.Sequential(
    nn.Li.
near(10, 20),
    nn.ReLU(),
    nn.Linear(20, 5)
)
 
# Przenieś model na GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
 
# Obuduj model za pomocą DataParallel
parallel_model = nn.DataParallel(model)

Teraz, gdy przekażesz dane wejściowe do parallel_model, zostaną one automatycznie podzielone na dostępne karty GPU. Moduł obsługuje zbieranie danych wyjściowych i gradientów, co czyni to przezroczystym dla reszty kodu szkoleniowego.

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

Zalety i ograniczenia

DataParallel jest łatwy w użyciu i może zapewnić dobre przyspieszenie, gdy masz kilka kart GPU na jednej maszynie. Jednak ma pewne ograniczenia:

  • Obsługuje tylko jednoprocesowe szkolenie na wielu GPU, więc nie skaluje się dobrze do większych klastrów.
  • Model musi zmieścić się w pamięci każdej karty GPU, co ogranicza maksymalny rozmiar modelu.
  • Może występować znaczne obciążenie z powodu kopiowania danych między kartami GPU, zwłaszcza przy wielu małych operacjach.

Mimo tych ograniczeń, DataParallel jest dobrym wyborem dla wielu typowych przypadków użycia i stanowi świetny sposób na rozpoczęcie szkolenia na wielu GPU w PyTorch.

Skalowanie w górę z DistributedDataParallel

W przypadku większych modeli i klastrów, moduł DistributedDataParallel (DDP) PyTorch oferuje bardziej elastyczne i wydajne podejście do szkolenia na wielu GPU. DDP używa wielu procesów, z których każdy ma własną kartę GPU, aby zrównoleglić szkolenie.

Kluczowe cechy DDP obejmują:

  • Obsługa wielu procesów: DDP może skalować się do setek kart GPU na wielu węzłach, umożliwiając szkolenie bardzo dużych modeli.
  • Wydajna komunikacja: Używa backendu NCCL do szybkiej komunikacji GPU-GPU, minimalizując obciążenie.
  • Synchronizacja gradientów: DDP automatycznie synchronizuje gradienty między procesami podczas przejścia wstecznego.

Oto przykład konfiguracji DDP w skrypcie szkoleniowym:

import torch
import torch.distributed as dist
import torch.multiprocessing as m.
```Oto tłumaczenie pliku na język polski. Komentarze w kodzie zostały przetłumaczone, a sam kod pozostał niezmieniony.
 
def train(rank, world_size):
    # Zainicjuj grupę procesów
    dist.init_process_group(backend='nccl', rank=rank, world_size=world_size)
    
    # Zdefiniuj swój model
    model = nn.Sequential(...)
    
    # Opatrz model DDP
    model = nn.parallel.DistributedDataParallel(model, device_ids=[rank])
    
    # Twoja pętla treningowa znajduje się tutaj
    ...
 
def main():
    world_size = torch.cuda.device_count()
    mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)
 
if __name__ == '__main__':
    main()

W tym przykładzie używamy torch.multiprocessing, aby uruchomić proces dla każdej karty GPU. Każdy proces inicjalizuje własną grupę procesów przy użyciu dist.init_process_group(), określając swój rank i całkowity rozmiar świata.

Model jest następnie opatrzony DDP, przekazując listę identyfikatorów urządzeń do użycia. W pętli treningowej model może być używany normalnie, a DDP zajmuje się dystrybucją danych i gradientów między procesami.

Porównanie wydajności

Aby zilustrować korzyści z wydajności szkolenia wieloGPU, porównajmy czasy szkolenia dla prostego modelu na pojedynczej karcie GPU, z DataParallel i z DDP:

KonfiguracjaCzas szkolenia (s)Przyspieszenie
Pojedyncza karta GPU1001x
DataParallel551.8x
DDP (4 karty GPU)303.3x

Jak widać, zarówno DataParallel, jak i DDP zapewniają znaczne przyspieszenie w porównaniu z pojedynczą kartą GPU. DDP skaluje się lepiej z większą liczbą kart GPU i może osiągnąć prawie liniowe skalowanie w wielu przypadkach.

Najlepsze praktyki dla szkolenia wieloGPU

Aby w pełni wykorzystać szkolenie wieloGPU w PyTorch, należy pamiętać o tych najlepszych praktykach:

  • Wybierz właściwą strategię równoległości: Użyj DataParallel dla prostych przypadków z kilkoma kartami GPU, a przejdź na DDP dla większych modeli i klastrów.
  • Dostosuj rozmiary partii: Większe rozmiary partii mogą poprawić wykorzystanie karty GPU i zmniejszyć narzut komunikacyjny. Eksperymentuj z różnymi rozmiarami partii.Oto tłumaczenie na język polski:

Znajdź idealny punkt dla twojego modelu i sprzętu.

  • Użyj mieszanej precyzji: Moduł torch.cuda.amp w PyTorch umożliwia szkolenie z mieszaną precyzją, co może znacznie zmniejszyć zużycie pamięci i poprawić wydajność na nowoczesnych kartach GPU.
  • Obsługa stanów losowych: Upewnij się, że jawnie ustawiasz ziarno losowe w celu zapewnienia powtarzalności, i użyj torch.manual_seed(), aby zapewnić, że każdy proces ma unikatowy stan losowy.
  • Profiluj i optymalizuj: Użyj narzędzi do profilowania, takich jak PyTorch Profiler lub NVIDIA Nsight, aby zidentyfikować wąskie gardła wydajności i zoptymalizować swój kod.

Przykłady z prawdziwego życia

Szkolenie na wielu GPU było wykorzystywane do osiągnięcia wyników na światowym poziomie w szerokim zakresie dziedzin, od widzenia komputerowego po przetwarzanie języka naturalnego. Oto kilka godnych uwagi przykładów:

  • BigGAN: Naukowcy z DeepMind użyli PyTorch DDP do wytrenowania modelu BigGAN na 128 GPU, generując wysokiej jakości obrazy o bezprecedensowym poziomie szczegółowości i różnorodności.
  • OpenAI GPT-3: Model językowy GPT-3 z 175 miliardami parametrów został wytrenowany na klastrze 10 000 GPU przy użyciu kombinacji równoległości modelu i danych.
  • AlphaFold 2: Model składania białek AlphaFold 2 firmy DeepMind został wytrenowany na 128 rdzeniach TPUv3, demonstrując skalowalność szkolenia na wielu urządzeniach poza samymi GPU.

Te przykłady pokazują moc szkolenia na wielu GPU w celu przesunięcia granic tego, co możliwe w uczeniu głębokim.

Wniosek

W tym artykule zbadaliśmy świat szkolenia na wielu GPU z PyTorch, od podstaw DataParallel po zaawansowane techniki DistributedDataParallel. Wykorzystując moc wielu GPU, możesz znacznie przyspieszyć swoje przepływy szkoleniowe i zająć się większymi, bardziej złożonymi modelami.

Pamiętaj, aby wybrać odpowiednią strategię równoległości dla Twojego przypadku użycia, dostroić swoje hiperpararametry i przestrzegać najlepszych praktyk w celu uzyskania optymalnej wydajności. Z właściwym podejściem, szkolenie na wielu GPU może być graczem zmieniającym zasady gry dla Twoich projektów uczenia głębokiego.

Aby dowiedzieć się więcej o szkoleniu na wielu GPU.Oto tłumaczenie na język polski:

Aby dowiedzieć się więcej na temat równoległego przetwarzania w PyTorch, zapoznaj się z tymi dodatkowymi zasobami:

Powodzenia w trenowaniu!

Przetwarzanie równoległe w Pythonie: Przewodnik dla początkującychTensorflow Gpu