Elosztott GPU betanítási útmutató (SDK v2)

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azure-ai-ml v2 (aktuális)

További információ az elosztott GPU-betanítási kód Azure Machine-Tanulás való használatáról. Ez a cikk segítséget nyújt a meglévő elosztott betanítási kód futtatásában, és tippeket és példákat kínál az egyes keretrendszerek követéséhez:

  • Üzenetátadó felület (MPI)
    • Horovod
    • Környezeti változók az Open MPI-ből
  • PyTorch
  • TensorFlow
  • GPU-betanítás felgyorsítása az InfiniBand használatával

Előfeltételek

Tekintse át az elosztott GPU-betanítás alapfogalmait, például az adat-párhuzamosságot, az elosztott adat-párhuzamosságot és a modell-párhuzamosságot.

Tipp.

Ha nem tudja, hogy milyen típusú párhuzamosságot használjon, az idő több mint 90%-ában elosztott adat-párhuzamosságot kell használnia.

MPI

Az Azure Machine Tanulás egy MPI-feladatot kínál az egyes csomópontok adott számú folyamatának elindításához. Az Azure Machine Tanulás a teljes MPI-indítási parancsot (mpirun) a színfalak mögött hozza létre. Nem adhat meg saját teljes head-node-launcher parancsokat, például mpirun vagy DeepSpeed launcher.

Tipp.

Az Azure Machine Tanulás MPI-feladat által használt alap Docker-rendszerképnek telepítve kell lennie egy MPI-kódtárnak. A nyílt MPI az Azure Machine Tanulás GPU-alaprendszerképek mindegyikében megtalálható. Ha egyéni Docker-rendszerképet használ, önnek kell gondoskodnia arról, hogy a rendszerkép tartalmaz-e MPI-kódtárat. Az MPI megnyitása ajánlott, de használhat más MPI-implementációt is, például az Intel MPI-t. Az Azure Machine Tanulás válogatott környezeteket is biztosít a népszerű keretrendszerekhez.

Elosztott betanítás MPI használatával történő futtatásához kövesse az alábbi lépéseket:

  1. Az előnyben részesített mélytanulási keretrendszerrel és MPI-vel Azure Machine-Tanulás környezetet használhat. Az Azure Machine Tanulás válogatott környezeteket biztosít a népszerű keretrendszerekhez. Vagy hozzon létre egy egyéni környezetet az előnyben részesített mélytanulási keretrendszerrel és MPI-vel.
  2. Adjon meg egy command .instance_count instance_count a folyamatindításhoz csomópontonkénti GPU-k számának kell lennie, vagy csomópontonkénti indítás esetén 1 (alapértelmezett) értékre kell állítania, ha a felhasználói szkript felelős a folyamatok csomópontonkénti elindításáért.
  3. distribution A paraméter használatával adja meg a command beállításokat a következőhözMpiDistribution: .
from azure.ai.ml import command, MpiDistribution

job = command(
    code="./src",  # local path where the code is stored
    command="python train.py --epochs ${{inputs.epochs}}",
    inputs={"epochs": 1},
    environment="AzureML-tensorflow-2.7-ubuntu20.04-py38-cuda11-gpu@latest",
    compute="gpu-cluster",
    instance_count=2,
    distribution=MpiDistribution(process_count_per_instance=2),
    display_name="tensorflow-mnist-distributed-horovod-example"
    # experiment_name: tensorflow-mnist-distributed-horovod-example
    # description: Train a basic neural network with TensorFlow on the MNIST dataset, distributed via Horovod.
)

Horovod

Az MPI-feladatkonfigurációt akkor használja, ha a Horovodot használja elosztott betanításhoz a mélytanulási keretrendszerrel.

Győződjön meg arról, hogy a kód az alábbi tippeket követi:

  • A betanítási kód megfelelően van kialakítva a Horovodtal, mielőtt hozzáadja az Azure Machine Tanulás részeit.
  • Az Azure Machine Tanulás környezete Horovodot és MPI-t tartalmaz. A PyTorch és a TensorFlow válogatott GPU-környezetek előre konfigurálhatók a Horovodtal és annak függőségeivel.
  • Hozzon létre egy command kívánt eloszlást.

Horovod-példa

Környezeti változók az Open MPI-ből

Ha MPI-feladatokat futtat open MPI-rendszerképekkel, az egyes elindított folyamatokhoz a következő környezeti változókat használhatja:

  1. OMPI_COMM_WORLD_RANK: A folyamat rangja
  2. OMPI_COMM_WORLD_SIZE: A világ mérete
  3. AZ_BATCH_MASTER_NODE: Az elsődleges cím porttal, MASTER_ADDR:MASTER_PORT
  4. OMPI_COMM_WORLD_LOCAL_RANK: A folyamat helyi rangja a csomóponton
  5. OMPI_COMM_WORLD_LOCAL_SIZE: A csomóponton lévő folyamatok száma

Tipp.

