Průvodce trénováním distribuovaného GPU (SDK v1)

Článek
09/01/2024

Přečtěte si další informace o tom, jak používat distribuovaný trénovací kód GPU ve službě Azure Machine Learning (ML). Tento článek vás nenaučí o distribuovaném trénování. Pomůže vám spouštět stávající distribuovaný trénovací kód ve službě Azure Machine Learning. Nabízí tipy a příklady, které můžete sledovat pro každou architekturu:

Rozhraní MPI (Message Passing Interface)
- Horovod
- DeepSpeed
- Proměnné prostředí z Open MPI
PyTorch
- Inicializace skupiny procesů
- Možnosti spuštění
- DistributedDataParallel (spuštění podle procesu)
- Použití torch.distributed.launch (spuštění podle uzlu)
- PyTorch Lightning
- Hugging Face Transformers
TensorFlow
- Proměnné prostředí pro TensorFlow (TF_CONFIG)
Zrychlení trénování GPU pomocí InfiniBandu

Požadavky

Projděte si tyto základní koncepty distribuovaného trénování GPU, jako je datový paralelismus, distribuovaný datový paralelismus a paralelismus modelu.

Tip

Pokud nevíte, jaký typ paralelismu použít, měli byste použít více než 90 % času, kdy byste měli použít distribuovaný datový paralelismus.

MPI

Azure Machine Learning nabízí úlohu MPI pro spuštění daného počtu procesů v každém uzlu. Tento přístup můžete použít ke spuštění distribuovaného trénování pomocí spouštěče procesů nebo spouštěče uzlů v závislosti na tom, jestli process_count_per_node je pro spouštěč uzlů nastavená hodnota 1 (výchozí) nebo rovna počtu zařízení nebo GPU pro spouštěč procesů. Azure Machine Learning vytváří úplný spouštěcí příkaz MPI (mpirun) na pozadí. Nemůžete zadat vlastní úplné příkazy head-node-launcher jako mpirun nebo DeepSpeed launcher.

Tip

Základní image Dockeru používaná úlohou MPI služby Azure Machine Learning musí mít nainstalovanou knihovnu MPI. Open MPI je součástí všech základních imagí GPU služby Azure Machine Learning. Při použití vlastní image Dockeru zodpovídáte za to, že image obsahuje knihovnu MPI. Doporučuje se otevřít MPI, ale můžete také použít jinou implementaci MPI, například Intel MPI. Azure Machine Learning také poskytuje kurátorovaná prostředí pro oblíbené architektury.

Pokud chcete spustit distribuované trénování pomocí MPI, postupujte takto:

Použijte prostředí Azure Machine Learning s upřednostňovanou architekturou hlubokého učení a MPI. Azure Machine Learning poskytuje kurátorované prostředí pro oblíbené architektury.
Definovat MpiConfiguration pomocí process_count_per_node a node_count. process_count_per_node pokud bude uživatelský skript zodpovědný za spouštění procesů na uzel, měl by se rovnat počtu GPU na uzel nebo na hodnotu 1 (výchozí) pro spuštění jednotlivých uzlů.
MpiConfiguration Předat objekt 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

Konfiguraci úlohy MPI použijte při použití Horovodu pro distribuované trénování s architekturou hlubokého učení.

Ujistěte se, že váš kód používá tyto tipy:

Trénovací kód se před přidáním částí Azure Machine Learning správně instrumentuje pomocí Horovodu.
Vaše prostředí Azure Machine Learning obsahuje Horovod a MPI. Kurátorovaná prostředí GPU PyTorch a TensorFlow jsou předem nakonfigurovaná s horovodem a jeho závislostmi.
Vytvořte požadovanou MpiConfiguration distribuci.

Příklad Horovodu

azureml-examples: TensorFlow distributed training using Horovod

DeepSpeed

