When Is Backdoor Repair Worth Its Accuracy Tax?

Defending a machine-learning model against backdoors almost always makes the model worse at its job. A backdoor is a hidden rule planted during training: the model behaves normally on ordinary inputs but misbehaves when a specific trigger appears. The defenses that remove such rules—pruning away "sleeping" neurons, unlearning the trigger, retraining with heavy augmentation—tend to shave accuracy off every future query, whether or not a trigger ever shows up. The security literature measures this damage as a percentage-point drop in clean accuracy; it almost never asks whether removing the backdoor was worth it in the first place. Yet a small literature on the economics of adversarial machine learning has already shown, for a different attack type, that this question has a sharp quantitative answer: Samsinger et al. derive a tipping point below which deploying an adversarially trained classifier is strictly worse than doing nothing (When Should You Defend Your Classifier?).

This proposal brings that economic lens to backdoor defense, and adds the ingredient that makes the question genuinely hard: an attacker who knows the defender is doing this arithmetic. The core hazard is that backdoor triggers can be deliberately entangled with the features the model legitimately needs, so that any repair which suppresses the backdoor also destroys benign accuracy. If an adaptive attacker can inflate that collateral damage enough, the rational defender is forced to leave the backdoor in place. Whether real attack–defense pairs sit above or below this tipping point is, as far as the indexed literature shows, entirely unmeasured.

Core Claim

The claim is threefold. First, the decision to repair a possibly backdoored model has a computable tipping point, directly analogous to the evasion-attack threshold of Samsinger et al., but with a different structure: in evasion, the accuracy tax is paid only on the adversarial fraction of traffic, whereas in backdoor repair the tax is paid on every future query while the benefit accrues only on the (typically tiny) fraction of queries that carry a trigger. Second, the economically meaningful summary of a defense is not its attack success rate (ASR) reduction alone but its exchange rate $\rho = \Delta_{\text{acc}}/\Delta_{\text{ASR}}$ — the clean accuracy points sacrificed per point of attack success removed. Third, an adaptive attacker can optimize the trigger to maximize $\rho$, turning the defender's own repair mechanism into the weapon. We call this a utility-collapse attack: it does not aim to evade detection, but to make every detected-and-repaired outcome economically unacceptable.

Prior work stops on both sides of this gap without crossing it. Samsinger et al. (When Should You Defend Your Classifier?) supply the tipping-point mathematics but only for test-time evasion and adversarial training, with an attacker whose only move is choosing an attack frequency. Fine-pruning supplies the empirical accuracy taxes — reducing attack success from 100% to 0% with negligible loss on face recognition but only from roughly 99% to about 30% on traffic signs, with clean accuracy degraded (Fine-Pruning) — but never asks whether those taxes were worth paying. The IsTr defense demonstrates that when a reverse-engineered trigger entangles with benign features, unlearning repair damages clean accuracy (Isolate Trigger), but treats this as an engineering caveat rather than an attacker objective. And the game-theoretic FLGAME defense handles adaptive backdoor attackers in federated learning (FLGAME), yet it uses game theory purely as a loss-minimization device with no financial costs, no accuracy-tax accounting, and no applicability outside multi-client aggregation. None of these computes when a single, centrally trained checkpoint should be repaired at all. That is the question we answer.

Research Program

The first deliverable is the formal decision model. Let $q$ be the fraction of deployment queries expected to carry the trigger, $\Delta_{\text{acc}}$ the clean accuracy points lost to repair, $\Delta_{\text{ASR}}$ the attack success points removed, $L$ the cost of one wrong clean prediction, $B$ the cost of one successful backdoor activation, $C_{\text{repair}}$ the one-time compute cost of the repair, and $N$ the expected remaining query volume. Repairing is rational exactly when $q$ exceeds a threshold

$$q^\* \;=\; \frac{\Delta_{\text{acc}}\,L \;+\; C_{\text{repair}}/N}{\Delta_{\text{ASR}}\,B}.$$

