Przewodnik trenowania rozproszonego procesora GPU (zestaw SDK w wersji 1)

  • Artykuł

DOTYCZY:Zestaw SDK języka Python w wersji 1

Dowiedz się więcej o sposobie używania rozproszonego kodu trenowania procesora GPU w usłudze Azure Machine Learning (ML). W tym artykule nie nauczysz się trenowania rozproszonego. Pomoże ci to uruchomić istniejący rozproszony kod szkoleniowy w usłudze Azure Machine Learning. Oferuje porady i przykłady, które należy wykonać dla każdej platformy:

  • Interfejs przekazywania komunikatów (MPI)
    • Horovod
    • DeepSpeed
    • Zmienne środowiskowe z interfejsu OPEN MPI
  • PyTorch
    • Inicjowanie grupy procesów
    • Opcje uruchamiania
    • DistributedDataParallel (uruchamianie poszczególnych procesów)
    • Korzystanie z torch.distributed.launch polecenia (uruchamianie według węzła)
    • Piorun PyTorch
    • Przytulanie transformatorów twarzy
  • TensorFlow
    • Zmienne środowiskowe dla biblioteki TensorFlow (TF_CONFIG)
  • Przyspieszanie trenowania procesora GPU za pomocą rozwiązania InfiniBand

Wymagania wstępne

Zapoznaj się z tymi podstawowymi pojęciami dotyczącymi trenowania rozproszonego procesora GPU , takich jak równoległość danych, równoległość rozproszonych danych i równoległość modelu.

Porada

Jeśli nie wiesz, jakiego typu równoległości używać, ponad 90% czasu należy użyć rozproszonego równoległości danych.

MPI

Usługa Azure Machine Learning oferuje zadanie MPI umożliwiające uruchomienie danej liczby procesów w każdym węźle. Tę metodę można zastosować do uruchamiania trenowania rozproszonego przy użyciu uruchamiania dla poszczególnych procesów lub uruchamiania na węzeł, w zależności od tego, czy process_count_per_node ustawiono wartość 1 (wartość domyślną) dla uruchamiania węzła, czy też liczbę urządzeń/procesorów GPU dla uruchamiania poszczególnych procesów. Usługa Azure Machine Learning tworzy pełne polecenie uruchamiania MPI (mpirun) w tle. Nie można podać własnych pełnych poleceń head-node-launcher, takich jak mpirun lub DeepSpeed launcher.

Porada

Podstawowy obraz platformy Docker używany przez zadanie MPI usługi Azure Machine Learning musi mieć zainstalowaną bibliotekę MPI. Otwarte interfejsy MPI są uwzględniane we wszystkich podstawowych obrazach procesora GPU usługi Azure Machine Learning. Podczas korzystania z niestandardowego obrazu platformy Docker odpowiadasz za upewnienie się, że obraz zawiera bibliotekę MPI. Zalecane jest otwieranie interfejsu MPI, ale można również użyć innej implementacji MPI, takiej jak Intel MPI. Usługa Azure Machine Learning udostępnia również wyselekcjonowane środowiska dla popularnych platform.

Aby uruchomić trenowanie rozproszone przy użyciu interfejsu MPI, wykonaj następujące kroki:

  1. Użyj środowiska usługi Azure Machine Learning z preferowaną strukturą uczenia głębokiego i interfejsem MPI. Usługa Azure Machine Learning udostępnia wyselekcjonowane środowisko dla popularnych platform.
  2. Zdefiniuj MpiConfiguration za pomocą polecenia process_count_per_node i node_count. process_count_per_node powinna być równa liczbie procesorów GPU na węzeł dla uruchamiania procesu lub ustawić wartość 1 (wartość domyślna) dla uruchamiania dla węzła, jeśli skrypt użytkownika będzie odpowiedzialny za uruchamianie procesów na węzeł.
  3. MpiConfiguration Przekaż obiekt do parametru distributed_job_config .ScriptRunConfig
from azureml.core import Workspace, ScriptRunConfig, Environment, Experiment
from azureml.core.runconfig import MpiConfiguration

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)
distr_config = MpiConfiguration(process_count_per_node=4, node_count=2)

