Pipeline Parallelism

Pipeline Parallelism é uma técnica avançada de distributed training concebida para particionar uma neural network (NN) grande através de múltiplos dispositivos de computação, tais como GPUs, ao separar o modelo de acordo com a sua profundidade. Quando os model weights e os estados do otimizador de uma arquitetura moderna excedem os limites de memória de um único acelerador, os engenheiros dividem as camadas sequenciais da rede em "estágios". Por exemplo, as primeiras 10 camadas podem residir na GPU 0, enquanto as 10 camadas subsequentes residem na GPU 1. Durante o forward pass, os dados fluem de um dispositivo para o próximo. Ao encadear estes dispositivos, os investigadores podem treinar algoritmos de deep learning (DL) massivos sem encontrar out-of-memory errors que limitam o hardware.

Link to this sectionComo funciona a Pipeline Parallelism#

Uma implementação ingénua de divisão de camadas entre dispositivos leva a ineficiências graves conhecidas como "pipeline bubbles". Como as camadas processam sequencialmente, a GPU 1 fica completamente inativa enquanto a GPU 0 processa as camadas iniciais. Para maximizar a utilização do hardware, os agendadores de pipeline modernos dividem o batch size global em "micro-batches" menores.

Em vez de esperar que um lote inteiro termine, a GPU 0 começa imediatamente a processar o segundo micro-batch assim que passa o primeiro micro-batch para a GPU 1. Ferramentas como o Microsoft DeepSpeed e a PyTorch Distributed Pipelining API utilizam habitualmente a 1F1B (One Forward, One Backward) scheduling strategy. Este método alterna o cálculo de passagens forward e backward para diferentes micro-batches simultaneamente, minimizando significativamente as pipeline bubbles e o consumo de memória. Avanços recentes de 2024 e 2025 introduzem até a Zero Bubble Pipeline Parallelism, uma estratégia de previsão de pesos ciente do otimizador que quase elimina o tempo de inatividade entre clusters de computação.

Link to this sectionDiferenciando Técnicas de Paralelismo Relacionadas#

A pipeline parallelism opera dentro de um ecossistema mais amplo de estratégias de computação distribuída. Compreender as diferenças é crítico para escalar modelos de IA de forma eficaz:

• Model Parallelism: Este é o termo geral para dividir um modelo entre dispositivos. A pipeline parallelism é uma forma altamente específica de model parallelism que particiona a arquitetura sequencialmente por profundidade.
• Tensor Parallelism: Ao contrário das divisões de profundidade da pipeline parallelism, a tensor parallelism fragmenta operações de matriz individuais horizontalmente entre GPUs. Estas duas técnicas são frequentemente combinadas para maximizar o rendimento.
• Data Parallelism: A data parallelism replica o modelo inteiro em cada GPU e distribui os dados de treino entre elas. Para arquiteturas compactas e altamente otimizadas de object detection e image segmentation, como o modelo Ultralytics YOLO26, que cabe nativamente na VRAM de um único dispositivo, a data parallelism via PyTorch's DistributedDataParallel (DDP) é o método preferido para acelerar o treino.

Link to this sectionAplicações no mundo real em IA e ML#

Escalar infraestruturas complexas é essencial para construir sistemas de IA modernos de última geração:

• Treino de Modelos de Fundação: Desenvolver Large Language Models (LLMs) e foundation models gigantescos, como o Llama 3 da Meta, requer a combinação de tensor, data e pipeline parallelism. Frameworks como o NVIDIA Megatron-LM aproveitam estas estratégias para treinar arquiteturas massivas de Mixture-of-Experts (MoE) através de milhares de GPUs em plataformas de cloud como o AWS SageMaker.
• Diagnósticos Médicos de Alta Resolução: Em AI in healthcare e modelação científica, os scans volumétricos 3D produzem frequentemente ativações demasiado massivas para um único acelerador. A criação de pipelines de camadas de rede através de nós permite que hospitais de investigação treinem redes profundas em conjuntos de dados de MRI imensos sem comprometer a resolução da imagem.

Link to this sectionExemplo de Código: Conceito de Particionamento de Camadas#

Historicamente, distribuir camadas entre dispositivos requeria código complexo e personalizado. Hoje, a lógica fundamental mapeia camadas específicas para diferentes identificadores de dispositivo. Abaixo encontra-se uma representação conceptual de como os estágios da rede são divididos entre dispositivos no PyTorch, estabelecendo a base para operações de pipeline parallel:

import torch.nn as nn


class SimplePipelineModel(nn.Module):
    def __init__(self):
        super().__init__()
        # Stage 1 is assigned to the first GPU
        self.stage1 = nn.Sequential(nn.Linear(1024, 1024), nn.ReLU()).to("cuda:0")
        # Stage 2 is assigned to the second GPU
        self.stage2 = nn.Sequential(nn.Linear(1024, 1024), nn.ReLU()).to("cuda:1")

    def forward(self, x):
        # The forward pass seamlessly crosses device boundaries
        x_out = self.stage1(x.to("cuda:0"))
        return self.stage2(x_out.to("cuda:1"))

Embora criar modelos de fundação exija uma orquestração complexa, implementar projetos rápidos e escaláveis de computer vision (CV) é geralmente mais simples. Para model deployment simplificado e utilização automatizada de múltiplas GPUs, os programadores confiam na Ultralytics Platform para escalar cargas de trabalho automaticamente. Aproveitando model training tips robustas, a plataforma abstrai a gestão da infraestrutura, permitindo que os engenheiros se concentrem inteiramente na construção de soluções de IA precisas capazes de real-time inference.