A név ellenére a környezeti változó OMPI_COMM_WORLD_NODE_RANK nem felel meg a NODE_RANK. Csomópontonkénti indító használatához állítsa be process_count_per_node=1 és használja OMPI_COMM_WORLD_RANK a következőt NODE_RANK: .

PyTorch

Az Azure Machine Tanulás támogatja az elosztott feladatok futtatását a PyTorch natív elosztott betanítási képességeivel (torch.distributed).

Tipp.

Az adat-párhuzamossághoz a PyTorch hivatalos útmutatója az DistributedDataParallel (DDP) használata DataParallel-en keresztül az egycsomópontos és a többcsomópontos elosztott betanításhoz. A PyTorch az DistributedDataParallel használatát is javasolja a többprocesszoros csomagon keresztül. Az Azure Machine Tanulás dokumentációja és példái ezért az DistributedDataParallel betanítására összpontosítanak.

Folyamatcsoport inicializálása

Az elosztott képzések gerince olyan folyamatokon alapul, amelyek ismerik egymást, és egy háttérrendszer használatával kommunikálhatnak egymással. A PyTorch esetében a folyamatcsoport úgy jön létre, hogy meghívja torch.distributed.init_process_group az összes elosztott folyamatból, hogy együttesen alakítsanak ki egy folyamatcsoportot.

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

A leggyakrabban használt kommunikációs háttérrendszerek a következők mpi: , ncclés gloo. GPU-alapú betanítás esetén a legjobb teljesítmény érdekében ajánlott, nccl és lehetőség szerint érdemes használni.

init_method ismerteti, hogy az egyes folyamatok hogyan deríthetik fel egymást, hogyan inicializálják és ellenőrzik a folyamatcsoportot a kommunikációs háttérrendszer használatával. Ha nincs megadva, init_method a PyTorch alapértelmezés szerint a környezeti változó inicializálási metódusát (env://) használja. init_methodA betanítási kódban ajánlott inicializálási módszer az elosztott PyTorch Azure Machine-Tanulás való futtatásához. A PyTorch a következő környezeti változókat keresi az inicializáláshoz:

  • MASTER_ADDR: A folyamatot 0. ranggal üzemeltető gép IP-címe
  • MASTER_PORT: Egy ingyenes port a gépen, amely a folyamatot a 0. ranggal üzemelteti
  • WORLD_SIZE: A folyamatok teljes száma. Egyenlőnek kell lennie az elosztott betanításhoz használt eszközök (GPU) teljes számával
  • RANK: Az aktuális folyamat (globális) rangja. A lehetséges értékek 0 és (világméret – 1)

A folyamatcsoportok inicializálásával kapcsolatos további információkért tekintse meg a PyTorch dokumentációját.

Számos alkalmazásnak a következő környezeti változókra is szüksége van:

  • LOCAL_RANK: A csomóponton belüli folyamat helyi (relatív) rangja. A lehetséges értékek 0 és (a csomóponton lévő folyamatok száma – 1). Ez az információ azért hasznos, mert sok műveletet, például az adatelőkészítést csomópontonként csak egyszer kell végrehajtani, általában local_rank = 0 értéken.
  • NODE_RANK: A csomópont rangja a többcsomópontos betanításhoz. A lehetséges értékek 0 és (csomópontok teljes száma – 1).

Nem kell olyan indító segédprogramot használnia, mint a torch.distributed.launch. Elosztott PyTorch-feladat futtatása:

  1. Adja meg a betanítási szkriptet és az argumentumokat.
  2. Hozzon létre egy értéketcommand, és adja meg a paraméter típusát és process_count_per_instancedistribution típusátPyTorch. Ez process_count_per_instance a feladathoz futtatni kívánt folyamatok teljes számának felel meg. process_count_per_instanceáltalában egyenlőnek kell lennie.# of GPUs per node Ha process_count_per_instance nincs megadva, az Azure Machine Tanulás alapértelmezés szerint csomópontonként egy folyamatot indít el.

Az Azure Machine Tanulás beállítja az MASTER_ADDRegyes csomópontokon a , MASTER_PORT, WORLD_SIZEés NODE_RANK a környezeti változókat, és beállítja a folyamatszintű RANK és LOCAL_RANK a környezeti változókat.

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-acpt-pytorch-2.0-cuda11.7:26",
    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_NC6s_v3", instance_count=2
)  # Serverless compute resources

Pytorch-példa

DeepSpeed

Az Azure Machine Tanulás első osztályú polgárként támogatja a DeepSpeedet elosztott feladatok futtatásához, közel lineáris skálázhatóság mellett:

  • A modell méretének növelése
  • GPU-k számának növekedése

A DeepSpeed pytorch-disztribúció vagy MPI használatával engedélyezhető elosztott betanítás futtatásához. Az Azure Machine Tanulás támogatja a DeepSpeed-indítót az elosztott betanítás elindításához, valamint az automatikustuninghoz az optimális ds konfiguráció érdekében.