run_config = ScriptRunConfig(
  source_directory= './src',
  script='train.py',
  compute_target=compute_target,
  environment=pytorch_env,
  distributed_job_config=distr_config,
)

# submit the run configuration to start the job
run = Experiment(ws, "experiment_name").submit(run_config)

Horovod

Konfiguracja zadania MPI jest używana podczas korzystania z platformy Horovod do trenowania rozproszonego za pomocą platformy uczenia głębokiego.

Upewnij się, że kod jest zgodny z następującymi wskazówkami:

  • Kod trenowania jest poprawnie instrumentowany przy użyciu struktury Horovod przed dodaniem części usługi Azure Machine Learning
  • Środowisko usługi Azure Machine Learning zawiera interfejsy Horovod i MPI. Środowiska PyTorch i TensorFlow wyselekcjonowane procesory GPU są wstępnie skonfigurowane przy użyciu platformy Horovod i jej zależności.
  • Utwórz element MpiConfiguration z żądaną dystrybucją.

Przykład horovod

DeepSpeed

Nie używaj niestandardowego uruchamiania deepSpeed do uruchamiania trenowania rozproszonego za pomocą biblioteki DeepSpeed w usłudze Azure Machine Learning. Zamiast tego skonfiguruj zadanie MPI, aby uruchomić zadanie trenowania za pomocą interfejsu MPI.

Upewnij się, że kod jest zgodny z następującymi wskazówkami:

  • Środowisko usługi Azure Machine Learning zawiera bibliotekę DeepSpeed i jej zależności, open MPI i mpi4py.
  • Utwórz obiekt MpiConfiguration z dystrybucją.

Przykład DeepSpeed

Zmienne środowiskowe z interfejsu OPEN MPI

Podczas uruchamiania zadań MPI z obrazami Open MPI następujące zmienne środowiskowe dla każdego uruchomionego procesu:

  1. OMPI_COMM_WORLD_RANK - ranga procesu
  2. OMPI_COMM_WORLD_SIZE - rozmiar świata
  3. AZ_BATCH_MASTER_NODE - adres podstawowy z portem, MASTER_ADDR:MASTER_PORT
  4. OMPI_COMM_WORLD_LOCAL_RANK — lokalna ranga procesu w węźle
  5. OMPI_COMM_WORLD_LOCAL_SIZE - liczba procesów w węźle

Porada

Pomimo nazwy zmienna środowiskowa OMPI_COMM_WORLD_NODE_RANK nie odpowiada zmiennej NODE_RANK. Aby użyć uruchamiania dla węzła, ustaw process_count_per_node=1 i użyj polecenia OMPI_COMM_WORLD_RANK jako NODE_RANK.

PyTorch

Usługa Azure Machine Learning obsługuje uruchamianie rozproszonych zadań przy użyciu natywnych funkcji trenowania rozproszonego PyTorch (torch.distributed).

Porada

W przypadku równoległości danych oficjalna wskazówka PyTorch polega na korzystaniu z metody DistributedDataParallel (DDP) na potrzeby trenowania rozproszonego zarówno dla jednego węzła, jak i wielu węzłów. PyTorch zaleca również używanie funkcji DistributedDataParallel w pakiecie wieloprocesorowym. W związku z tym dokumentacja i przykłady usługi Azure Machine Learning koncentrują się na trenowaniu DistributedDataParallel.

Inicjowanie grupy procesów

Szkielet każdego trenowania rozproszonego opiera się na grupie procesów, które znają się nawzajem i mogą komunikować się ze sobą przy użyciu zaplecza. W przypadku PyTorch grupa procesów jest tworzona przez wywołanie torch.distributed.init_process_group we wszystkich procesach rozproszonych w celu utworzenia grupy procesów zbiorczo.

torch.distributed.init_process_group(backend='nccl', init_method='env://', ...)

Najczęściej używane zaplecza komunikacji to mpi, nccli gloo. W przypadku trenowania nccl opartego na procesorze GPU zaleca się najlepszą wydajność i należy ich używać zawsze, gdy jest to możliwe.

