Pipeline Parallelism

O paralelismo de pipeline é uma técnica de treinamento distribuído que divide uma rede neural por profundidade em grupos consecutivos de camadas, chamados estágios, coloca cada estágio na sua própria GPU e transmite as ativações de um estágio para o seguinte. Para manter todas as GPUs ocupadas, cada lote é dividido em microlotes menores que percorrem os estágios como peças numa linha de montagem. Também é chamado paralelismo de modelo entre camadas. Investigadores da Google, liderados por Yanping Huang, popularizaram a abordagem com microlotes através do GPipe em novembro de 2018, treinando uma AmoebaNet com 557 milhões de parâmetros até atingir 84,4% de precisão top-1 no ImageNet e um transformer multilíngue de tradução com 6 mil milhões de parâmetros e 128 camadas.

Microlotes e a bolha do pipeline#

Com um lote de cada vez, apenas um estágio trabalha enquanto os outros esperam: o estágio 2 não pode começar até o estágio 1 terminar e, durante a retropropagação, a ordem se inverte. Os microlotes permitem que o estágio 1 comece o segundo microlote assim que entrega o primeiro ao estágio 2. Os intervalos ociosos que restam enquanto o pipeline se enche e se esvazia são chamados de bolha. A impressão de uma agenda de propagação para a frente no estilo GPipe, com 4 estágios e 6 microlotes, mostra o seu formato:

stages, micro_batches = 4, 6
steps = micro_batches + stages - 1  # time steps until the last micro-batch leaves the last stage

for stage in range(stages):
    row = ""
    for t in range(steps):
        m = t - stage  # stage s starts micro-batch m once stage s-1 hands it over
        row += f" F{m}" if 0 <= m < micro_batches else "  ."
    print(f"GPU {stage}:{row}")

# Every stage idles for stages - 1 of the steps, in the forward and again in the backward pass
bubble = (stages - 1) / steps
print(f"Idle fraction: {bubble:.0%}")

O resultado é uma escada: a GPU 0 executa passagens de propagação para a frente de F0 a F5 nos primeiros seis dos nove passos e depois espera; a GPU 3 espera três passos antes de começar F0, e a última linha mostra Idle fraction: 33%. A fração da bolha é (estágios − 1) / (microlotes + estágios − 1); assim, 24 microlotes nos mesmos 4 estágios reduzem-na a 11%. Os gradientes de todos os microlotes são somados antes de uma única etapa do otimizador, a mesma operação aritmética da acumulação de gradientes, pelo que a atualização corresponde ao treinamento com o lote completo. O GPipe também descarta as ativações dentro de cada estágio e volta a calculá-las durante a passagem para trás, uma forma de checkpointing de gradientes.

Agendas de pipeline#

Agendas posteriores reordenam o mesmo trabalho para poupar memória ou reduzir a bolha:

• 1F1B: Introduzido pelo sistema PipeDream em 2018, alterna um microlote de propagação para a frente e um de propagação para trás por estágio assim que o pipeline está cheio. Cada estágio mantém então as ativações de, no máximo, tantos microlotes quantos os estágios, em vez de os manter todos.
• 1F1B intercalado: Atribui a cada GPU vários estágios menores e não adjacentes. A equipa Megatron-LM da NVIDIA relatou um aumento de rendimento superior a 10% com este método e treinou um modelo de 1 bilião de parâmetros a 502 petaFLOP/s em 3.072 GPUs, ou 52% do pico.
• Bolha zero: Divide a passagem para trás em gradiente da entrada do estágio, aguardado pelo estágio anterior, e gradiente dos pesos, que pode preencher intervalos ociosos mais tarde. Supera o rendimento do 1F1B em até 23% com um orçamento de memória semelhante.

O PyTorch disponibiliza estas opções como ScheduleGPipe, Schedule1F1B, ScheduleInterleaved1F1B, ScheduleInterleavedZeroBubble e ScheduleDualPipeV na sua API de pipeline, que também divide um modelo em estágios. O DualPipe vem do DeepSeek-V3, cuja equipa executou 16 estágios de pipeline e usou o método para sobrepor computação e comunicação e reduzir a bolha.

Onde se enquadra o paralelismo de pipeline#

Os estágios trocam apenas as ativações nos seus limites, uma vez por microlote; por isso, o paralelismo de pipeline tolera melhor ligações mais lentas entre servidores do que o paralelismo de tensores, que comunica dentro de cada camada. Por isso, as grandes execuções de treinamento combinam ambos. A Meta treinou o Llama 3 405B com paralelismo de tensores em 8 vias dentro de cada servidor com 8 GPUs, 16 estágios de pipeline entre servidores e paralelismo de dados em 64 a 128 réplicas; mecanismos de inferência como o vLLM usam a mesma divisão quando um modelo de linguagem grande (LLM) precisa de mais de um nó. O estágio mais lento determina o ritmo de todo o pipeline, e os estágios inicial e final de um modelo de linguagem também contêm a tabela de embeddings e a camada de saída; por isso, o Llama 3 atribuiu a cada um deles uma camada transformer a menos.

As abordagens relacionadas dividem o trabalho de outras formas:

• Paralelismo de tensores: Divide as matrizes de pesos dentro de cada camada, para que todas as GPUs participem em todas as camadas.
• Paralelismo de contexto: Divide uma sequência de entrada longa entre GPUs.
• Aprendizado dividido: Também divide uma rede por profundidade, mas entre organizações, para que o proprietário dos dados nunca envie dados brutos ao servidor que executa as camadas posteriores.

O paralelismo de dados mantém cada camada em todas as GPUs e, em vez disso, divide o lote, o que é tudo de que um modelo precisa quando cabe num único dispositivo. É assim que o Ultralytics YOLO26 treina em várias GPUs: com device=[0, 1, 2, 3] e batch=64 no modo de treinamento, cada GPU executa o modelo completo de deteção de objetos em 16 imagens, e o PyTorch DistributedDataParallel calcula a média dos gradientes entre GPUs após cada passagem para trás.