Panduan pelatihan GPU terdistribusi (SDK v1)

  • Artikel

BERLAKU UNTUK:Python SDK azureml v1

Pelajari selengkapnya tentang cara menggunakan kode pelatihan GPU terdistribusi di Azure Machine Learning (ML). Artikel ini tidak akan mengajarkan Anda tentang pelatihan terdistribusi. Ini akan membantu Anda menjalankan kode pelatihan terdistribusi yang ada di Azure Machine Learning. Ini menawarkan tips dan contoh bagi Anda untuk mengikuti untuk setiap kerangka kerja:

  • Antarmuka Penerusan Pesan (MPI)
    • Horovod
    • DeepSpeed
    • Variabel lingkungan dari Open MPI
  • PyTorch
    • Inisialisasi grup proses
    • Opsi peluncuran
    • DistributedDataParallel (per-proses-peluncuran)
    • Menggunakan torch.distributed.launch (per-node-launch)
    • Petir PyTorch
    • Memeluk Transformers Wajah
  • TensorFlow
    • Variabel lingkungan untuk TensorFlow (TF_CONFIG)
  • Mempercepat pelatihan GPU dengan InfiniBand

Prasyarat

Tinjau konsep dasar pelatihan GPU terdistribusi ini seperti paralelisme data, paralelisme data terdistribusi, dan paralelisme model.

Tip

Jika Anda tidak tahu jenis paralelisme mana yang akan digunakan, lebih dari 90% dari waktu Anda harus menggunakan Paralelisme Data Terdistribusi.

MPI

Azure Machine Learning menawarkan pekerjaan MPI untuk meluncurkan sejumlah proses tertentu di setiap simpul. Anda dapat mengadopsi pendekatan ini untuk menjalankan pelatihan terdistribusi menggunakan peluncur per proses atau peluncur per simpul, bergantung pada apakah process_count_per_node disetel ke 1 (default) untuk peluncur per simpul, atau sama dengan jumlah perangkat/GPU untuk per-proses-peluncur. Azure Machine Learning membangun perintah peluncuran MPI lengkap (mpirun) di belakang layar. Anda tidak dapat memberikan perintah head-node-launcher lengkap Anda sendiri seperti mpirun atau DeepSpeed launcher.

Tip

Gambar Dasar Docker yang digunakan oleh pekerjaan MPI Azure Machine Learning perlu memiliki perpustakaan MPI yang diinstal. Open MPI disertakan dalam semua gambar dasar GPU Azure Machine Learning. Saat Anda menggunakan gambar Docker kustom, Anda bertanggung jawab untuk memastikan gambar menyertakan pustaka MPI. Open MPI direkomendasikan, tetapi Anda juga dapat menggunakan implementasi MPI yang berbeda seperti Intel MPI. Azure Machine Learning juga menyediakan lingkungan yang dikumpulkan untuk kerangka kerja populer.

Untuk menjalankan pelatihan terdistribusi menggunakan MPI, ikuti langkah-langkah berikut:

  1. Gunakan lingkungan Azure Machine Learning dengan kerangka kerja pembelajaran mendalam dan MPI pilihan. Azure Machine Learning menyediakan lingkungan yang dikumpulkan untuk kerangka kerja populer.
  2. Tentukan MpiConfiguration dengan process_count_per_node dan node_count. process_count_per_node harus sama dengan jumlah GPU per node untuk peluncuran per proses, atau disetel ke 1 (default) untuk peluncuran per node jika skrip pengguna akan bertanggung jawab untuk meluncurkan proses per node.
  3. Teruskan objek MpiConfiguration ke parameter distributed_job_config dari 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

Gunakan konfigurasi tugas MPI saat Anda menggunakan Horovod untuk pelatihan terdistribusi dengan kerangka pembelajaran mendalam.

Pastikan kode Anda mengikuti tips ini:

  • Kode pelatihan diinstrumentasikan dengan benar dengan Horovod sebelum menambahkan bagian Azure Machine Learning
  • Lingkungan Azure Machine Learning Anda berisi Horovod dan MPI. Lingkungan GPU PyTorch dan TensorFlow yang dikuratori telah dikonfigurasi sebelumnya dengan Horovod dan dependensinya.
  • Buat MpiConfiguration dengan distribusi yang Anda inginkan.

