Panduan pelatihan GPU terdistribusi (SDK v2)

BERLAKU UNTUK: Python SDK azure-ai-ml v2 (versi saat ini)

Artikel ini menjelaskan cara menggunakan kode pelatihan GPU terdistribusi di Azure Machine Learning. Anda melihat cara menjalankan kode yang ada dengan tips dan contoh untuk PyTorch, DeepSpeed, dan TensorFlow. Anda juga mempelajari tentang mempercepat pelatihan GPU terdistribusi dengan InfiniBand.

Petunjuk / Saran

Lebih dari 90% waktu, Anda harus menggunakan paralelisme data terdistribusi sebagai jenis paralelisme terdistribusi Anda.

Prasyarat

Memahami konsep dasar pelatihan GPU terdistribusi, seperti paralelisme data, paralelisme data terdistribusi, dan paralelisme model.
Azure Machine Learning SDK untuk Python dengan paket versi 1.5.0 atau yang lebih baru telah terinstal.

PyTorch

Azure Machine Learning mendukung menjalankan pekerjaan terdistribusi dengan menggunakan kemampuan pelatihan terdistribusi asli PyTorch, torch.distributed.

Untuk paralelisme data, panduan PyTorch resmi menyarankan penggunaan DistributedDataParallel (DDP) daripada DataParallel untuk pelatihan terdistribusi baik untuk satu simpul maupun multi-node. PyTorch juga menyarankan untuk menggunakan DistributedDataParallel melalui paket multipemrosesan. Oleh karena itu, dokumentasi dan contoh Azure Machine Learning berfokus pada pelatihan DistributedDataParallel.

Inisialisasi grup proses

Tulang punggung pelatihan terdistribusi adalah sekelompok proses yang mengenali dan dapat berkomunikasi satu sama lain dengan menggunakan backend. Untuk PyTorch, Anda membuat grup proses dengan memanggil torch.distributed.init_process_group di semua proses terdistribusi untuk membentuk grup proses secara kolektif.

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

Backend komunikasi yang paling umum adalah mpi, , nccldan gloo. Untuk pelatihan berbasis GPU, gunakan nccl untuk performa terbaik.

Untuk menjalankan PyTorch terdistribusi di Azure Machine Learning, gunakan init_method parameter dalam kode pelatihan Anda. Parameter ini menentukan bagaimana setiap proses menemukan proses lain dan bagaimana mereka menginisialisasi dan memverifikasi grup proses dengan menggunakan backend komunikasi. Secara default, jika Anda tidak menentukan init_method, PyTorch menggunakan metode env://inisialisasi variabel lingkungan .

PyTorch mencari variabel lingkungan berikut untuk inisialisasi:

MASTER_ADDR: Alamat IP komputer yang menghosting proses dengan peringkat 0.
MASTER_PORT: Port gratis pada komputer yang menghosting 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. Nilai yang mungkin adalah dari 0 hingga (<world size> - 1).

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

Variabel lingkungan

Banyak aplikasi juga memerlukan variabel lingkungan berikut:

