Share via

Trainingshandleiding voor gedistribueerde GPU (SDK v1)

  • Artikel

VAN TOEPASSING OP:Python SDK azureml v1

Meer informatie over het gebruik van gedistribueerde GPU-trainingscode in Azure Machine Learning (ML). Dit artikel bevat geen informatie over gedistribueerde training. Hiermee kunt u uw bestaande gedistribueerde trainingscode uitvoeren in Azure Machine Learning. Het bevat tips en voorbeelden die u voor elk framework kunt volgen:

  • Message Passing Interface (MPI)
    • Horovod
    • DeepSpeed
    • Omgevingsvariabelen van Open MPI
  • PyTorch
    • Initialisatie van procesgroepen
    • Startopties
    • DistributedDataParallel (per proces-lancering)
    • Met ( torch.distributed.launch per knooppunt starten)
    • PyTorch Lightning
    • Knuffelende gezichtstransformaties
  • TensorFlow
    • Omgevingsvariabelen voor TensorFlow (TF_CONFIG)
  • GPU-training versnellen met InfiniBand

Vereisten

Bekijk deze basisconcepten van gedistribueerde GPU-training , zoals gegevensparallellisme, gedistribueerde gegevensparallellisme en modelparallellisme.

Tip

Als u niet weet welk type parallelle uitvoering u moet gebruiken, moet u meer dan 90% van de tijd Distributed Data Parallelism gebruiken.

MPI

Azure Machine Learning biedt een MPI-taak om een bepaald aantal processen in elk knooppunt te starten. U kunt deze methode gebruiken om gedistribueerde training uit te voeren met behulp van het startprogramma per proces of per knooppunt, afhankelijk van of process_count_per_node is ingesteld op 1 (de standaardinstelling) voor het startprogramma per knooppunt of gelijk is aan het aantal apparaten/GPU's voor startprogramma per proces. Azure Machine Learning maakt de volledige MPI-startopdracht (mpirun) achter de schermen. U kunt niet uw eigen volledige opdrachten voor hoofdknooppunt-launcher opgeven, zoals mpirun of DeepSpeed launcher.

Tip

Voor de basis-Docker-installatiekopieën die door een Azure Machine Learning MPI-taak worden gebruikt, moet een MPI-bibliotheek zijn geïnstalleerd. Open MPI is opgenomen in alle Azure Machine Learning GPU-basisinstallatiekopieën. Wanneer u een aangepaste Docker-installatiekopieën gebruikt, moet u ervoor zorgen dat de installatiekopieën een MPI-bibliotheek bevatten. Open MPI wordt aanbevolen, maar u kunt ook een andere MPI-implementatie gebruiken, zoals Intel MPI. Azure Machine Learning biedt ook gecureerde omgevingen voor populaire frameworks.

Voer de volgende stappen uit om gedistribueerde training uit te voeren met behulp van MPI:

  1. Gebruik een Azure Machine Learning-omgeving met het gewenste Deep Learning-framework en MPI. Azure Machine Learning biedt een gecureerde omgeving voor populaire frameworks.
  2. Definieer MpiConfiguration met process_count_per_node en node_count. process_count_per_node moet gelijk zijn aan het aantal GPU's per knooppunt voor starten per proces of ingesteld op 1 (de standaardinstelling) voor starten per knooppunt als het gebruikersscript verantwoordelijk is voor het starten van de processen per knooppunt.
  3. Geef het MpiConfiguration object door aan de distributed_job_config parameter van 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

Gebruik de MPI-taakconfiguratie wanneer u Horovod gebruikt voor gedistribueerde training met het deep learning-framework.

Zorg ervoor dat uw code deze tips volgt:

  • De trainingscode is correct geïnstrueerd met Horovod voordat de Azure Machine Learning-onderdelen worden toegevoegd
  • Uw Azure Machine Learning-omgeving bevat Horovod en MPI. De gecureerde GPU-omgevingen van PyTorch en TensorFlow zijn vooraf geconfigureerd met Horovod en de bijbehorende afhankelijkheden.
  • Maak een MpiConfiguration met de gewenste distributie.

Horovod-voorbeeld

DeepSpeed

