Papers for

distributed ai engineers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Federated learning improves hypergraph predictions with less communication

More Is Better? Exploring Latent Correspondence in Federated Hypergraph Learning

Abstract: Federated hypergraph learning with latent cross-client hyperedge correspondence poses fundamental identifiability and computational challenges, as the same local release can correspond to multiple global hypergraph structures. We characterize the tractability of recovering these latent correspondences, showing tractable pairwise assignment but generally intractable multi-client hyperedge matching. Building on this characterization, we derive a cross-entropy decomposition that reveals when local prediction can outperform predictors fitted with additional cross-client information. Motivated by this principle, we introduce Federated Adaptive Spectral Training with Representation Alignment (FedASTRA), which learns correspondence-invariant diffusion representations through adaptive heat diffusion and masked latent prediction while communicating model parameters only. We establish its asymptotic optimality with respect to the permitted local information and prove global population-risk convergence under explicit conditions on recovery, representation, and update alignment. Experiments on eight real-world datasets demonstrate the effectiveness of FedASTRA against identifier-free federated graph and hypergraph methods. On ogbn-papers100M, FedASTRA reaches the performance-communication Pareto frontier, achieving 50.07 Accuracy and 29.73 Macro-F1 while communicating only 59.60 MiB per round.

Thu 29 OctMachine LearningDistributed, Parallel, and Cluster Computing
The gist
Working with complex data structures called hypergraphs across multiple devices is hard because the connections between parts on different devices can match in many ways. The authors show it's easier to match pairs of devices but much harder to match multiple devices at once. They create a new method called FedASTRA that learns good representations of this data while only sharing model details, not raw data. Their method performs well on big datasets, efficiently balancing accuracy and communication.
Open → 2610.39362v1

Federated reinforcement learning attacks depend on timing of manipulation

When to Intervene? State-Aware Sparse Manipulation in Federated Reinforcement Learning

Abstract: Federated reinforcement learning (FRL) enables distributed agents to collaboratively train decision-making policies, but its decentralized training process also exposes global policy learning to Byzantine manipulation. Existing poisoning attacks primarily focus on how to construct malicious updates, while trajectory-level intervention timing remains largely implicit. In sequential decision making, however, where an intervention is applied can alter subsequent trajectories and learning signals. Through controlled experiments, we find that changing the selected trajectory states materially alters attack efficacy even when the malicious-update construction is fixed. We therefore identify when as a distinct attack dimension and introduce the Viability-constrained Behavioral Steering Attack (V-BSA), which uses local policy uncertainty to select sparse intervention states and applies envelope-constrained behavioral steering. Across discrete-action benchmarks, V-BSA achieves substantial degradation against robust aggregators and ensemble defenses with only a fraction of the interventions used by dense poisoning, while revealing task- and aggregation-dependent boundaries. Overall, our results highlight intervention timing as a distinct dimension of sequential robustness in FRL. The code is available at https://github.com/Yodeesy/V-BSA

Thu 8 OctMachine Learning
The gist
Federated reinforcement learning lets many agents train a shared decision-making model without centralizing data, but attackers can try to corrupt this process. The authors found that when an attacker intervenes during an agent's decision path matters a lot for how harmful the attack is. They designed a new attack method that picks critical moments based on uncertainty and uses fewer disruptions to mislead the training. This shows that timing is an important factor to consider when defending distributed learning systems.
Open → 2610.11523v1

NCCL M2N speeds up tensor reshaping for large GPU clusters

NCCL M2N: A Layout- and Topology-Aware Collective for Distributed Tensor Resharding

Abstract: Distributed training and rollout generation often use different tensor layouts, requiring model weights to be resharded across distinct process groups. This M-to-N redistribution is not directly expressed by standard collectives. Flat direct sends duplicate traffic across destination replicas, while gather-then-broadcast concentrates network injection at one root and transfers data that destinations do not need. For DeepSeek-V3 on 256 GPUs, legacy all-gather plus broadcast accounts for 29.4% of the reported reinforcement-learning step time. We present NCCL M2N, a layout- and topology-aware collective primitive for distributed tensor resharding. Given source and destination meshes and placements, it derives the required transfer regions and a global communication schedule. Its hierarchical route balances source contributions across eligible destination ranks, forwards one copy between destination NVLink domains, and completes local replication over NVLink. Network transfer and local replication overlap, avoiding replica-multiplied source egress. An aggregate data-movement model captures the limits of both stages. We evaluate NCCL M2N on up to 256 GB200 GPUs in an NVL72 cluster with NDR InfiniBand. A single FFN-MoE layer transfer achieves up to 7.9x speedup over flat direct sends (9.8 ms versus 77.3 ms). In a separate 256-GPU DeepSeek-V3 NeMo-RL experiment, NCCL M2N reduces reported weight-sync time from 5.78 s to 2.77 s, a 2.09x speedup over legacy all-gather plus broadcast, and reduces step time by 12.7%.

Mon 5 OctDistributed, Parallel, and Cluster Computing
The gist
When computers train large AI models, they often need to rearrange pieces of data across many GPUs, which can be slow and inefficient. The authors designed NCCL M2N, a smarter way to shuffle data by understanding the layout of data and the network connections between GPUs. This new approach shares data more evenly and overlaps communication steps to save time. As a result, it can transfer data much faster and reduces the time taken in a real AI training task by over 12%.
Open → 2610.07516v1

