Introduction
Federated Learning (FL) enables a central server to aggregate model updates from a vast number of distributed users without accessing their raw local data. However, the model updates themselves are vulnerable to "model inversion attacks" that can leak sensitive information. Secure Aggregation (SecAgg) protocols address this by allowing the server to compute the sum of updates while keeping individual contributions private.
Despite their promise, existing SecAgg protocols often suffer from high communication overhead (scaling quadratically or logarithmically with the number of users), sensitivity to user dropouts (requiring costly recovery rounds), and reliance on computational security assumptions rather than stronger information-theoretic guarantees. SwiftAgg+ is proposed to overcome these hurdles, achieving asymptotically optimal communication loads while remaining robust to dropouts.
Methodology: Hierarchical Aggregation and Coding
SwiftAgg+ introduces a hierarchical approach to aggregation, moving away from the traditional "all-to-all" communication patterns that create bottlenecks in large-scale networks.
Partitioning and Grouping
Users are organized into groups, which are then arranged into an aggregation tree with the server at the root. This structure allows for flexible network connectivity. As shown in Figure 3, the protocol supports various topologies, from simple chains to complex multi-level trees, allowing system designers to trade off between network connectivity and communication load.
Ramp Secret Sharing and Polynomial Masking
To minimize overhead, SwiftAgg+ utilizes Ramp Secret Sharing. Unlike standard Shamir’s Secret Sharing, Ramp Secret Sharing allows multiple model partitions to be packed into a single polynomial, significantly reducing the size of inter-user messages. Users encode their updates as coefficients of a polynomial and add random noise to ensure information-theoretic privacy against up to $T$ colluding semi-honest users.
One-Shot Recovery
The protocol is designed for "one-shot" recovery. The server receives evaluations of a global "sum polynomial." By leveraging Lagrange interpolation, the server can recover the total sum in a single round, even if up to $D$ users drop out, without needing a separate recovery phase.
Key Results and Performance Comparison
The primary achievement of SwiftAgg+ is its asymptotic optimality. As the network size $N$ grows, the communication overhead per user effectively vanishes, approaching the theoretical minimum—the size of the model itself ($L$).
As detailed in the comparison table (Figure 6), SwiftAgg+ achieves a server communication load of $(1 + \frac{T}{N-T-D})L$ and a per-user communication load of $(1 + \frac{T+D}{N-T-D})L$. In scenarios where the number of dropouts ($D$) and colluding users ($T$) are small relative to $N$ (i.e., $o(N)$), the load becomes $(1 + o(1))L$. This represents a significant improvement over previous protocols like SecAgg or TurboAgg, which have overheads scaling with $N$ or $\log N$.
Furthermore, SwiftAgg+ provides information-theoretic security, a stronger guarantee than the computational security used in many efficient alternatives. It also maintains a competitive computational complexity, which can be further optimized using Fast Fourier Transform (FFT) techniques for large-scale deployments.
Conclusion and Future Directions
SwiftAgg+ sets a new benchmark for communication efficiency in secure aggregation. By combining hierarchical grouping with advanced coding theory, it achieves near-optimal performance in large networks while handling user dropouts gracefully.
Future work may involve developing automated algorithms to determine the optimal tree topology for heterogeneous networks with varying link capacities. Additionally, addressing potential "straggler" issues in highly asynchronous environments remains an open challenge for hierarchical aggregation structures.
Summary updated