Gebruik het aangepaste startprogramma van DeepSpeed niet om gedistribueerde training uit te voeren met de DeepSpeed-bibliotheek op Azure Machine Learning. Configureer in plaats daarvan een MPI-taak om de trainingstaak met MPI te starten.

Zorg ervoor dat uw code deze tips volgt:

  • Uw Azure Machine Learning-omgeving bevat DeepSpeed en de bijbehorende afhankelijkheden, Open MPI en mpi4py.
  • Maak een MpiConfiguration met uw distributie.

Voorbeeld van DeepSpeed

Omgevingsvariabelen van Open MPI

Bij het uitvoeren van MPI-taken met MPI-installatiekopieën openen, worden de volgende omgevingsvariabelen gebruikt voor elk proces dat wordt gestart:

  1. OMPI_COMM_WORLD_RANK - de rang van het proces
  2. OMPI_COMM_WORLD_SIZE - de grootte van de wereld
  3. AZ_BATCH_MASTER_NODE - primair adres met poort, MASTER_ADDR:MASTER_PORT
  4. OMPI_COMM_WORLD_LOCAL_RANK - de lokale rangschikking van het proces op het knooppunt
  5. OMPI_COMM_WORLD_LOCAL_SIZE - aantal processen op het knooppunt

Tip

Ondanks de naam komt de omgevingsvariabele OMPI_COMM_WORLD_NODE_RANK niet overeen met de NODE_RANK. Als u het startprogramma per knooppunt wilt gebruiken, stelt process_count_per_node=1 u in en gebruikt u OMPI_COMM_WORLD_RANK als de NODE_RANK.

PyTorch

Azure Machine Learning ondersteunt het uitvoeren van gedistribueerde taken met behulp van de systeemeigen gedistribueerde trainingsmogelijkheden van PyTorch (torch.distributed).

Tip

Voor gegevensparallelisme is de officiële PyTorch-richtlijn het gebruik van DistributedDataParallel (DDP) via DataParallel voor gedistribueerde training met één knooppunt en met meerdere knooppunten. PyTorch raadt ook aan om DistributedDataParallel te gebruiken in plaats van het multiprocessing-pakket. Documentatie en voorbeelden van Azure Machine Learning zijn daarom gericht op DistributedDataParallel-training.

Initialisatie van procesgroepen

De ruggengraat van elke gedistribueerde training is gebaseerd op een groep processen die elkaar kennen en met elkaar kunnen communiceren via een back-end. Voor PyTorch wordt de procesgroep gemaakt door torch.distributed.init_process_group aan te roepen in alle gedistribueerde processen om gezamenlijk een procesgroep te vormen.

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

De meest gebruikte communicatie-back-ends zijn mpi, ncclen gloo. Voor GPU-gebaseerde training nccl wordt aanbevolen voor de beste prestaties en moet waar mogelijk worden gebruikt.