Mixing local and global preconditioners improves federated model training

FedMIX-P: Mixing Local and Global Preconditioners for Federated Vision and Language Model Training

Abstract: Adaptive preconditioners accelerate model training, but heterogeneous client geometries can bias federated updates even when gradients are evaluated at the same model. Round-start synchronization alone cannot prevent this mismatch from reappearing during local training. We propose \texttt{FedMIX-P}, which mixes shared and local preconditioners at every local step, retaining local adaptation while reducing mean-squared operator mismatch by a factor of $λ^2$. For smooth nonconvex objectives with stochastic gradients and partial participation, we establish an $O(R^{-1/2})$ stationarity bound using suitable stepsizes and a horizon-dependent mixing weight, without requiring local preconditioners to converge to one another. A two-client counterexample shows that fixed positive mixing can preserve a nonstationary fixed point. The theory covers bounded linear symmetric positive-definite preconditioners. Experiments with SOAP, Sophia, and Muon variants across vision and language tasks show improvements over corresponding local optimizers, including accuracy gains of up to $19.47$ percentage points and lower validation loss for 60M--350M language models. Full nonlinear and momentum-based updates require separate analysis.

Thu 1 OctMachine LearningArtificial Intelligence
The gist
Training large AI models on many devices at once can be tricky because each device learns a bit differently, which can slow things down or lead to poorer results. The authors propose a new way to combine shared and local information during training steps to keep the benefits of learning locally while reducing mismatches between devices. They prove this method converges under certain assumptions and show it improves performance on vision and language tasks, sometimes very significantly. This approach helps train big models more efficiently across different devices without requiring all devices to behave the same way.
Open → 2610.01515v1

Latent compression speeds up multi-agent AI collaboration fourfold

LatCom: Cross-Agent Latent Compression for Efficient Multi-Agent Collaboration

Abstract: LLM-based multi-agent systems (MAS) increasingly use latent collaboration to avoid the information loss and repeated encoding-decoding overhead of natural-language communication. However, directly forwarding all sender latents makes the receiver-side context scale with both the number of agents and the reasoning length, increasing computation, memory usage, and collaboration latency. A natural solution is latent compression. But we find that cross-agent redundancy remains unresolved in existing latent compression approaches, which typically compress each sender independently and then concatenate the results. We propose LatCom, a cross-agent latent compression framework for efficient multi-agent latent collaboration. LatCom maps multiple sender latents into a fixed number of receiver-readable and task-relevant slots. Rather than reconstructing all sender hidden states, it optimizes the compressed latents for receiver-side task utility. LatCom trains the compressor in two stages: single-sender readability learning first establishes a latent interface interpretable by the frozen receiver, and multi-sender fusion learning then trains the compressor to fuse complementary evidence and remove redundancy across agents. Experiments on multiple benchmarks with Qwen3-4B show that LatCom achieves an average 2.46x inference speed-up over LatentMAS and reduces output token usage by 70.3% while maintaining comparable average accuracy.

Tue 29 SeptComputation and Language
The gist
Multi-agent AI systems often share information internally using compressed messages to work together efficiently. The authors found that compressing each agent’s message separately misses opportunities to reduce overlap and wastes space. Their LatCom method compresses all messages together into a fixed, efficient format that keeps the important information for the task. This approach speeds up the system, lowers memory and communication costs, and still keeps accuracy steady.
Open → 2609.37017v1

Efficient ring communication method speeds up distributed training

Communication-Efficient Distributed Training via Ring-Based Coded Approximate All-Reduce

Abstract: Ring All-Reduce is widely used within large-scale distributed training for exact computation of the aggregate gradient. For a system with $N$ workers, its normalized per-worker communication is $2(N-1)/N$. In this work we present a communication-efficient Ring All-Reduce (CERAR) protocol for ``approximate'' gradient aggregation. CERAR partitions each local gradient into $c$ components and crucially relies on linear encoding and decoding operations. It performs $L=c+N-2$ communication rounds over an $N$-worker ring, yielding normalized communication rate $1+(N-2)/c$ and normalized storage $1+N/c$. We present an explicit Vandermonde-based construction, whose approximation error can be made arbitrarily close to zero with communication and storage rates approaching one with increasing $c$. However, this limit is achieved through ill-conditioned encoding matrices. Accordingly, we give a multiplicative perturbation construction whose error is $O(ε)$, while the relevant condition numbers are $O(ε^{-r_\star})$, where $r_\star=\lceil c/N\rceil-1$. This naturally motivates a condition-number-constrained optimization formulation for trading off the competing objectives and obtaining numerically stable practical designs. We present experiments on multi-GPU clusters with low-bandwidth and high-bandwidth interconnects. Our results demonstrate clear benefits in the low-bandwidth setting, even for moderate parameter length. We expect corresponding improvements even in the high-bandwidth setting for experiments with much higher parameter lengths.

Sun 20 SeptInformation Theory
The gist
Training large AI models often involves multiple computers working together and sharing information, which can slow things down. This paper introduces a new way to communicate approximate updates among these computers more efficiently by splitting data and cleverly encoding it. The authors show that their approach requires less communication and storage per computer while maintaining accuracy close to exact methods. They tested their method on GPU clusters and found it especially helpful when network speeds are limited.
Open → 2609.23898v1