Nepoužívejte vlastní spouštěč DeepSpeed ke spuštění distribuovaného trénování s knihovnou DeepSpeed ve službě Azure Machine Learning. Místo toho nakonfigurujte úlohu MPI tak, aby spustila trénovací úlohu pomocí MPI.

Ujistěte se, že váš kód používá tyto tipy:

Prostředí Azure Machine Learning obsahuje DeepSpeed a jeho závislosti, Open MPI a mpi4py.
Vytvořte s vaší distribucí.MpiConfiguration

Příklad DeepSpeed

azureml-examples: Distribuované trénování s deepSpeedem na CIFAR-10

Proměnné prostředí z Open MPI

Při spouštění úloh MPI s otevřenými imagemi MPI se pro každý spuštěný proces spustí následující proměnné prostředí:

OMPI_COMM_WORLD_RANK - pořadí procesu
OMPI_COMM_WORLD_SIZE - velikost světa
AZ_BATCH_MASTER_NODE – primární adresa s portem, MASTER_ADDR:MASTER_PORT
OMPI_COMM_WORLD_LOCAL_RANK – místní pořadí procesu na uzlu
OMPI_COMM_WORLD_LOCAL_SIZE – počet procesů na uzlu

Tip

Navzdory názvu proměnné OMPI_COMM_WORLD_NODE_RANK prostředí neodpovídá NODE_RANK. Chcete-li použít spouštěč pro jednotlivé uzly, nastavte process_count_per_node=1 a použijte OMPI_COMM_WORLD_RANK jako NODE_RANK.

PyTorch

Azure Machine Learning podporuje spouštění distribuovaných úloh pomocí nativních funkcí distribuovaného trénování PyTorch (torch.distributed).

Tip

V případě datového paralelismu je oficiální pokyny PyTorchu použít DistributedDataParallel (DDP) přes DataParallel pro distribuované trénování s jedním uzlem i více uzly. PyTorch také doporučuje používat DistributedDataParallel přes balíček multiprocessingu. Dokumentace a příklady služby Azure Machine Learning se proto zaměří na trénování DistributedDataParallel.

Inicializace skupiny procesů

Páteř všech distribuovaných trénování je založená na skupině procesů, které navzájem znají a můžou mezi sebou komunikovat pomocí back-endu. Pro PyTorch se skupina procesů vytvoří voláním torch.distributed.init_process_group ve všech distribuovaných procesech , aby souhrnně vytvořily skupinu procesů.

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

Nejběžnějšími používanými back-endy komunikace jsou mpi, nccla gloo. Pro trénování nccl na základě GPU se doporučuje nejlepší výkon a měli byste ho použít, kdykoli je to možné.

