A backdoored network behaves normally until a hidden trigger, such as a small patch, a warp, or a few altered pixels, appears in the input. Then it outputs whatever the attacker chose. The standard repairs either cut out neurons that look inactive on clean data or fine-tune the whole network on a small trusted dataset. The first fails when the attacker forces the backdoor to share neurons with the real task. The second rewrites millions of weights using a few hundred images, which risks clean accuracy and says nothing about where the backdoor lived. We propose a third option. The repair is a sparse edit: a change to the weights that touches only a few convolutional filters. The edit is found by iteratively reweighted group sparsity, a classical technique that approximates "change as few groups as possible" by repeatedly solving a weighted, easier problem.
The core bet is that a backdoor is usually a small, localized circuit, even when it shares neurons with benign features. If so, the minimal set of filters whose weights must change to break the trigger is both a cleaner repair and a forensic map of the backdoor. Iterative reweighting matters here because the obvious convex choice, an unweighted group-$\ell_1$ penalty on the edit, shrinks the edits that matter most. It therefore pushes the solution toward many small, diffuse changes, which is exactly what we want to avoid.
Core Claim
Consider repairing a suspect model with a small clean set and inverted trigger samples. A weight edit penalized by a reweighted, log-sum group penalty over filters removes the backdoor at equal or better clean accuracy than dense fine-tuning-based unlearning. It does this while modifying a small fraction of filters. The advantage over dense unlearning should grow as the clean-data budget shrinks, and should hold under pruning-aware attacks where activation-based pruning fails. If the backdoor is genuinely spread across many filters, the method should visibly lose its advantage, and we treat that case as a falsification test rather than something to hide.
Where This Sits
The closest existing intersection is Attack-Resistant Federated Learning with Residual-based Reweighting. That paper weights whole client updates by their residual from a repeated-median baseline, borrowing the reweighting rule from iteratively reweighted least squares. It cuts CIFAR-10 backdoor attack success from nearly 100% to 9.65%. It operates only at federated aggregation time, never inspects or edits a single centralized model, and reweights clients rather than parameters. Our setting, post-hoc repair of a downloaded model, is one it does not address.
Two works motivate the proposal by exposing the gap. Fine-Pruning prunes neurons with the lowest average clean activation and then fine-tunes. It reaches 0% attack success on face and speech tasks. It also documents its own failure: against a pruning-aware attacker, traffic-sign attack success stays near 30%, because the trigger lives in neurons the clean task needs. A unified DNN weight compression framework using reweighted optimization methods shows that weight or activation magnitude is a poor proxy for importance. Its reweighted group Lasso, run inside the Alternating Direction Method of Multipliers (ADMM, a splitting method for constrained optimization), finds the right filters to remove for compression. That paper supplies our method. It never targets backdoors, and it prunes weights rather than editing them. Editing is the key difference: a shared neuron can be partly rewired instead of deleted.
Three works supply the mechanism. Enhancing Sparsity by Reweighted L1 Minimization shows that minimizing a log-sum surrogate through a sequence of weighted $\ell_1$ problems recovers markedly sparser signals than plain $\ell_1$. In their compressed sensing test, the recoverable sparsity rises from about 25 to 33 nonzeros at $n=256$, $m=100$. Efficient and Robust Feature Selection via Joint ℓ2,1-Norms Minimization gives a convergent reweighting scheme for row-group norms, which is the structure we put on filters. Global Minimizers of ℓp-Regularized Objectives Yield the Sparsest ReLU Neural Networks shows that reweighted $\ell_1$ can be run with Adam inside network training, so the method is practical at scale.
For generating trigger samples we reuse existing inversion methods. Towards Reliable and Efficient Backdoor Trigger Inversion via Decoupling Benign Features (BTI-DBF) trains a class-agnostic generator of trigger-like perturbations. Better Trigger Inversion Optimization in Backdoor Scanning gives a fast mask-free inversion. We deliberately do not propose a new inversion method. A log-sum penalty on the trigger mask is the obvious reweighting idea at this intersection. Tao et al. trace inversion failures to the multiplicative coupling of mask and pattern, not to the sparsity penalty, so reweighting the penalty would likely be an incremental fix to the wrong problem.
Research Program
Let $\theta_0$ be the suspect model's weights and $\Delta$ the edit, partitioned into groups $\Delta_g$, one per convolutional filter or fully connected unit. Let $D_c$ be a small clean set. Let $D_t$ be clean images stamped with inverted triggers and labeled with their true class. The repair solves
$$\min_{\Delta}\; \mathcal{L}(\theta_0+\Delta;\, D_c \cup D_t) \;+\; \lambda \sum_g \log\big(\lVert \Delta_g \rVert_2 + \epsilon\big),$$
where $\mathcal{L}$ is cross-entropy, $\lambda$ sets the sparsity strength, and $\epsilon>0$ keeps the penalty finite. The log term is concave, so it is majorized by its tangent at the current iterate. This yields a weighted group-$\ell_1$ subproblem with weights $w_g = 1/(\lVert \Delta_g\rVert_2+\epsilon)$. We solve each subproblem with Adam steps followed by group soft-thresholding, refreshing the weights every few hundred steps.
Filters that need a large edit get a small penalty and are free to change fully. Filters with tiny edits get a large penalty and snap back to zero. Plain group-$\ell_1$ cannot behave this way, because it charges every filter the same amount per unit of change. To address the known sensitivity to $\epsilon$, we use continuation: $\epsilon$ starts large, where the method behaves like plain group Lasso, and decays geometrically. This prevents early zeroing from becoming permanent.
The output is a repaired model plus the support of $\Delta$: the set of edited filters. We test whether that support localizes the backdoor. If so, then on a clean model the same procedure should need a much larger or nonexistent support to "repair" a natural spurious correlation. This could address the false-positive problem from natural backdoors described in the TrojAI Final Report.
Baselines
The do-nothing reference is the poisoned model as delivered, which fixes the attack success rate to beat. Near 100% is typical for the attacks we use.
The strongest competitor is the unlearning mode of BTI-DBF (Towards Reliable and Efficient Backdoor Trigger Inversion via Decoupling Benign Features), which fine-tunes the full network on clean data plus generated trigger samples relabeled correctly. The paper reports reducing attack success from near 100% to below 5% in most scenarios while maintaining high clean accuracy. No exact clean-accuracy figure is given in the file. This baseline is the closest competitor because it uses the same ingredients as our method, inverted triggers plus clean data, and differs only in imposing no sparsity on the change. To keep the comparison fair, both methods consume the identical generator output and the same clean subset. Both also get the same optimizer, number of gradient steps, and hyperparameter search budget of 20 configurations, with model selection on a held-out clean split. We beat it if, at matched clean accuracy (within 0.5 points), we reach equal or lower attack success. We also need either a clear advantage at clean budgets of 1% of the training set or less, or an edit touching under 10% of filters with no loss in either metric.
Fine-Pruning (Fine-Pruning) is run with the authors' activation ranking on the last convolutional layer and the same clean set. It represents the magnitude-based view. Its reported traffic-sign result under a pruning-aware attacker, roughly 99% falling only to about 30% attack success, is the number our method must clearly beat on the pruning-aware setting.
Three ablations isolate the key ingredient. The first uses unweighted group-$\ell_1$ on $\Delta$, that is, the same objective with fixed weights, and tests whether reweighting itself matters. The second selects the top-$k$ filters by clean/triggered activation difference, then fine-tunes only those at matched $k$. This tests whether a one-shot heuristic selection captures what the iterative reweighting finds. The third is dense fine-tuning on clean data only, without trigger samples, which tests the contribution of inversion.
Why not just…?
Why not just fine-tune the whole model on clean data plus inverted triggers? This is the real threat, and BTI-DBF reports that it already works well. Our proposal does not claim dense unlearning fails at generous clean budgets. The bet is that dense edits overfit or erode clean accuracy when trusted data is scarce, and that they give no localization. We settle this with a clean-budget sweep from 0.5% to 10% of the training set. If dense unlearning matches us at every budget, the remaining contribution is only the forensic support of the edit, and we would say so.
Why not just prune dormant neurons? Fine-Pruning's own pruning-aware experiment shows that when the trigger shares neurons with the clean task, deleting neurons either leaves about 30% attack success or damages accuracy. Zhang et al. show more generally that magnitude misjudges importance. Our edit can rewire a shared filter without deleting it, and the pruning-aware experiment below tests this directly.
Why not just use plain group Lasso on the edit? It is convex and simpler. However, Candès et al. show that uniform $\ell_1$ penalties bias large coefficients toward zero and leave many small nonzeros. That would yield an edit spread across many filters with each necessary change under-applied. The unweighted ablation measures this directly, through edit support size and attack success at matched clean accuracy. If the two are indistinguishable, reweighting is not earning its cost.
Why not just pick the most trigger-sensitive filters once and fine-tune them? This heuristic is cheap and may capture most of the benefit. The top-$k$ ablation at matched $k$ answers it. Iterative reweighting should win when the attack is pruning-aware, because the filters that need editing are not the ones with the largest activation difference.
Proposed Experiments
We use CIFAR-10 and GTSRB with ResNet-18, plus a 100-class ImageNet subset as in BTI-DBF. The attacks are a patch trigger, WaNet warping, BppAttack, and SIBA's sparse invisible trigger (Backdoor Attack With Sparse and Invisible Trigger). We add a pruning-aware attack reimplemented on GTSRB following the Fine-Pruning description. The metrics are attack success rate, clean accuracy, the fraction of filters with nonzero edit, and wall-clock time. All results are averaged over five poisoned models per setting.
The first decisive check is the clean-budget curve against BTI-DBF unlearning. The second is the pruning-aware attack, where we must beat Fine-Pruning's roughly 30% residual attack success by a wide margin at comparable clean accuracy. The third is an adaptive attacker that adds a penalty during poisoning to spread the backdoor across many filters. Here we expect the sparse edit's support to grow and its advantage to shrink. Measuring how much spreading costs the attacker in clean accuracy or attack success tells us whether sparsity is a durable defense or an assumption an attacker can break. The fourth runs the procedure on clean models: if edit support on clean models is reliably larger than on backdoored ones, support size becomes a detection score. We would evaluate it by ROC-AUC on a held-out mix of clean and poisoned models, against the TrojAI report's figure of above 0.90 for inversion-based detection.
References
- Attack-Resistant Federated Learning with Residual-based Reweighting
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- A unified DNN weight compression framework using reweighted optimization methods
- Enhancing Sparsity by Reweighted L1 Minimization
- Efficient and Robust Feature Selection via Joint ℓ2, 1-Norms Minimization
- Global Minimizers of $\ell^p$-Regularized Objectives Yield the Sparsest ReLU Neural Networks
- Towards Reliable and Efficient Backdoor Trigger Inversion via Decoupling Benign Features
- Better Trigger Inversion Optimization in Backdoor Scanning
- Trojans in Artificial Intelligence (TrojAI) Final Report
- Backdoor Attack With Sparse and Invisible Trigger