init_method informuje, jak każdy proces może odnaleźć się nawzajem, jak inicjuje i weryfikuje grupę procesów przy użyciu zaplecza komunikacji. Domyślnie, jeśli init_method nie określono parametru PyTorch, użyje metody inicjowania zmiennej środowiskowej (env://). init_method to zalecana metoda inicjowania używana w kodzie trenowania do uruchamiania rozproszonego narzędzia PyTorch w usłudze Azure Machine Learning. PyTorch będzie szukać następujących zmiennych środowiskowych do inicjowania:

  • MASTER_ADDR - Adres IP maszyny, która będzie hostować proces o klasyfikacji 0.
  • MASTER_PORT - Bezpłatny port na maszynie, który będzie hostować proces o klasyfikacji 0.
  • WORLD_SIZE - Całkowita liczba procesów. Powinna być równa łącznej liczbie urządzeń (GPU) używanych do trenowania rozproszonego.
  • RANK - (globalna) ranga bieżącego procesu. Możliwe wartości to od 0 do (rozmiar świata — 1).

Aby uzyskać więcej informacji na temat inicjowania grupy procesów, zobacz dokumentację PyTorch.

Poza tym wiele aplikacji będzie również potrzebować następujących zmiennych środowiskowych:

  • LOCAL_RANK - Lokalna (względna) ranga procesu w węźle. Możliwe wartości to od 0 do (liczba procesów w węźle — 1). Te informacje są przydatne, ponieważ wiele operacji, takich jak przygotowywanie danych, powinno być wykonywanych tylko raz na węzeł, --- zwykle na local_rank = 0.
  • NODE_RANK - Ranga węzła na potrzeby trenowania z wieloma węzłami. Możliwe wartości to od 0 do (łączna liczba węzłów — 1).

Opcje uruchamiania PyTorch

Zadanie PyTorch usługi Azure Machine Learning obsługuje dwa typy opcji uruchamiania trenowania rozproszonego:

  • Uruchamianie poszczególnych procesów: system uruchomi wszystkie procesy rozproszone wraz ze wszystkimi odpowiednimi informacjami (takimi jak zmienne środowiskowe) w celu skonfigurowania grupy procesów.
  • Uruchamianie poszczególnych węzłów: udostępniasz usługę Azure Machine Learning za pomocą uruchamiania narzędzi, które będą uruchamiane w każdym węźle. Narzędzie uruchamiania będzie obsługiwać uruchamianie każdego z procesów w danym węźle. Lokalnie w każdym węźle RANK i LOCAL_RANK są konfigurowane przez moduł uruchamiania. Narzędzie torch.distributed.launch i PyTorch Lightning należą do tej kategorii.

Nie ma podstawowych różnic między tymi opcjami uruchamiania. Wybór zależy w dużej mierze od preferencji lub konwencji struktur/bibliotek opartych na wanilii PyTorch (takich jak Lightning lub Hugging Face).

W poniższych sekcjach szczegółowo opisano sposób konfigurowania zadań usługi Azure Machine Learning PyTorch dla każdej z opcji uruchamiania.

DistributedDataParallel (uruchamianie poszczególnych procesów)

Nie musisz używać narzędzia uruchamiania, takiego jak torch.distributed.launch. Aby uruchomić rozproszone zadanie PyTorch:

  1. Określanie skryptu trenowania i argumentów
  2. Utwórz element PyTorchConfiguration i określ elementy process_count i node_count. Wartość process_count odpowiada całkowitej liczbie procesów, które mają zostać uruchomione dla zadania. process_count zazwyczaj powinna być równa # GPUs per node x # nodes. Jeśli process_count nie zostanie określony, usługa Azure Machine Learning domyślnie uruchomi jeden proces na węzeł.

Usługa Azure Machine Learning ustawi MASTER_ADDRzmienne środowiskowe , MASTER_PORT, WORLD_SIZEi NODE_RANK na każdym węźle oraz ustawi zmienne środowiskowe i LOCAL_RANK na poziomie RANK procesu.

Aby użyć tej opcji na potrzeby trenowania wielu procesów na węzeł, użyj zestawu SDK >= 1.22.0języka Python usługi Azure Machine Learning. Process_count wprowadzono w wersji 1.22.0.

from azureml.core import ScriptRunConfig, Environment, Experiment
from azureml.core.runconfig import PyTorchConfiguration

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)
distr_config = PyTorchConfiguration(process_count=8, node_count=2)