Contoh Horovod

DeepSpeed

Jangan gunakan peluncur kustom DeepSpeed untuk menjalankan pelatihan terdistribusi dengan pustaka DeepSpeed di Azure Machine Learning. Alih-alih, konfigurasikan tugas MPI untuk meluncurkan tugas pelatihan dengan MPI.

Pastikan kode Anda mengikuti tips ini:

  • Lingkungan Azure Machine Learning Anda berisi DeepSpeed dan dependensinya, Open MPI, dan mpi4py.
  • Buat MpiConfiguration dengan distribusi Anda.

Contoh DeepSpeed

Variabel lingkungan dari Open MPI

Saat menjalankan pekerjaan MPI dengan gambar Open MPI, variabel lingkungan berikut untuk setiap proses diluncurkan:

  1. OMPI_COMM_WORLD_RANK - peringkat proses
  2. OMPI_COMM_WORLD_SIZE - ukuran dunia
  3. AZ_BATCH_MASTER_NODE - alamat utama dengan porta, MASTER_ADDR:MASTER_PORT
  4. OMPI_COMM_WORLD_LOCAL_RANK - peringkat lokal dari proses pada simpul
  5. OMPI_COMM_WORLD_LOCAL_SIZE - jumlah proses pada simpul

Tip

Terlepas dari namanya, variabel lingkungan OMPI_COMM_WORLD_NODE_RANK tidak sesuai dengan NODE_RANK. Untuk menggunakan per-node-launcher, setel process_count_per_node=1 dan gunakan OMPI_COMM_WORLD_RANK sebagai NODE_RANK.

PyTorch

Azure Machine Learning mendukung menjalankan pekerjaan terdistribusi menggunakan kemampuan pelatihan terdistribusi asli PyTorch (torch.distributed).

Tip

Untuk paralelisme data, panduan resmi PyTorch adalah menggunakan DistributedDataParallel (DDP) di atas DataParallel untuk pelatihan terdistribusi single-node dan multi-node. PyTorch juga menyarankan untuk menggunakan DistributedDataParallel melalui paket multipemrosesan. Oleh karena itu, dokumentasi dan contoh Pembelajaran Mesin Azure akan fokus pada pelatihan DistributedDataParallel.

Inisialisasi grup proses

Tulang punggung dari setiap pelatihan terdistribusi didasarkan pada sekelompok proses yang saling mengenal dan dapat berkomunikasi satu sama lain menggunakan backend. Untuk PyTorch, grup proses dibuat dengan memanggil torch.distributed.init_process_group di semua proses terdistribusi untuk secara kolektif membentuk grup proses.

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

Backend komunikasi yang paling umum digunakan adalah mpi, nccl, dan gloo. Untuk pelatihan berbasis GPU nccl direkomendasikan untuk performa terbaik dan harus digunakan bila memungkinkan.