When all mistakes cost the same ($B \approx L$) and repair compute is amortized over a long deployment, this collapses to $q^\* \approx \rho$, the exchange rate itself — the direct backdoor analogue of Samsinger et al.'s finding that adversarial training is irrational unless adversarial traffic exceeds 17% for Madry-style models or 10% for Shafahi-style models (When Should You Defend Your Classifier?). The structural difference is that realistic trigger frequencies $q$ are typically fractions of a percent, so even single-digit accuracy taxes can push $q^\*$ above any plausible $q$ — a priori, doing nothing often wins. Our first analysis task is to compute $q^\*$ for every attack–defense pair in a large benchmark grid and report the distribution.

The second deliverable is the empirical exchange-rate map. We will run the BackdoorBench evaluation suite (BackdoorBench, BackdoorBench: A Comprehensive Benchmark and Analysis), which standardizes attacks and defenses with the metrics we need (clean accuracy C-Acc, attack success rate ASR, and post-defense robust accuracy R-Acc), and extract $\rho$ for each pair. BackdoorBench's own findings motivate the shape of this map: the "poisoning paradox," where high poisoning ratios create the statistical separation that defenses exploit, suggests $\rho$ is strongly attack-dependent. We augment the grid with the adaptive attacks that the standard benchmark omits: the texture-aware, parameter-clipped triggers of Adaptive Backdoor Attack against Deep Neural Networks, which survive pruning of over 90% of neurons while costing less than 1% clean accuracy, and the latent-mimicking strategies (Laundry, Slow Release, Target Mapping) catalogued by TED-LaST.

The third deliverable is the utility-collapse attacker, which is the proposal's key technical novelty. Existing adaptive attacks optimize for stealth — evading Neural Cleanse or latent outlier detectors. Ours optimizes for repair damage: the poisoning objective maximizes the overlap between the trigger representation and the features that benign classes depend on, so that any defense which suppresses the trigger must also suppress those features. This is the deliberate weaponization of the failure mode that IsTr documents accidentally (Isolate Trigger) and that adversarial neuron pruning exhibits when it destroys features needed for general classification (Adversarial Neuron Pruning Purifies Backdoored Deep Models). Concretely, we will optimize the trigger (and a poisoning-ratio schedule) against a surrogate of the defender's unlearning pipeline, maximizing measured $\rho$ rather than stealth.

The fourth deliverable is constructive: an economically gated defense policy. Instead of always repairing, the defender chooses among doing nothing, a runtime input filter such as STRIP, post-hoc repair, or full retraining, by minimizing expected total cost under the threshold above. This directly addresses the latency economics that the literature flags but does not act on: STRIP's trigger detection is effective but multiplies inference latency by roughly 1.32 times on every query (Energy-based Backdoor Defense without Task-Specific Samples and Model Retraining), which is exactly the kind of universal tax our threshold is built to price. The same gate also gives principled conditions under which the system-level-first posture of You Don't Need Robust Machine Learning to Manage Adversarial Attack Risks is correct — and, crucially, conditions under which it is wrong.

A secondary analysis extends the same machinery to the attacker's side of the table, following the reasoning that real attackers optimize return on investment rather than raw success (Position: "Real Attackers Don't Compute Gradients") and will only adopt tooling with a demonstrated financial advantage (SoK: On the Offensive Potential of AI). Combining the poisoning paradox with a per-sample poisoning cost and a detection probability that rises with volume yields an interior equilibrium poisoning ratio — the attacker's best response to the gated defender. We will solve this two-stage game and check whether observed benchmark attack configurations (small ratios, entangled triggers) are consistent with its equilibrium.

Baselines