run_config = ScriptRunConfig(
  source_directory='./src',
  script='train.py',
  arguments=['--epochs', 50],
  compute_target=compute_target,
  environment=pytorch_env,
  distributed_job_config=distr_config,
)

run = Experiment(ws, 'experiment_name').submit(run_config)

Porada

Jeśli skrypt trenowania przekazuje informacje, takie jak ranga lokalna lub ranga argumentów skryptu, można odwołać się do zmiennych środowiskowych w argumentach:

arguments=['--epochs', 50, '--local_rank', $LOCAL_RANK]

Przykład Pytorch per-process-launch

Korzystanie z narzędzia torch.distributed.launch (uruchamianie poszczególnych węzłów)

PyTorch udostępnia narzędzie uruchamiania w pliku torch.distributed.launch , którego można użyć do uruchamiania wielu procesów na węzeł. Moduł torch.distributed.launch duplikuje wiele procesów trenowania na każdym z węzłów.

W poniższych krokach pokazano, jak skonfigurować zadanie PyTorch za pomocą modułu uruchamiania dla poszczególnych węzłów w usłudze Azure Machine Learning. Zadanie osiąga odpowiednik uruchomienia następującego polecenia:

python -m torch.distributed.launch --nproc_per_node <num processes per node> \
  --nnodes <num nodes> --node_rank $NODE_RANK --master_addr $MASTER_ADDR \
  --master_port $MASTER_PORT --use_env \
  <your training script> <your script arguments>
  1. torch.distributed.launch Podaj polecenie command dla parametru konstruktoraScriptRunConfig. Usługa Azure Machine Learning uruchamia to polecenie w każdym węźle klastra szkoleniowego. --nproc_per_node powinna być mniejsza lub równa liczbie procesorów GPU dostępnych w każdym węźle. MASTER_ADDR, MASTER_PORT i NODE_RANK są ustawiane przez usługę Azure Machine Learning, dzięki czemu można odwoływać się tylko do zmiennych środowiskowych w poleceniu . Usługa Azure Machine Learning ustawia MASTER_PORT na 6105, ale jeśli chcesz, możesz przekazać inną wartość do argumentu --master_port polecenia torch.distributed.launch. (Narzędzie uruchamiania spowoduje zresetowanie zmiennych środowiskowych).
  2. Utwórz element PyTorchConfiguration i określ element node_count.
from azureml.core import ScriptRunConfig, Environment, Experiment
from azureml.core.runconfig import PyTorchConfiguration

curated_env_name = 'AzureML-PyTorch-1.6-GPU'
pytorch_env = Environment.get(workspace=ws, name=curated_env_name)
distr_config = PyTorchConfiguration(node_count=2)
launch_cmd = "python -m torch.distributed.launch --nproc_per_node 4 --nnodes 2 --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT --use_env train.py --epochs 50".split()

run_config = ScriptRunConfig(
  source_directory='./src',
  command=launch_cmd,
  compute_target=compute_target,
  environment=pytorch_env,
  distributed_job_config=distr_config,
)

run = Experiment(ws, 'experiment_name').submit(run_config)

Porada

Trenowanie z wieloma procesorami GPU z jednym węzłem: Jeśli używasz narzędzia uruchamiania do uruchamiania trenowania z wieloma procesorami GPU PyTorch z jednym węzłem, nie musisz określać distributed_job_config parametru ScriptRunConfig.

launch_cmd = "python -m torch.distributed.launch --nproc_per_node 4 --use_env train.py --epochs 50".split()

run_config = ScriptRunConfig(
 source_directory='./src',
 command=launch_cmd,
 compute_target=compute_target,
 environment=pytorch_env,
)

Przykład uruchamiania rozwiązania PyTorch dla węzła

Piorun PyTorch

