Trainingshandleiding voor gedistribueerde GPU

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 op Azure Machine Learning. Het biedt 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 starten)
    • Gebruiken torch.distributed.launch (per knooppunt starten)
    • PyTorch Lightning
    • Gezichtstransformaties omhelzen
  • 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 parallellisme u moet gebruiken, moet u meer dan 90% van de tijd Distributed Data Parallelism gebruiken.

MPI

Azure ML 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 ML maakt achter de schermen de volledige MPI-startopdracht (mpirun) . U kunt niet uw eigen volledige opdrachten voor het startprogramma voor hoofdknooppunten 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 AzureML 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 ML 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 ML-omgeving met het gewenste Deep Learning-framework en MPI. AzureML 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 het starten per proces of ingesteld op 1 (de standaardinstelling) voor het 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 wordt correct geïnstrueerd met Horovod voordat u de Azure ML-onderdelen toevoegt
  • Uw Azure ML-omgeving bevat Horovod en MPI. De gecureerde GPU-omgevingen 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 ML. Configureer in plaats daarvan een MPI-taak om de trainingstaak met MPI te starten.

Zorg ervoor dat uw code deze tips volgt:

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

DeepSeed-voorbeeld

Omgevingsvariabelen van Open MPI

Bij het uitvoeren van MPI-taken met MPI-installatiekopieën openen, worden de volgende omgevingsvariabelen voor elk proces 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 rangorde 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 ML 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-richtlijnen het gebruik van DistributedDataParallel (DDP) via DataParallel voor gedistribueerde training met één knooppunt en meerdere knooppunten. PyTorch raadt ook het gebruik van DistributedDataParallel aan in plaats van het pakket voor meervoudige verwerking. Documentatie en voorbeelden van Azure Machine Learning zijn daarom gericht op DistributedDataParallel-training.

Initialisatie van procesgroepen

De ruggengraat van 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 geeft aan 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 in Azure ML. PyTorch zoekt naar de volgende omgevingsvariabelen voor initialisatie:

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

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

Daarnaast hebben veel toepassingen ook de volgende omgevingsvariabelen nodig:

  • LOCAL_RANK - De lokale (relatieve) rangschikking 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 eenmaal per knooppunt moeten worden uitgevoerd --- meestal op local_rank = 0.
  • NODE_RANK - De positie van het knooppunt voor training met meerdere knooppunten. De mogelijke waarden zijn 0 tot (totaal aantal knooppunten - 1).

Opties voor het starten van PyTorch

De Azure ML 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 verstrekt Azure ML 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 ML PyTorch-taken voor elk van de startopties.

DistributedDataParallel (per proces-lancering)

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 niet is opgegeven, start Azure ML standaard één proces per knooppunt.

Azure ML stelt de MASTER_ADDRomgevingsvariabelen , MASTER_PORT, WORLD_SIZEen NODE_RANK in op elk knooppunt en stelt u 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 ML Python SDK >= 1.22.0. Process_count is 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 doorgeeft zoals lokale rangschikking of rang als scriptargumenten, kunt u in de argumenten verwijzen naar de omgevingsvariabelen:

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

Voorbeeld van Pytorch per proces/starten

Met ( torch.distributed.launch per knooppunt starten)

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 brengt meerdere trainingsprocessen op elk van de knooppunten voort.

De volgende stappen laten zien hoe u een PyTorch-taak configureert met een startprogramma per knooppunt in Azure ML. 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 ML 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 ML, zodat u in de opdracht alleen kunt verwijzen naar de omgevingsvariabelen. Azure ML 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 pytorchtraining met één knooppunt met meerdere GPU's uit te voeren, hoeft u de distributed_job_config parameter van 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 knooppunt starten

PyTorch Lightning

PyTorch Lightning is een lichtgewicht opensource-bibliotheek die een interface op hoog niveau biedt voor PyTorch. Bliksem 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, multi-GPU met één knooppunt 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 multi-GPU met één knooppunt) kunt u uw code uitvoeren in Azure ML 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 gezegd, num_nodes * process_count_per_node). Geef in de Lightning Trainer-module beide num_nodes en gpus op 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 beide num_nodes en gpus 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 worden ingesteld op elk knooppunt van uw trainingscluster:

      • MASTER_ADDR
      • MASTER_PORT
      • NODE_RANK
      • LOCAL_RANK

      Stel deze omgevingsvariabelen die Lightning nodig heeft handmatig in de belangrijkste trainingsscripts 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
      )
    

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

Knuffelende gezichtstransformaties

Hugging Face biedt veel voorbeelden voor het gebruik van de Transformers-bibliotheek met torch.distributed.launch om gedistribueerde training uit te voeren. Volg de sectie Using torch.distributed.launch om deze voorbeelden en uw eigen aangepaste trainingsscripts uit te voeren met behulp van de Transformers Trainer-API.

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 transformers TrainingArguments verwachten dat de lokale rang moet worden doorgegeven als een argument (--local_rank). torch.distributed.launch zorgt hiervoor wanneer --use_env=False, maar als u per proces-starten gebruikt, moet u de lokale rangschikking expliciet doorgeven als argument voor het trainingsscript --local_rank=$LOCAL_RANK , omdat Azure ML 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 ML met behulp van de TensorflowConfiguration.

Geef hiervoor 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 TF_CONFIG omgevingsvariabele vereist voor training op meerdere computers. Voor TensorFlow-taken configureert en stelt Azure ML de TF_CONFIG variabele op de juiste manier in voor elke werkrol voordat u uw trainingsscript uitvoert.

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

Voorbeeld van TF_CONFIG ingesteld op een hoofdwerkrolknooppunt:

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

Voorbeeld van TensorFlow

Gedistribueerde GPU-training versnellen met InfiniBand

Naarmate het aantal VM's dat een model traint toeneemt, moet de tijd die nodig is om dat model te trainen, afnemen. De afname in 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 lage latentie, GPU-naar-GPU-communicatie mogelijk tussen knooppunten in een cluster. Voor InfiniBand is speciale hardware vereist. Bepaalde Azure VM-series, 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 DE NCCL-software van NVIDIA.) Deze SKU's zijn bedoeld om te voldoen aan de behoeften van rekenintensieve, GPU-acclerated machine learning-workloads. ZieDistributed Training in Azure Machine Learning versnellen met SR-IOV voor meer informatie.

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 machine-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 AmlCompute cluster maakt van een van deze RDMA-compatibele grootten met InfiniBand, 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