Udostępnij za pośrednictwem

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 to uruchomić istniejący rozproszony kod szkoleniowy w usłudze Azure Machine Learning. Oferuje on porady i przykłady, które należy wykonać dla każdej struktury:

  • 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 torch.distributed.launch z polecenia (uruchamianie na węzeł)
    • 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.

Napiwek

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. To podejście można zastosować do uruchamiania trenowania rozproszonego przy użyciu modułu uruchamiania 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 modułu uruchamiania dla węzła, czy jest równa liczbie urządzeń/procesorów GPU dla modułu uruchamiania poszczególnych procesów. Usługa Azure Machine Learning tworzy pełne polecenie uruchamiania MPI () wmpirun tle. Nie można podać własnych pełnych poleceń head-node-launcher, takich jak mpirun lub DeepSpeed launcher.

Napiwek

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. Gdy używasz 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ą i process_count_per_node node_count. process_count_per_node powinna być równa liczbie procesorów GPU na węzeł dla uruchamiania poszczególnych procesów lub ustawiona na 1 (wartość domyślna) dla uruchamiania poszczególnych węzłów, 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 używania struktury Horovod do trenowania rozproszonego z platformą 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 struktury Horovod i jego zależności.
  • Utwórz element z żądaną dystrybucją MpiConfiguration .

Przykład struktury Horovod

DeepSpeed

Nie używaj niestandardowego modułu uruchamiania DeepSpeed do uruchamiania trenowania rozproszonego za pomocą biblioteki DeepSpeed w usłudze Azure Machine Learning. Zamiast tego skonfiguruj zadanie MPI, aby uruchomić zadanie szkoleniowe 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 element z dystrybucją MpiConfiguration .

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

Napiwek

Pomimo nazwy zmienna środowiskowa OMPI_COMM_WORLD_NODE_RANK nie odpowiada zmiennej NODE_RANK. Aby użyć modułu uruchamiania dla węzła, ustaw process_count_per_node=1 element i użyj go 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).

Napiwek

W przypadku równoległości danych oficjalna wskazówka PyTorch polega na korzystaniu z metody DistributedDataParallel (DDP) na potrzeby trenowania rozproszonego zarówno w jednym węźle, jak i w wielu węzłach. Firma PyTorch zaleca również używanie elementu DistributedDataParallel w pakiecie wieloprocesorowym. W związku z tym dokumentacja i przykłady usługi Azure Machine Learning skupią 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 usługi PyTorch grupa procesów jest tworzona przez wywołanie torch.distributed.init_process_group we wszystkich procesach rozproszonych w celu utworzenia grupy procesów .

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 zainicjować i zweryfikować grupę procesów przy użyciu zaplecza komunikacji. init_method Jeśli 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 rozproszonej biblioteki 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 - Wolny port na maszynie, który będzie hostować proces o klasyfikacji 0.
  • WORLD_SIZE - Całkowita liczba procesów. Powinna być równa całkowitej 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 rozwiązania PyTorch

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

  • Uruchamianie poszczególnych procesów: system uruchomi wszystkie procesy rozproszone z wszystkimi odpowiednimi informacjami (takimi jak zmienne środowiskowe), aby skonfigurować grupę procesów.
  • Uruchamianie na węzeł: udostępniasz usługę Azure Machine Learning przy użyciu uruchamiania narzędzi, które będą uruchamiane w każdym węźle. Uruchamianie narzędzi 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 żadnych podstawowych różnic między tymi opcjami uruchamiania. Wybór jest w dużej mierze do Twoich preferencji lub konwencji struktur/bibliotek opartych na wanilii PyTorch (takich jak Lightning lub Hugging Face).

W poniższych sekcjach opisano bardziej szczegółowo 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 wartości process_count i node_count. Odpowiada process_count całkowitej liczbie procesów, które chcesz uruchomić 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 w każdym węźle oraz ustawi zmienne środowiskowe na poziomie RANK procesu i LOCAL_RANK zmienne środowiskowe.

Aby użyć tej opcji na potrzeby trenowania obejmującego wiele 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)

Napiwek

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

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

Przykład uruchamiania narzędzia Pytorch na proces

