Delen via

Handleiding voor gedistribueerde GPU-training (SDK v1)

  • Artikel

VAN TOEPASSING OP: Python SDK azureml v1

Meer informatie over het gebruik van gedistribueerde GPU-trainingscode in Azure Machine Learning (ML). In dit artikel krijgt u geen informatie over gedistribueerde training. Hiermee kunt u uw bestaande gedistribueerde trainingscode uitvoeren in 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 modelparallelisme.

Tip

Als u niet weet welk type parallelle uitvoering moet worden gebruikt, moet u meer dan 90% van de tijd gedistribueerde gegevensparallellisme gebruiken.

MPI

Azure Machine Learning biedt een MPI-taak om een bepaald aantal processen in elk knooppunt te starten. U kunt deze benadering gebruiken om gedistribueerde training uit te voeren met behulp van een startprogramma per proces of per knooppunt, afhankelijk van of process_count_per_node deze is ingesteld op 1 (de standaardinstelling) voor startprogramma per knooppunt of gelijk is aan het aantal apparaten/GPU's voor het starten per proces. Azure Machine Learning bouwt de volledige MPI-startopdracht (mpirun) achter de schermen. 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 basisinstallatiekopieën van Azure Machine Learning GPU. Wanneer u een aangepaste Docker-installatiekopieën gebruikt, bent u verantwoordelijk voor het controleren of 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 MPI:

  1. Gebruik een Azure Machine Learning-omgeving met het favoriete Deep Learning-framework en MPI. Azure Machine Learning biedt een gecureerde omgeving voor populaire frameworks.
  2. Definiëren 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 configuratie van de MPI-taak wanneer u Horovod gebruikt voor gedistribueerde training met het Deep Learning-framework.

Zorg ervoor dat uw code de volgende tips volgt:

  • De trainingscode wordt correct geïnstrualiseerd met Horovod voordat u de Azure Machine Learning-onderdelen toevoegt
  • 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.

Voorbeeld van Horovod

DeepSpeed

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

Zorg ervoor dat uw code de volgende tips volgt:

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

DeepSpeed-voorbeeld

Omgevingsvariabelen van Open MPI

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

  1. OMPI_COMM_WORLD_RANK - de rang van het proces
  2. OMPI_COMM_WORLD_SIZE - de wereldgrootte
  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 u deze in process_count_per_node=1 en gebruikt u OMPI_COMM_WORLD_RANK deze als de NODE_RANK.

PyTorch

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

Tip

Voor gegevensparallel is de officiële PyTorch-richtlijnen bedoeld voor het gebruik van DistributedDataParallel (DDP) via DataParallel voor zowel één knooppunt als gedistribueerde training met meerdere knooppunten. PyTorch raadt ook het gebruik van DistributedDataParallel aan via het multiprocessing-pakket. Documentatie en voorbeelden van Azure Machine Learning richten zich daarom op DistributedDataParallel-training.

Initialisatie van procesgroepen

De backbone van elke gedistribueerde training is gebaseerd op een groep processen die elkaar kennen en met elkaar kunnen communiceren met behulp van 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 voorkomende communicatieback-ends die worden gebruikt, zijn mpi, ncclen gloo. Voor gpu-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 communicatieback-end. Als pyTorch niet is opgegeven, wordt standaard init_method de initialisatiemethode van de omgevingsvariabele (env://) gebruikt. init_method is de aanbevolen initialisatiemethode voor gebruik in uw trainingscode 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 die het proces host met rang 0.
  • MASTER_PORT - Een gratis poort op de computer waarop het proces wordt gehost 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) rang 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) 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 eenmaal 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 biedt Azure Machine Learning met het startprogramma voor hulpprogramma's dat op elk knooppunt wordt uitgevoerd. Het startprogramma voor hulpprogramma's verwerkt het starten van elk van de processen op een bepaald knooppunt. Lokaal binnen elk knooppunt RANK en LOCAL_RANK worden ingesteld door het startprogramma. Het hulpprogramma torch.distributed.launch en PyTorch Lightning behoren beide in deze categorie.

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

De volgende secties gaan dieper in op het configureren van Azure Machine Learning PyTorch-taken voor elk van de startopties.

DistributedDataParallel (per proces starten)

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

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

Azure Machine Learning stelt de MASTER_ADDRvariabelen , MASTER_PORTen WORLD_SIZENODE_RANK omgevingsvariabelen op elk knooppunt in en stelt de omgevingsvariabelen op procesniveau RANK en LOCAL_RANK omgevingsvariabelen in.

