As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Treinamento distribuído na Amazon SageMaker

SageMaker fornece bibliotecas de treinamento distribuídas e oferece suporte a várias opções de treinamento distribuído para tarefas de aprendizado profundo, como visão computacional (CV) e processamento de linguagem natural (NLP). Com as bibliotecas SageMaker de treinamento distribuídas, você pode executar paralelamente dados personalizados altamente escaláveis e econômicos e modelar trabalhos paralelos de treinamento de aprendizado profundo. Você também pode usar outras estruturas e pacotes de treinamento distribuídos, como PyTorch DistributedDataParallel (DDP),torchrun, MPI (mpirun) e servidor de parâmetros. Em toda a documentação, as instruções e os exemplos se concentram em como configurar as opções de treinamento distribuído para tarefas de aprendizado profundo usando o SageMaker PythonSDK.

Antes de começar

SageMaker O treinamento oferece suporte ao treinamento distribuído em uma única instância e em várias instâncias, para que você possa executar treinamentos de qualquer tamanho em grande escala. Recomendamos que você use as classes do estimador de estrutura, como PyTorche TensorFlowno SageMaker PythonSDK, que são os inicializadores de trabalhos de treinamento com várias opções de treinamento distribuídas. Quando você cria um objeto estimador, o objeto configura a infraestrutura de treinamento distribuída, a executa CreateTrainingJob API no back-end, encontra a região em que sua sessão atual está sendo executada e extrai um dos contêineres de aprendizado AWS profundo pré-criados, pré-empacotados com várias bibliotecas, incluindo estruturas de aprendizado profundo, estruturas de treinamento distribuídas e o driver. EFA Se você quiser montar um sistema de FSx arquivos nas instâncias de treinamento, precisará passar o ID da VPC sub-rede e do grupo de segurança para o estimador. Antes de executar seu trabalho de treinamento distribuído no SageMaker, leia as orientações gerais a seguir sobre a configuração básica da infraestrutura.

Zonas de disponibilidade e backplane de rede

Ao usar várias instâncias (também chamadas de nós), é importante entender a rede que conecta as instâncias, como elas lêem os dados de treinamento e como compartilham informações entre si. Por exemplo, quando você executa um trabalho de treinamento paralelo de dados distribuídos, vários fatores, como a comunicação entre os nós de um cluster computacional para executar a AllReduce operação e a transferência de dados entre os nós e o armazenamento de dados no Amazon Simple Storage Service ou no Amazon for Lustre, desempenham um papel crucial FSx para obter um uso ideal dos recursos computacionais e uma velocidade de treinamento mais rápida. Para reduzir a sobrecarga de comunicação, certifique-se de configurar instâncias, VPC sub-rede e armazenamento de dados na mesma Região da AWS zona de disponibilidade.

GPUinstâncias com rede mais rápida e armazenamento de alto rendimento

Tecnicamente, você pode usar qualquer instância para treinamento distribuído. Para casos em que você precisa executar trabalhos de treinamento distribuído de vários nós para treinar modelos grandes, como modelos de linguagem grandes (LLMs) e modelos de difusão, que exigem uma comutação mais rápida entre nós, recomendamos EFA instâncias habilitadas com suporte de. GPU SageMaker Especialmente, para obter o trabalho de treinamento distribuído com o melhor desempenho SageMaker, recomendamos instâncias P4d e P4de equipadas com A100. NVIDIA GPUs Essas instâncias também estão equipadas com armazenamento local de alto throughput e baixa latência, além de uma rede intra-nó mais rápida. Para armazenamento de dados, recomendamos o Amazon FSx for Lustre, que fornece alto rendimento para armazenar conjuntos de dados de treinamento e pontos de verificação de modelos.

Comece com o treinamento distribuído na Amazon SageMaker

Se você já estiver familiarizado com o treinamento distribuído, escolha uma das opções a seguir que corresponda à sua estratégia ou framework preferido para começar. Se quiser aprender sobre treinamento distribuído em geral, consulte Conceitos básicos de treinamento distribuído.

As bibliotecas de treinamento SageMaker distribuídas são otimizadas para o ambiente de SageMaker treinamento, ajudam a adaptar seus trabalhos de treinamento distribuídos e melhoram a velocidade e a produtividade do treinamento. SageMaker As bibliotecas oferecem estratégias de treinamento tanto para paralelismo de dados quanto para paralelismo de modelos. Eles combinam tecnologias de software e hardware para melhorar as comunicações entre nós GPU e entre nós e ampliam os recursos SageMaker de treinamento com opções integradas que exigem o mínimo de alterações de código em seus scripts de treinamento. 

Use a biblioteca de paralelismo de dados SageMaker distribuídos () SMDDP

