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

Cikk
06/13/2024

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azureml v1

További információ az elosztott GPU-betanítási kód használatáról az Azure Machine Learningben (ML). Ez a cikk nem tanítja meg az elosztott betanítást. Segít a meglévő elosztott betanítási kód futtatásában az Azure Machine Learningben. Tippeket és példákat kínál az egyes keretrendszerekhez:

Üzenetátadó felület (MPI)
- Horovod
- DeepSpeed
- Környezeti változók az Open MPI-ből
PyTorch
- Folyamatcsoport inicializálása
- Indítási beállítások
- DistributedDataParallel (folyamatonkénti indítás)
- Használat torch.distributed.launch (csomópontonkénti indítás)
- PyTorch Lightning
- Arcformálók ölelésében
TensorFlow
- A TensorFlow környezeti változói (TF_CONFIG)
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 kell használnia, az idő több mint 90%-ában az elosztott adat-párhuzamosságot kell használnia.

MPI

Az Azure Machine Learning egy MPI-feladatot kínál az egyes csomópontok adott számú folyamatának elindításához. Ezt a megközelítést alkalmazhatja az elosztott betanítás futtatásához folyamatindítónként vagy csomópontonkénti indítással, attól függően, hogy a csomópontonkénti indításhoz 1 (alapértelmezett) értékre van-e állítva, vagy egyenlő-e process_count_per_node a folyamatindítónkénti eszközök/GPU-k számával. Az Azure Machine Learning 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 Learning MPI-feladatok által használt alap Docker-rendszerképnek telepítve kell lennie egy MPI-kódtárnak. A nyílt MPI minden Azure Machine Learning GPU-alaprendszerképben 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 Learning 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:

Azure Machine Learning-környezet használata az előnyben részesített mélytanulási keretrendszerrel és MPI-vel. Az Azure Machine Learning válogatott környezetet biztosít a népszerű keretrendszerekhez.
Definiálás MpiConfiguration és node_countprocess_count_per_node . process_count_per_node 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.
Adja át az MpiConfiguration objektumot a distributed_job_config paraméternek 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

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 Learning-részeket
Az Azure Machine Learning-környezet horovodot és MPI-t tartalmaz. A PyTorch és a TensorFlow válogatott GPU-környezetek előre konfigurálva lesznek a Horovodtal és annak függőségeivel.
Hozzon létre egy MpiConfiguration kívánt eloszlást.

Horovod-példa

azureml-examples: TensorFlow elosztott betanítás a Horovod használatával

DeepSpeed

Ne használja a DeepSpeed egyéni indítóját elosztott betanítások futtatására az Azure Machine Learning DeepSpeed-kódtárával . Ehelyett konfiguráljon egy MPI-feladatot a betanítási feladat MPI-vel való elindításához.

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

Az Azure Machine Learning-környezet tartalmazza a DeepSpeedet és annak függőségeit, az Open MPI-t és az mpi4py-t.
Hozzon létre egy disztribúciót MpiConfiguration .

DeepSpeed-példa

azureml-examples: Elosztott betanítás a DeepSpeedtel a CIFAR-10-en

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

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

OMPI_COMM_WORLD_RANK - a folyamat rangja
OMPI_COMM_WORLD_SIZE - a világ mérete
AZ_BATCH_MASTER_NODE - elsődleges cím porttal, MASTER_ADDR:MASTER_PORT
OMPI_COMM_WORLD_LOCAL_RANK - a folyamat helyi rangja a csomóponton
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 Learning 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 Learning 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. A GPU-alapú betanítás nccl a legjobb teljesítmény érdekében ajánlott, és amikor csak lehetséges, é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, a PyTorch alapértelmezés szerint init_method a környezeti változó inicializálási módszerét (env://) használja. init_method Az ajánlott inicializálási módszer, amelyet a betanítási kódban az elosztott PyTorch Azure Machine Learningen való futtatásához érdemes használni. A PyTorch a következő környezeti változókat fogja keresni az inicializáláshoz:

MASTER_ADDR - Annak a gépnek az IP-címe, amely a folyamatot a 0. ranggal fogja üzemeltetni.
MASTER_PORT - Egy ingyenes port a gépen, amely a folyamatot a 0. ranggal fogja üzemeltetni.
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.

Ezeken túl számos alkalmazásnak a következő környezeti változókra is szüksége lesz:

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 adat-elő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).

A PyTorch indítási beállításai

Az Azure Machine Learning PyTorch-feladat kétféle lehetőséget támogat az elosztott betanítás elindításához:

Folyamatindítónként: A rendszer elindítja az összes elosztott folyamatot, a folyamatcsoport beállításához szükséges összes releváns információval (például környezeti változókkal).
Csomópontonkénti indító: Megadja az Azure Machine Learningnek az egyes csomópontokon futtatható segédprogramindítót. A segédprogramindító kezeli az egyes folyamatok indítását egy adott csomóponton. Az egyes csomópontok helyileg vannak beállítva, RANK és LOCAL_RANK a indító állítja be őket. A torch.distributed.launch segédprogram és a PyTorch Lightning is ebbe a kategóriába tartozik.

Az indítási lehetőségek között nincsenek alapvető különbségek. A választás nagyrészt az Ön igényeinek vagy a vanilla PyTorchra épülő keretrendszerek/kódtárak konvencióinak (például a Villám vagy az Ölelés arc) függvényén múlik.

Az alábbi szakaszok részletesebben ismertetik, hogyan konfigurálhatók az Azure Machine Learning PyTorch-feladatok az egyes indítási lehetőségekhez.

DistributedDataParallel (folyamatonkénti indítás)

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

A betanítási szkript és az argumentumok megadása
Hozzon létre egy, PyTorchConfiguration majd adja meg az ésnode_count.process_count Ez process_count a feladathoz futtatni kívánt folyamatok teljes számának felel meg. process_count általában egyenlőnek # GPUs per node x # nodeskell lennie. Ha process_count nincs megadva, az Azure Machine Learning alapértelmezés szerint csomópontonként egy folyamatot indít el.

Az Azure Machine Learning minden csomóponton beállítja a , , és NODE_RANK környezeti változókat, és beállítja a folyamatszintű RANK és LOCAL_RANK a környezeti változókatWORLD_SIZE. MASTER_PORTMASTER_ADDR

Ha ezt a lehetőséget csomópontonkénti többfolyamatos betanításhoz szeretné használni, használja az Azure Machine Learning Python SDK-t >= 1.22.0. Process_count 1.22.0-ban vezették be.

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)

Tipp.

Ha a betanítási szkript olyan információkat ad át, mint a helyi rang vagy a rangsor, hivatkozhat a környezeti változó(ka)ra az argumentumokban:

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

Pytorch per-process-launch példa

azureml-examples: Elosztott betanítás a PyTorch-tal a CIFAR-10-en

A torch.distributed.launch (csomópontonkénti indítás) használata

A PyTorch egy indítási segédprogramot biztosít a torch.distributed.launch fájlban, amellyel csomópontonként több folyamatot indíthat el. A torch.distributed.launch modul több betanítási folyamatot is elindít az egyes csomópontokon.

Az alábbi lépések bemutatják, hogyan konfigurálhat PyTorch-feladatokat csomópontonkénti indítású indítóval az Azure Machine Learningben. A feladat a következő parancs futtatásával egyenértékű eredményt ad:

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>

Adja meg a torch.distributed.launch parancsot a command konstruktor paraméterének ScriptRunConfig . Az Azure Machine Learning ezt a parancsot a betanítási fürt minden csomópontján futtatja. --nproc_per_node kisebbnek vagy egyenlőnek kell lennie az egyes csomópontokon elérhető GPU-k számával. MASTER_ADDR, MASTER_PORT és NODE_RANK az Azure Machine Learning állítja be, így egyszerűen hivatkozhat a parancs környezeti változóira. Az Azure Machine Learning MASTER_PORT 6105, de igény szerint más értéket adhat át a --master_port torch.distributed.launch parancs argumentumának. (Az indítási segédprogram alaphelyzetbe állítja a környezeti változókat.)
Hozzon létre egy PyTorchConfiguration elemet, és adja meg a 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)

Tipp.

Egycsomópontos több GPU-s betanítás: Ha az indítási segédprogrammal futtat egycsomópontos több GPU-s PyTorch-betanítást, nem kell megadnia a distributed_job_config ScriptRunConfig paraméterét.

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 per-node-launch example

azureml-examples: Elosztott betanítás a PyTorch-tal a CIFAR-10-en

PyTorch Lightning

A PyTorch Lightning egy könnyű, nyílt forráskódú kódtár, amely magas szintű felületet biztosít a PyTorch számára. A Villám elvonja a Vanilla PyTorchhoz szükséges alacsonyabb szintű elosztott betanítási konfigurációk nagy részét. A Villám lehetővé teszi a betanítási szkriptek futtatását egyetlen GPU-, egycsomópontos több-GPU- és többcsomópontos több-GPU-beállításokban. A jelenet mögött több folyamatot indít el, amelyekhez hasonló.torch.distributed.launch

Az egycsomópontos betanításhoz (beleértve az egycsomópontos több GPU-t is) futtathatja a kódot az Azure Machine Learningben anélkül, hogy meg kellene adnia egy distributed_job_config. Ha több csomópontot használó kísérletet szeretne futtatni több GPU-val, két lehetőség közül választhat:

PyTorch-konfiguráció használata (ajánlott): Definiálja PyTorchConfiguration és adja meg communication_backend="Nccl", node_countés process_count (vegye figyelembe, hogy ez a folyamatok teljes száma, azaz num_nodes * process_count_per_node). A Lightning Trainer modulban adja meg mindkettőt num_nodes , és gpus konzisztens legyen a következővel PyTorchConfiguration: . Például: num_nodes = node_count és gpus = process_count_per_node.

MPI-konfiguráció használata:

Definiálja MpiConfiguration és adja meg a mindkettőt node_count és a process_count_per_node. A Lightning Trainerben adja meg mindkettőt, és gpus hogy azonos node_count legyen a következővel és process_count_per_node a következővelMpiConfiguration.num_nodes
Az MPI-vel végzett többcsomópontos betanításhoz a Lightningnak a következő környezeti változókat kell beállítania a betanítási fürt minden csomópontján:
- MASTER_ADDR
- MASTER_PORT
- NODE_RANK
- LOCAL_RANK
Manuálisan állítsa be a Lightning által igényelt környezeti változókat a fő betanítási szkriptekben:

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
  )

Villám kezeli a számítástechnika a világ mérete a Trainer zászlók --gpus és --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)

Arcformálók ölelésében

Az Ölelés arc számos példát kínál a Transformers-kódtár torch.distributed.launch elosztott betanítás futtatására. Ha ezeket a példákat és saját egyéni betanítási szkripteket szeretné futtatni a Transformers Trainer API használatával, kövesse a Használat torch.distributed.launch szakaszt.

Mintafeladat-konfigurációs kód a nagy BERT-modell finomhangolásához a szövegbesorolási MNLI-feladaton az run_glue.py egyik csomópont szkriptjével, 8 GPU-val:

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

A folyamatonkénti indítási lehetőséggel elosztott betanítást is futtathat anélkül, hogy használna torch.distributed.launch. Egy dolog, amit szem előtt kell tartani, ha ezt a módszert használja, hogy az átalakítók TrainingArguments elvárják, hogy a helyi rangot adja át argumentumként (--local_rank). torch.distributed.launch Ezt a folyamatonkénti indításkor --use_env=Falsekell kezelnie, de ha folyamatonkénti indítást használ, explicit módon át kell adnia a helyi rangot argumentumként a betanítási szkriptnek --local_rank=$LOCAL_RANK , mivel az Azure Machine Learning csak a környezeti változót LOCAL_RANK állítja be.

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, elindíthatja az elosztott feladatot az Azure Machine Learning használatával.TensorflowConfiguration

Ehhez adjon meg egy TensorflowConfiguration objektumot a distributed_job_config ScriptRunConfig konstruktor paraméteréhez. Ha használja tf.distribute.experimental.MultiWorkerMirroredStrategy, adja meg a worker_count TensorflowConfiguration betanítási feladathoz tartozó csomópontok számának megfelelő értéket.

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)

Ha a betanítási szkript a paraméterkiszolgálói 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, tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1)például.

TF_CONFIG

A TensorFlow-ban a TF_CONFIG környezeti változó szükséges több gép betanításához. TensorFlow-feladatok esetén az Azure Machine Learning az egyes feldolgozókhoz megfelelően konfigurálja és állítja be a TF_CONFIG változót a betanítási szkript végrehajtása előtt.

A TF_CONFIG a betanítási szkriptből érheti el, ha szükséges: os.environ['TF_CONFIG'].

Példa egy fő feldolgozó csomóponton beállított TF_CONFIG:

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

TensorFlow-példa

azureml-examples: Distributed TensorFlow training with MultiWorkerMirroredStrategy

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 az SKU-k a számításigényes, GPU-val rendelkező gépi tanulási számítási feladatok igényeinek kielégítésére szolgálnak. További információ: Az elosztott képzés felgyorsítása az Azure Machine Learningben az 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 "távoli közvetlen memória-hozzáférés" kifejezé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 ezen RDMA-kompatibilis, InfiniBand-kompatibilis méretű fürtöket hozza létre AmlCompute , az operációs rendszer lemezképe az InfiniBand előtelepített és előre konfigurált verziójának engedélyezéséhez szükséges Mellanox OFED illesztőprogrammal fog rendelkezni.

Megosztás a következőn keresztül:

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

Előfeltételek

MPI

Horovod

Horovod-példa

DeepSpeed

DeepSpeed-példa

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

PyTorch

Folyamatcsoport inicializálása

A PyTorch indítási beállításai

DistributedDataParallel (folyamatonkénti indítás)

Pytorch per-process-launch példa

A torch.distributed.launch (csomópontonkénti indítás) használata

PyTorch per-node-launch example

PyTorch Lightning

Arcformálók ölelésében

TensorFlow

TF_CONFIG

TensorFlow-példa

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

Következő lépések

Visszajelzés

Visszajelzés

További források