When people ask a model to "forget" their data (machine unlearning, which updates a trained model so it behaves as if certain examples had never been seen), the requests rarely come evenly from everyone. If one demographic group deletes more often, the model's accuracy on the remaining members of that group drops. Methods now exist to repair this damage. Every one of them reports its cost as runtime or iterations, and every one assumes the repair is a one-off event. In practice, deletions arrive in waves over a model's lifetime, and repairs are run on whatever hardware the operator has. The Green AI literature shows that time and FLOP counts can mis-predict physical energy by tens of percent. It also shows that this error depends on whether a computation is limited by arithmetic or by memory traffic, and that is exactly where the candidate repair methods differ from each other.
This proposal measures the physical energy, in Joules, needed to keep a model within a fixed fairness tolerance across a stream of skewed deletion requests, on four GPU generations and a CPU. It tests whether the cheapest way to stay fair is a property of the algorithm or of the chip. If the ranking of repair strategies flips between devices, or between runtime and Joules, then published efficiency claims for fair unlearning are not portable. Operators would need a per-device choice of when and how to repair. If the ranking is stable, that is also worth reporting, and the note says below how this would be decided.
Core Claim
We claim that the energy cost of fair unlearning is mainly a lifecycle quantity. Two things drive it: how often you repair, and which repair you use. How much a single repair step costs matters less. We also claim that the ordering of repair strategies by energy is hardware-dependent. The reason is that the strategies stress the hardware differently. A second-order Newton step that inverts a Hessian (the matrix of second derivatives of the loss) is dominated by memory traffic. Mutual-information-aware fine-tuning is a dense first-order workload. Shard retraining is many small jobs.
The quantity we measure is the energy-to-fairness cost $E_\tau(m,h)$. It is the cumulative energy in Joules that repair policy $m$ spends on hardware $h$ over a fixed deletion sequence, under a constraint. The constraint is that, after every wave, the model's worst-group gap stays within $\tau$ of a reference model retrained from scratch with group reweighting. Any policy that breaks the constraint is reported as infeasible at that $\tau$, not as cheap. No paper in the file reports physical energy for any fair unlearning method; we found no reported result on Lacuna for Joules of fair unlearning.
Research Program
The motivating evidence comes from three papers. Group-robust Machine Unlearning frames skewed deletion as a distribution shift. It shows minority accuracy on CelebA falling from roughly 40% to 20% when 90% of blond males are deleted, and it proposes two fixes: REWEIGHT, which resamples remaining data to match original group proportions, and MIU, which adds unlearning, calibration and reweighted retaining losses. To be forgotten or to be fair finds that uniform deletion is benign while targeted deletion destabilizes fairness on Adult, Bank and COMPAS. Has Approximate Machine Unlearning been evaluated properly? shows that repeated unlearning degrades earlier deletions and treats groups unequally. That finding is why we model a lifecycle and not a single event.
Two papers supply the repair methods. MIU and REWEIGHT come from the group-robust paper. Fair Machine Unlearning gives a closed-form Newton update for convex losses with equalized-odds regularizers and reports a 2x to 20x speedup over retraining. That figure is runtime only, and the cost of its Hessian inversion on different backends has never been measured.
The measurement method comes from the energy literature. Normalizing Energy Consumption for Hardware-Independent Evaluation evaluated 43 architectures on RTX 2080 Ti, GTX 1080 Ti, Tesla T4 and A40. It calibrates each device with a "min-max" anchor pair, meaning the least and most energy-hungry reference workloads on that device, and adds FLOPs and parameter counts as regression features. We reuse its devices and its calibration so that results can also be reported in normalized units. An Experimental Analysis of the Power Consumption of CNNs for Keyword Spotting found up to 25% energy spread at equal multiply counts, and a latency-energy $R^2$ of 0.8863. This is the specific reason runtime may not suffice. Two further papers show that one-off accounting hides amortized costs and motivate charging the whole lifecycle: End-to-End Energy Accounting of Distillation Pipelines, where the teacher-side generation of about 10.6 kWh dwarfs student training, and How Green is AutoML for Tabular Data?.
The program runs on two tracks.
Deep-network track. We use CelebA and Waterbirds with the group definitions from the group-robust paper. We generate sequences of deletion waves in which a chosen minority subgroup requests deletion at rates rising to 0.9.
Convex tabular track. We use COMPAS, Adult and HSLS with the Newton-step fair unlearning. Deletions are skewed by race and sex and reach up to 20% of the training data, the range the original paper covers.
On both tracks we charge everything to the energy ledger: forgetting, fairness repair, and completeness auditing with UnleScore after each wave. Energy is logged with NVML on the GPUs and with CodeCarbon (RAPL) on the CPU. Idle power is subtracted using a fixed protocol, and all runs are repeated across seeds.
Beyond the fixed per-request policies, we test one simple triggered policy. It applies a cheap forget step (SCRUB or SalUn) on every wave. It runs the expensive repair (MIU, Newton step, or REWEIGHT retraining) only when an audited worst-group gap on a small held-out set crosses $\tau$. The triggered policy is a stand-in for "repair timing matters". We do not present it as a contribution in its own right.
Baselines
The naive reference point is doing nothing about fairness. Each wave is handled by fast approximate unlearning alone, SCRUB or SalUn, as in the group-robust and robustness papers. This is expected to be the cheapest in Joules and infeasible at tight $\tau$. Fairness and Robustness in Machine Unlearning already shows these methods distort normalization-layer statistics and drop ResNet50 adversarial accuracy from 0.52 to 0.12–0.19.
The gold reference is full retraining with REWEIGHT after every wave. It defines $\tau$'s anchor and gives the upper bound on energy.
The strongest existing competitor on the deep track is MIU applied after every wave. The group-robust paper reports a 99.0% average gap score on CelebA at about 1.03x fine-tuning time. Because it is already nearly as cheap as fine-tuning, it is the method our triggered policy must beat.
On the tabular track, the strongest competitor is the Newton-step fair unlearning. Its reported benchmark is a 2x to 20x runtime speedup over retraining at stable AEOD (absolute equalized odds difference). The file gives no per-dataset numbers for it.
For fairness, every method gets the same deletion sequences, the same backbone and pretrained checkpoint, the same hyperparameter search budget measured in GPU-hours on a single tuning device, and the same auditing cost. Tuning energy is reported separately so that it is not hidden.
The key ablation isolates repair timing. It compares triggered MIU with per-wave MIU at matched $\tau$. A second ablation replaces the audited trigger with a fixed schedule, repairing every $k$ waves, to test whether auditing is worth its own Joules.
Beating MIU means one of two things. The first is lower cumulative Joules at the same feasibility across all $\tau$ values tested on at least three of four GPUs. The second is feasibility at a tighter $\tau$ for equal energy.
Why not just…?
Why not just report runtime and multiply by board power? This is the most serious threat. It would make the hardware half of the proposal unnecessary. The file suggests runtime explains most but not all energy variance ($R^2$ = 0.8863 in the keyword-spotting study). The normalization paper finds non-linear mappings between some GPU pairs, such as RTX 2080 Ti versus T4. Neither result was measured on unlearning workloads.
We settle this directly. We compute the Kendall rank correlation between policy rankings by runtime and by measured Joules on each device. If the correlation is near one everywhere, we will say runtime suffices for choosing among fair-unlearning policies. The contribution then narrows to the lifecycle accounting, which remains useful because no prior work charges repair and auditing across waves.
Why not just count FLOPs? The Newton step's cost is dominated by moving and factoring a dense matrix, not by arithmetic. The keyword-spotting study already found 25% energy spread at equal multiply counts. We fit the hybrid FLOPs-plus-parameters regression from the normalization paper to our workloads. If it predicts unlearning energy within measurement noise, FLOPs-plus-calibration becomes the recommended cheap protocol, and we will say so.
Why not just retrain with REWEIGHT every time, since compute is cheap? It is the fairness anchor, and it guarantees feasibility. Retraining costs 2x to 20x more runtime than the convex unlearning update, and 1.3x to 6.2x more than tree sharding in FedShard. Over dozens of waves, that multiplier compounds. Our ledger reports its exact Joule premium over the best feasible policy, so readers can judge whether the premium is affordable.
Why not just run MIU after every request? At about 1.03x fine-tuning time per repair, this may already be near-optimal. If sequential waves do not erode MIU's fairness and repairs are cheap on every device, the triggered policy will not win. We would then report "always MIU" as the answer. The ablation above decides this.
Decisive Checks
The first check is rank reversal. It asks whether the ordering of feasible policies by $E_\tau$ changes across the A40, T4, RTX 2080 Ti, GTX 1080 Ti and the CPU. It also asks whether the Joule ordering disagrees with the runtime ordering on any device. We expect this to be most likely on the tabular track, where the Newton step's Hessian inversion competes against first-order alternatives, and we will sweep feature dimension to locate any crossover point.
The second check is lifecycle dominance. It asks whether cumulative repair-plus-audit energy over a realistic wave sequence exceeds single-request cost by a margin large enough that per-request speedups, like those FedShard and Fair Machine Unlearning report, mis-rank methods.
The third check is timing. It asks whether triggered repair is feasible at the same $\tau$ as per-wave MIU while using fewer Joules. If all three checks come back null, the result is still a clear negative finding: runtime-based fair-unlearning comparisons transfer across hardware. The field currently assumes this without having tested it.
References
- Group-robust Machine Unlearning
- To be forgotten or to be fair: unveiling fairness implications of machine unlearning methods
- Has Approximate Machine Unlearning been evaluated properly? From Auditing to Side Effects
- Fair Machine Unlearning: Data Removal while Mitigating Disparities
- Normalizing Energy Consumption for Hardware-Independent Evaluation
- An Experimental Analysis of the Power Consumption of Convolutional Neural Networks for Keyword Spotting
- Towards Resource-Efficient LLMs: End-to-End Energy Accounting of Distillation Pipelines
- How Green is AutoML for Tabular Data?
- Fairness and Robustness in Machine Unlearning
- FedShard: Federated Unlearning with Efficiency Fairness and Performance Fairness