Share via

Trainingshandleiding voor gedistribueerde GPU (SDK v2)

  • Artikel

VAN TOEPASSING OP: Python SDK azure-ai-ml v2 (actueel)

Meer informatie over het gebruik van gedistribueerde GPU-trainingscode in Azure Machine Learning. Dit artikel helpt u bij het uitvoeren van uw bestaande gedistribueerde trainingscode en biedt tips en voorbeelden die u kunt volgen voor elk framework:

  • PyTorch
  • TensorFlow
  • GPU-training versnellen met InfiniBand

Vereisten

Bekijk de basisconcepten van gedistribueerde GPU-training, zoals gegevensparallellisme, gedistribueerde gegevensparallellisme en modelparallellisme.

Tip

Als u niet weet welk type parallelle uitvoering moet worden gebruikt, moet u meer dan 90% van de tijd gedistribueerde gegevensparallelisme gebruiken.

PyTorch

Azure Machine Learning biedt ondersteuning voor het uitvoeren van gedistribueerde taken met behulp van de systeemeigen gedistribueerde trainingsmogelijkheden van PyTorch (torch.distributed).

Tip

Voor gegevensparallel is de officiële PyTorch-richtlijnen bedoeld voor het gebruik van DistributedDataParallel (DDP) via DataParallel voor zowel één knooppunt als gedistribueerde training met meerdere knooppunten. PyTorch raadt ook het gebruik van DistributedDataParallel aan via het multiprocessing-pakket. Documentatie en voorbeelden van Azure Machine Learning richten zich daarom op DistributedDataParallel-training.

Initialisatie van procesgroepen

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 torch.distributed.init_process_group aan te roepen in alle gedistribueerde processen om gezamenlijk een procesgroep te vormen.

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

De meest voorkomende communicatieback-ends die worden gebruikt, zijn mpi, ncclen gloo. Voor gpu-training nccl wordt aanbevolen voor de beste prestaties en moet waar mogelijk worden gebruikt.

init_method vertelt hoe elk proces elkaar kan detecteren, hoe ze de procesgroep initialiseren en verifiëren met behulp van de communicatieback-end. Als dit niet is opgegeven, gebruikt PyTorch standaard init_method de initialisatiemethode van de omgevingsvariabele (env://). init_method is de aanbevolen initialisatiemethode voor gebruik in uw trainingscode om gedistribueerde PyTorch uit te voeren op Azure Machine Learning. PyTorch zoekt naar de volgende omgevingsvariabelen voor initialisatie:

  • MASTER_ADDR: IP-adres van de machine die als host fungeert voor het proces met rang 0
  • MASTER_PORT: Een gratis poort op de computer waarop het proces wordt gehost met rang 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) rang van het huidige proces. De mogelijke waarden zijn 0 tot (wereldgrootte - 1)

Zie de PyTorch-documentatie voor meer informatie over initialisatie van procesgroepen.

Veel toepassingen hebben ook de volgende omgevingsvariabelen nodig:

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

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

  1. Geef het trainingsscript en de argumenten op.
  2. Maak een command en geef het type op als PyTorch en de process_count_per_instance parameter.distribution Dit process_count_per_instance komt overeen met het totale aantal processen dat u wilt uitvoeren voor uw taak. process_count_per_instance moet doorgaans gelijk zijn aan # of GPUs per node. Als process_count_per_instance dit niet is opgegeven, start Azure Machine Learning standaard één proces per knooppunt.

Azure Machine Learning stelt de MASTER_ADDRvariabelen , MASTER_PORTen WORLD_SIZENODE_RANK omgevingsvariabelen op elk knooppunt in en stelt de variabelen op procesniveau RANK en LOCAL_RANK omgeving in.

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.2-cuda12.1@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_NC6s_v3", instance_count=2
)  # Serverless compute resources

Voorbeeld van Pytorch

DeepSpeed

Azure Machine Learning biedt ondersteuning voor DeepSpeed als eersteklas burger om gedistribueerde taken uit te voeren met bijna lineaire schaalbaarheid in termen van:

  • Grotere modelgrootte
  • Toename van het aantal GPU's

DeepSpeed kan worden ingeschakeld met behulp van Pytorch-distributie of MPI voor het uitvoeren van gedistribueerde training. Azure Machine Learning ondersteunt het DeepSpeed-startprogramma voor het starten van gedistribueerde training en het automatisch afstemmen om een optimale ds configuratie te krijgen.

