Trainingshandleiding voor gedistribueerde GPU

Meer informatie over het gebruik van gedistribueerde GPU-trainingscode in Azure Machine Learning (ML). In dit artikel krijgt u geen informatie over gedistribueerde training. Het helpt u bij het uitvoeren van uw bestaande gedistribueerde trainingscode op Azure Machine Learning. Het biedt tips en voorbeelden die u voor elk framework kunt volgen:

  • Message Passing Interface (MPI)
    • Horovod
    • DeepSpeed
    • Omgevingsvariabelen van Open MPI
  • PyTorch
    • Initialisatie van procesgroep
    • Opties voor starten
    • DistributedDataParallel (per proces starten)
    • Met torch.distributed.launch behulp van (per knooppunt starten)
    • PyTorch Lightning
    • Gezichtsherkenningssytegen
  • TensorFlow
    • Omgevingsvariabelen voor TensorFlow (TF_CONFIG)
  • GPU-training versnellen met InfiniBand

Vereisten

Bekijk deze basisconcepten van gedistribueerde GPU-training, zoals gegevens parallellisme, gedistribueerde parallelle uitvoering van gegevens en modellisme.

Tip

Als u niet weet welk type parallellisme u moet gebruiken, moet u meer dan 90% van de tijd Distributed Data Parallelism gebruiken.

MPI

Azure ML een MPI-taak voor het starten van een bepaald aantal processen in elk knooppunt. U kunt deze methode gebruiken om gedistribueerde training uit te voeren met behulp van een launcher per proces of een launcher per knooppunt, afhankelijk van of is ingesteld op 1 (de standaardinstelling) voor het startsprogramma per knooppunt of gelijk is aan het aantal process_count_per_node apparaten/GPU's voor een launcher per proces. Azure ML de volledige MPI-startopdracht ( mpirun ) achter de schermen. U kunt niet uw eigen volledige head-node-launcher-opdrachten zoals mpirun of DeepSpeed launcher leveren.

Tip

Op de Docker-basiskopie die wordt gebruikt door Azure Machine Learning MPI-taak moet een MPI-bibliotheek zijn geïnstalleerd. Open MPI is opgenomen in alle AzureML GPU-basisafbeeldingen. Wanneer u een aangepaste Docker-afbeelding gebruikt, moet u ervoor zorgen dat de afbeelding een MPI-bibliotheek bevat. Open MPI wordt aanbevolen, maar u kunt ook een andere MPI-implementatie gebruiken, zoals Intel MPI. Azure ML biedt ook gecureerde omgevingen voor populaire frameworks.

Volg deze stappen om gedistribueerde training uit te voeren met MPI:

  1. Gebruik een Azure ML omgeving met het deep learning-framework en de MPI van uw voorkeur. AzureML biedt een gecureerde omgeving voor populaire frameworks.
  2. MpiConfigurationDefinieer process_count_per_node met en node_count . process_count_per_node moet gelijk zijn aan het aantal GPU's per knooppunt voor het starten per proces of op 1 (de standaardinstelling) voor starten per knooppunt als het gebruikersscript verantwoordelijk is voor het starten van de processen per knooppunt.
  3. Geef het MpiConfiguration -object door aan distributed_job_config de parameter van 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

Gebruik de configuratie van de MPI-taak wanneer u Horovod gebruikt voor gedistribueerde training met het deep learning-framework.

Zorg ervoor dat uw code de volgende tips volgt:

  • De trainingscode is correct instrumenteerd met Horovod voordat u de Azure ML toevoegt
  • Uw Azure ML-omgeving bevat Horovod en MPI. De door PyTorch en TensorFlow gecureerde GPU-omgevingen zijn vooraf geconfigureerd met Horovod en de afhankelijkheden ervan.
  • Maak een MpiConfiguration met de gewenste distributie.

Horovod-voorbeeld

DeepSpeed

Gebruik het aangepaste startplatform van DeepSpeed niet om gedistribueerde training uit te voeren met de DeepSpeed-bibliotheek op Azure ML. Configureer in plaats daarvan een MPI-taak om de trainings job te starten met MPI.

Zorg ervoor dat uw code de volgende tips volgt:

  • Uw Azure ML-omgeving bevat DeepSpeed en de afhankelijkheden, Open MPI en mpi4py.
  • Maak een MpiConfiguration met uw distributie.

DeepSeed-voorbeeld

Omgevingsvariabelen van Open MPI