PyTorch Lightning to uproszczona biblioteka typu open source, która zapewnia interfejs wysokiego poziomu dla biblioteki PyTorch. Błyskawica oddziela wiele konfiguracji trenowania rozproszonego niższego poziomu wymaganych dla vanilla PyTorch. Lightning umożliwia uruchamianie skryptów szkoleniowych w ustawieniach pojedynczego procesora GPU, wielowęźleowego procesora GPU i wielu węzłów z wieloma procesorami GPU. W tle uruchamia wiele procesów podobnych do torch.distributed.launch.

W przypadku trenowania z jednym węzłem (w tym z wieloma procesorami GPU z jednym węzłem) można uruchomić kod w usłudze Azure Machine Learning bez konieczności określania elementu distributed_job_config. Aby uruchomić eksperyment przy użyciu wielu węzłów z wieloma procesorami GPU, dostępne są 2 opcje:

  • Przy użyciu konfiguracji PyTorch (zalecane): zdefiniuj PyTorchConfiguration i określ communication_backend="Nccl"wartości , node_counti process_count (pamiętaj, że jest to łączna liczba procesów, tj. num_nodes * process_count_per_node). W module Lightning Trainer określ zarówno element , jak num_nodes i gpus , aby był zgodny z elementem PyTorchConfiguration. Na przykład num_nodes = node_count i gpus = process_count_per_node.

  • Korzystanie z konfiguracji MPI:

    • Zdefiniuj MpiConfiguration i określ wartości i node_countprocess_count_per_node. W obszarze Lightning Trainer określ odpowiednio wartości num_nodes i gpus , aby były takie same jak node_count i process_count_per_node z MpiConfiguration.

    • W przypadku trenowania z wieloma węzłami za pomocą interfejsu MPI błyskawica wymaga ustawienia następujących zmiennych środowiskowych w każdym węźle klastra szkoleniowego:

      • MASTER_ADDR
      • MASTER_PORT
      • NODE_RANK
      • LOCAL_RANK

      Ręcznie ustaw te zmienne środowiskowe wymagane przez program Lightning w głównych skryptach szkoleniowych:

    import os
from argparse import ArgumentParser

