Dağıtılmış GPU eğitim kılavuzu (SDK v1)

ŞUNUN IÇIN GEÇERLIDIR: Python SDK azureml v1

Azure Machine Learning'de (ML) dağıtılmış GPU eğitim kodunu kullanma hakkında daha fazla bilgi edinin. Bu makale size dağıtılmış eğitim hakkında bilgi vermez. Mevcut dağıtılmış eğitim kodunuzu Azure Machine Learning'de çalıştırmanıza yardımcı olur. Her çerçeve için izlemeniz gereken ipuçları ve örnekler sunar:

• İleti Geçirme Arabirimi (MPI)
  • Horovod
  • DeepSpeed
  • Open MPI'dan ortam değişkenleri
• PyTorch
  • İşlem grubu başlatma
  • Başlatma seçenekleri
  • DistributedDataParallel (işlem başlatma başına)
  • Kullanma torch.distributed.launch (düğüm başına başlatma)
  • PyTorch Lightning
  • Yüz Transformatörlerine Sarılma
• TensorFlow
  • TensorFlow için ortam değişkenleri (TF_CONFIG)
• InfiniBand ile GPU eğitimini hızlandırma

Önkoşullar

Veri paralelliği, dağıtılmış veri paralelliği ve model paralelliği gibi dağıtılmış GPU eğitimine yönelik bu temel kavramları gözden geçirin.

MPI

Azure Machine Learning, her düğümde belirli sayıda işlem başlatmak için bir MPI işi sunar. Düğüm başına başlatıcı için 1 'e (varsayılan) veya işlem başlatıcısı başına cihaz/GPU sayısına eşit olarak, işlem başlatıcısı başına veya düğüm başına başlatıcıyı process_count_per_node kullanarak dağıtılmış eğitim çalıştırmak için bu yaklaşımı benimseyebilirsiniz. Azure Machine Learning, arka planda tam MPI başlatma komutunu (mpirun) oluşturur. veya DeepSpeed launchergibi mpirun kendi tam baş düğüm başlatıcı komutlarınızı sağlayamazsınız.

MPI kullanarak dağıtılmış eğitimi çalıştırmak için şu adımları izleyin:

1. Tercih edilen derin öğrenme çerçevesi ve MPI ile bir Azure Machine Learning ortamı kullanın. Azure Machine Learning, popüler çerçeveler için seçilmiş ortam sağlar.
2. ve node_countile process_count_per_node tanımlayınMpiConfiguration. process_count_per_node işlem başına başlatma için düğüm başına GPU sayısına eşit olmalıdır veya kullanıcı betiği düğüm başına işlemleri başlatmaktan sorumlu olacaksa düğüm başına başlatma için 1 (varsayılan) olarak ayarlanmalıdır.
3. MpiConfiguration nesnesini parametresine distributed_job_config ScriptRunConfiggeçirin.

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

Derin öğrenme çerçevesiyle dağıtılmış eğitim için Horovod kullanırken MPI iş yapılandırmasını kullanın.

Kodunuzun şu ipuçlarına uydığından emin olun:

• Eğitim kodu, Azure Machine Learning bölümlerini eklemeden önce Horovod ile doğru şekilde izleniyor
• Azure Machine Learning ortamınız Horovod ve MPI içerir. PyTorch ve TensorFlow tarafından seçilen GPU ortamları Horovod ve bağımlılıklarıyla önceden yapılandırılmış olarak gelir.
• İstediğiniz dağıtımla bir MpiConfiguration oluşturun.

Horovod örneği

• azureml-examples: Horovod kullanarak TensorFlow dağıtılmış eğitimi

DeepSpeed

Azure Machine Learning'de DeepSpeed kitaplığıyla dağıtılmış eğitim çalıştırmak için DeepSpeed'in özel başlatıcısını kullanmayın. Bunun yerine, MPI ile eğitim işini başlatmak için bir MPI işi yapılandırın.

Kodunuzun şu ipuçlarına uydığından emin olun:

• Azure Machine Learning ortamınızda DeepSpeed ve bağımlılıkları, Open MPI ve mpi4py bulunur.
• Dağıtımınızla bir MpiConfiguration oluşturun.