Bij het uitvoeren van MPI-taken met Open MPI-afbeeldingen, worden de volgende omgevingsvariabelen voor elk gestart proces gestart:

  1. OMPI_COMM_WORLD_RANK - de rangschikking van het proces
  2. OMPI_COMM_WORLD_SIZE - de wereldgrootte
  3. AZ_BATCH_MASTER_NODE - primair adres met poort, MASTER_ADDR:MASTER_PORT
  4. OMPI_COMM_WORLD_LOCAL_RANK - de lokale rangschikking van het proces op het knooppunt
  5. OMPI_COMM_WORLD_LOCAL_SIZE - aantal processen op het knooppunt

Tip

Ondanks de naam komt de OMPI_COMM_WORLD_NODE_RANK omgevingsvariabele niet overeen met de NODE_RANK . Als u het startpunt per knooppunt wilt gebruiken, stelt u in process_count_per_node=1 en gebruikt u als de OMPI_COMM_WORLD_RANK NODE_RANK .

PyTorch

Azure ML ondersteuning voor het uitvoeren van gedistribueerde taken met behulp van de native gedistribueerde trainingsmogelijkheden van PyTorch ( torch.distributed ).

Tip

De officiële PyTorch-richtlijnen voor gegevensparallel zijn het gebruik van DistributedDataParallel (DDP) via DataParallel voor gedistribueerde training met zowel één knooppunt als meerdere knooppunt. PyTorch raadt ook aan DistributedDataParallel te gebruiken via het multiprocessing-pakket. Azure Machine Learning documentatie en voorbeelden richten zich daarom op DistributedDataParallel-training.

Initialisatie van procesgroep

De backbone van elke gedistribueerde training is gebaseerd op een groep processen die elkaar kennen en met elkaar kunnen communiceren met behulp van een back-end. Voor PyTorch wordt de procesgroep gemaakt door het aanroepen van torch.distributed.init_process_group in alle gedistribueerde processen om gezamenlijk een procesgroep te vormen.

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

De meest gebruikte communicatieback-en zijn mpi nccl , en gloo . Voor op GPU gebaseerde training nccl wordt aanbevolen voor de beste prestaties en moet deze indien mogelijk worden gebruikt.