def set_environment_variables_for_mpi(num_nodes, gpus_per_node, master_port=54965):
     if num_nodes > 1:
         os.environ["MASTER_ADDR"], os.environ["MASTER_PORT"] = os.environ["AZ_BATCH_MASTER_NODE"].split(":")
     else:
         os.environ["MASTER_ADDR"] = os.environ["AZ_BATCHAI_MPI_MASTER_NODE"]
         os.environ["MASTER_PORT"] = str(master_port)

     try:
         os.environ["NODE_RANK"] = str(int(os.environ.get("OMPI_COMM_WORLD_RANK")) // gpus_per_node)
         # additional variables
         os.environ["MASTER_ADDRESS"] = os.environ["MASTER_ADDR"]
         os.environ["LOCAL_RANK"] = os.environ["OMPI_COMM_WORLD_LOCAL_RANK"]
         os.environ["WORLD_SIZE"] = os.environ["OMPI_COMM_WORLD_SIZE"]
     except:
         # fails when used with pytorch configuration instead of mpi
         pass

if __name__ == "__main__":
     parser = ArgumentParser()
     parser.add_argument("--num_nodes", type=int, required=True)
     parser.add_argument("--gpus_per_node", type=int, required=True)
     args = parser.parse_args()
     set_environment_variables_for_mpi(args.num_nodes, args.gpus_per_node)

     trainer = Trainer(
      num_nodes=args.num_nodes,
      gpus=args.gpus_per_node
  )

    Błyskawica obsługuje obliczenia rozmiaru świata z flag --gpus trenera i --num_nodes.

    from azureml.core import ScriptRunConfig, Experiment
from azureml.core.runconfig import MpiConfiguration

nnodes = 2
gpus_per_node = 4
args = ['--max_epochs', 50, '--gpus_per_node', gpus_per_node, '--accelerator', 'ddp', '--num_nodes', nnodes]
distr_config = MpiConfiguration(node_count=nnodes, process_count_per_node=gpus_per_node)

run_config = ScriptRunConfig(
   source_directory='./src',
   script='train.py',
   arguments=args,
   compute_target=compute_target,
   environment=pytorch_env,
   distributed_job_config=distr_config,
)

run = Experiment(ws, 'experiment_name').submit(run_config)

Przytulanie transformatorów twarzy

Przytulanie twarzy zawiera wiele przykładów użycia biblioteki Transformers do torch.distributed.launch uruchamiania trenowania rozproszonego. Aby uruchomić te przykłady i własne niestandardowe skrypty szkoleniowe przy użyciu interfejsu API trenera przekształcania, postępuj zgodnie z sekcją Using (Używanie torch.distributed.launch ).

Przykładowy kod konfiguracji zadania w celu dostosowania dużego modelu BERT do zadania MNLI klasyfikacji tekstu przy użyciu skryptu run_glue.py w jednym węźle z 8 procesorami GPU:

from azureml.core import ScriptRunConfig
from azureml.core.runconfig import PyTorchConfiguration

distr_config = PyTorchConfiguration() # node_count defaults to 1
launch_cmd = "python -m torch.distributed.launch --nproc_per_node 8 text-classification/run_glue.py --model_name_or_path bert-large-uncased-whole-word-masking --task_name mnli --do_train --do_eval --max_seq_length 128 --per_device_train_batch_size 8 --learning_rate 2e-5 --num_train_epochs 3.0 --output_dir /tmp/mnli_output".split()

run_config = ScriptRunConfig(
  source_directory='./src',
  command=launch_cmd,
  compute_target=compute_target,
  environment=pytorch_env,
  distributed_job_config=distr_config,
)

Możesz również użyć opcji uruchamiania poszczególnych procesów , aby uruchomić trenowanie rozproszone bez użycia polecenia torch.distributed.launch. Należy pamiętać, że użycie tej metody polega na tym, że przekształcanie TrainingArguments oczekuje, że ranga lokalna zostanie przekazana jako argument (--local_rank). torch.distributed.launch Zajmuje się tym w przypadku --use_env=False, ale jeśli używasz uruchamiania poszczególnych procesów, musisz jawnie przekazać rangę lokalną jako argument do skryptu --local_rank=$LOCAL_RANK trenowania, ponieważ usługa Azure Machine Learning ustawia LOCAL_RANK tylko zmienną środowiskową.

TensorFlow

Jeśli używasz natywnego rozproszonego biblioteki TensorFlow w kodzie trenowania, takim jak interfejs API biblioteki tf.distribute.Strategy TensorFlow 2.x, możesz uruchomić zadanie rozproszone za pośrednictwem usługi Azure Machine Learning przy użyciu polecenia TensorflowConfiguration.

W tym celu określ TensorflowConfiguration obiekt dla distributed_job_config parametru konstruktora ScriptRunConfig . Jeśli używasz polecenia tf.distribute.experimental.MultiWorkerMirroredStrategy, określ element worker_count w TensorflowConfiguration odpowiadającym liczbie węzłów zadania szkoleniowego.

from azureml.core import ScriptRunConfig, Environment, Experiment
from azureml.core.runconfig import TensorflowConfiguration

curated_env_name = 'AzureML-TensorFlow-2.3-GPU'
tf_env = Environment.get(workspace=ws, name=curated_env_name)
distr_config = TensorflowConfiguration(worker_count=2, parameter_server_count=0)

run_config = ScriptRunConfig(
  source_directory='./src',
  script='train.py',
  compute_target=compute_target,
  environment=tf_env,
  distributed_job_config=distr_config,
)

# submit the run configuration to start the job
run = Experiment(ws, "experiment_name").submit(run_config)

Jeśli skrypt trenowania używa strategii serwera parametrów do trenowania rozproszonego, takiego jak w przypadku starszej wersji biblioteki TensorFlow 1.x, należy również określić liczbę serwerów parametrów do użycia w zadaniu, na przykład tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1).

TF_CONFIG

W systemie TensorFlow zmienna środowiskowa TF_CONFIG jest wymagana do trenowania na wielu maszynach. W przypadku zadań TensorFlow usługa Azure Machine Learning skonfiguruje i ustawi odpowiednio zmienną TF_CONFIG dla każdego procesu roboczego przed wykonaniem skryptu szkoleniowego.

