FedShard: Fair & Efficient Federated Unlearning

• FedShard is a federated unlearning algorithm that removes a leaving client's data by retraining only affected shards, ensuring exact unlearning.
• Its design employs hierarchical sharding with adaptive merge and variance-aware round allocation to simultaneously achieve efficiency fairness and performance fairness.
• Experimental results on CIFAR-10 demonstrate that FedShard outperforms full retraining and approximate methods in speed, fairness metrics, and unlearning effectiveness.

FedShard is a federated unlearning (FU) algorithm for federated learning (FL) that targets the removal of a leaving client’s data contribution from the global learned model while explicitly treating fairness as a first-class design objective. In "FedShard: Federated Unlearning with Efficiency Fairness and Performance Fairness" (Wen et al., 13 Aug 2025), FedShard is presented as the first federated unlearning algorithm designed to concurrently guarantee both efficiency fairness and performance fairness, while remaining exact and substantially faster than retraining from scratch. Its central mechanism is a hierarchical sharding design with adaptive shard-merging and training-round allocation, together with fairness metrics that quantify whether unlearning cost and post-unlearning accuracy degradation are distributed in a manner aligned with client contribution and data similarity.

1. Problem setting and fairness objectives

FL enables multiple clients to jointly train a global model without sharing raw data. When a client withdraws, for example by exercising a “right to be forgotten,” its data influence must be removed from the global model; this is the FU problem addressed by FedShard (Wen et al., 13 Aug 2025). The paper’s motivation is that prior FU work focused mainly on unlearning efficiency and effectiveness, but did not directly address two fairness questions among decentralized clients.

The first is Efficiency Fairness (E.F.), defined as ensuring that the computational cost of unlearning does not vary wildly among clients, so that no client faces an unfairly large retraining burden when it leaves. The second is Performance Fairness (P.F.), defined as ensuring that the model’s accuracy degradation on each client’s data is commensurate with how similar that data is to the leaving client’s data, so that remaining clients are not unduly harmed and leaving clients’ privacy is protected (Wen et al., 13 Aug 2025).

This framing makes FedShard more than a latency optimization. The paper argues that, without these fairness guarantees, malicious or risk-averse clients may opt out of FL in a cascaded leaving pattern, may exploit unlearning to launch poisoning attacks, and honest clients may be discouraged from participation. In that sense, fairness is treated as a systems property with security consequences, not merely as an ethical desideratum.

A recurring misconception in FU is that exactness and speed are sufficient system-level criteria. FedShard explicitly rejects that reduction: the paper’s stated objective is to jointly achieve high unlearning efficiency and both E.F. and P.F. (Wen et al., 13 Aug 2025). This suggests that FU should be analyzed as a multi-objective problem involving retraining cost, removal correctness, and the distribution of impact across clients.

2. Hierarchical sharding architecture and training workflow

FedShard organizes clients into hierarchical shards across multiple stages, with a user-specified merging rate $R$. At stage $p$, there are shards $S_1^p,\ldots,S_{N_p}^p$, each carrying a local global model $\theta_s^p$ (Wen et al., 13 Aug 2025). The training procedure is divided into four phases per stage.

In Shard Generation (Algorithm $\mathcal{A}_1$), prior-stage shards are clustered by their average update direction, measured via cosine similarity to the global average, into three groups: “under-fit,” “over-fit positive,” and “over-fit negative.” New shards are then formed by picking approximately equal numbers from each cluster so that each super-shard has a balanced update direction (Wen et al., 13 Aug 2025). This design addresses the instability that naive hierarchical partitioning can introduce.

In Shard Initialization, parent-shard models are aggregated to form the initial model for each new shard:

$$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$

where $w_i^{p-1}$ is the parent aggregation weight (Wen et al., 13 Aug 2025). The framework also computes each shard’s contribution-variance $\sigma^2(\alpha_s^p)$ from its clients’ angles $\alpha_c$ and assigns training rounds $T_s^p$ using Algorithm $p$0, described as variance-aware allocation.

In Parallel Federated Training, each shard runs $p$1 rounds of FedAvg among its clients, updating $p$2. In State Caching, the tuple $p$3 is stored into FLCache for future unlearning (Wen et al., 13 Aug 2025).

The practical importance of this design appears in the reported ablation on CIFAR-10 with $p$4, $p$5, and $p$6. Naive sharding collapses, with accuracy descending to $p$7; adding $p$8 stabilizes convergence to $p$9 accuracy; and adding $S_1^p,\ldots,S_{N_p}^p$0 yields $S_1^p,\ldots,S_{N_p}^p$1 accuracy, outperforming standard FedAvg at $S_1^p,\ldots,S_{N_p}^p$2 (Wen et al., 13 Aug 2025). The paper interprets this as evidence that adaptive balanced merging and variance-aware round allocation are necessary for preserving both convergence and fairness under sharded training.

3. Unlearning procedure, exactness, and complexity