init_method memberi tahu bagaimana setiap proses dapat menemukan satu sama lain, bagaimana mereka menginisialisasi dan memverifikasi grup proses menggunakan backend komunikasi. Secara default jika init_method tidak ditentukan, PyTorch akan menggunakan metode inisialisasi variabel lingkungan (env://). init_method adalah metode inisialisasi yang direkomendasikan untuk digunakan dalam kode pelatihan Anda untuk menjalankan PyTorch terdistribusi di Azure Machine Learning. PyTorch akan mencari variabel lingkungan berikut untuk inisialisasi:

  • MASTER_ADDR - Alamat IP komputer yang akan menjadi host proses dengan peringkat 0.
  • MASTER_PORT - Port gratis pada komputer yang akan menjadi host proses dengan peringkat 0.
  • WORLD_SIZE - Jumlah total proses. Harus sama dengan jumlah total perangkat (GPU) yang digunakan untuk pelatihan terdistribusi.
  • RANK - Peringkat (global) dari proses saat ini. Kemungkinan nilainya adalah 0 hingga (ukuran dunia - 1).

Untuk informasi selengkapnya tentang inisialisasi grup proses, lihat dokumentasi PyTorch.

Di luar ini, banyak aplikasi juga akan membutuhkan variabel lingkungan berikut:

  • LOCAL_RANK - Peringkat lokal (relatif) dari proses di dalam simpul. Kemungkinan nilainya adalah 0 hingga (# dari proses pada simpul - 1). Informasi ini berguna karena banyak operasi seperti persiapan data hanya harus dilakukan sekali per node --- biasanya pada local_rank = 0.
  • NODE_RANK - Peringkat simpul untuk pelatihan multinode. Kemungkinan nilainya adalah 0 hingga (total # dari simpul - 1).

Opsi peluncuran PyTorch

Pekerjaan Azure Machine Learning PyTorch mendukung dua jenis opsi untuk meluncurkan pelatihan terdistribusi:

  • Per-proses-peluncur: Sistem akan meluncurkan semua proses terdistribusi untuk Anda, dengan semua informasi yang relevan (seperti variabel lingkungan) untuk menyiapkan grup proses.
  • Per-node-launcher: Anda menyediakan Azure Machine Learning dengan peluncur utilitas yang akan dijalankan pada setiap simpul. Peluncur utilitas akan menangani peluncuran masing-masing proses pada node tertentu. Secara lokal dalam setiap simpul, RANK dan LOCAL_RANK disiapkan oleh peluncur. Utilitas torch.distributed.launch dan PyTorch Lightning keduanya termasuk dalam kategori ini.

Tidak ada perbedaan mendasar antara opsi peluncuran ini. Pilihannya sebagian besar tergantung pada preferensi Anda atau konvensi kerangka kerja/pustaka yang dibangun di atas vanilla PyTorch (seperti Lightning atau Hugging Face).

Bagian berikut masuk ke detail selengkapnya tentang cara mengonfigurasi pekerjaan Azure Machine Learning PyTorch untuk setiap opsi peluncuran.

DistributedDataParallel (per-proses-peluncuran)

Anda tidak perlu menggunakan utilitas peluncur seperti torch.distributed.launch. Untuk menjalankan tugas PyTorch terdistribusi:

  1. Menentukan skrip dan argumen pelatihan
  2. Buat PyTorchConfiguration dan tentukan process_count dan node_count. process_count sesuai dengan jumlah total proses yang ingin Anda jalankan untuk pekerjaan Anda. process_count biasanya harus sama dengan # GPUs per node x # nodes. Jika process_count tidak ditentukan, Azure Machine Learning secara default akan meluncurkan satu proses per simpul.

Azure Machine Learning akan mengatur MASTER_ADDRvariabel lingkungan , MASTER_PORT, WORLD_SIZE, dan NODE_RANK pada setiap simpul, dan mengatur variabel tingkat RANK proses dan LOCAL_RANK lingkungan.

Untuk menggunakan opsi ini untuk pelatihan multi-proses per simpul, gunakan Azure Machine Learning Python SDK >= 1.22.0. Process_count diperkenalkan pada 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

Jika skrip pelatihan Anda memberikan informasi seperti peringkat atau peringkat lokal sebagai argumen skrip, Anda dapat mereferensikan variabel lingkungan dalam argumen:

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

Contoh per-proses-peluncuran Pytorch

Menggunakan torch.distributed.launch (per-node-launch)

PyTorch menyediakan utilitas peluncuran di torch.distributed.launch yang dapat Anda gunakan untuk meluncurkan beberapa proses per node. Modul torch.distributed.launch memunculkan beberapa proses pelatihan di setiap node.

Langkah-langkah berikut menunjukkan cara mengonfigurasi pekerjaan PyTorch dengan peluncur per simpul di Azure Machine Learning. Pekerjaan mencapai setara dengan menjalankan perintah berikut:

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. Berikan perintah torch.distributed.launch ke parameter command dari konstruktor ScriptRunConfig. Azure Machine Learning menjalankan perintah ini pada setiap simpul kluster pelatihan Anda. --nproc_per_node harus kurang dari atau sama dengan jumlah GPU yang tersedia pada setiap simpul. MASTER_ADDR, MASTER_PORT, dan NODE_RANK diatur oleh Azure Machine Learning, sehingga Anda dapat mereferensikan variabel lingkungan dalam perintah. Azure Machine Learning mengatur MASTER_PORT ke 6105, tetapi Anda dapat meneruskan nilai yang berbeda ke --master_port argumen perintah torch.distributed.launch jika Anda mau. (Utilitas peluncuran akan mengatur ulang variabel lingkungan.)
  2. Buat PyTorchConfiguration dan tentukan 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

Pelatihan multi-GPU single-node: Jika Anda menggunakan utilitas peluncuran untuk menjalankan pelatihan PyTorch multi-GPU single-node, Anda tidak perlu menentukan parameter distributed_job_config ScriptRunConfig.

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

Contoh peluncuran per-node PyTorch

Petir PyTorch

PyTorch Lightning adalah pustaka sumber terbuka ringan yang menyediakan antarmuka tingkat tinggi untuk PyTorch. Lightning abstrak pergi banyak tingkat yang lebih rendah konfigurasi pelatihan terdistribusi yang diperlukan untuk vanili PyTorch. Lightning memungkinkan Anda untuk menjalankan skrip pelatihan Anda dalam pengaturan GPU tunggal, multi-GPU single-node, dan multi-node multi-GPU. Di belakang layar, ini meluncurkan beberapa proses untuk Anda yang mirip dengan torch.distributed.launch.

Untuk pelatihan simpul tunggal (termasuk multi-GPU simpul tunggal), Anda dapat menjalankan kode Anda di Azure Machine Learning tanpa perlu menentukan distributed_job_config. Untuk menjalankan eksperimen menggunakan beberapa node dengan beberapa GPU, ada 2 opsi:

  • Menggunakan konfigurasi PyTorch (disarankan): Tentukan PyTorchConfiguration dan tentukan communication_backend="Nccl", node_count, dan process_count (perhatikan bahwa ini adalah jumlah total proses, yaitu num_nodes * process_count_per_node). Dalam modul Lightning Trainer, tentukan num_nodes dan gpus agar konsisten dengan PyTorchConfiguration. Misalnya, num_nodes = node_count dan gpus = process_count_per_node.

  • Menggunakan Konfigurasi MPI:

    • Tentukan MpiConfiguration dan tentukan node_count dan process_count_per_node. Di Lightning Trainer, tentukan num_nodes dan gpus masing-masing sama dengan node_count dan process_count_per_node dari MpiConfiguration.

    • Untuk pelatihan multi-node dengan MPI, Lightning memerlukan variabel lingkungan berikut untuk ditetapkan pada setiap node dari kluster pelatihan Anda:

      • MASTER_ADDR
      • MASTER_PORT
      • NODE_RANK
      • LOCAL_RANK

      Atur variabel lingkungan ini secara manual yang diperlukan Lightning dalam skrip pelatihan utama:

    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 menangani komputasi ukuran dunia dari bendera Pelatih --gpus dan --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)

Memeluk Transformers Wajah

Hugging Face menyediakan banyak contoh untuk menggunakan perpustakaan Transformers-nya dengan torch.distributed.launch untuk menjalankan pelatihan terdistribusi. Untuk menjalankan contoh ini dan skrip pelatihan khusus Anda sendiri menggunakan Transformers Trainer API, ikuti bagian Menggunakan torch.distributed.launch.

Sampel kode konfigurasi pekerjaan untuk menyempurnakan model besar BERT pada tugas MNLI klasifikasi teks menggunakan skrip run_glue.py pada satu node dengan 8 GPU:

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

Anda juga dapat menggunakan opsi per-proses-peluncuran untuk menjalankan pelatihan terdistribusi tanpa menggunakan torch.distributed.launch. Satu hal yang perlu diingat jika menggunakan metode ini adalah bahwa TrainingArguments transformer mengharapkan peringkat lokal diteruskan sebagai argumen (--local_rank). torch.distributed.launch mengurus ini ketika --use_env=False, tetapi jika Anda menggunakan peluncuran per proses, Anda harus secara eksplisit meneruskan peringkat lokal sebagai argumen ke skrip --local_rank=$LOCAL_RANK pelatihan karena Azure Machine Learning hanya mengatur LOCAL_RANK variabel lingkungan.

TensorFlow

Jika Anda menggunakan TensorFlow terdistribusi asli dalam kode pelatihan Anda, seperti API TensorFlow 2.x tf.distribute.Strategy , Anda dapat meluncurkan pekerjaan terdistribusi melalui Azure Machine Learning menggunakan TensorflowConfiguration.

Untuk melakukannya, tentukan objek TensorflowConfiguration ke parameter distributed_job_config dari konstruktor ScriptRunConfig. Jika Anda menggunakan tf.distribute.experimental.MultiWorkerMirroredStrategy, tentukan worker_count di TensorflowConfiguration yang sesuai dengan jumlah simpul untuk tugas pelatihan Anda.

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)

Jika skrip pelatihan Anda menggunakan strategi server parameter untuk pelatihan terdistribusi, seperti untuk warisan TensorFlow 1.x, Anda juga harus menentukan jumlah server parameter yang akan digunakan dalam pekerjaan, misalnya, tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1).