Jeśli potrzebujesz: , możesz uzyskać dostęp do TF_CONFIG ze skryptu szkoleniowego: os.environ['TF_CONFIG'].

Przykład TF_CONFIG ustawiony w węźle głównego procesu roboczego:

TF_CONFIG='{
    "cluster": {
        "worker": ["host0:2222", "host1:2222"]
    },
    "task": {"type": "worker", "index": 0},
    "environment": "cloud"
}'

Przykład tensorFlow

Przyspieszanie trenowania rozproszonego procesora GPU za pomocą rozwiązania InfiniBand

Wraz ze wzrostem liczby maszyn wirtualnych do trenowania modelu czas wymagany do wytrenowania tego modelu powinien się zmniejszyć. W idealnym przypadku spadek czasu powinien być liniowo proporcjonalny do liczby trenowanych maszyn wirtualnych. Jeśli na przykład trenowanie modelu na jednej maszynie wirtualnej trwa 100 sekund, trenowanie tego samego modelu na dwóch maszynach wirtualnych powinno potrwać 50 sekund. Trenowanie modelu na czterech maszynach wirtualnych powinno potrwać 25 sekund itd.

InfiniBand może być ważnym czynnikiem w osiągnięciu tego skalowania liniowego. InfiniBand umożliwia komunikację między węzłami w klastrze o małych opóźnieniach i komunikacji między procesorami GPU. Rozwiązanie InfiniBand wymaga wyspecjalizowanego sprzętu do działania. Niektóre serie maszyn wirtualnych platformy Azure, w szczególności NC, ND i H, mają teraz maszyny wirtualne z obsługą funkcji RDMA z obsługą funkcji SR-IOV i InfiniBand. Te maszyny wirtualne komunikują się za pośrednictwem sieci InfiniBand o małych opóźnieniach i wysokiej przepustowości, co jest znacznie bardziej wydajne niż łączność oparta na sieci Ethernet. Sr-IOV dla InfiniBand umożliwia niemal bez systemu operacyjnego wydajność dowolnej biblioteki MPI (MPI jest używana przez wiele rozproszonych struktur szkoleniowych i narzędzi, w tym oprogramowania NCCL firmy NVIDIA). Te jednostki SKU są przeznaczone do spełnienia wymagań obciążeń uczenia maszynowego intensywnie korzystających z obliczeń. Aby uzyskać więcej informacji, zobacz Przyspieszanie trenowania rozproszonego w usłudze Azure Machine Learning przy użyciu funkcji SR-IOV.

Zwykle jednostki SKU maszyn wirtualnych o nazwie "r" zawierają wymagany sprzęt InfiniBand, a te bez "r" zwykle nie. ('r' jest odwołaniem do FUNKCJI RDMA, która oznacza "zdalny bezpośredni dostęp do pamięci"). Na przykład jednostka SKU Standard_NC24rs_v3 maszyny wirtualnej jest włączona w rozwiązaniu InfiniBand, ale jednostka SKU Standard_NC24s_v3 nie jest. Oprócz możliwości InfiniBand specyfikacje między tymi dwoma jednostkami SKU są w dużej mierze takie same — oba mają 24 rdzenie, 448 GB pamięci RAM, 4 procesory GPU tej samej jednostki SKU itp. Dowiedz się więcej o jednostkach SKU maszyn z obsługą funkcji RDMA i InfiniBand.

Ostrzeżenie

Jednostka SKU Standard_NC24r maszyny starszej generacji jest włączona przez funkcję RDMA, ale nie zawiera sprzętu SR-IOV wymaganego dla rozwiązania InfiniBand.

Jeśli tworzysz AmlCompute klaster z jedną z tych funkcji RDMA, rozmiary z włączoną funkcją InfiniBand, obraz systemu operacyjnego będzie wyposażony w sterownik Mellanox OFED wymagany do włączenia wstępnie zainstalowanej i wstępnie skonfigurowanej aplikacji InfiniBand.

Następne kroki