A SMDDP biblioteca melhora a comunicação entre os nós com implementações AllReduce e operações de comunicação AllGather coletiva que são otimizadas para a infraestrutura de AWS rede e a topologia de instâncias do Amazon SageMaker ML. Você pode usar a SMDDPbiblioteca como back-end de pacotes de treinamento distribuídos PyTorch baseados: PyTorch distributed data parallel (DDP), full PyTorch sharded data paralelism (FSDP) e Megatron-. DeepSpeedDeepSpeed O exemplo de código a seguir mostra como definir um PyTorch estimador para iniciar um trabalho de treinamento distribuído em duas ml.p4d.24xlarge instâncias.

from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

Para saber como preparar seu script de treinamento e iniciar um trabalho de treinamento paralelo de dados distribuídos em SageMaker, consulte. Execute treinamento distribuído com a biblioteca de SageMaker paralelismo de dados distribuídos

Use a biblioteca de paralelismo de SageMaker modelos () SMP

SageMaker fornece a SMP biblioteca e oferece suporte a várias técnicas de treinamento distribuído, como paralelismo de dados fragmentados, pipelining, paralelismo de tensores, fragmentação de estado do otimizador e muito mais. Para saber mais sobre o que a SMP biblioteca oferece, consultePrincipais características da biblioteca de SageMaker paralelismo de modelos.

Para usar a biblioteca SageMaker de paralelismo de modelos, configure o distribution parâmetro dos estimadores da SageMaker estrutura. Os estimadores de estrutura suportados são e. PyTorchTensorFlow O exemplo de código a seguir mostra como estruturar um estimador de framework para treinamento distribuído com a biblioteca de paralelismo de dados em duas instâncias ml.p4d.24xlarge.

from sagemaker.framework import Framework

distribution={
    "smdistributed": {
        "modelparallel": {
            "enabled":True,
            "parameters": {
                ...   # enter parameter key-value pairs here
            }
        },
    },
    "mpi": {
        "enabled" : True,
        ...           # enter parameter key-value pairs here
    }
}

estimator = Framework(
    ...,
    instance_count=2,
    instance_type="ml.p4d.24xlarge",
    distribution=distribution
)

Para saber como adaptar seu script de treinamento, configurar parâmetros de distribuição na estimator classe e iniciar um trabalho de treinamento distribuído, consulte a biblioteca de paralelismo de modelos SageMaker da (consulte também Treinamento distribuído na documentação APIs do PythonSageMaker ). SDK

Use frameworks de treinamento distribuído de código aberto

SageMaker também oferece suporte às seguintes opções de operação mpirun e torchrun no back-end.

Conceitos básicos de treinamento distribuído

SageMakerAs bibliotecas de treinamento distribuído da usam os seguintes termos e recursos de treinamento distribuído.

Conjuntos de dados e lotes

Treinamento

Instâncias e GPUs

Soluções de treinamento distribuído

Conceitos avançados

Os profissionais de Machine Learning (ML) geralmente enfrentam dois desafios de escalabilidade ao treinar modelos: escalar o tamanho do modelo e escalar os dados de treinamento. Embora o tamanho e a complexidade do modelo possam resultar em melhor precisão, há um limite para o tamanho do modelo que você pode encaixar em um único CPU ouGPU. Além disso, a escalabilidade do tamanho do modelo pode resultar em mais cálculos e períodos de treinamento mais longos.

Nem todos os modelos lidam igualmente bem com a escalabilidade dos dados de treinamento, pois precisam carregar todos os dados de treinamento na memória para o treinamento. Eles apenas escalonam verticalmente, ou seja, para instâncias maiores e maiores. Na maioria dos casos, a escalabilidade dos dados de treinamento resulta em períodos de treinamento mais longos.

O aprendizado profundo (Deep Learning, DL) é uma família específica de algoritmos de machine learning que consiste em várias camadas de redes neurais artificiais. O método de treinamento mais comum é com o Stochastic Gradient Descent () em minilote. SGD No mini-loteSGD, o modelo é treinado conduzindo pequenas mudanças iterativas de seus coeficientes na direção que reduz seu erro. Essas iterações são conduzidas em subamostras de tamanhos iguais do conjunto de dados de treinamento, chamadas de minilotes. Para cada minilote, o modelo é executado em cada registro do minilote, seu erro medido e o gradiente do erro estimado. Em seguida, o gradiente médio é calculado para todas as amostras do minilote e fornece uma direção de atualização para cada coeficiente do modelo. Uma passagem completa pelo conjunto de dados de treinamento é chamada de época. Treinamentos de modelos geralmente consistem em dezenas a centenas de épocas. O mini-lote SGD tem vários benefícios: primeiro, seu design iterativo torna o tempo de treinamento teoricamente linear em relação ao tamanho do conjunto de dados. Segundo, em um determinado minilote, cada registro é processado individualmente pelo modelo sem a necessidade de comunicação entre registros, exceto pela média final do gradiente. Consequentemente, o processamento de um minilote é particularmente adequado para paralelização e distribuição. 