DeepSpeed örneği

• azureml-examples: CIFAR-10 üzerinde DeepSpeed ile dağıtılmış eğitim

Open MPI'dan ortam değişkenleri

MPI işlerini Open MPI görüntüleriyle çalıştırırken, her işlem için aşağıdaki ortam değişkenleri başlatılır:

1. OMPI_COMM_WORLD_RANK - sürecin sırası
2. OMPI_COMM_WORLD_SIZE - dünya boyutu
3. AZ_BATCH_MASTER_NODE - bağlantı noktası ile birincil adres, MASTER_ADDR:MASTER_PORT
4. OMPI_COMM_WORLD_LOCAL_RANK - düğümdeki işlemin yerel sırası
5. OMPI_COMM_WORLD_LOCAL_SIZE - düğümdeki işlem sayısı

PyTorch

Azure Machine Learning, PyTorch'un yerel dağıtılmış eğitim özelliklerini (torch.distributed ) kullanarak dağıtılmış işlerin çalıştırılmasını destekler.

İşlem grubu başlatma

Herhangi bir dağıtılmış eğitimin omurgası, birbirini bilen ve arka uç kullanarak birbirleriyle iletişim kurabilen bir grup işleme dayanır. PyTorch için işlem grubu, toplu olarak bir işlem grubu oluşturmak üzere tüm dağıtılmış işlemlerde torch.distributed.init_process_group çağrılarak oluşturulur.

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

Kullanılan en yaygın iletişim arka uçları , ncclve gloo'dirmpi. GPU tabanlı eğitim nccl için en iyi performans için önerilir ve mümkün olduğunda kullanılmalıdır.

init_method her işlemin birbirini nasıl bulabileceğini, iletişim arka ucu kullanarak işlem grubunu nasıl başlatıp doğruladıklarını bildirir. Varsayılan olarak belirtilmezse init_method PyTorch ortam değişkeni başlatma yöntemini (env://) kullanır. init_method , Azure Machine Learning'de dağıtılmış PyTorch çalıştırmak için eğitim kodunuzda kullanmanız önerilen başlatma yöntemidir. PyTorch başlatma için aşağıdaki ortam değişkenlerini arar:

• MASTER_ADDR - 0 derecesine sahip işlemi barındıracak makinenin IP adresi.
• MASTER_PORT - 0 derecesine sahip işlemi barındıracak makinede ücretsiz bir bağlantı noktası.
• WORLD_SIZE - Toplam işlem sayısı. Dağıtılmış eğitim için kullanılan toplam cihaz sayısına (GPU) eşit olmalıdır.
• RANK - Geçerli işlemin (genel) sırası. Olası değerler 0 ile (dünya boyutu - 1) arasıdır.

İşlem grubu başlatma hakkında daha fazla bilgi için PyTorch belgelerine bakın.

Bunların ötesinde, birçok uygulama aşağıdaki ortam değişkenlerine de ihtiyaç duyar:

• LOCAL_RANK - Düğümün içindeki işlemin yerel (göreli) sırası. Olası değerler 0 ile (düğümdeki işlem sayısı: 1) arasıdır. Bu bilgiler yararlıdır çünkü veri hazırlama gibi birçok işlem genellikle local_rank = 0 üzerinde --- düğüm başına yalnızca bir kez gerçekleştirilmelidir.
• NODE_RANK - Çok düğümlü eğitim için düğümün sırası. Olası değerler 0 ile (toplam düğüm sayısı - 1) olur.

PyTorch başlatma seçenekleri

Azure Machine Learning PyTorch işi, dağıtılmış eğitimi başlatmak için iki tür seçeneği destekler:

• İşlem başlatıcısı başına: Sistem, işlem grubunu ayarlamak için tüm ilgili bilgilerle (ortam değişkenleri gibi) sizin için tüm dağıtılmış işlemleri başlatır.
• Düğüm başına başlatıcı: Azure Machine Learning'e her düğümde çalıştırılacak yardımcı program başlatıcısını sağlarsınız. Yardımcı program başlatıcı, belirli bir düğümdeki işlemlerin her birini başlatmayı işler. Her düğümde RANK yerel olarak bulunur ve LOCAL_RANK başlatıcı tarafından ayarlanır. Torch.distributed.launch yardımcı programı ve PyTorch Lightning bu kategoriye aittir.

Bu başlatma seçenekleri arasında temel bir fark yoktur. Seçim büyük ölçüde tercihinize veya vanilya PyTorch üzerinde oluşturulan çerçevelerin/kitaplıkların kurallarına (Şimşek veya Sarılma Yüzü gibi) bağlıdır.

Aşağıdaki bölümlerde, başlatma seçeneklerinin her biri için Azure Machine Learning PyTorch işlerini yapılandırma hakkında daha ayrıntılı bilgi ve bulabilirsiniz.

DistributedDataParallel (işlem başlatma başına)

gibi torch.distributed.launchbir başlatıcı yardımcı programı kullanmanız gerekmez. Dağıtılmış bir PyTorch işini çalıştırmak için:

1. Eğitim betiğini ve bağımsız değişkenlerini belirtme
2. PyTorchConfiguration bir oluşturun ve ve node_countdeğerini process_count belirtin. , process_count işiniz için çalıştırmak istediğiniz toplam işlem sayısına karşılık gelir. process_count genellikle eşit # GPUs per node x # nodesolmalıdır. Belirtilmezse process_count , Azure Machine Learning varsayılan olarak düğüm başına bir işlem başlatır.

Azure Machine Learning her düğümde MASTER_ADDR, MASTER_PORT, WORLD_SIZEve NODE_RANK ortam değişkenlerini, işlem düzeyi RANK ile LOCAL_RANK ortam değişkenlerini de ayarlar.

Düğüm başına çok işlemli eğitim için bu seçeneği kullanmak için Azure Machine Learning Python SDK'sını >= 1.22.0kullanın. Process_count 1.22.0'da kullanıma sunulmuştur.

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)

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