Als u deze optie wilt gebruiken voor training met meerdere processen per knooppunt, gebruikt u de 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 doorgeeft, zoals lokale rangschikking of rangschikking als scriptargumenten, kunt u verwijzen naar de omgevingsvariabelen in de argumenten:

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

Voorbeeld van pytorch per proces starten

Torch.distributed.launch gebruiken (per knooppunt starten)

PyTorch biedt een starthulpprogramma in torch.distributed.launch dat u kunt gebruiken om meerdere processen per knooppunt te starten . De torch.distributed.launch module spawt 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, zodat u alleen naar de omgevingsvariabelen in de opdracht kunt verwijzen. Azure Machine Learning stelt MASTER_PORT in 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 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 starthulpprogramma gebruikt om training met meerdere GPU's met één knooppunt 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. Lightning abstraheert veel van de gedistribueerde trainingsconfiguraties op lager niveau die vereist zijn voor vanille PyTorch. Met Lightning kunt u uw trainingsscripts uitvoeren in één GPU, multi-GPU-knooppunt en multi-GPU-instellingen voor meerdere knooppunten. Achter de schermen worden meerdere processen voor u gestart, vergelijkbaar met torch.distributed.launch.

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

  • PyTorch-configuratie gebruiken (aanbevolen): Definiëren PyTorchConfiguration en opgeven communication_backend="Nccl", node_counten process_count (houd er rekening mee dat dit het totale aantal processen is, d.i num_nodes * process_count_per_node. ). Geef in de Lightning Trainer-module beide num_nodes op en gpus moet consistent zijn met PyTorchConfiguration. Bijvoorbeeld num_nodes = node_count en gpus = process_count_per_node.

  • MPI-configuratie gebruiken:

    • Definieer MpiConfiguration en geef zowel node_count als process_count_per_node. Geef in Lightning Trainer beide num_nodes en gpus respectievelijk hetzelfde node_count als en process_count_per_node van MpiConfiguration.

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

      • MASTER_ADDR
      • MASTER_PORT
      • NODE_RANK
      • LOCAL_RANK

      Stel deze omgevingsvariabelen handmatig in die Lightning nodig heeft in de hoofdtrainingsscripts:

    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 wereldgrootte 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

Het knuffelen van Face biedt veel voorbeelden voor het gebruik van de transformers-bibliotheek waarmee torch.distributed.launch gedistribueerde training kan worden uitgevoerd. Als u deze voorbeelden en uw eigen aangepaste trainingsscripts wilt uitvoeren met behulp van de Transformers Trainer-API, volgt u de sectie Using torch.distributed.launch .

Voorbeeldcode voor taakconfiguratie om het grote BERT-model op de MNLI-taak voor tekstclassificatie af te stemmen 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 torch.distributed.launch. Houd er rekening mee als u deze methode gebruikt, is dat de transformers TrainingArguments verwachten dat de lokale rang wordt doorgegeven als een argument (--local_rank). torch.distributed.launch dit doet u 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 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.

Geef hiervoor een TensorflowConfiguration object op voor de distributed_job_config parameter van de ScriptRunConfig constructor. Als u gebruikmaakt tf.distribute.experimental.MultiWorkerMirroredStrategy, geeft u de worker_count vermelding op die TensorflowConfiguration 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 Machine Learning de TF_CONFIG variabele op de juiste wijze in voor elke werkrol voordat u uw trainingsscript uitvoert.

U kunt TF_CONFIG openen vanuit uw trainingsscript als u het volgende wilt doen: 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"
}'

Voorbeeld van TensorFlow

Gedistribueerde GPU-training versnellen met InfiniBand

Naarmate het aantal VM's voor het trainen van een model 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 VIRTUELE machine 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 communicatie met lage latentie, GPU-naar-GPU mogelijk tussen knooppunten in een cluster. Voor InfiniBand is speciale hardware vereist voor gebruik. 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 maakt bijna bare-metalprestaties mogelijk 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 Gedistribueerde training versnellen in Azure Machine Learning met SR-IOV voor meer informatie.

Vm-SKU's met een r in hun naam bevatten doorgaans de vereiste InfiniBand-hardware en die zonder r zijn doorgaans niet. ('r' is een verwijzing naar RDMA, die staat voor 'externe directe geheugentoegang'.) 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-computer-SKU's.

Waarschuwing

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

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

Volgende stappen