init_method vertelt hoe elk proces elkaar kan detecteren, hoe ze de procesgroep initialiseren en verifiëren met behulp van de communicatie-back-end. Als niet is opgegeven, gebruikt PyTorch standaard init_method de initialisatiemethode van de omgevingsvariabele (env://). init_method is de aanbevolen initialisatiemethode die u in uw trainingscode kunt gebruiken om gedistribueerde PyTorch uit te voeren op Azure Machine Learning. PyTorch zoekt naar de volgende omgevingsvariabelen voor initialisatie:

  • MASTER_ADDR - IP-adres van de machine waarop het proces wordt gehost met rang 0.
  • MASTER_PORT - Een vrije poort op de computer die het proces met rang 0 host.
  • WORLD_SIZE - Het totale aantal processen. Moet gelijk zijn aan het totale aantal apparaten (GPU) dat wordt gebruikt voor gedistribueerde training.
  • RANK - De (globale) rang van het huidige proces. De mogelijke waarden zijn 0 tot (wereldgrootte - 1).

Zie de PyTorch-documentatie voor meer informatie over het initialiseren van procesgroepen.

Daarnaast hebben veel toepassingen ook de volgende omgevingsvariabelen nodig:

  • LOCAL_RANK - De lokale (relatieve) rang van het proces binnen het knooppunt. De mogelijke waarden zijn 0 tot (# van processen op het knooppunt - 1). Deze informatie is nuttig omdat veel bewerkingen, zoals gegevensvoorbereiding, slechts één keer per knooppunt moeten worden uitgevoerd --- meestal op local_rank = 0.
  • NODE_RANK - De rang van het knooppunt voor training met meerdere knooppunten. De mogelijke waarden zijn 0 tot (totaal aantal knooppunten - 1).

PyTorch-startopties

De Azure Machine Learning PyTorch-taak ondersteunt twee typen opties voor het starten van gedistribueerde training:

  • Startprogramma per proces: het systeem start alle gedistribueerde processen voor u, met alle relevante informatie (zoals omgevingsvariabelen) om de procesgroep in te stellen.
  • Startprogramma per knooppunt: u levert Azure Machine Learning met het startprogramma voor hulpprogramma's dat op elk knooppunt wordt uitgevoerd. Het startprogramma voor hulpprogramma's zorgt ervoor dat elk van de processen op een bepaald knooppunt wordt gestart. Lokaal binnen elk knooppunt RANK en LOCAL_RANK worden ingesteld door het startprogramma. Het hulpprogramma torch.distributed.launch en PyTorch Lightning behoren beide tot deze categorie.

Er zijn geen fundamentele verschillen tussen deze startopties. De keuze is grotendeels afhankelijk van uw voorkeur of de conventies van de frameworks/bibliotheken die zijn gebouwd op vanille PyTorch (zoals Lightning of Hugging Face).

In de volgende secties wordt dieper ingegaan op het configureren van Azure Machine Learning PyTorch-taken voor elk van de startopties.

DistributedDataParallel (per proces starten)

U hoeft geen startprogramma torch.distributed.launchzoals te gebruiken. Een gedistribueerde PyTorch-taak uitvoeren:

  1. Het trainingsscript en de argumenten opgeven
  2. Maak een PyTorchConfiguration en geef de en node_countopprocess_count. De process_count komt overeen met het totale aantal processen dat u voor uw taak wilt uitvoeren. process_count moet doorgaans gelijk zijn aan # GPUs per node x # nodes. Als process_count dit niet is opgegeven, start Azure Machine Learning standaard één proces per knooppunt.

Azure Machine Learning stelt de MASTER_ADDRomgevingsvariabelen , MASTER_PORT, WORLD_SIZEen NODE_RANK in op elk knooppunt en stelt de variabelen op procesniveau RANK en LOCAL_RANK omgevingsvariabelen in.

Als u deze optie wilt gebruiken voor training met meerdere processen per knooppunt, gebruikt u Azure Machine Learning Python SDK >= 1.22.0. Process_count werd geïntroduceerd in 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

Als uw trainingsscript informatie zoals lokale rangschikking of rangschikking doorgeeft als scriptargumenten, kunt u verwijzen naar de omgevingsvariabele(n) in de argumenten:

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

Voorbeeld van pytorch per proces starten

Torch.distributed.launch gebruiken (per-node-launch)

PyTorch biedt een hulpprogramma voor starten in torch.distributed.launch dat u kunt gebruiken om meerdere processen per knooppunt te starten. De torch.distributed.launch module bevat meerdere trainingsprocessen op elk van de knooppunten.

De volgende stappen laten zien hoe u een PyTorch-taak configureert met een startprogramma per knooppunt in Azure Machine Learning. De taak bereikt het equivalent van het uitvoeren van de volgende opdracht:

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. Geef de torch.distributed.launch opdracht op voor de command parameter van de ScriptRunConfig constructor. Azure Machine Learning voert deze opdracht uit op elk knooppunt van uw trainingscluster. --nproc_per_node moet kleiner zijn dan of gelijk zijn aan het aantal GPU's dat beschikbaar is op elk knooppunt. MASTER_ADDR, MASTER_PORT en NODE_RANK zijn allemaal ingesteld door Azure Machine Learning, dus u kunt alleen verwijzen naar de omgevingsvariabelen in de opdracht. Azure Machine Learning stelt MASTER_PORT in op 6105, maar u kunt desgewenst een andere waarde doorgeven aan het --master_port argument torch.distributed.launch. (Het starthulpprogramma stelt de omgevingsvariabelen opnieuw in.)
  2. Maak een PyTorchConfiguration en geef de op 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

Training voor meerdere GPU's met één knooppunt: Als u het hulpprogramma voor starten gebruikt om pytorch met één knooppunt met meerdere knooppunten uit te voeren, hoeft u de distributed_job_config parameter scriptrunconfig niet op te geven.

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,
)

Voorbeeld van PyTorch per knooppuntlancering

PyTorch Lightning

PyTorch Lightning is een lichtgewicht opensource-bibliotheek die een interface op hoog niveau biedt voor PyTorch. Lightning abstraheert veel van de gedistribueerde trainingsconfiguraties op lager niveau die vereist zijn voor vanille PyTorch. Met Lightning kunt u uw trainingsscripts uitvoeren in instellingen voor één GPU, meerdere knooppunten en meerdere knooppunten voor meerdere GPU's. Achter de schermen worden meerdere processen voor u gestart, vergelijkbaar met torch.distributed.launch.

Voor training met één knooppunt (inclusief één knooppunt met meerdere GPU's) kunt u uw code uitvoeren op Azure Machine Learning zonder dat u een distributed_job_confighoeft op te geven. Als u een experiment wilt uitvoeren met meerdere knooppunten met meerdere GPU's, zijn er twee opties:

  • PyTorch-configuratie gebruiken (aanbevolen): definieer PyTorchConfiguration en geef communication_backend="Nccl", node_counten process_count op (houd er rekening mee dat dit het totale aantal processen is, dat wil zeggen num_nodes * process_count_per_node). Geef in de module Lightning Trainer zowel als num_nodes op gpus om consistent te zijn met PyTorchConfiguration. Bijvoorbeeld num_nodes = node_count en gpus = process_count_per_node.

  • MPI-configuratie gebruiken:

    • Definieer MpiConfiguration en geef zowel als op node_countprocess_count_per_node. Geef in Lightning Trainer zowel als num_nodesgpus op om respectievelijk hetzelfde te zijn als node_count en process_count_per_node van MpiConfiguration.

    • Voor training met meerdere knooppunten met MPI moet Lightning de volgende omgevingsvariabelen op elk knooppunt van uw trainingscluster instellen:

      • MASTER_ADDR
      • MASTER_PORT
      • NODE_RANK
      • LOCAL_RANK

      Stel deze omgevingsvariabelen die Lightning nodig heeft in de belangrijkste trainingsscripts handmatig in:

    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
  )

    Bliksem verwerkt het berekenen van de grootte van de wereld van de Trainer vlaggen --gpus en --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)

