---
title: 'FedShard: Fair & Efficient Federated Unlearning'
url: https://www.emergentmind.com/topics/fedshard
type: topic
---

# FedShard: Fair & Efficient Federated Unlearning

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" [2508.09866], 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 [2508.09866]. 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 [2508.09866].

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. [2508.09866]. 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$ [2508.09866]. 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 [2508.09866]. 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 [2508.09866]. 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 $\mathcal{A}_2$, described as variance-aware allocation.

In **Parallel Federated Training**, each shard runs $T_s^p$ rounds of FedAvg among its clients, updating $\theta_s^p$. In **State Caching**, the tuple $(S_s^p,\theta_s^p,\alpha_s^p,w_s^p,T_s^p)$ is stored into FLCache for future unlearning [2508.09866].

The practical importance of this design appears in the reported ablation on CIFAR-10 with $\rho=0.1$, $K=32$, and $R=2$. Naive sharding collapses, with accuracy descending to $0$; adding $\mathcal{A}_1$ stabilizes convergence to $56.3\%$ accuracy; and adding $\mathcal{A}_2$ yields $64.14\%$ accuracy, outperforming standard FedAvg at $62.92\%$ [2508.09866]. 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 $\mathcal{A}_3$, operates by identifying the affected shards for a leaving client $c_l$: 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 [2508.09866]. 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 $\theta$ was trained on $D_0$ without using $D_l$, then dropping or bypassing cached updates is exactly equivalent to retraining on $D_0\setminus D_l$. By induction across the stages, FedShard’s partial retraining of only the affected shards yields the same result as full retraining from scratch [2508.09866]. 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 $T_0$ rounds. Total rounds for vanilla retraining via FedAvg are
$$
P\cdot T_0\cdot K.
$$
FedShard unlearning rounds are
$$
T_{\mathrm{un}}=\sum_{p=1}^{P} T_0 R^p
= T_0\cdot \frac{R(R^P-1)}{R-1}
\approx T_0\cdot K\cdot \frac{R}{R-1}.
$$
The resulting single-client speedup is
$$
r_1=\frac{P\cdot T_0\cdot K}{T_0\cdot K\cdot R/(R-1)}
= \frac{R-1}{R}\cdot \frac{K}{K-1}\cdot P
\gtrsim \frac{P}{2}.
$$
With variable $T_s^p$ determined by $\mathcal{A}_2$, the bounds become
$$
r_1\cdot \frac{T_0}{T_{\max}} \le \hat r_1 \le r_1\cdot \frac{T_0}{T_{\min}},
$$
so keeping $T_s^p\in[T_{\min},T_{\max}]$ tight preserves high efficiency [2508.09866].

For simultaneous unlearning of $m$ clients, the best-case speedup is $r_2^+=m$ when all leavers are in one shard. The worst-case bound is
$$
r_2^-=\frac{R}{R-1}\cdot \frac{K-1}{K}\cdot \frac{m}{P-p'} \ge 1,
$$
where $p'$ is the stage when all shards include at least one leaver. The paper gives time complexity $O(K)$ for one client and $O(K\cdot \log m)$ for $m$ clients [2508.09866]. 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 [2508.09866].

For **Performance Fairness**, let $\Delta \mathcal{Y}(D_c)=\mathcal{Y}_{\text{before}}(D_c)-\mathcal{Y}_{\text{after}}(D_c)$ denote the local accuracy drop for client $c$, and let the minimal data-distance to any remaining client be
$$
\mathrm{Dis}(c)=\min_{c_r\in C_R} |\alpha_c-\alpha_{c_r}|.
$$
The performance fairness score is
$$
M_p=\frac{1}{|C|}\sum_{c\in C} f_{\oplus}\bigl(\Delta \mathcal{Y}(D_c),\mathrm{Dis}(c)\bigr),
$$
where
$$
f_{\oplus}(x,y)= (\bar x+\bar y)\cdot \left(\frac{1}{\bar x}+\frac{1}{\bar y}\right),
$$
with $\bar x=(\epsilon+(x-x_{\min})/(x_{\max}-x_{\min}))$ and similarly for $\bar y$ [2508.09866]. The function is convex and minimized at $\bar x=\bar y$, so lower $M_p$ means that the observed accuracy drop is aligned with data uniqueness and therefore indicates better performance fairness.

The paper states that $M_p$ satisfies envy-freeness, Pareto-optimality, continuity, homogeneity, partition-linearity, and starvation-avoidance [2508.09866]. 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 $Z_c$ be the wall-clock cost to unlearn client $c$, let $Z_{\mathrm{avg}}$ be the mean cost, and let $|\alpha_c|$ denote contribution magnitude. The efficiency fairness score is
$$
M_e=\frac{1}{|C|}\sum_{c\in C}\frac{(Z_{\mathrm{avg}}-Z_c)^2}{|\alpha_c|}.
$$
Lower $M_e$ indicates that costs are proportional to contributions and therefore implies better efficiency fairness [2508.09866].

The paper states that $M_e$ reduces to equality when all $\alpha_c$ are equal, is continuous, partition-linear, saturation-independent of $|C|$, but not homogeneous because units matter, and is starvation-aligned [2508.09866]. The pairing of $M_p$ and $M_e$ 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 $\rho\in\{0.1,0.5,0.9\}$ and client counts $K\in\{32,64,128,256,512\}$. 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 [2508.09866].

On CIFAR-10 with $K=256$ and $\rho=0.1$, averaged over three runs, the reported unlearning times in seconds are FA $=13459$, FE $=4167$, RR $=4645$, FT $=8404$, FR $=17.3$, and FS $=3361$. The paper summarizes this as FS being $1.3$–$6.2\times$ faster than FA and $4.9\times$ faster than FT [2508.09866]. For efficiency fairness on the same setting, the reported $M_e$ values are FS $=10.9$, FT $=1081.7$, FE/RR/FR $=35$–$41$, and FA $=75.6$, with the interpretation that FS matches approximate speed while having the best $M_e$ among exact methods [2508.09866].

For unlearning effectiveness, the paper reports Membership-Inference Attack F1-score on CIFAR-10 as follows: unlearned FA $=34.2$, FS $=35.0$, FT $=36.1$, FE $=30.1$, RR $=28.7$, FR $=25.1$, and non-unlearned $=91.4$ [2508.09866]. 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 $\rho$ decreases, FE and RR cause $5$–$8$ extra leavers and high $M_p\approx 9.2$, whereas FA, FT, and FS cause no cascaded leaving with low $M_p\approx 6.1$–$6.7$ [2508.09866]. For data poisoning via unfair FU, measured by uf-DPA precision, FE and RR yield $20$–$23\%$ clients poisoned, while FA, FT, FS, and FR yield $0\%$ [2508.09866]. 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 [2508.09866]. 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" [2604.22072], 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 $M$ 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 [2604.22072].

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 $O(|\theta|/M)$ independent of client count, evaluates deployment across model sizes from $43$ MB to $5$ GB, reports a cost crossover at approximately $500$ MB gradient size, reports $2.7\times$ cost reduction at VGG-16 scale, and states that GradsSharding is the only architecture that remains deployable beyond the serverless memory ceiling [2604.22072]. 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 [2508.09866]. In the 2026 systems sense, “FedShard” is the environment into which a sharded serverless aggregation design may be embedded [2604.22072]. 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 [2508.09866]. 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.

Source: https://www.emergentmind.com/topics/fedshard