FedShard’s unlearning procedure, Algorithm $S_1^p,\ldots,S_{N_p}^p$3, operates by identifying the affected shards for a leaving client $S_1^p,\ldots,S_{N_p}^p$4: specifically, one affected shard per stage on the path from leaf to root. It reloads their initial states and retrains only those shards in each stage, while reusing cached models for unaffected shards (Wen et al., 13 Aug 2025). The intended effect is to localize the computational work induced by a removal request.

The paper’s exactness claim is formalized in Proposition 1. Adapted from prior exact unlearning approaches, the proposition states that if a subsystem model $S_1^p,\ldots,S_{N_p}^p$5 was trained on $S_1^p,\ldots,S_{N_p}^p$6 without using $S_1^p,\ldots,S_{N_p}^p$7, then dropping or bypassing cached updates is exactly equivalent to retraining on $S_1^p,\ldots,S_{N_p}^p$8. By induction across the stages, FedShard’s partial retraining of only the affected shards yields the same result as full retraining from scratch (Wen et al., 13 Aug 2025). This is the basis for classifying FedShard as an exact FU framework rather than an approximate calibration method.

For efficiency analysis, the paper first assumes that each shard trains $S_1^p,\ldots,S_{N_p}^p$9 rounds. Total rounds for vanilla retraining via FedAvg are

$\theta_s^p$0

FedShard unlearning rounds are

$\theta_s^p$1

The resulting single-client speedup is

$\theta_s^p$2

With variable $\theta_s^p$3 determined by $\theta_s^p$4, the bounds become

$\theta_s^p$5

so keeping $\theta_s^p$6 tight preserves high efficiency (Wen et al., 13 Aug 2025).

For simultaneous unlearning of $\theta_s^p$7 clients, the best-case speedup is $\theta_s^p$8 when all leavers are in one shard. The worst-case bound is

$\theta_s^p$9

where $\mathcal{A}_1$0 is the stage when all shards include at least one leaver. The paper gives time complexity $\mathcal{A}_1$1 for one client and $\mathcal{A}_1$2 for $\mathcal{A}_1$3 clients (Wen et al., 13 Aug 2025). This suggests that the hierarchical cache structure is intended to make exact FU scale with client population more favorably than naive full retraining.

4. Fairness metrics: performance and efficiency

FedShard introduces two orthogonal fairness metrics intended to make FU fairness quantitatively analyzable (Wen et al., 13 Aug 2025).

For Performance Fairness, let $\mathcal{A}_1$4 denote the local accuracy drop for client $\mathcal{A}_1$5, and let the minimal data-distance to any remaining client be

$\mathcal{A}_1$6

The performance fairness score is

$\mathcal{A}_1$7

where

$\mathcal{A}_1$8

with $\mathcal{A}_1$9 and similarly for $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$0 (Wen et al., 13 Aug 2025). The function is convex and minimized at $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$1, so lower $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$2 means that the observed accuracy drop is aligned with data uniqueness and therefore indicates better performance fairness.

The paper states that $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$3 satisfies envy-freeness, Pareto-optimality, continuity, homogeneity, partition-linearity, and starvation-avoidance (Wen et al., 13 Aug 2025). These properties are significant because they place the metric in continuity with established fairness-measurement principles rather than treating FU fairness as an ad hoc scalar.

For Efficiency Fairness, let $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$4 be the wall-clock cost to unlearn client $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$5, let $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$6 be the mean cost, and let $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$7 denote contribution magnitude. The efficiency fairness score is

$$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$8

Lower $$\theta_s^{p,0}=\frac{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}\theta_i^{p-1}}{\sum_{i\in \mathrm{parents}(s)} w_i^{p-1}},$$9 indicates that costs are proportional to contributions and therefore implies better efficiency fairness (Wen et al., 13 Aug 2025).

The paper states that $w_i^{p-1}$0 reduces to equality when all $w_i^{p-1}$1 are equal, is continuous, partition-linear, saturation-independent of $w_i^{p-1}$2, but not homogeneous because units matter, and is starvation-aligned (Wen et al., 13 Aug 2025). The pairing of $w_i^{p-1}$3 and $w_i^{p-1}$4 is structurally important: one metric addresses how the consequences of forgetting are distributed in model performance space, and the other addresses how the computational burden of forgetting is distributed in systems space.

5. Empirical behavior, robustness, and deployment implications

The experimental evaluation covers MNIST, FMNIST, CIFAR-10, CIFAR-100, EMNIST, SVHN, Purchase, and Adult under Dirichlet non-IID splits $w_i^{p-1}$5 and client counts $w_i^{p-1}$6. The models are a 2-layer CNN for image datasets and an MLP for tabular datasets. Baselines are FA, defined as retrain from scratch via FedAvg; FT, defined as FATS; FE, defined as FedEraser; RR, defined as RapidRetrain; and FR, defined as FedRecovery (Wen et al., 13 Aug 2025).