Gezichtstransformaties omhelzen

Knuffelen van Face biedt veel voorbeelden voor het gebruik van de Transformers-bibliotheek met torch.distributed.launch om gedistribueerde training uit te voeren. Als u deze voorbeelden en uw eigen aangepaste trainingsscripts wilt uitvoeren met behulp van de Transformers Trainer-API, volgt u de sectie Gebruiken torch.distributed.launch .

Voorbeeld van taakconfiguratiecode om het GROTE BERT-model af te stemmen op de MNLI-taak voor tekstclassificatie met behulp van het run_glue.py script op één knooppunt met 8 GPU's:

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,
)

U kunt ook de optie per proces starten gebruiken om gedistribueerde training uit te voeren zonder gebruik te maken van torch.distributed.launch. Een ding om in gedachten te houden als u deze methode gebruikt, is dat de trainingarguments van de transformers verwachten dat de lokale rang als een argument () wordt doorgegeven.--local_rank torch.distributed.launch zorgt voor dit wanneer --use_env=False, maar als u per proces starten gebruikt, moet u de lokale rangschikking expliciet doorgeven aan het trainingsscript --local_rank=$LOCAL_RANK , omdat Azure Machine Learning alleen de LOCAL_RANK omgevingsvariabele instelt.

TensorFlow

Als u systeemeigen gedistribueerde TensorFlow gebruikt in uw trainingscode, zoals de API van tf.distribute.Strategy TensorFlow 2.x, kunt u de gedistribueerde taak starten via Azure Machine Learning met behulp van de TensorflowConfiguration.