Pytorch işlem başına başlatma örneği

• azureml-examples: CIFAR-10 üzerinde PyTorch ile dağıtılmış eğitim

torch.distributed.launch kullanma (düğüm başına-başlatma)

PyTorch, torch.distributed.launch içinde düğüm başına birden çok işlemi başlatmak için kullanabileceğiniz bir başlatma yardımcı programı sağlar. Modül, torch.distributed.launch düğümlerin her birinde birden çok eğitim işlemi oluşturur.

Aşağıdaki adımlar, Azure Machine Learning'de düğüm başına başlatıcı ile pyTorch işini yapılandırmayı gösterir. İş, aşağıdaki komutu çalıştırmanın eşdeğerini elde eder:

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. Oluşturucunun torch.distributed.launch command parametresine ScriptRunConfig komutunu sağlayın. Azure Machine Learning, eğitim kümenizin her düğümünde bu komutu çalıştırır. --nproc_per_node her düğümde kullanılabilen GPU sayısından küçük veya buna eşit olmalıdır. MASTER_ADDR, MASTER_PORT ve NODE_RANK, Azure Machine Learning tarafından ayarlandığından, komuttaki ortam değişkenlerine başvurabilirsiniz. Azure Machine Learning MASTER_PORT 6105olarak ayarlar, ancak isterseniz torch.distributed.launch komutunun bağımsız değişkenine --master_port farklı bir değer geçirebilirsiniz. (Başlatma yardımcı programı ortam değişkenlerini sıfırlar.)
2. bir PyTorchConfiguration oluşturun ve belirtin 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)

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

PyTorch düğüm başına başlatma örneği

• azureml-examples: CIFAR-10 üzerinde PyTorch ile dağıtılmış eğitim

PyTorch Lightning

PyTorch Lightning , PyTorch için üst düzey bir arabirim sağlayan basit bir açık kaynak kitaplığıdır. Lightning, vanilya PyTorch için gereken alt düzey dağıtılmış eğitim yapılandırmalarının çoğunu soyutlar. Lightning, eğitim betiklerinizi tek GPU, tek düğümlü çoklu GPU ve çok düğümlü çoklu GPU ayarlarında çalıştırmanıza olanak tanır. Sahne arkasında, sizin için benzeri torch.distributed.launchbirden çok işlem başlatır.