init_method informuje, jak se jednotlivé procesy můžou navzájem zjišťovat, jak inicializují a ověřují skupinu procesů pomocí back-endu komunikace. Ve výchozím nastavení, pokud init_method není zadán PyTorch použije metodu inicializace proměnné prostředí (env://). init_method je doporučená inicializační metoda, která se použije v trénovacím kódu ke spuštění distribuovaného PyTorchu ve službě Azure Machine Learning. PyTorch bude hledat následující proměnné prostředí pro inicializaci:

MASTER_ADDR – IP adresa počítače, který bude hostovat proces s pořadím 0.
MASTER_PORT – Volný port na počítači, který bude hostovat proces s pořadím 0.
WORLD_SIZE - Celkový počet procesů. Měl by se rovnat celkovému počtu zařízení (GPU) používaných k distribuovanému trénování.
RANK - (globální) pořadí aktuálního procesu. Možné hodnoty jsou 0 až (velikost světa - 1).

Další informace o inicializaci skupin procesů najdete v dokumentaci k PyTorch.

Kromě toho bude mnoho aplikací potřebovat také následující proměnné prostředí:

LOCAL_RANK – Místní (relativní) pořadí procesu v rámci uzlu. Možné hodnoty jsou 0 až (počet procesů na uzlu – 1). Tyto informace jsou užitečné, protože mnoho operací, jako je příprava dat, by se mělo provádět pouze jednou na uzel --- obvykle na local_rank = 0.
NODE_RANK - Pořadí uzlu pro trénování s více uzly. Možné hodnoty jsou 0 až (celkový počet uzlů – 1).

Možnosti spuštění PyTorch

Úloha Azure Machine Learning PyTorch podporuje dva typy možností spuštění distribuovaného trénování:

Spouštěč procesů: Systém spustí všechny distribuované procesy za vás se všemi relevantními informacemi (například proměnnými prostředí) pro nastavení skupiny procesů.
Spouštěč uzlů: Azure Machine Learning poskytnete spouštěči nástrojů, který se spustí na každém uzlu. Spouštěč nástrojů bude zpracovávat spouštění jednotlivých procesů na daném uzlu. Místně v každém uzlu RANK a LOCAL_RANK jsou nastaveny spouštěčem. Nástroj torch.distributed.launch a PyTorch Lightning patří do této kategorie.

Mezi těmito možnostmi spuštění nejsou žádné zásadní rozdíly. Volba je z velké části na vaše preference nebo konvence architektur/knihoven postavených na vanilla PyTorch (například Blesk nebo Hugging Face).

V následujících částech najdete podrobnější informace o tom, jak nakonfigurovat úlohy PyTorch služby Azure Machine Learning pro každou z možností spuštění.

DistributedDataParallel (spuštění podle procesu)

Nemusíte používat spouštěcí nástroj, jako je torch.distributed.launch. Spuštění distribuované úlohy PyTorch:

Zadání trénovacího skriptu a argumentů
Vytvořte PyTorchConfiguration a zadejte process_count node_count Odpovídá process_count celkovému počtu procesů, které chcete pro úlohu spustit. process_count by měla být obvykle rovna # GPUs per node x # nodes. Pokud process_count není zadaný, Azure Machine Learning ve výchozím nastavení spustí jeden proces na uzel.

Azure Machine Learning nastaví MASTER_ADDRproměnné prostředí , , WORLD_SIZEMASTER_PORTa NODE_RANK prostředí na každém uzlu a nastaví proměnné na úrovni RANK procesu a LOCAL_RANK prostředí.

Pokud chcete tuto možnost použít pro trénování s více procesy na uzly, použijte sadu Azure Machine Learning Python SDK >= 1.22.0. Process_count byla zavedena ve verzi 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)

Tip

Pokud trénovací skript předá informace, jako je místní pořadí nebo pořadí jako argumenty skriptu, můžete odkazovat na proměnné prostředí v argumentech:

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

Příklad spuštění Pytorchu na proces

příklady azureml: Distribuované trénování pomocí PyTorchu na CIFAR-10

Použití torch.distributed.launch (pro-node-launch)

PyTorch poskytuje spouštěcí nástroj v torch.distributed.launch , který můžete použít ke spuštění více procesů na uzel. Modul torch.distributed.launch vytváří na každém uzlu několik trénovacích procesů.

Následující kroky ukazují, jak nakonfigurovat úlohu PyTorch pomocí spouštěče pro jednotlivé uzly ve službě Azure Machine Learning. Úloha dosáhne ekvivalentu spuštění následujícího příkazu:

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>

torch.distributed.launch Zadejte příkaz k command parametru konstruktoruScriptRunConfig. Azure Machine Learning spustí tento příkaz na každém uzlu vašeho trénovacího clusteru. --nproc_per_node by měl být menší nebo roven počtu grafických procesorů dostupných na každém uzlu. Služba Azure Machine Learning nastavuje všechny MASTER_ADDR, MASTER_PORT a NODE_RANK, takže stačí odkazovat na proměnné prostředí v příkazu. Azure Machine Learning nastaví MASTER_PORT na 6105, ale pokud chcete, můžete argumentu torch.distributed.launch předat jinou hodnotu --master_port . (Spouštěcí nástroj resetuje proměnné prostředí.)
PyTorchConfiguration Vytvořte a zadejte .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)