Hiertoe geeft u een TensorflowConfiguration -object op voor de distributed_job_config parameter van de ScriptRunConfig constructor. Als u gebruikt tf.distribute.experimental.MultiWorkerMirroredStrategy, geeft u de worker_count op in de TensorflowConfiguration die overeenkomt met het aantal knooppunten voor uw trainingstaak.

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)

Als uw trainingsscript gebruikmaakt van de parameterserverstrategie voor gedistribueerde training, zoals voor verouderde TensorFlow 1.x, moet u ook het aantal parameterservers opgeven dat in de taak moet worden gebruikt, bijvoorbeeld tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1).

TF_CONFIG

In TensorFlow is de omgevingsvariabele TF_CONFIG vereist voor training op meerdere computers. Voor TensorFlow-taken configureert en stelt Azure Machine Learning de variabele TF_CONFIG op de juiste manier in voor elke werkrol voordat u uw trainingsscript uitvoert.

U kunt TF_CONFIG openen vanuit uw trainingsscript als u het volgende nodig hebt: os.environ['TF_CONFIG'].

Voorbeeld TF_CONFIG ingesteld op een chief worker-knooppunt:

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

TensorFlow-voorbeeld

Gedistribueerde GPU-training versnellen met InfiniBand

Naarmate het aantal VM's dat een model traint toeneemt, neemt de tijd die nodig is om dat model te trainen, af. De afname van de tijd moet in het ideale geval lineair evenredig zijn met het aantal trainings-VM's. Als het trainen van een model op één VM bijvoorbeeld 100 seconden duurt, duurt het trainen van hetzelfde model op twee VM's idealiter 50 seconden. Het trainen van het model op vier VM's duurt 25 seconden, enzovoort.

InfiniBand kan een belangrijke factor zijn bij het bereiken van deze lineaire schaalaanpassing. InfiniBand maakt gpu-naar-GPU-communicatie met lage latentie mogelijk tussen knooppunten in een cluster. InfiniBand vereist gespecialiseerde hardware om te kunnen werken. Bepaalde Azure VM-serie, met name de NC-, ND- en H-serie, hebben nu RDMA-compatibele VM's met SR-IOV- en InfiniBand-ondersteuning. Deze VM's communiceren via het InfiniBand-netwerk met lage latentie en hoge bandbreedte, wat veel beter presteert dan ethernetconnectiviteit. SR-IOV voor InfiniBand biedt bijna bare-metalprestaties voor elke MPI-bibliotheek (MPI wordt gebruikt door veel gedistribueerde trainingsframeworks en hulpprogramma's, waaronder NCCL-software van NVIDIA.) Deze SKU's zijn bedoeld om te voldoen aan de behoeften van rekenintensieve, GPU-acclerated machine learning-workloads. Zie Voor meer informatie Het versnellen van gedistribueerde training in Azure Machine Learning met SR-IOV.

VM-SKU's met een 'r' in hun naam bevatten doorgaans de vereiste InfiniBand-hardware, en die zonder een 'r' meestal niet. ('r' is een verwijzing naar RDMA, wat staat voor 'remote direct memory access'.) De VM-SKU Standard_NC24rs_v3 is bijvoorbeeld ingeschakeld voor InfiniBand, maar de SKU Standard_NC24s_v3 niet. Afgezien van de InfiniBand-mogelijkheden zijn de specificaties tussen deze twee SKU's grotendeels hetzelfde: beide hebben 24 kernen, 448 GB RAM, 4 GPU's van dezelfde SKU, enzovoort. Meer informatie over RDMA- en InfiniBand-compatibele computer-SKU's.

Waarschuwing

De machine-SKU Standard_NC24r van de oudere generatie is RDMA ingeschakeld, maar bevat geen SR-IOV-hardware die vereist is voor InfiniBand.

Als u een cluster maakt van een AmlCompute van deze RDMA-compatibele InfiniBand-grootten, wordt de installatiekopie van het besturingssysteem geleverd met het Mellanox OFED-stuurprogramma dat is vereist om Vooraf geïnstalleerde en vooraf geconfigureerde InfiniBand in te schakelen.

Volgende stappen