TF_CONFIG

Di TensorFlow, variabel lingkungan TF_CONFIG diperlukan untuk pelatihan di beberapa mesin. Untuk pekerjaan TensorFlow, Azure Machine Learning akan mengonfigurasi dan mengatur variabel TF_CONFIG dengan tepat untuk setiap pekerja sebelum menjalankan skrip pelatihan Anda.

Anda dapat mengakses TF_CONFIG dari skrip pelatihan jika Anda perlu: os.environ['TF_CONFIG'].

Contoh TF_CONFIG yang disetel pada node kepala pekerja:

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

Contoh TensorFlow

Mempercepat pelatihan GPU dengan InfiniBand

Ketika jumlah VM yang melatih model meningkat, waktu yang dibutuhkan untuk melatih model itu harus berkurang. Penurunan waktu, idealnya, harus proporsional secara linier dengan jumlah VM pelatihan. Misalnya, jika melatih model pada satu VM membutuhkan waktu 100 detik, maka melatih model yang sama pada dua VM idealnya membutuhkan waktu 50 detik. Melatih model pada empat VM harus memakan waktu 25 detik, dan seterusnya.

InfiniBand dapat menjadi faktor penting dalam mencapai penskalaan linier ini. InfiniBand memungkinkan komunikasi GPU-ke-GPU latensi rendah di seluruh node dalam kluster. InfiniBand membutuhkan perangkat keras khusus untuk beroperasi. Seri Azure VM tertentu, khususnya NC, ND, dan H-series, sekarang memiliki VM berkemampuan RDMA dengan dukungan SR-IOV dan InfiniBand. VM ini berkomunikasi melalui latensi rendah dan jaringan InfiniBand bandwidth tinggi, yang jauh lebih performant daripada konektivitas berbasis Ethernet. SR-IOV untuk InfiniBand memungkinkan performa bare-metal untuk perpustakaan MPI (MPI digunakan oleh banyak kerangka pelatihan terdistribusi dan perkakas, termasuk perangkat lunak NCCL NVIDIA.) SKU ini dimaksudkan untuk memenuhi kebutuhan beban kerja pembelajaran mesin yang intensif secara komputasi dan aklerasi GPU. Untuk informasi selengkapnya, lihat Mempercepat Pelatihan Terdistribusi dalam Pembelajaran Mesin Azure dengan SR-IOV.