A paralelização do SGD treinamento distribuindo os registros de um mini-lote em diferentes dispositivos de computação é chamada de treinamento distribuído paralelo de dados e é o paradigma de distribuição de DL mais comumente usado. O treinamento de paralelismo de dados é uma estratégia de distribuição relevante para dimensionar o tamanho do minilote e processar cada minilote mais rapidamente. No entanto, o treinamento de paralelismo de dados vem com a complexidade adicional de ter que calcular a média do gradiente do minilote com gradientes provenientes de todos os operadores e comunicá-la para todos os operadores, uma etapa chamada allreduce, que pode representar uma sobrecarga crescente à medida que o cluster de treinamento é escalado, e que também pode penalizar drasticamente o tempo de treinamento se implementado de forma inadequada ou em hardware inadequado. 

O data parallel SGD ainda exige que os desenvolvedores sejam capazes de ajustar pelo menos o modelo e um único registro em um dispositivo de computação, como um único CPU ouGPU. Ao treinar modelos muito grandes, como grandes transformadores em Processamento de Linguagem Natural (NLP) ou modelos de segmentação em imagens de alta resolução, pode haver situações em que isso não seja viável. Uma forma alternativa de dividir o workload é particionar o modelo em vários dispositivos de computação, uma abordagem chamada treinamento distribuído de paralelismo de modelos.

Estratégias

O treinamento distribuído geralmente é dividido em duas abordagens: paralelismo de dados e paralelismo de modelos. O data parallel é a abordagem mais comum para o treinamento distribuído: você tem muitos dados, agrupa-os e envia blocos de dados para vários CPUs ou GPUs (nós) para serem processados pela rede neural ou pelo algoritmo de ML e, em seguida, combina os resultados. A rede neural é a mesma em cada nó. Uma abordagem de paralelismo de modelos é utilizado com modelos grandes que não cabem na memória de um nó de uma vez; ele quebra o modelo e coloca diferentes partes em diferentes nós. Nessa situação, você precisa enviar seus lotes de dados para cada nó para que os dados sejam processados em todas as partes do modelo.

Os termos rede e modelo costumam ser usados de forma intercambiável: um modelo grande é, na verdade, uma rede grande com muitas camadas e parâmetros. Treinar com uma rede grande produz um modelo extenso, e carregar o modelo de volta para a rede com todos os seus parâmetros pré-treinados e seus pesos implica carregar um modelo grande na memória. Quando você divide um modelo para distribuí-lo entre os nós, você também está fragmentando a rede subjacente. Uma rede consiste em camadas, e para dividir a rede, você coloca camadas em diferentes dispositivos de computação.

Uma armadilha comum de dividir camadas ingenuamente entre dispositivos é a subutilização severa. GPU O treinamento é inerentemente sequencial nos passes para frente e para trás e, em um determinado momento, apenas um GPU pode computar ativamente, enquanto os outros aguardam o envio das ativações. As bibliotecas modernas de paralelismo de modelos resolvem esse problema utilizando cronogramas de execução em pipeline para melhorar a utilização de dispositivos. No entanto, somente a biblioteca paralela SageMaker de modelos distribuídos da Amazon inclui a divisão automática de modelos. Os dois atributos principais da biblioteca, divisão automática de modelos e programação de execução em pipeline, simplificam o processo de implementação do paralelismo de modelos ao tomar decisões automatizadas que resultam em uma utilização eficiente de dispositivos.

Treine com paralelismo de dados e de modelos

Se você está treinando com um conjunto de dados grande, comece com uma abordagem de paralelismo de dados. Se você ficar sem memória durante o treinamento, pode ser interessante alternar para uma abordagem de paralelismo de modelos ou tentar uma combinação de paralelismo de modelos e de dados. Você também pode tentar o seguinte para melhorar o desempenho com paralelismo de dados:

Experimente a compressão de gradiente (FP16,INT8):

Tente reduzir o tamanho da entrada:

Verifique se você usa a normalização em lote, pois isso pode afetar a convergência. Quando você usa treinamento distribuído, seu lote é dividido GPUs e o efeito de um tamanho de lote muito menor pode ser uma taxa de erro maior, impedindo a convergência do modelo. Por exemplo, se você prototipou sua rede em uma única GPU com um tamanho de lote de 64 e depois escalou para usar quatro p3dn.24xlarge, agora você tem 32 GPUs e o tamanho por lote cai de 64 para 2. GPU Isso provavelmente comprometerá a convergência que você observou com um único nó.

Comece com o treinamento de paralelismo de modelos quando:

Para saber mais sobre as bibliotecas SageMaker distribuídas, consulte o seguinte:

Otimizar o treinamento distribuído