LOCAL_RANK: Peringkat relatif lokal proses dalam simpul. Nilai yang mungkin adalah dari 0 hingga (<# of processes on the node> - 1). Informasi ini berguna karena banyak operasi seperti persiapan data hanya perlu dilakukan sekali per simpul, biasanya pada local_rank = 0.
NODE_RANK: Peringkat simpul untuk pelatihan multinode. Nilai yang mungkin adalah dari 0 hingga (<total # of nodes> - 1).

Menjalankan pekerjaan PyTorch terdistribusi

Anda tidak perlu menggunakan utilitas peluncur seperti torch.distributed.launch untuk menjalankan pekerjaan PyTorch terdistribusi. Kamu bisa:

Tentukan skrip dan argumen pelatihan.
Buat command, dan tentukan type sebagai PyTorch dan process_count_per_instance dalam distribution parameter .

Parameter process_count_per_instance sesuai dengan jumlah proses yang ingin Anda jalankan untuk tugas Anda, dan biasanya harus sama dengan jumlah GPU per simpul. Jika Anda tidak menentukan process_count_per_instance, Azure Machine Learning meluncurkan satu proses per simpul secara default.

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

Contoh PyTorch

from azure.ai.ml import command
from azure.ai.ml.entities import Data
from azure.ai.ml import Input
from azure.ai.ml import Output
from azure.ai.ml.constants import AssetTypes

# === Note on path ===
# can be can be a local path or a cloud path. AzureML supports https://`, `abfss://`, `wasbs://` and `azureml://` URIs.
# Local paths are automatically uploaded to the default datastore in the cloud.
# More details on supported paths: https://docs.microsoft.com/azure/machine-learning/how-to-read-write-data-v2#supported-paths

inputs = {
    "cifar": Input(
        type=AssetTypes.URI_FOLDER, path=returned_job.outputs.cifar.path
    ),  # path="azureml:azureml_stoic_cartoon_wgb3lgvgky_output_data_cifar:1"), #path="azureml://datastores/workspaceblobstore/paths/azureml/stoic_cartoon_wgb3lgvgky/cifar/"),
    "epoch": 10,
    "batchsize": 64,
    "workers": 2,
    "lr": 0.01,
    "momen": 0.9,
    "prtfreq": 200,
    "output": "./outputs",
}

from azure.ai.ml.entities import ResourceConfiguration

job = command(
    code="./src",  # local path where the code is stored
    command="python train.py --data-dir ${{inputs.cifar}} --epochs ${{inputs.epoch}} --batch-size ${{inputs.batchsize}} --workers ${{inputs.workers}} --learning-rate ${{inputs.lr}} --momentum ${{inputs.momen}} --print-freq ${{inputs.prtfreq}} --model-dir ${{inputs.output}}",
    inputs=inputs,
    environment="azureml:AzureML-acpt-pytorch-2.8-cuda12.6@latest",
    instance_count=2,  # In this, only 2 node cluster was created.
    distribution={
        "type": "PyTorch",
        # set process count to the number of gpus per node
        # NC6s_v3 has only 1 GPU
        "process_count_per_instance": 1,
    },
)
job.resources = ResourceConfiguration(
    instance_type="STANDARD_NC4AS_T4_V3", instance_count=2
)  # Serverless compute resources

Untuk notebook lengkap guna menjalankan contoh PyTorch, lihat azureml-examples: Pelatihan terdistribusi dengan PyTorch pada CIFAR-10.

DeepSpeed

Azure Machine Learning mendukung DeepSpeed sebagai fitur tingkat atas untuk menjalankan pekerjaan terdistribusi dengan skalabilitas dekat linier untuk peningkatan ukuran model dan peningkatan nomor GPU.

Anda dapat mengaktifkan DeepSpeed untuk menjalankan pelatihan terdistribusi dengan menggunakan distribusi PyTorch atau Message Passing Interface (MPI). Azure Machine Learning mendukung peluncur DeepSpeed untuk meluncurkan pelatihan terdistribusi, dan penyetelan otomatis untuk mendapatkan konfigurasi yang optimal ds .

Anda dapat menggunakan lingkungan yang dikumpulkan dengan teknologi canggih terbaru, termasuk DeepSpeed, ONNX (Open Neural Network Exchange) Runtime (ORT), Microsoft Collective Communication Library (MSSCCL), dan PyTorch, untuk pekerjaan pelatihan DeepSpeed Anda.

Contoh DeepSpeed

Untuk contoh pelatihan dan penyetelan otomatis DeepSpeed, lihat https://github.com/Azure/azureml-examples/cli/jobs/deepspeed.

TensorFlow

Jika Anda menggunakan TensorFlow terdistribusi asli dalam kode pelatihan Anda, seperti TensorFlow 2.x tf.distribute.Strategy API, Anda dapat meluncurkan pekerjaan terdistribusi melalui Azure Machine Learning dengan menggunakan distribution parameter atau TensorFlowDistribution objek .

# create the command
job = command(
    code="./src",  # local path where the code is stored
    command="python main.py --epochs ${{inputs.epochs}} --model-dir ${{inputs.model_dir}}",
    inputs={"epochs": 1, "model_dir": "outputs/keras-model"},
    environment="AzureML-tensorflow-2.16-cuda12@latest",
    compute="cpu-cluster",
    instance_count=2,
    # distribution = {"type": "mpi", "process_count_per_instance": 1},
    # distribution={
    #     "type": "tensorflow",
    #     "parameter_server_count": 1,  # for legacy TensorFlow 1.x
    #     "worker_count": 2,
    #     "added_property": 7,
    # },
    # distribution = {
    #        "type": "pytorch",
    #        "process_count_per_instance": 4,
    #        "additional_prop": {"nested_prop": 3},
    #    },
    display_name="tensorflow-mnist-distributed-example"
    # experiment_name: tensorflow-mnist-distributed-example
    # description: Train a basic neural network with TensorFlow on the MNIST dataset, distributed via TensorFlow.
)

# can also set the distribution in a separate step and using the typed objects instead of a dict
job.distribution = TensorFlowDistribution(worker_count=2)

Jika skrip pelatihan Anda menggunakan strategi server parameter untuk pelatihan terdistribusi, seperti untuk TensorFlow 1.x warisan, Anda juga perlu menentukan jumlah server parameter yang akan digunakan dalam pekerjaan. Dalam contoh sebelumnya, Anda menentukan "parameter_server_count" : 1 dan "worker_count": 2 di dalam distribution parameter command.

TF_CONFIG

Untuk melatih beberapa komputer di TensorFlow, Anda menggunakan TF_CONFIG variabel lingkungan. Untuk pekerjaan TensorFlow, Azure Machine Learning mengatur TF_CONFIG variabel dengan benar untuk setiap pekerja sebelum menjalankan skrip pelatihan Anda.

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

Contoh berikut mengatur TF_CONFIG pada node pekerja utama:

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

Contoh TensorFlow

Untuk menjalankan contoh lengkap TensorFlow pada notebook, lihat tensorflow-mnist-distributed-example.

InfiniBand

Saat Anda meningkatkan jumlah komputer virtual (VM) yang melatih model, waktu yang diperlukan untuk melatih model tersebut harus menurun dalam proporsi linier ke jumlah VM pelatihan. Misalnya, jika melatih model pada satu komputer virtual (VM) membutuhkan waktu 100 detik, melatih model yang sama pada dua VM harus memakan waktu 50 detik, melatih model pada empat VM harus memakan waktu 25 detik, dan sebagainya.

InfiniBand dapat membantu Anda mencapai penskalaan linier ini dengan mengaktifkan komunikasi GPU-ke-GPU latensi rendah di seluruh simpul dalam kluster. InfiniBand memerlukan perangkat keras khusus untuk beroperasi, seperti Azure VM NC-, ND-, atau H-series. VM ini mendukung Akses Memori Langsung Jarak Jauh (RDMA), Virtualisasi I/O Akar Tunggal (SR-IOV), dan InfiniBand.

VM ini berkomunikasi melalui jaringan InfiniBand latensi rendah dan bandwidth tinggi, yang berkinerja lebih baik daripada konektivitas berbasis Ethernet. SR-IOV untuk InfiniBand memungkinkan kinerja mendekati bare-metal untuk pustaka MPI apa pun, yang digunakan oleh banyak kerangka kerja pelatihan terdistribusi dan alat seperti NVIDIA Collective Communications Library (NCCL).

Stock Keeping Units (SKU) ini dimaksudkan untuk memenuhi kebutuhan beban kerja pembelajaran mesin yang dipercepat secara komputasi dan dipercepat GPU. Untuk informasi selengkapnya, lihat Mempercepat Pelatihan Terdistribusi dalam Pembelajaran Mesin Azure dengan SR-IOV.

Biasanya, hanya SKU VM yang memiliki r dalam namanya, yang mengacu pada RDMA, yang berisi perangkat keras InfiniBand yang diperlukan. Misalnya, SKU Standard_NC24rs_v3 VM mendukung InfiniBand, tetapi Standard_NC24s_v3 tidak. Spesifikasi untuk kedua SKU ini sebagian besar sama kecuali untuk kemampuan InfiniBand. Kedua SKU memiliki 24 core, RAM 448 GB, 4 GPU dari SKU yang sama, dan sebagainya. Untuk informasi selengkapnya tentang SKU komputer berkemampuan RDMA dan InfiniBand, lihat Komputasi performa tinggi.

Nota

SKU Standard_NC24r komputer generasi lama yang mendukung RDMA, tetapi tidak berisi perangkat keras SR-IOV yang diperlukan untuk keperluan InfiniBand.

Jika Anda membuat AmlCompute kluster menggunakan salah satu ukuran berkemampuan RDMA yang mendukung InfiniBand ini, gambar OS dilengkapi dengan driver Mellanox OpenFabrics Enterprise Distribution (OFED) yang diperlukan untuk mengaktifkan InfiniBand yang telah diinstal dan telah dikonfigurasi sebelumnya.

Saran dan Komentar

Apakah halaman ini membantu?

Terakhir diperbarui pada 2026-01-15