Válogatott környezeteket használhat a környezeten kívüli környezetekhez a legújabb korszerű technológiákkal, például a DeepSpeed, az ORT, az MSSCCL és a Pytorch használatával a DeepSpeed betanítási feladataihoz.

DeepSpeed-példa

  • A DeepSpeed-betanítási és automatikustuning-példákért tekintse meg ezeket a mappákat.

TensorFlow

Ha natív elosztott TensorFlow-t használ a betanítási kódban, például a TensorFlow 2.x API-jábantf.distribute.Strategy, az elosztott feladatot az Azure Machine-Tanulás indíthatja el paraméterek vagy az TensorFlowDistribution objektum használatávaldistribution.

# 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.4-ubuntu18.04-py37-cuda11-gpu@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)

Ha a betanítási szkript a paraméterkiszolgáló-stratégiát használja az elosztott betanításhoz, például az örökölt TensorFlow 1.x-hez, meg kell adnia a feladatban használandó paraméterkiszolgálók számát is a distributioncommandparaméter paraméterén belül. A fentiekben például és "parameter_server_count" : 1"worker_count": 2.

TF_CONFIG

A TensorFlow-ban a TF_CONFIG környezeti változóra több gépen való betanításhoz van szükség. TensorFlow-feladatok esetén az Azure Machine Tanulás konfigurálja és beállítja a TF_CONFIG változót az egyes feldolgozókhoz a betanítási szkript végrehajtása előtt.

A betanítási szkriptből a következő esetekben férhet hozzá TF_CONFIG : os.environ['TF_CONFIG'].

Példa TF_CONFIG egy fő feldolgozó csomóponton:

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

TensorFlow-példa

Elosztott GPU-betanítás felgyorsítása az InfiniBand használatával

A modellek betanításának számának növekedésével a modell betanításához szükséges időnek csökkennie kell. Az idő csökkenésének ideális esetben lineárisan arányosnak kell lennie a betanítási virtuális gépek számával. Ha például egy modell betanítása egy virtuális gépen 100 másodpercet vesz igénybe, akkor ugyanazon modell betanítása két virtuális gépen ideális esetben 50 másodpercet vesz igénybe. A modell betanítása négy virtuális gépen 25 másodpercet vesz igénybe, és így tovább.

Az InfiniBand fontos tényező lehet ennek a lineáris skálázásnak a elérésében. Az InfiniBand alacsony késleltetésű, GPU–GPU kommunikációt tesz lehetővé a fürt csomópontjai között. Az InfiniBand használatához speciális hardver szükséges. Egyes Azure-beli virtuálisgép-sorozatok, különösen az NC, az ND és a H sorozat mostantól RDMA-kompatibilis virtuális gépekkel rendelkeznek SR-IOV és InfiniBand támogatással. Ezek a virtuális gépek alacsony késéssel és nagy sávszélességű InfiniBand-hálózaton keresztül kommunikálnak, ami sokkal teljesítményesebb, mint az Ethernet-alapú kapcsolat. Az InfiniBandhez készült SR-IOV szinte bármilyen MPI-kódtár esetében lehetővé teszi az operációs rendszer nélküli teljesítményt (az MPI-t számos elosztott betanítási keretrendszer és eszköz, köztük az NVIDIA NCCL-szoftvere használja.) Ezek a termékváltozatok a számításigényes, GPU-gyorsított gépi tanulási számítási feladatok igényeinek kielégítésére szolgálnak. További információ: Elosztott betanítás felgyorsítása az Azure Machine Tanulás SR-IOV használatával.

A nevükben "r" betűvel ellátott virtuálisgép-termékváltozatok általában tartalmazzák a szükséges InfiniBand-hardvert, és az "r" nélküli virtuálisgép-termékváltozatok általában nem. Az "r" az RDMA-ra való hivatkozás, amely a közvetlen távoli memóriahozzáférést jelenti.) A virtuálisgép-termékváltozat Standard_NC24rs_v3 például InfiniBand-kompatibilis, de a termékváltozat Standard_NC24s_v3 nem. Az InfiniBand képességein kívül a két termékváltozat specifikációi nagyrészt megegyeznek. Mindkettő 24 maggal, 448 GB RAM-mal, 4 GPU-val rendelkezik ugyanahhoz a termékváltozathoz stb. További információ az RDMA- és InfiniBand-kompatibilis gépi termékváltozatokról.

Figyelmeztetés

A régebbi generációs gép termékváltozata Standard_NC24r RDMA-kompatibilis, de nem tartalmaz az InfiniBandhoz szükséges SR-IOV hardvert.

Ha egy ilyen RDMA-kompatibilis, InfiniBand-kompatibilis méretű fürtöt hoz létre AmlCompute , az operációs rendszer képe tartalmazza az InfiniBand előtelepített és előre konfigurált infiniBand engedélyezéséhez szükséges Mellanox OFED illesztőprogramot.

Következő lépések