Korzystanie z narzędzia torch.distributed.launch (uruchamianie na węzeł)

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 przy użyciu modułu uruchamiania dla węzła 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 do command 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 --master_port argumentu 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)

Napiwek

Trenowanie z wieloma procesorami GPU z jednym węzłem: jeśli używasz narzędzia uruchamiania do uruchamiania trenowania wielowężnego procesora GPU PyTorch, 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 PyTorch na węzeł

Piorun PyTorch

PyTorch Lightning to uproszczona biblioteka typu open source, która zapewnia interfejs wysokiego poziomu dla rozwiązania PyTorch. Błyskawica abstrakcji od wielu konfiguracji treningowych rozproszonych niższego poziomu wymaganych dla wanilii PyTorch. Błyskawica umożliwia uruchamianie skryptów szkoleniowych w jednym procesorze GPU, wielowęźleowym procesorze GPU i ustawieniach wielowęźleowych wielowęźleowych procesorów GPU. W tle uruchamia wiele procesów podobnych do torch.distributed.launch.

W przypadku trenowania z jednym węzłem (w tym wielowęźle z wieloma procesorami GPU) 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", 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 wartość i num_nodes gpus , aby była spójna z PyTorchConfiguration. 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_count process_count_per_node. W funkcji Lightning Trainer określ wartości i num_nodes gpus , aby były odpowiednio 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 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żywania 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 transformers Trainer, postępuj zgodnie z sekcją Korzystanie torch.distributed.launch .

Przykładowy kod konfiguracji zadania w celu dostosowania dużego modelu do zadania klasyfikacji tekstu MNLI 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 transformatory TrainingArguments oczekują, że ranga lokalna zostanie przekazana jako argument (--local_rank). torch.distributed.launch Dba o to, gdy --use_env=Falseparametr , ale jeśli używasz uruchamiania poszczególnych procesów, musisz jawnie przekazać rangę lokalną jako argument do skryptu --local_rank=$LOCAL_RANK szkoleniowego, ponieważ usługa Azure Machine Learning ustawia LOCAL_RANK tylko zmienną środowiskową.

TensorFlow

Jeśli używasz natywnego rozproszonego biblioteki TensorFlow w kodzie szkoleniowym, takim jak interfejs API TensorFlow 2.x tf.distribute.Strategy , możesz uruchomić zadanie rozproszone za pośrednictwem usługi Azure Machine Learning przy użyciu narzędzia 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 worker_count element w TensorflowConfiguration odpowiadającym liczbie węzłów zadania trenowania.

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 starsza wersja 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 przypadku biblioteki 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 na głównym węźle roboczym:

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

Przykład biblioteki TensorFlow

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

Wraz ze wzrostem liczby maszyn wirtualnych trenowania modelu czas wymagany do trenowania tego modelu powinien się zmniejszyć. Skrócenie czasu, najlepiej, powinno być liniowo proporcjonalne do liczby maszyn wirtualnych trenowania. 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 umożliwiającym osiągnięcie tego liniowego skalowania. InfiniBand umożliwia komunikację między węzłami w klastrze z małymi opóźnieniami i komunikacją 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 funkcją RDMA z obsługą funkcji SR-IOV i InfiniBand. Te maszyny wirtualne komunikują się za pośrednictwem sieci InfiniBand o małym opóźnieniu i wysokiej przepustowości, która jest o wiele bardziej wydajna niż łączność oparta na sieci Ethernet. Sr-IOV dla InfiniBand zapewnia niemal bez systemu operacyjnego wydajność dla dowolnej biblioteki MPI (MPI jest używana przez wiele rozproszonych struktur szkoleniowych i narzędzi, w tym oprogramowania NCCL firmy NVIDIA). Te jednostki SKU mają spełniać potrzeby 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.

Zazwyczaj jednostki SKU maszyn wirtualnych o nazwie "r" zawierają wymagany sprzęt InfiniBand, a te bez "r" zwykle nie. ('r' jest odwołaniem do RDMA, co 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 utworzysz AmlCompute klaster z jedną z tych funkcji RDMA, rozmiary z włączoną funkcją InfiniBand, obraz systemu operacyjnego będzie zawierać sterownik Mellanox OFED wymagany do włączenia wstępnie zainstalowanej i wstępnie skonfigurowanej aplikacji InfiniBand.

Następne kroki