Biasanya, SKU VM dengan 'r' dalam namanya berisi perangkat keras InfiniBand yang diperlukan, dan yang tidak memiliki 'r' biasanya tidak. ('r' adalah referensi untuk RDMA, yang merupakan singkatan dari "akses memori langsung jarak jauh.") Misalnya, VM SKU Standard_NC24rs_v3 diaktifkan InfiniBand, tetapi SKU Standard_NC24s_v3 tidak. Selain kemampuan InfiniBand, spesifikasi antara kedua SKU ini sebagian besar sama – keduanya memiliki 24 core, RAM 448 GB, GPU 4 dari SKU yang sama, dll. Pelajari lebih lanjut tentang SKU mesin berkemampuan RDMA dan InfiniBand.

Peringatan

Mesin generasi lama SKU Standard_NC24r diaktifkan RDMA, tetapi tidak mengandung perangkat keras SR-IOV yang diperlukan untuk InfiniBand.

Jika Anda membuat kluster AmlCompute dari salah satu ukuran berkemampuan RDMA, berkemampuan InfiniBand ini, seperti, citra OS akan datang dengan driver Mellanox OFED yang diperlukan untuk mengaktifkan InfiniBand yang telah dipasang dan dikonfigurasi sebelumnya.

Langkah berikutnya