The naive reference point is doing nothing: deploy the backdoored model unrepaired, holding its full clean accuracy and paying only on triggered queries. This is a genuine competitor, not a strawman, because the whole point of the tipping-point analysis is that it sometimes wins — and the recent adaptive attacks make it a strong one, reporting backdoor success rates of 99% to 100% with under 1% clean accuracy cost (Adaptive Backdoor Attack against Deep Neural Networks). Beating "do nothing" means reducing expected deployment loss, which under our cost model can be achieved either by lowering ASR or by avoiding an uneconomical accuracy tax; a defense that cuts ASR to near zero but costs more clean accuracy than the attack's expected damage does not beat it.

The strongest existing repair method we will compare against is IsTr, the unlearning-based defense that separates deep-layer "posterior" trigger knowledge from shallow-layer benign knowledge and repairs the model rather than merely detecting inputs (Isolate Trigger). We pick it because it is the one method in the indexed literature that both handles adaptive, entangled triggers and performs model repair, reporting attack success reduced from 100% to below 3% across MNIST, GTSRB, and PubFig while maintaining high benign accuracy — no reported result found on Lacuna for IsTr's clean accuracy under the enhanced adaptive attack combining Laundry, Slow Release, and Target Mapping, which is precisely the gap our experiments fill. We will run IsTr on identical models, datasets, and poisoning configurations, with the same clean reference data and the same tuning budget, and score it not only on ASR and C-Acc but on the exchange rate $\rho$ and the implied threshold $q^\*$. Our method beats IsTr if, at matched ASR reduction and matched compute, it yields a strictly lower $\rho$ under the utility-collapse attacker, or if the gated policy correctly identifies deployment regimes where IsTr's own accuracy tax makes running it worse than doing nothing — a dimension on which no current method reports anything at all.

Two further comparison points bracket the space. CutMix-style strong augmentation retraining (Strong Data Augmentation Sanitizes Poisoning and Backdoor Attacks Without an Accuracy Tradeoff) is the strongest known "free lunch" repair, cutting BadNets attack success from 100% to 36% on CIFAR-10 while raising validation accuracy from 85% to 94%; we rerun it against the adaptive triggers it was never tested on, since it only leaves a 36% residual attack success even in its best case. And Fine-Pruning (Fine-Pruning) is the classic lightweight repair, included because its own results already span the economic spectrum — from a free repair on speech recognition (attack success to 0% at a 0.4% accuracy cost) to a poor one on traffic signs (roughly 99% down to about 30% with degraded clean accuracy). Finally, the key ablation isolates the proposal's central ingredient: we compute the tipping point twice, once from trade-off measurements taken only against static BadNets-style attacks and once against the adaptive-entangled suite. If the two thresholds agree, the adaptive-awareness component is unnecessary; the hypothesis, grounded in the collapse of static defenses under adaptive attacks (TED-LaST), is that they will differ by an order of magnitude.

Why not just…?

Why not just train with CutMix or Mixup and eliminate the trade-off entirely? Borgnia et al.'s results are real, and we adopt their method as a baseline rather than dismiss it (Strong Data Augmentation). But the free lunch has two documented limits: even in the favorable static case, CutMix leaves a 36% residual attack success rate, unacceptable anywhere a triggered failure is costly; and the augmentation only disrupts localized patch-like triggers, while texture-distributed, parameter-clipped triggers of the adaptive backdoor literature are explicitly designed to survive spatial mixing and even 90% neuron pruning (Adaptive Backdoor Attack against Deep Neural Networks). Our exchange-rate measurement against adaptive triggers is exactly the experiment that settles whether the free lunch survives, and if it does survive at low $\rho$, our gated policy would correctly recommend it — the framework does not care which repair wins, only what each costs.