init_method vertelt hoe elk proces elkaar kan ontdekken, hoe ze de procesgroep initialiseren en verifiëren met behulp van de back-end voor communicatie. Als niet is opgegeven, gebruikt PyTorch standaard de initialisatiemethode van de init_method omgevingsvariabele ( env:// ). init_methodis de aanbevolen initialisatiemethode die u in uw trainingscode kunt gebruiken om gedistribueerde PyTorch uit te voeren op Azure ML. PyTorch zal zoeken naar de volgende omgevingsvariabelen voor initialisatie, :

  • MASTER_ADDR - IP-adres van de computer die het proces host met rang 0.
  • MASTER_PORT - Een vrije poort op de computer die het proces gaat hosten met positie 0.
  • WORLD_SIZE - Het totale aantal processen. Moet gelijk zijn aan het totale aantal apparaten (GPU) dat wordt gebruikt voor gedistribueerde training.
  • RANK - De (globale) rangschikking van het huidige proces. De mogelijke waarden zijn 0 tot (wereldgrootte - 1).

Zie de PyTorch-documentatievoor meer informatie over initialisatie van procesgroep.

Daarnaast hebben veel toepassingen ook de volgende omgevingsvariabelen nodig:

  • LOCAL_RANK - De lokale (relatieve) rangschikking van het proces binnen het knooppunt. De mogelijke waarden zijn 0 tot (aantal processen op het knooppunt - 1). Deze informatie is nuttig omdat veel bewerkingen, zoals gegevensvoorbereiding, slechts één keer per knooppunt moeten worden uitgevoerd --- meestal op local_rank = 0.
  • NODE_RANK - De rangschikking van het knooppunt voor training met meerdere knooppunt. De mogelijke waarden zijn 0 tot (totaal aantal knooppunten - 1).

Opties voor PyTorch starten

De Azure ML PyTorch-taak ondersteunt twee typen opties voor het starten van gedistribueerde training:

  • Per processtarter: het systeem start alle gedistribueerde processen voor u, met alle relevante informatie (zoals omgevingsvariabelen) om de procesgroep in te stellen.
  • Launcher per knooppunt: u geeft Azure ML met het startprogramma voor hulpprogramma's dat op elk knooppunt wordt uitgevoerd. Het startprogramma voor hulpprogramma's verwerkt het starten van elk van de processen op een bepaald knooppunt. Lokaal binnen elk knooppunt RANK en worden ingesteld door het start LOCAL_RANK startpunt. Het hulpprogramma voor distributed.launch en PyTorch Lightning behoren beide tot deze categorie.

Er zijn geen fundamentele verschillen tussen deze opstartopties. De keuze is grotendeels aan uw voorkeur of de conventies van de frameworks/bibliotheken die zijn gebouwd op vanille PyTorch (zoals Bliksem of Hugging Face).

De volgende secties gaan verder in op het configureren van Azure ML PyTorch-taken voor elk van de startopties.

DistributedDataParallel (per proces starten)

U hoeft geen startprogramma zoals te torch.distributed.launch gebruiken. Een gedistribueerde PyTorch-taak uitvoeren:

  1. Het trainingsscript en de argumenten opgeven
  2. Maak een PyTorchConfiguration en geef de en process_count node_count op. De process_count komt overeen met het totale aantal processen dat u wilt uitvoeren voor uw taak. process_count moet doorgaans gelijk zijn aan # GPUs per node x # nodes . Als process_count niet is opgegeven, start Azure ML standaard één proces per knooppunt.

Azure ML stelt de omgevingsvariabelen , , en in op elk knooppunt en stelt de variabelen op procesniveau en MASTER_ADDR MASTER_PORT omgeving WORLD_SIZE NODE_RANK RANK LOCAL_RANK in.

Als u deze optie wilt gebruiken voor training met meerdere processen per knooppunt, gebruikt u Azure ML Python >= 1.22.0 SDK. Process_count is geïntroduceerd in 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

Als uw trainingsscript informatie zoals lokale rangschikking of positie als scriptargumenten door geeft, kunt u verwijzen naar de omgevingsvariabelen in de argumenten:

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

Voorbeeld van Pytorch per proces starten

Met torch.distributed.launch behulp van (per knooppunt starten)

PyTorch biedt een startprogramma in het programma voor het starten van.distributed.launch dat u kunt gebruiken om meerdere processen per knooppunt te starten. De torch.distributed.launch module bevat meerdere trainingsprocessen op elk van de knooppunten.

In de volgende stappen wordt gedemonstreerd hoe u een PyTorch-taak configureert met een launcher per knooppunt in Azure ML. De taak bereikt het equivalent van het uitvoeren van de volgende opdracht:

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. Geef de torch.distributed.launch opdracht op voor de parameter van de command ScriptRunConfig constructor. Azure ML deze opdracht uit op elk knooppunt van uw trainingscluster. --nproc_per_node moet kleiner zijn dan of gelijk zijn aan het aantal GPU's dat beschikbaar is op elk knooppunt. MASTER_ADDR, MASTER_PORT en NODE_RANK zijn allemaal ingesteld door Azure ML, zodat u gewoon naar de omgevingsvariabelen in de opdracht kunt verwijzen. Azure ML stelt MASTER_PORT in op , maar u kunt indien nodig een andere waarde doorgeven aan het 6105 argument van de opdracht --master_port distributed.launch. (Met het startprogramma worden de omgevingsvariabelen opnieuw ingesteld.)
  2. Maak een PyTorchConfiguration en geef de node_count op.
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

Training met meerdere GPU's met één knooppunt: Als u het startprogramma gebruikt voor het uitvoeren van PyTorch-training met één knooppunt met meerdere GPU's, hoeft u de distributed_job_config parameter scriptRunConfig niet op te geven.

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

Voorbeeld van PyTorch per knooppunt starten

PyTorch Lightning

PyTorch Lightning is een lichtgewicht opensource-bibliotheek die een interface op hoog niveau biedt voor PyTorch. Bliksem abstraheert veel van de gedistribueerde trainingsconfiguraties op lager niveau die vereist zijn voor vanille PyTorch. Met Lightning kunt u uw trainingsscripts uitvoeren in instellingen voor één GPU, meerdere GPU's met één knooppunt en meerdere knooppunts. Achter de scène worden meerdere processen voor u gelanceerd, vergelijkbaar met torch.distributed.launch .

Voor training met één knooppunt (inclusief meerdere GPU's met één knooppunt) kunt u uw code uitvoeren op Azure ML zonder dat u een hoeft op te distributed_job_config geven. Voor het trainen van meerdere knooppunts in Lightning moeten de volgende omgevingsvariabelen worden ingesteld op elk knooppunt van uw trainingscluster:

  • MASTER_ADDR
  • MASTER_PORT
  • NODE_RANK

Als u een Lightning-training met meerdere knooppunt wilt uitvoeren op Azure ML, kunt u de handleiding voor het starten per knooppunt grotendeels volgen:

  • Definieer PyTorchConfiguration de en geef de node_count op. Geef niet op, omdat Lightning intern het starten van de werkprocessen voor process_count elk knooppunt verwerkt.
  • Voor PyTorch-taken verwerkt Azure ML het instellen van de MASTER_ADDR, MASTER_PORT en NODE_RANK omgevingsvariabelen die vereist zijn voor Lightning.
  • Bliksem verwerkt het berekenen van de wereldgrootte van de Ajax-vlaggen en beheert de --gpus --num_nodes rangschikking en lokale rangschikking intern.
from azureml.core import ScriptRunConfig, Experiment
from azureml.core.runconfig import PyTorchConfiguration

nnodes = 2
args = ['--max_epochs', 50, '--gpus', 2, '--accelerator', 'ddp', '--num_nodes', nnodes]
distr_config = PyTorchConfiguration(node_count=nnodes)

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)

Gezichtsherkenningssytegen

Hugging Face biedt veel voorbeelden voor het gebruik van de Library met om torch.distributed.launch gedistribueerde training uit te voeren. Als u deze voorbeelden en uw eigen aangepaste trainingsscripts wilt uitvoeren met behulp van de Ajax-API, volgt u de sectie Using torch.distributed.launch (Gebruiken).

Voorbeeldtaakconfiguratiecode voor het afstemmen van het grote MODEL VAN DEL op de MNLI-taak voor tekstclassificatie met behulp van het script op één knooppunt met run_glue.py 8 GPU's:

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

U kunt ook de optie per proces starten gebruiken om gedistribueerde training uit te voeren zonder te torch.distributed.launch gebruiken. Eén ding om rekening mee te houden als u deze methode gebruikt, is dat de trainingsargumenten verwachten dat de lokale rangschikking wordt doorgegeven als argument ( --local_rank ). torch.distributed.launchdoet dit wanneer , maar als u per proces-launch gebruikt, moet u de lokale rangschikking expliciet doorgeven als argument voor het trainingsscript, omdat Azure ML alleen de omgevingsvariabele in --use_env=False --local_rank=$LOCAL_RANK LOCAL_RANK stelt.

TensorFlow

Als u native gedistribueerde TensorFlow gebruikt in uw trainingscode, zoals de API van TensorFlow 2.x, kunt u de gedistribueerde taak starten via Azure ML met behulp van tf.distribute.Strategy TensorflowConfiguration de .

Om dit te doen, geeft u TensorflowConfiguration een -object op voor distributed_job_config de parameter van de ScriptRunConfig constructor. Als u gebruikt, geeft tf.distribute.experimental.MultiWorkerMirroredStrategy u de op in de die overeenkomt met het aantal worker_count TensorflowConfiguration knooppunten voor uw trainings job.

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)

