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

ŞUNLAR 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 modelparalelliği gibi dağıtılmışGPU eğitimine yönelik bu temel kavramları gözden geçirin.

İpucu

Hangi paralellik türünü kullanacağınızı bilmiyorsanız, zamanın %90'ından fazlasını Dağıtılmış Veri Paralelliği'ni kullanmanız gerekir.

MPI

Azure Machine Learning, her düğümde belirli sayıda işlemi 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 ayarlı olmasına process_count_per_node bağlı olarak, işlem başlatıcısı veya düğüm başlatıcı başına 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.

İpucu

Azure Machine Learning MPI işi tarafından kullanılan temel Docker görüntüsünde bir MPI kitaplığının yüklü olması gerekir. Açık MPI , tüm Azure Machine Learning GPU temel görüntülerine dahildir. Özel bir Docker görüntüsü kullandığınızda, görüntünün bir MPI kitaplığı içerdiğinden emin olmak sizin sorumluluğunuzdadır. Açık MPI önerilir, ancak Intel MPI gibi farklı bir MPI uygulaması da kullanabilirsiniz. Azure Machine Learning ayrıca popüler çerçeveler için seçilmiş ortamlar sağlar.

MPI kullanarak dağıtılmış eğitim ç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şlatma başına 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_configScriptRunConfiggeç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, başlatılan 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ı

İpucu

Adına rağmen ortam değişkeni OMPI_COMM_WORLD_NODE_RANK öğesine NODE_RANKkarşılık gelmez. Düğüm başına başlatıcıyı kullanmak için olarak ayarlayın process_count_per_node=1 ve kullanın OMPI_COMM_WORLD_RANKNODE_RANK.

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.

İpucu

Veri paralelliği için resmi PyTorch kılavuzu , tek düğümlü ve çok düğümlü dağıtılmış eğitim için DataParallel üzerinden DistributedDataParallel (DDP) kullanmaktır. PyTorch ayrıca çok işlemli paket üzerinden DistributedDataParallel kullanılmasını önerir. Bu nedenle Azure Machine Learning belgeleri ve örnekleri DistributedDataParallel eğitimine odaklanacaktır.

İşlem grubu başlatma

Herhangi bir dağıtılmış eğitimin omurgası, birbirini bilen ve bir 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 için tüm dağıtılmış işlemlerdetorch.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. En iyi performans için GPU tabanlı eğitim nccl ö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. Belirtilmezse init_method varsayılan olarak 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 - İşlemlerin toplam sayısı. Dağıtılmış eğitim için kullanılan toplam cihaz (GPU) sayısına eşit olmalıdır.
• RANK - Geçerli sürecin (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. Veri hazırlama gibi birçok işlem genellikle local_rank = 0 üzerinde --- düğüm başına yalnızca bir kez gerçekleştirilmesi gerektiğinden bu bilgiler yararlıdır.
• 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 gerekli tüm 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 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şlerinin nasıl yapılandırıldığı hakkında daha ayrıntılı bilgi sağlanır.

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şi çalıştırmak için:

1. Eğitim betiğini ve bağımsız değişkenlerini belirtme
2. bir PyTorchConfiguration 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 değerine 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 tanıtıldı.

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)

İpucu

Eğitim betiğiniz yerel sıralama veya sıralama gibi bilgileri betik bağımsız değişkenleri olarak geçirirse, bağımsız değişkenlerde ortam değişkenlerine başvurabilirsiniz:

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 başına)

PyTorch , torch.distributed.launch dosyasında düğüm başına birden çok işlem 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.launchcommand parametresine ScriptRunConfig komutunu sağlayın. Azure Machine Learning bu komutu eğitim kümenizin her düğümünde ç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 ayarlanmıştır, bu nedenle komuttaki ortam değişkenlerine başvurabilirsiniz. Azure Machine Learning MASTER_PORT olarak 6105ayarlar, 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 değerini node_countbelirtin.

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)

İpucu

Tek düğümlü çoklu GPU eğitimi: Tek düğümlü çoklu GPU PyTorch eğitimini çalıştırmak için başlatma yardımcı programını kullanıyorsanız ScriptRunConfig parametresini belirtmeniz distributed_job_config gerekmez.

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 hafif bir açık kaynak kitaplıktır. Şimşek, 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. Arka planda, sizin için benzer torch.distributed.launchşekilde birden çok işlem başlatır.

Tek düğümlü eğitim için (tek düğümlü çoklu GPU dahil) kodunuzu Azure Machine Learning'de bir distributed_job_configbelirtmenize gerek kalmadan ç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 gpus de num_nodes ile PyTorchConfigurationtutarlı olmasını 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 ve ile MpiConfigurationaynı node_countprocess_count_per_node 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 handles computing the world size from the Trainer flags --gpus and --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)
  

Yüz Transformatörlerine Sarılma

Yüze Sarılma, dağıtılmış eğitimi çalıştırmak için Transformers kitaplığını ile torch.distributed.launch kullanmaya yönelik birçok örnek sağlar. Transformers Eğitmeni 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üğümdeki betiği kullanarak run_glue.py metin sınıflandırması MNLI 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'in yerel derecelendirmenin bağımsız değişken olarak geçirilmesini beklemesidir (--local_rank). 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 derecelendirmeyi LOCAL_RANK açıkça geçirmeniz gerekir.

TensorFlow

Eğitim kodunuzda TensorFlow 2.x'in API'si tf.distribute.Strategy 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ız tf.distribute.experimental.MultiWorkerMirroredStrategy, içinde eğitim işinizin düğüm sayısına karşılık gelen öğesini belirtin worker_countTensorflowConfiguration .

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.

Gerekirse 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

Bir modeli eğiten VM sayısı arttıkça, modeli eğitmek için gereken süre azalmalıdır. Zamandaki düşüş, ideal olarak eğitim VM'lerinin sayısıyla doğrusal olarak orantılı olmalıdır. Örneğin, bir modelin bir VM üzerinde 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'lar arası iletişim sağlar. InfiniBand'in çalışması için özel donanım gerekir. Özellikle NC, ND ve H serisi olmak üzere bazı Azure VM serileri artık SR-IOV ve InfiniBand desteğine sahip RDMA özellikli VM'lere sahiptir. Bu VM'ler, Ethernet tabanlı bağlantıdan çok daha 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şilebilir 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' bulunan 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 etkinleştirilmez. 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.

Uyarı

Eski nesil makine SKU'su Standard_NC24r RDMA özelliklidir, ancak InfiniBand için gereken SR-IOV donanımını içermez.

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