Pipeline Parallelism

Pipeline Parallelism é uma técnica avançada de distributed training projetada para particionar uma neural network (NN) de grande porte em vários dispositivos de computação, como GPUs, separando o modelo em 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 seguinte. Ao encadear esses dispositivos, os pesquisadores podem treinar algoritmos massivos de deep learning (DL) sem encontrar out-of-memory errors que limitam o hardware.

Como funciona a Pipeline Parallelism#

Uma implementação simples de divisão de camadas entre dispositivos leva a sérias ineficiências conhecidas como "bolhas de pipeline". Como as camadas são processadas sequencialmente, a GPU 1 fica totalmente ociosa 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-lotes" menores.

Em vez de esperar que um lote inteiro termine, a GPU 0 começa imediatamente a processar o segundo micro-lote assim que passa o primeiro micro-lote para a GPU 1. Ferramentas como o Microsoft DeepSpeed e a PyTorch Distributed Pipelining API usam comumente a 1F1B (One Forward, One Backward) scheduling strategy. Esse método alterna o cálculo de passes para a frente e para trás para diferentes micro-lotes simultaneamente, minimizando significativamente as bolhas de pipeline e o consumo de memória. Os recentes avanços de 2024 e 2025 introduzem até mesmo o Zero Bubble Pipeline Parallelism, uma estratégia de previsão de pesos ciente do otimizador que elimina quase totalmente o tempo ocioso em clusters de computação.

Diferenciando 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 em profundidade do paralelismo de pipeline, o paralelismo de tensores fragmenta operações individuais de matriz horizontalmente entre GPUs. Essas duas técnicas são frequentemente combinadas para maximizar a taxa de transferência.
• Data Parallelism: O paralelismo de dados replica o modelo inteiro em cada GPU e distribui os dados de treinamento 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, o paralelismo de dados via DistributedDataParallel (DDP) do PyTorch é o método preferido para acelerar o treinamento.

Aplicações no mundo real em IA e ML#

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

• Training Foundation Models: Desenvolver Large Language Models (LLMs) gigantescos e foundation models como o Llama 3 da Meta exige combinar paralelismo de tensores, de dados e de pipeline. Frameworks como o NVIDIA Megatron-LM aproveitam essas estratégias para treinar arquiteturas massivas de Mixture-of-Experts (MoE) em milhares de GPUs em plataformas de nuvem como o AWS SageMaker.
• High-Resolution Medical Diagnostics: Em AI in healthcare e modelagem científica, exames volumétricos 3D geralmente produzem ativações grandes demais para um único acelerador. O uso de pipelines em camadas de rede entre nós permite que hospitais de pesquisa treinem redes profundas em vastos conjuntos de dados de MRI sem comprometer a resolução da imagem.

Exemplo de Código: Conceito de Particionamento de Camadas#

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

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 a criação de modelos fundamentais exija orquestração complexa, implantar projetos rápidos e escaláveis de computer vision (CV) é geralmente mais simples. Para uma model deployment simplificada e utilização automatizada de múltiplas GPUs, os desenvolvedores confiam na Ultralytics Platform para dimensionar cargas de trabalho automaticamente. Aproveitando dicas robustas de model training tips, a plataforma abstrai o gerenciamento de infraestrutura, permitindo que os engenheiros se concentrem inteiramente na criação de soluções de IA precisas capazes de real-time inference.