Als uw trainingsscript gebruikmaakt van de parameterserverstrategie voor gedistribueerde training, zoals voor verouderde TensorFlow 1.x, moet u ook het aantal parameterservers opgeven dat in de taak moet worden gebruikt, bijvoorbeeld tf_config = TensorflowConfiguration(worker_count=2, parameter_server_count=1) .

TF_CONFIG

In TensorFlow is de TF_CONFIG omgevingsvariabele vereist voor training op meerdere computers. Voor TensorFlow-taken configureert en stelt Azure ML de variabele TF_CONFIG op de juiste wijze in voor elke werker voordat het trainingsscript wordt uitgevoerd.

U hebt toegang TF_CONFIG uw trainingsscript als u het volgende nodig hebt: os.environ['TF_CONFIG'] .

Voorbeeld TF_CONFIG ingesteld op een Chief Worker-knooppunt:

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

TensorFlow-voorbeeld

GPU-training versnellen met InfiniBand

Bepaalde Azure VM-serie, met name de NC-, ND- en H-serie, hebben nu VM's die geschikt zijn voor RDMA met ondersteuning voor SR-IOV en Infiniband. Deze VM's communiceren via het InfiniBand-netwerk met lage latentie en hoge bandbreedte, wat veel beter presteert dan Ethernet-connectiviteit. SR-IOV voor InfiniBand maakt bijna bare-metalprestaties mogelijk voor elke MPI-bibliotheek (MPI wordt gebruikt door veel gedistribueerde trainings frameworks en hulpprogramma's, waaronder NCCL-software van NVIDIA.) Deze SKU's zijn bedoeld om te voldoen aan de behoeften van rekenintensieve, gpu-machine learning workloads. Zie Accelerating Distributed Training in Azure Machine Learning with SR-IOV (Gedistribueerde training versnellen in Azure Machine Learning met SR-IOV) voor meer informatie.

Als u een cluster maakt van een van deze voor RDMA geschikte grootten met InfiniBand-functie, zoals , wordt de installatie installatier van het besturingssysteem met het AmlCompute Mellanox OFED-stuurprogramma dat is vereist om InfiniBand vooraf geïnstalleerd en vooraf geconfigureerd in te Standard_ND40rs_v2 stellen.

Volgende stappen