On CIFAR-10 with $w_i^{p-1}$7 and $w_i^{p-1}$8, averaged over three runs, the reported unlearning times in seconds are FA $w_i^{p-1}$9, FE $\sigma^2(\alpha_s^p)$0, RR $\sigma^2(\alpha_s^p)$1, FT $\sigma^2(\alpha_s^p)$2, FR $\sigma^2(\alpha_s^p)$3, and FS $\sigma^2(\alpha_s^p)$4. The paper summarizes this as FS being $\sigma^2(\alpha_s^p)$5–$\sigma^2(\alpha_s^p)$6 faster than FA and $\sigma^2(\alpha_s^p)$7 faster than FT (Wen et al., 13 Aug 2025). For efficiency fairness on the same setting, the reported $\sigma^2(\alpha_s^p)$8 values are FS $\sigma^2(\alpha_s^p)$9, FT $\alpha_c$0, FE/RR/FR $\alpha_c$1–$\alpha_c$2, and FA $\alpha_c$3, with the interpretation that FS matches approximate speed while having the best $\alpha_c$4 among exact methods (Wen et al., 13 Aug 2025).

For unlearning effectiveness, the paper reports Membership-Inference Attack F1-score on CIFAR-10 as follows: unlearned FA $\alpha_c$5, FS $\alpha_c$6, FT $\alpha_c$7, FE $\alpha_c$8, RR $\alpha_c$9, FR $T_s^p$0, and non-unlearned $T_s^p$1 (Wen et al., 13 Aug 2025). The paper interprets FS as matching retraining and therefore demonstrating exact unlearning, while approximate methods “over-unlearn” by driving the F1-score too low.

The robustness claims are tied directly to fairness. For cascaded leaving on CIFAR-10, as $T_s^p$2 decreases, FE and RR cause $T_s^p$3–$T_s^p$4 extra leavers and high $T_s^p$5, whereas FA, FT, and FS cause no cascaded leaving with low $T_s^p$6–$T_s^p$7 (Wen et al., 13 Aug 2025). For data poisoning via unfair FU, measured by uf-DPA precision, FE and RR yield $T_s^p$8–$T_s^p$9 clients poisoned, while FA, FT, FS, and FR yield $p$00 (Wen et al., 13 Aug 2025). The paper’s summary is that only FedShard simultaneously achieves high efficiency, efficiency fairness, performance fairness, model accuracy approximately equal to standard FL, and unlearning effectiveness aligned with retraining.

The stated practical implications are FL services subject to GDPR/CCPA data-erasure requests, medical and financial FL with strict privacy requirements, and collaborative edge systems where departure churn is high (Wen et al., 13 Aug 2025). This suggests that FedShard is most naturally situated in regulated or adversarial multi-party settings where client exit behavior materially affects system viability.

6. Scope of the name, related sharding usage, and open directions

A separate systems paper, "Shard the Gradient, Scale the Model: Serverless Federated Aggregation via Gradient Partitioning" (Barrak, 23 Apr 2026), describes GradsSharding and states that it is suitable for embedding in a system called “FedShard.” In that work, the FedAvg aggregation step is reorganized by slicing each client’s gradient vector into $p$01 equally sized shards and assigning each shard index to a separate stateless serverless function. Because FedAvg averaging is element-wise, averaging each shard independently and then re-concatenating yields bit-identical results, assuming the same summation order (Barrak, 23 Apr 2026).

That work is conceptually distinct from the 2025 FU algorithm. Its focus is serverless aggregation scalability rather than right-to-be-forgotten unlearning. It proves a per-aggregator memory bound of $p$02 independent of client count, evaluates deployment across model sizes from $p$03 MB to $p$04 GB, reports a cost crossover at approximately $p$05 MB gradient size, reports $p$06 cost reduction at VGG-16 scale, and states that GradsSharding is the only architecture that remains deployable beyond the serverless memory ceiling (Barrak, 23 Apr 2026). A plausible implication is that the label “FedShard” can refer both to a specific FU algorithm and to a broader sharded FL systems context.

This dual usage makes scope clarification important. In the 2025 sense, FedShard is an exact FU method centered on fairness-aware unlearning (Wen et al., 13 Aug 2025). In the 2026 systems sense, “FedShard” is the environment into which a sharded serverless aggregation design may be embedded (Barrak, 23 Apr 2026). The two are related by the general idea of sharding, but they address different bottlenecks: one targets selective removal of client influence under fairness constraints, and the other targets serverless memory ceilings during aggregation.

The open directions stated for the FU algorithm are extension to non-convex personalization objectives, integration with differential privacy, scaling to thousands of clients, and dynamic client arrivals (Wen et al., 13 Aug 2025). These limitations identify the current boundary of the method’s claims. They also indicate that FedShard should be understood as a framework for exact and fairness-aware FU under the experimental regimes studied, rather than as a complete solution to all personalization, privacy, or large-scale dynamism issues in federated systems.