U kunt een gecureerde omgeving gebruiken voor een out-of-the-box-omgeving met de nieuwste geavanceerde technologieën, waaronder DeepSpeed, ORT, MSSCCL en Pytorch voor uw DeepSpeed-trainingstaken.

DeepSpeed-voorbeeld

TensorFlow

Als u systeemeigen gedistribueerde TensorFlow gebruikt in uw trainingscode, zoals de API van tf.distribute.Strategy TensorFlow 2.x, kunt u de gedistribueerde taak starten via Azure Machine Learning met behulp van distribution parameters of het TensorFlowDistribution object.

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

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, binnen de distribution parameter van de command. In het bovenstaande, bijvoorbeeld "parameter_server_count" : 1 en "worker_count": 2.

TF_CONFIG

In TensorFlow is de TF_CONFIG omgevingsvariabele vereist voor training op meerdere computers. Voor TensorFlow-taken configureert en stelt Azure Machine Learning de variabele op de TF_CONFIG juiste wijze in voor elke werkrol voordat u uw trainingsscript uitvoert.

U kunt toegang krijgen TF_CONFIG vanuit uw trainingsscript als u het volgende wilt doen: 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"
}'

Voorbeeld van TensorFlow

Gedistribueerde GPU-training versnellen met InfiniBand

Naarmate het aantal VM's voor het trainen van een model toeneemt, neemt de tijd die nodig is om dat model te trainen af. De afname van de tijd moet in het ideale geval lineair evenredig zijn met het aantal trainings-VM's. Als het trainen van een model op één VIRTUELE machine bijvoorbeeld 100 seconden duurt, duurt het trainen van hetzelfde model op twee VM's idealiter 50 seconden. Het trainen van het model op vier VM's duurt 25 seconden, enzovoort.

InfiniBand kan een belangrijke factor zijn bij het bereiken van deze lineaire schaalaanpassing. InfiniBand maakt communicatie met lage latentie, GPU-naar-GPU mogelijk tussen knooppunten in een cluster. Voor InfiniBand is speciale hardware vereist voor gebruik. Bepaalde Azure VM-serie, met name de NC-, ND- en H-serie, hebben nu RDMA-compatibele VM's met SR-IOV- en InfiniBand-ondersteuning. Deze VM's communiceren via het InfiniBand-netwerk met lage latentie en hoge bandbreedte, wat veel beter presteert dan ethernetconnectiviteit. SR-IOV voor InfiniBand maakt bijna bare-metalprestaties mogelijk voor elke MPI-bibliotheek (MPI wordt gebruikt door veel gedistribueerde trainingsframeworks en hulpprogramma's, waaronder NCCL-software van NVIDIA.) Deze SKU's zijn bedoeld om te voldoen aan de behoeften van rekenintensieve, met GPU versnelde machine learning-workloads. Zie Gedistribueerde training versnellen in Azure Machine Learning met SR-IOV voor meer informatie.

Vm-SKU's met een 'r' in hun naam bevatten doorgaans de vereiste InfiniBand-hardware en die zonder 'r' bevatten doorgaans niet. ("r" is een verwijzing naar RDMA, die staat voor externe directe geheugentoegang.) De VM-SKU Standard_NC24rs_v3 is bijvoorbeeld Ingeschakeld voor InfiniBand, maar de SKU Standard_NC24s_v3 niet. Afgezien van de Mogelijkheden van InfiniBand zijn de specificaties tussen deze twee SKU's grotendeels hetzelfde. Beide hebben 24 kernen, 448 GB RAM, 4 GPU's van dezelfde SKU, enzovoort. Meer informatie over RDMA- en InfiniBand-computer-SKU's.

Waarschuwing

De SKU Standard_NC24r van de oudere generatie is RDMA ingeschakeld, maar bevat geen SR-IOV-hardware die is vereist voor InfiniBand.

Als u een AmlCompute cluster maakt van een van deze RDMA-compatibele, infiniBand geschikte grootten, wordt de installatiekopieën van het besturingssysteem geleverd met het Mellanox OFED-stuurprogramma dat is vereist om InfiniBand vooraf geïnstalleerd en vooraf geconfigureerd in te schakelen.

Volgende stappen