Tek düğümlü eğitim (tek düğümlü çoklu GPU dahil) için, kodunuzu bir distributed_job_configbelirtmenize gerek kalmadan Azure Machine Learning'de çalıştırabilirsiniz. Birden çok GPU'ya sahip birden çok düğüm kullanarak deneme çalıştırmak için 2 seçenek vardır:

• PyTorch yapılandırmasını kullanma (önerilen): , node_countve değerlerini tanımlayın PyTorchConfiguration ve process_count belirtin communication_backend="Nccl"(bunun toplam işlem sayısı (örneğin) num_nodes * process_count_per_nodeolduğunu unutmayın). Lightning Trainer modülünde hem hem de num_nodes gpus ile PyTorchConfigurationtutarlı olacak şekilde belirtin. Örneğin, num_nodes = node_count ve gpus = process_count_per_node.

• MPI Yapılandırmasını Kullanma:

  • hem hem de node_count öğesini tanımlayın MpiConfiguration ve process_count_per_nodebelirtin. Lightning Trainer'da, hem hem gpus de num_nodes öğesinin sırasıyla ve process_count_per_node ile MpiConfigurationaynı node_count olmasını belirtin.

  • MPI ile çok düğümlü eğitim için Lightning, eğitim kümenizin her düğümünde aşağıdaki ortam değişkenlerinin ayarlanmasını gerektirir:

    • MASTER_ADDR
    • MASTER_PORT
    • NODE_RANK
    • LOCAL_RANK

    Lightning'in gerektirdiği bu ortam değişkenlerini ana eğitim betiklerinde el ile ayarlayın:

  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, Trainer bayraklarından ve --num_nodes'den dünya boyutunu hesaplamayı sağlar--gpus.

  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)
  

Yüz Transformatörlerine Sarılma

Yüzü Kucaklama, dağıtılmış eğitimi çalıştırmak için Transformers kitaplığını ile torch.distributed.launch kullanmak için birçok örnek sağlar. Transformers Trainer API'sini kullanarak bu örnekleri ve kendi özel eğitim betiklerinizi çalıştırmak için Kullanma torch.distributed.launch bölümünü izleyin.

8 GPU'ya sahip bir düğümde betiği kullanarak run_glue.py MNLI metin sınıflandırması görevinde BERT büyük modeline ince ayar yapmak için örnek iş yapılandırma kodu:

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

Dağıtılmış eğitimi kullanmadan çalıştırmak için işlem başına başlatma seçeneğini de kullanabilirsiniz.torch.distributed.launch Bu yöntemi kullanıyorsanız aklınızda bulundurmanız gereken bir şey, transformers TrainingArguments'ın yerel derecelendirmenin bağımsız değişken (--local_rank) olarak geçirilmesini beklemesidir. torch.distributed.launch bunu yaparken --use_env=Falsehalleder, ancak işlem başına başlatmayı kullanıyorsanız, Azure Machine Learning yalnızca ortam değişkenini ayarlarken eğitim betiğine --local_rank=$LOCAL_RANK bağımsız değişken olarak yerel sıralamayı LOCAL_RANK açıkça geçirmeniz gerekir.

TensorFlow

Eğitim kodunuzda TensorFlow 2.x'in tf.distribute.Strategy API'si gibi yerel dağıtılmış TensorFlow kullanıyorsanız, dağıtılmış işi kullanarak TensorflowConfigurationAzure Machine Learning aracılığıyla başlatabilirsiniz.

Bunu yapmak için oluşturucunun distributed_job_config parametresine ScriptRunConfig bir TensorflowConfiguration nesne belirtin. kullanıyorsanıztf.distribute.experimental.MultiWorkerMirroredStrategy, eğitim işinizin TensorflowConfiguration düğüm sayısına karşılık gelen içinde öğesini belirtinworker_count.

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)

