Paper 2602.21196
Untied Ulysses: Memory-Efficient Context Parallelism via Headwise Chunking
- Published
- Feb 2026
- Research lab
- Together AI
- Citations
- 0
- GitHub
- 25 stars
01 In brief
Summary
The paper introduces UPipe, a context parallelism technique that reduces activation memory in Transformer training by chunking attention heads.
It builds on DeepSpeed-Ulysses, processing attention in stages with a subset of heads (U) at a time, reusing buffers to cut intermediate memory from O(H) to O(U).
For Qwen3-32B, this reduces attention intermediate tensor memory by up to 87.5%.
UPipe supports 5M-token contexts for Llama3-8B on a single 8×H100 node (25% longer than FPDT) and 8M tokens on 16 H100s (33% longer than USP-Hybrid), with throughput comparable to Ulysses.
It includes a GQA scheduling algorithm that reuses key/value heads to reduce communication volume.
Experiments on Llama3-8B and Qwen3-32B show UPipe matches or exceeds baselines in throughput and memory efficiency, and it is composable with methods like FPDT and activation offloading.
The paper also explores reinvesting memory savings via strided activation offloading, selective activation checkpointing, and larger batch sizes, all improving performance while maintaining lower memory usage than Ulysses.
UPipe is implemented in TorchTitan and is available as a drop-in replacement for existing context parallelism methods.
02 From the paper
Abstract
Efficiently processing long sequences with Transformer models usually requires splitting the computations across accelerators via context parallelism. The dominant approaches in this family of methods, such as Ring Attention or DeepSpeed Ulysses, enable scaling over the context dimension but do not focus on memory efficiency, which limits the sequence lengths they can support. More advanced techniques, such as Fully Pipelined Distributed Transformer or activation offloading, can further extend the possible context length at the cost of training throughput. In this paper, we present UPipe, a simple yet effective context parallelism technique that performs fine-grained chunking at the attention head level. This technique significantly reduces the activation memory usage of self-attention, breaking the activation memory barrier and unlocking much longer context lengths. Our approach reduces intermediate tensor memory usage in the attention layer by as much as 87.5$\%$ for 32B Transformers, while matching previous context parallelism techniques in terms of training speed. UPipe can support the context length of 5M tokens when training Llama3-8B on a single 8$\times$H100 node, improving upon prior methods by over 25$\%$.