Personalizar hiperparâmetros para seu caso de uso e seus dados para obter a melhor eficiência de escalabilidade. Na discussão a seguir, destacamos algumas das variáveis de treinamento mais impactantes e fornecemos referências às state-of-the-art implementações para que você possa aprender mais sobre suas opções. Além disso, recomendamos que você consulte a documentação de treinamento distribuído do seu framework preferido.

Tamanho do lote

SageMaker kits de ferramentas distribuídos geralmente permitem que você treine em lotes maiores. Por exemplo, se um modelo cabe em um único dispositivo, mas só pode ser treinado com um lote pequeno, o uso do treinamento de paralelismo do modelos ou do treinamento de paralelismo de dados permite que você experimente lotes maiores.

Esteja ciente de que o tamanho do lote influencia diretamente na precisão do modelo, controlando a quantidade de ruído na atualização do modelo a cada iteração. O aumento do tamanho do lote reduz a quantidade de ruído na estimativa do gradiente, o que pode ser benéfico ao aumentar de tamanhos de lote muito pequenos, mas pode resultar em uma precisão de modelo degradada à medida que o tamanho do lote aumenta para valores grandes. 

Uma série de técnicas foram desenvolvidas para manter uma boa convergência do modelo quando o tamanho do lote é aumentado.

Tamanho do minilote

EmSGD, o tamanho do minilote quantifica a quantidade de ruído presente na estimativa do gradiente. Um minilote pequeno resulta em um gradiente de minilote muito ruidoso, que não é representativo do verdadeiro gradiente sobre o conjunto de dados. Um minilote grande resulta em um gradiente de minilote próximo ao gradiente verdadeiro sobre o conjunto de dados e potencialmente não barulhento o suficiente, provavelmente permanecerá preso em mínimos irrelevantes.

Para saber mais sobre essas técnicas, consulte os seguintes documentos:

Cenários

As seções a seguir abordam cenários nos quais você pode querer ampliar o treinamento e como fazer isso usando AWS recursos.

Escalando de um GPU para vários GPUs

A quantidade de dados ou o tamanho do modelo usado em machine learning pode criar situações em que o tempo para treinar um modelo é mais longo do que você está disposto a esperar. Às vezes, o treinamento simplesmente não funciona porque o modelo ou os dados de treinamento são muito grandes. Uma solução é aumentar o número de pessoas GPUs que você usa para treinamento. Em uma instância com váriosGPUs, como uma p3.16xlarge que tem oitoGPUs, os dados e o processamento são divididos entre os oitoGPUs. Quando você utiliza bibliotecas de treinamento distribuído, isso pode resultar em um aumento quase linear na velocidade com que o modelo é treinado. Demora um pouco mais de 1/8 do tempo que levaria p3.2xlarge com umGPU.

Escalabilidade de uma única instância para várias instâncias

Se quiser escalar ainda mais seu treinamento, você pode usar mais instâncias. No entanto, você deve escolher um tipo de instância maior antes de adicionar mais instâncias. Analise a tabela anterior para ver quantas GPUs estão em cada tipo de instância p3.

Se você passou de um em um p3.2xlarge para quatro GPU GPUs em ump3.8xlarge, mas decide que precisa de mais poder de processamento, você pode ver um melhor desempenho e ter custos mais baixos se escolher um p3.16xlarge antes de tentar aumentar o número de instâncias. Dependendo das bibliotecas que você utiliza, manter seu treinamento em uma única instância pode oferecer melhor desempenho e custos mais baixos do que um cenário em que você utiliza várias instâncias.

Quando estiver pronto para escalar o número de instâncias, você pode fazer isso com a SDK estimator função SageMaker Python definindo seu. instance_count Por exemplo, você pode criar instance_type = p3.16xlarge e instance_count = 2. Em vez de oito GPUs em uma únicap3.16xlarge, você tem 16 GPUs em duas instâncias idênticas. O gráfico a seguir mostra a escalabilidade e a taxa de transferência começando com oito GPUs em uma única instância e aumentando para 64 instâncias, totalizando 256. GPUs

Scripts de treinamento personalizados

Embora SageMaker simplifique a implantação e a escalabilidade do número de instâncias eGPUs, dependendo da estrutura de sua escolha, o gerenciamento dos dados e dos resultados pode ser muito desafiador, e é por isso que bibliotecas externas de suporte são frequentemente usadas. Essa forma mais básica de treinamento distribuído exige a modificação do seu script de treinamento para gerenciar a distribuição de dados.

SageMaker também oferece suporte ao Horovod e às implementações de treinamento distribuído nativo de cada estrutura principal de aprendizado profundo. Se você optar por usar exemplos dessas estruturas, poderá seguir SageMaker o guia de contêineres para Deep Learning Containers e vários exemplos de cadernos que demonstram implementações.