Eğitim betiğiniz, eski TensorFlow 1.x gibi dağıtılmış eğitim için parametre sunucusu stratejisini kullanıyorsa, işte kullanılacak parametre sunucularının sayısını da belirtmeniz gerekir. Örneğin, tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1).

TF_CONFIG

TensorFlow'da, birden çok makinede eğitim için TF_CONFIG ortam değişkeni gereklidir. TensorFlow işleri için Azure Machine Learning, eğitim betiğinizi yürütmeden önce TF_CONFIG değişkenini her çalışan için uygun şekilde yapılandırıp ayarlar.

eğitim betiğinizden TF_CONFIG erişebilirsiniz: os.environ['TF_CONFIG'].

Bir baş çalışan düğümünde ayarlanan örnek TF_CONFIG:

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

TensorFlow örneği

• azureml-examples: MultiWorkerMirroredStrategy ile Dağıtılmış TensorFlow eğitimi

InfiniBand ile dağıtılmış GPU eğitimini hızlandırma

Modeli eğiten VM sayısı arttıkça, modeli eğitmek için gereken süre azalmalıdır. İdeal olarak zamandaki azalma, eğitim VM'lerinin sayısıyla doğrusal olarak orantılı olmalıdır. Örneğin, bir modelin bir VM'de eğitilmesi 100 saniye sürüyorsa, aynı modeli iki VM üzerinde eğitme ideal olarak 50 saniye sürmelidir. Modelin dört VM üzerinde eğitilmesi 25 saniye sürmelidir ve bu şekilde devam eder.

InfiniBand, bu doğrusal ölçeklendirmenin elde edilmesinde önemli bir faktör olabilir. InfiniBand, bir kümedeki düğümler arasında düşük gecikme süreli GPU'ya iletişim sağlar. InfiniBand'in çalışması için özel donanım gerekir. Belirli Azure VM serisi, özellikle NC, ND ve H serisi, artık SR-IOV ve InfiniBand desteğine sahip RDMA özellikli VM'lere sahiptir. Bu VM'ler, Ethernet tabanlı bağlantıdan çok daha yüksek performanslı olan düşük gecikme süresi ve yüksek bant genişliğine sahip InfiniBand ağı üzerinden iletişim kurar. InfiniBand için SR-IOV, herhangi bir MPI kitaplığı için neredeyse çıplak performans sağlar (MPI, NVIDIA'nın NCCL yazılımı da dahil olmak üzere birçok dağıtılmış eğitim çerçevesi ve aracı tarafından kullanılır.) Bu SKU'lar hesaplama açısından yoğun, GPU tarafından erişimli makine öğrenmesi iş yüklerinin gereksinimlerini karşılamaya yöneliktir. Daha fazla bilgi için bkz . SR-IOV ile Azure Machine Learning'de Dağıtılmış Eğitimi Hızlandırma.

Normalde, adında 'r' olan VM SKU'ları gerekli InfiniBand donanımını içerir ve 'r' olmayanlar genellikle içermez. ('r', "uzaktan doğrudan bellek erişimi" anlamına gelen RDMA başvurusudur.) Örneğin, VM SKU'su Standard_NC24rs_v3 InfiniBand özelliklidir, ancak SKU Standard_NC24s_v3 etkin değildir. InfiniBand özelliklerinin yanı sıra, bu iki SKU arasındaki belirtimler büyük ölçüde aynıdır; her ikisi de 24 çekirdek, 448 GB RAM, aynı SKU'nun 4 GPU'su vb. içerir. RDMA ve InfiniBand özellikli makine SKU'ları hakkında daha fazla bilgi edinin.

Bu RDMA özellikli, InfiniBand özellikli boyutlardan birinin kümesini oluşturursanız AmlCompute , işletim sistemi görüntüsü InfiniBand'i önceden yüklenmiş ve önceden yapılandırılmış olarak etkinleştirmek için gereken Mellanox OFED sürücüsüyle birlikte gelir.

Sonraki adımlar

• Makine öğrenmesi modellerini Azure'a dağıtma
• Azure'da dağıtılmış derin öğrenme eğitimi için başvuru mimarisi