Guia de treinamento de GPU distribuída (SDK v2)

APLICA-SE A: Python SDK azure-ai-ml v2 (atual)

Saiba mais sobre como usar o código de treinamento de GPU distribuída no Aprendizado de Máquina do Azure. Este artigo ajuda você a executar seu código de treinamento distribuído existente e oferece dicas e exemplos a serem seguidos para cada estrutura:

• PyTorch
• TensorFlow
• Acelere o treinamento de GPU com a InfiniBand

Pré-requisitos

Analise os conceitos básicos do treinamento de GPU distribuída, como paralelismo de dados, paralelismo de dados distribuídos e paralelismo de modelo.

PyTorch

O Azure Machine Learning suporta a execução de trabalhos distribuídos utilizando as capacidades nativas de treino distribuído do PyTorch (torch.distributed).

Inicialização do grupo de processos

A espinha dorsal de qualquer treino distribuído é um conjunto de processos que se conhecem e podem comunicar entre si através de um backend. Para o PyTorch, cria-se o grupo de processos chamando torch.distributed.init_process_groupem todos os processos distribuídos para formar coletivamente um grupo de processos.

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

Os backends de comunicação mais comuns são mpi, nccl, e gloo. Para treino baseado em GPU, use nccl para obter o melhor desempenho.