Tip

Trénování více GPU s jedním uzlem: Pokud ke spuštění trénování PyTorch s jedním uzlem používáte spouštěcí nástroj, nemusíte zadávat distributed_job_config parametr 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,
)

Příklad spuštění PyTorch na uzel

příklady azureml: Distribuované trénování pomocí PyTorchu na CIFAR-10

PyTorch Lightning

PyTorch Lightning je jednoduchá opensourcová knihovna, která poskytuje rozhraní vysoké úrovně pro PyTorch. Blesk abstrahuje mnoho konfigurací distribuovaného trénování nižší úrovně vyžadovaných pro vanilla PyTorch. Blesk umožňuje spouštět trénovací skripty v jednom GPU, v jednom uzlu s více GPU a v nastavení s více uzly s více uzly. Za scénou spustí několik procesů, které se vám podobají torch.distributed.launch.

Pro trénování s jedním uzlem (včetně více uzlů s více uzly) můžete kód spustit ve službě Azure Machine Learning, aniž byste museli zadávat distributed_job_config. Pokud chcete spustit experiment s více uzly s více grafickými procesory, existují 2 možnosti:

Použití konfigurace PyTorch (doporučeno): Definovat PyTorchConfiguration a zadat communication_backend="Nccl", node_counta process_count (všimněte si, že se jedná o celkový počet procesů, tj. num_nodes * process_count_per_node). V modulu Lightning Trainer určete, jak num_nodes a gpus být konzistentní s PyTorchConfiguration. Příklad: num_nodes = node_count a gpus = process_count_per_node.

Použití konfigurace MPI:

Definujte MpiConfiguration a zadejte oba node_count a process_count_per_node. V Lightning Traineru určete, jak num_nodes a gpus být v uvedeném pořadí stejné jako node_count a process_count_per_node z MpiConfiguration.
Pro trénování s více uzly pomocí MPI vyžaduje, aby se na každém uzlu trénovacího clusteru nastavily následující proměnné prostředí:
- MASTER_ADDR
- MASTER_PORT
- NODE_RANK
- LOCAL_RANK
Ručně nastavte tyto proměnné prostředí, které Lightning vyžaduje v hlavních trénovacích skriptech:

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
  )

Blesk zpracovává výpočet velikosti světa z příznaků trenéra --gpus a --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)

Hugging Face Transformers

Hugging Face nabízí mnoho příkladů použití knihovny torch.distributed.launch Transformers ke spuštění distribuovaného trénování. Pokud chcete tyto příklady spustit a vlastní trénovací skripty pomocí rozhraní API Transformers Trainer, postupujte podle části Použití torch.distributed.launch .

Vzorový konfigurační kód úlohy pro vyladění velkého modelu BERT u úlohy MNLI klasifikace textu pomocí run_glue.py skriptu na jednom uzlu s 8 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,
)

Můžete také použít možnost spuštění jednotlivých procesů ke spuštění distribuovaného trénování bez použití torch.distributed.launch. Při použití této metody je třeba mít na paměti, že transformátory TrainingArguments očekávají, že místní pořadí bude předáno jako argument (--local_rank). torch.distributed.launch se o to postará, --use_env=Falseale pokud používáte spuštění podle procesu, budete muset explicitně předat místní pořadí jako argument trénovacímu skriptu --local_rank=$LOCAL_RANK , protože Azure Machine Learning nastaví LOCAL_RANK pouze proměnnou prostředí.

TensorFlow

Pokud ve svém trénovacím kódu používáte nativní distribuovaný TensorFlow , například rozhraní API TensorFlow 2.x tf.distribute.Strategy , můžete distribuovanou úlohu spustit pomocí služby Azure Machine Learning pomocí nástroje TensorflowConfiguration.