Why not just rely on system-level security — data auditing, signatures, rate limits — as the "You Don't Need Robust ML" argument suggests? That paper's own evidence (7 of 8 MITRE ATLAS incidents handled better by non-ML controls) is about evasion and perimeter attacks, and its poisoning dismissal assumes the defender can see the training data (You Don't Need Robust Machine Learning). Clean-label attacks such as Laundry keep every poisoned sample paired with its correct ground-truth label (TED-LaST), so label audits find nothing; and the modern supply chain — third-party checkpoints, outsourced fine-tuning, exported computation graphs (Architectural Backdoors in Vision-Language Model Supply Chains) — delivers weights, not data, leaving nothing to audit. Our framework concedes the paper's central point in a principled form: for low trigger frequency $q$ and modest backdoor damage $B$, the gate outputs "do nothing, monitor," which is their recommendation made quantitative. Where it disagrees is when $qB$ is large, and we test exactly that regime.

Why not just prune the dormant neurons post-hoc (Fine-Pruning) and be done? Because the literature already records both its successes and its failures, and the failures are the interesting regime: on traffic signs it removes barely two-thirds of the attack while degrading clean accuracy (Fine-Pruning), and a parameter-clipped adaptive backdoor survives pruning of over 90% of neurons until the model is unusable (Adaptive Backdoor Attack). Fine-Pruning's authors themselves document a pruning-aware attacker that co-opts the same neurons for benign and malicious computation. Our contribution is to price this: the pruning-aware attacker is a special case of the utility-collapse attacker, and our experiments measure the $\rho$ it induces rather than treating the outcome as an anecdote.

Why not just run STRIP at inference time and never touch the weights? STRIP avoids the clean accuracy tax on the model but replaces it with a latency tax on every query — a 1.32 times inference cost (Energy-based Backdoor Defense) — which is the same kind of universal per-query payment that makes the economics nontrivial. Its authors also note it presumes input-agnostic triggers, and partial or source-specific triggers break the entropy signature. STRIP is one of the actions in our gated policy, deployed exactly when the threshold arithmetic favors paying its tax; our experiments will identify that region rather than assume it is empty or universal.

Proposed Experiments and Decisive Checks

All experiments run on the BackdoorBench codebase (SCLBD/BackdoorBench) with CIFAR-10, GTSRB, and ImageNet100 as primary benchmarks, since these host the strongest reported numbers on both sides: TED-LaST's 0.981 detection AUROC and 94.0% precision against adaptive blending on CIFAR-10 (TED-LaST), and the adaptive backdoor's 99–100% success with sub-1% clean cost across the same data (Adaptive Backdoor Attack). The attack suite spans static (BadNets, Blended, WaNet via the benchmark), adaptive-stealth (the TED-LaST enhanced combination of Laundry, Slow Release, and Target Mapping), and our new adaptive-damage triggers; the defense suite spans Fine-Pruning, CutMix retraining, STRIP, IsTr-style unlearning, and the gated policy over all of them. Metrics are the benchmark's standard C-Acc, ASR, and R-Acc, plus three new ones: the exchange rate $\rho$, the implied tipping point $q^\*$, and repair compute cost in GPU-hours — no reported result found on Lacuna for repair compute cost in any indexed defense, which is itself a finding the field should stop omitting.

Three checks are decisive. First, the exchange-rate map must show a clear ordering — static triggers yielding low $\rho$ (near the CutMix free-lunch regime) and adaptive-entangled triggers yielding high $\rho$ — with non-overlapping confidence intervals across at least five defenses per attack. If adaptive and static triggers produce statistically indistinguishable $\rho$, the core hazard claim fails and the gated policy is just a wrapper around existing methods. Second, the utility-collapse attacker must move the measured tipping point above realistic trigger frequencies for at least one deployed-quality defense, demonstrating that "successfully defended but economically ruined" is a real outcome and not an artifact of one unlucky pairing. Third, the gated policy must dominate every fixed policy on expected total loss across a swept grid of trigger frequencies and cost ratios, including the two corners where fixed policies currently live: always-repair (the implicit assumption of the backdoor-defense literature) and never-repair (the implicit recommendation of the systems-security literature). If a fixed policy matches the gate everywhere, the decision model adds nothing beyond a rule of thumb — and we will report which rule of thumb, because even that would be the first quantitative answer this problem has received.