Pipeline Parallelism for Deep Learning is the distributed training strategy that partitions a neural network's layers across multiple GPUs in a sequential pipeline — with each GPU processing a different micro-batch simultaneously at different pipeline stages, achieving near-linear throughput scaling for models too large to fit on a single GPU while managing the pipeline bubble overhead that is the fundamental efficiency challenge of this approach.

Why Pipeline Parallelism

When a model's memory exceeds a single GPU's capacity (common for LLMs with >10B parameters), the model must be split. Tensor parallelism splits individual layers (requiring high-bandwidth communication within each forward/backward step). Pipeline parallelism splits groups of layers across GPUs, with communication only at the partition boundaries — lower bandwidth requirements, enabling inter-node scaling over slower interconnects.

Basic Pipeline Execution

With a model split across 4 GPUs (stages S1-S4):

• Forward: Micro-batch enters S1, output passes to S2, etc.
• Backward: Gradients flow back from S4 to S1.
• Pipeline Fill/Drain: During fill, only S1 is active; during drain, only S4 is active. The idle time is the "pipeline bubble" — wasted computation proportional to (P-1)/M where P = pipeline stages and M = micro-batches in flight.

Pipeline Schedules

• GPipe (Google): Forward all M micro-batches through the pipeline, then backward all M. Simple but the bubble fraction is (P-1)/(M+P-1). Requires M >> P for efficiency. Memory scales linearly with M (all activations stored simultaneously).

• 1F1B (PipeDream): Interleaves forward and backward passes — after the pipeline fills, each stage alternates one forward and one backward step in steady state. Same bubble fraction as GPipe but activations are freed earlier, reducing peak memory from O(M) to O(P). The industry standard.

• Interleaved 1F1B (Virtual Stages): Each GPU handles multiple non-contiguous virtual stages (e.g., GPU 0 handles layers 1-4 and 9-12). Micro-batches see more stages on each GPU, reducing the effective pipeline depth and halving the bubble. Used in Megatron-LM.

• Zero Bubble Pipeline: Research schedules that overlap the backward pass of one micro-batch with the forward pass of the next, eliminating the bubble entirely at the cost of more complex scheduling and minor memory overhead.

Practical Considerations

• Partition Balance: Each stage should have approximately equal compute time. An imbalanced partition (one slow stage) throttles the entire pipeline. Balanced partitioning considers both layer compute cost and activation size.
• Communication Overhead: Only activation tensors (forward) and gradient tensors (backward) cross stage boundaries. The communication volume is determined by the activation size at the partition point — choosing boundaries at dimensionality bottlenecks minimizes transfer.
• Combination with Other Parallelism: Production LLM training (GPT-4, LLaMA) uses 3D parallelism: data parallelism across replicas × tensor parallelism within each layer × pipeline parallelism across layer groups.

Pipeline Parallelism is the assembly line of model-parallel training — keeping every GPU busy by flowing different micro-batches through the pipeline simultaneously, converting what would be sequential layer-by-layer execution into overlapped, throughput-optimized parallel processing.