Provedete to tak, že zadáte TensorflowConfiguration objekt distributed_job_config parametru konstruktoru ScriptRunConfig . Pokud používáte tf.distribute.experimental.MultiWorkerMirroredStrategy, zadejte worker_count v TensorflowConfiguration poli odpovídajícím počtu uzlů pro trénovací úlohu.

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)

Pokud váš trénovací skript používá pro distribuované trénování strategii serveru parametrů, například pro starší verzi TensorFlow 1.x, budete také muset zadat počet serverů parametrů, které se mají použít v úloze, tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1)například .

TF_CONFIG

V TensorFlow se pro trénování na více počítačích vyžaduje proměnná prostředí TF_CONFIG . U úloh TensorFlow azure Machine Learning nakonfiguruje a nastaví proměnnou TF_CONFIG odpovídajícím způsobem pro každý pracovní proces před spuštěním trénovacího skriptu.

Přístup k TF_CONFIG můžete získat z trénovacího skriptu, pokud potřebujete: os.environ['TF_CONFIG'].

Příklad TF_CONFIG nastavený na hlavním pracovním uzlu:

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

Příklad TensorFlow

příklady azureml: Distribuované trénování TensorFlow pomocí MultiWorkerMirroredStrategy

Zrychlení distribuovaného trénování GPU pomocí InfiniBandu

S rostoucím počtem virtuálních počítačů trénování modelu by se měl zkrátit čas potřebný k trénování tohoto modelu. V ideálním případě by mělo být snížení času lineární úměrné počtu trénovacích virtuálních počítačů. Pokud například trénování modelu na jednom virtuálním počítači trvá 100 sekund, trénování stejného modelu na dvou virtuálních počítačích by mělo v ideálním případě trvat 50 sekund. Trénování modelu na čtyřech virtuálních počítačích by mělo trvat 25 sekund atd.

InfiniBand může být důležitým faktorem při dosažení tohoto lineárního měřítka. InfiniBand umožňuje komunikaci s GPU na GPU mezi uzly v clusteru s nízkou latencí. InfiniBand vyžaduje specializovaný hardware pro provoz. Některé řady virtuálních počítačů Azure, konkrétně nc, ND a H-series, teď mají virtuální počítače podporující RDMA s podporou SR-IOV a InfiniBand. Tyto virtuální počítače komunikují přes nízkou latenci a síť InfiniBand s velkou šířkou pásma, což je mnohem výkonnější než připojení založené na ethernetu. SR-IOV pro InfiniBand umožňuje téměř holý výkon pro libovolnou knihovnu MPI (MPI používá mnoho distribuovaných trénovacích architektur a nástrojů, včetně softwaru NCCL NVIDIA.) Tyto skladové položky jsou určeny ke splnění potřeb výpočetních úloh, které jsou náročné na GPU. Další informace najdete v tématu Urychlení distribuovaného trénování ve službě Azure Machine Learning pomocí SR-IOV.

Skladové položky virtuálních počítačů s "r" v jejich názvu obvykle obsahují požadovaný hardware InfiniBand a ty bez r obvykle ne. ('r' je odkaz na RDMA, což je zkratka "vzdálený přímý přístup do paměti".) Skladová položka virtuálního počítače Standard_NC24rs_v3 je například povolená pro InfiniBand, ale skladová Standard_NC24s_v3 položka není. Kromě možností InfiniBand jsou specifikace mezi těmito dvěma skladovými jednotkami z velké části stejné – oba mají 24 jader, 448 GB RAM, 4 GPU stejné skladové položky atd. Přečtěte si další informace o SKU počítačů s podporou RDMA a InfiniBand.

Upozorňující

Skladová položka Standard_NC24r počítače starší generace je povolená SDMA, ale neobsahuje hardware SR-IOV vyžadovaný pro InfiniBand.

Pokud vytvoříte AmlCompute cluster s jednou z těchto velikostí podporujících RDMA, image operačního systému bude mít ovladač Mellanox OFED potřebný k povolení předinstalovaného a předkonfigurovaného infiniBandu.

Sdílet prostřednictvím