O init_method parâmetro especifica como cada processo descobre os outros processos e como inicializam e verificam o grupo de processos através do backend de comunicação. Por defeito, se não especificares init_method, o PyTorch usa o método de inicialização da variável de ambiente (env://). Use init_method no seu código de treino para executar o PyTorch distribuído no Azure Machine Learning. O PyTorch procura as seguintes variáveis de ambiente para inicialização:

• MASTER_ADDR: Endereço IP da máquina que hospeda o processo com classificação 0
• MASTER_PORT: Uma porta livre na máquina que hospeda o processo com classificação 0
• WORLD_SIZE: O número total de processos. Deve ser igual ao número total de dispositivos (GPU) usados para treinamento distribuído
• RANK: A classificação (global) do processo atual. Os valores possíveis são 0 a (tamanho do mundo - 1)

Para obter mais informações sobre a inicialização do grupo de processos, consulte a documentação do PyTorch.

Muitos aplicativos também precisam das seguintes variáveis de ambiente:

• LOCAL_RANK: A classificação local (relativa) do processo dentro do nó. Os valores possíveis são 0 a (# de processos no nó - 1). Esta informação é útil porque muitas operações, como a preparação de dados, só precisam de ser realizadas uma vez por nó, geralmente em local_rank = 0.
• NODE_RANK: A classificação do nó para treinamento de vários nós. Os valores possíveis são 0 a (total # de nós - 1).

Você não precisa usar um utilitário lançador como torch.distributed.launcho . Para executar um trabalho distribuído do PyTorch:

1. Especifique o script de treinamento e os argumentos.
2. Crie um command e especifique o tipo como PyTorch e o process_count_per_instance no distribution parâmetro. O process_count_per_instance corresponde ao número total de processos que você deseja executar para o seu trabalho. process_count_per_instance deve normalmente ser igual a # of GPUs per node. Se não especificar process_count_per_instance, Azure Machine Learning lança por defeito um processo por nó.

O Azure Machine Learning define as variáveis de ambiente MASTER_ADDR, MASTER_PORT, WORLD_SIZE e NODE_RANK em cada nó. Define as variáveis ao nível RANK do processo e LOCAL_RANK do ambiente.

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

Exemplo de PyTorch

• Para obter o bloco de anotações completo para executar o exemplo do PyTorch, consulte azureml-examples: Distributed training with PyTorch on CIFAR-10.

DeepSpeed

O Azure Machine Learning suporta o DeepSpeed como um cidadão de primeira classe para executar trabalhos distribuídos com escalabilidade quase linear em termos de:

• Aumento do tamanho do modelo
• Aumento no número de GPUs

Pode ativar o DeepSpeed usando a distribuição PyTorch ou o MPI para realizar treino distribuído. O Azure Machine Learning suporta o iniciador DeepSpeed para iniciar formação distribuída, bem como o ajuste automático para obter a configuração ideal ds .

Você pode usar um ambiente com curadoria para um ambiente pronto para uso com as mais recentes tecnologias de ponta, incluindo DeepSpeed, ORT, MSSCCL e PyTorch para seus trabalhos de treinamento DeepSpeed.

Exemplo de DeepSpeed

• Para obter exemplos de treinamento e ajuste automático do DeepSpeed, consulte estas pastas.

TensorFlow

Se usar TensorFlow distribuído nativo no seu código de treinamento, como a API tf.distribute.Strategy do TensorFlow 2.x, pode lançar o trabalho distribuído via Azure Machine Learning usando distribution parâmetros ou o TensorFlowDistribution objeto.

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

Se o script de treinamento usa a estratégia de servidor de parâmetros para treinamento distribuído, como para o TensorFlow 1.x herdado, você também precisa especificar o número de servidores de parâmetros a serem usados no trabalho, dentro do distributioncommandparâmetro do . No exemplo anterior, especifica "parameter_server_count" : 1 e "worker_count": 2.

TF_CONFIG

No TensorFlow, precisas da TF_CONFIG variável ambiente para treinar em várias máquinas. Para trabalhos TensorFlow, o Azure Machine Learning define corretamente a TF_CONFIG variável para cada trabalhador antes de executar o seu script de treino.

Você pode acessar TF_CONFIG a partir do seu script de treinamento se precisar: os.environ['TF_CONFIG'].

Exemplo TF_CONFIG definido em um nó de trabalhador principal:

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

Exemplo do TensorFlow

• Para obter o bloco de anotações completo para executar o exemplo do TensorFlow, consulte azureml-examples: Train a basic neural network with distributed MPI on the MNIST dataset using TensorFlow with Horovod.

Acelerando o treinamento distribuído de GPU com o InfiniBand

À medida que aumentas o número de VMs a treinar um modelo, o tempo necessário para treinar esse modelo deverá diminuir. A diminuição do tempo deve ser linearmente proporcional ao número de VMs de treino. Por exemplo, se treinar um modelo numa VM demora 100 segundos, então treinar o mesmo modelo em duas VMs deve demorar 50 segundos. O treinamento do modelo em quatro VMs deve levar 25 segundos, e assim por diante.

O InfiniBand pode ajudá-lo a alcançar esta escala linear. A InfiniBand permite a comunicação GPU-a-GPU de baixa latência entre nós em um cluster. InfiniBand requer hardware especializado para operar. Algumas séries de VMs do Azure, especificamente as séries NC, ND e H, agora têm VMs compatíveis com RDMA com suporte a SR-IOV e InfiniBand. Essas VMs se comunicam pela rede InfiniBand de baixa latência e alta largura de banda, que é muito mais eficiente do que a conectividade baseada em Ethernet. O SR-IOV para InfiniBand permite um desempenho quase bare-metal para qualquer biblioteca MPI (o MPI é usado por muitas estruturas de treinamento distribuídas e ferramentas, incluindo o software NCCL da NVIDIA.) Esses SKUs destinam-se a atender às necessidades de cargas de trabalho de aprendizado de máquina aceleradas por GPU e com uso intensivo de computação. Para obter mais informações, consulte Acelerando o treinamento distribuído no Azure Machine Learning com SR-IOV.

Normalmente, as SKUs de VM com "r" no nome contêm o hardware InfiniBand necessário, e aquelas sem "r" normalmente não têm. ("r" é uma referência a RDMA, que significa acesso direto remoto à memória.) Por exemplo, o SKU Standard_NC24rs_v3 da VM é compatível com InfiniBand, mas o SKU Standard_NC24s_v3 não está. Além dos recursos da InfiniBand, as especificações entre esses dois SKUs são basicamente as mesmas. Ambos têm 24 núcleos, 448 GB de RAM, 4 GPUs do mesmo SKU, e assim sucessivamente. Saiba mais sobre SKUs de máquinas habilitadas para RDMA e InfiniBand.

Se você criar um AmlCompute cluster de um desses tamanhos habilitados para RDMA e habilitados para InfiniBand, a imagem do sistema operacional será fornecida com o driver Mellanox OFED necessário para habilitar o InfiniBand pré-instalado e pré-configurado.

Próximos passos

• Implantar e pontuar um modelo de aprendizado de máquina usando um ponto de extremidade online
• Arquitetura de referência para treinamento distribuído de aprendizado profundo no Azure
• Solução de problemas de ambiente