A backdoored image classifier behaves normally on ordinary inputs but switches to an attacker's chosen label whenever a hidden trigger, such as a small patch or a faint blended pattern, appears in the image. Recent work found that the poisoned training images that plant these triggers are geometrically unusual. They sit much farther from the model's decision boundary, the surface in input space where the predicted label changes, than clean images do. When they are pushed across that boundary, they tend to fall back into their true class. The first observation lets a defender flag poison. The second lets the defender relabel it and fine-tune the backdoor away, and it needs no clean reference data. The catch is cost. Measuring each training image's distance to the boundary with a full iterative attack means running an attack on every image in the training set.
We propose replacing that attack with a short walk of two or three linear steps toward the boundary. Each step fits a local flat approximation of the boundary from a single input gradient and jumps to it, which is how DeepFool-style attacks work. The walk returns three things for each training image: a boundary distance, a curvature signal (how much the first linear guess disagrees with where the walk ends up), and the label on the far side of the boundary. We claim these recover nearly all of the poison-detection and relabeling power of a full boundary attack, at a small fraction of its gradient budget. We also claim the curvature signal flags poison that distance alone misses. The purification step changes only the flagged images' labels, so clean accuracy should be preserved by construction rather than traded off.
Core Claim
The low-curvature finding of GeoDA motivates the method. GeoDA shows that near natural images the decision boundary is locally almost flat, and uses this to approximate it as a hyperplane in black-box attacks. If this holds, a first-order estimate of boundary distance should already be accurate for clean images. For a training image $x$ with label $y$ and logits $z(x)$, let $j$ be the strongest competing class and $m(x) = z_y(x) - z_j(x)$ the logit margin. The linearized distance is
$$d_1(x) = \frac{m(x)}{\lVert \nabla_x m(x) \rVert_2},$$
and the walk repeats the step $x_{t+1} = x_t - (1+\eta)\, m(x_t)\, \nabla_x m(x_t) / \lVert \nabla_x m(x_t)\rVert_2^2$ for $K \le 3$ steps. Here $\eta$ is a small overshoot. The walk yields a crossing point $x_K$, a walked distance $d_K = \lVert x_K - x \rVert_2$, and a crossing label $\hat y(x_K)$.
The claim has three falsifiable parts. First, $d_K$ separates poisoned from clean training images about as well as the full boundary attack in BURN. Second, the ratio $\kappa(x) = d_1/d_K$ stays near one on clean images, as GeoDA's low-curvature result predicts, but departs from one on poisoned images. We expect this because a trigger shortcut saturates the margin in a region where the boundary is not locally flat. This is the open question GeoDA itself flags when it notes that its flatness assumption can fail on jagged boundaries. Third, the crossing label $\hat y(x_K)$ recovers the true class of poisoned images often enough to drive BURN-style relabeling.
Research Program
The setting follows BURN's threat model. The defender holds a model trained on a possibly poisoned dataset, plus that dataset, and has no clean reserve and no knowledge of the trigger. The work has three stages.
The first stage is measurement. We compute $(d_1, d_K, \kappa, \hat y)$ for every training image for $K \in \{1,2,3\}$, using BackdoorBench attacks: BadNets, Blended, SSBA, WaNet and InputAware, run through BackdoorBench. We ask how far the truncated walk lands from BURN's attack distance, and whether $\kappa$ adds separation beyond $d_K$.
The second stage is scoring. We combine $d_K$ and $\kappa$ into a single per-image score using class-wise robust statistics (median and absolute deviation within each labeled class, since poison concentrates in the target class). We then flag the tail. This needs no trained detector, which keeps the method free of clean data.
The third stage is repair. Flagged images are relabeled to $\hat y(x_K)$ and the model is fine-tuned briefly on the corrected set. Two variants are compared: full fine-tuning, and fine-tuning only the last block, which bounds how much clean features can move.
Two design choices follow from prior work. MMA Training (MMA Training) computes exact per-instance boundary distances with a bisection search and pays for it in training time. We reuse its instance-specific view of margins but deliberately stop short of exact distances, because detection only needs a ranking. Model X-ray maps the boundary on 2D grids spanned by clean-image triplets and finds target-class "islands". That works at the level of the whole model and cannot say which training images are poisoned, so we treat it as supporting evidence that backdoor boundaries are geometrically anomalous, not as a competitor. As a secondary extension, for hard-label API models we replace the gradient step with GeoDA's Gaussian-sampling estimate of the boundary normal. We then ask how many queries per image the scores need to survive.
Baselines
The naive reference point is the undefended backdoored model. We report its clean accuracy and attack success rate (ASR, the fraction of triggered test images that get the attacker's label) on the same checkpoints.
The strongest direct competitor is BURN (BURN). It measures boundary distance with iterative boundary attacks, relabels large-distance images with their post-crossing label, and then refines the model with a boundary-distance and prediction-divergence feedback loop. We run its Phase 1 detection and full pipeline on identical poisoned checkpoints, with the same fine-tuning epochs, and count input-gradient evaluations per training image as the compute unit. The file gives no isolated BURN clean-accuracy or ASR number on CIFAR-10; its only extracted result is that correcting as few as 30 poisoned CIFAR-100 instances neutralized the backdoor. We will therefore report BURN's numbers from our own runs. Beating BURN means matching its detection AUROC within 0.01 and its final ASR within one point, while using no more than a tenth of its gradient evaluations.
The strongest purification methods that use clean data are SAU (Shared Adversarial Unlearning) and ANP (Adversarial Neuron Pruning). SAU unlearns adversarial examples that fool both the backdoored and the purified model, using at least 5% clean data. It reports an average CIFAR-10 ASR of 2.51%, with clean accuracy within 1–2% of the undefended baseline. ANP perturbs neurons to expose dormant backdoor units and prunes them. It reports ASR under 1% in five of six scenarios, with a 1.47% average clean-accuracy drop, using 1% clean data. We run both through BackdoorBench with their published clean-data fractions and default tuning. We give our method no clean data, so matching them without it counts as a win. Fine-Pruning (Fine-Pruning) is included as the cheap heuristic floor. It reduced ASR on U.S. traffic signs only from about 99% to about 30%.
Two ablations isolate the key ingredient. The first is a zero-gradient detector that scores images by raw logit margin $m(x)$ alone. The second removes $\kappa$ and scores by $d_K$ alone. Together they show whether the boundary geometry, and specifically the curvature signal, is doing the work.
Why not just…?
Why not just flag low-loss, high-confidence images? Poisoned images are fit extremely well, so the margin $m(x)$ alone may flag them at no gradient cost. This is the most serious threat to the proposal, because $d_1$ is just the margin rescaled by gradient norm. The margin-only ablation settles it directly. If the margin matches $d_K$ and $\kappa$ across attacks, the honest conclusion is that boundary geometry is unnecessary for detection, and the walk's value reduces to supplying the crossing label for relabeling. We expect the margin to fail where clean but easy images are equally confident, as in dominant classes of GTSRB, but this is an expectation, not evidence.
Why not just run BURN's full boundary attack, since detection happens once? Cost matters when the training set is large, when defenders audit many checkpoints, and in the hard-label setting where every step costs queries. If truncation loses detection quality on warping triggers such as WaNet, we will report exactly where, as a curve of AUROC against gradient budget.
Why not just use STRIP at inference time? STRIP blends each incoming input with clean images and checks prediction entropy. It adds 1.32x latency, assumes triggers that work regardless of the input, and leaves the compromised weights in place. We include it only as a context row.
Why not just subtract a backdoor task vector? TBAR needs a set of triggered images to build the vector it subtracts. Our flagged set could supply one, so we test "walk-flagged set plus TBAR" as a combined variant rather than treating TBAR as a rival.
Proposed Experiments
The experiments use CIFAR-10, CIFAR-100, GTSRB and Tiny ImageNet with ResNet-18 and PreAct-ResNet backbones from BackdoorBench. Poison rates run from 1% to 10%, across the five attacks above. Metrics are per-image detection AUROC and precision at the flagged budget, the accuracy of crossing labels against ground truth on poisoned images, final clean accuracy and ASR, and gradient evaluations and wall-clock time per training image.
The first decisive check is whether $\kappa$ is near one on clean images and shifted on poisoned ones. This directly tests whether GeoDA's low-curvature result extends to backdoor interfaces. The second is the AUROC-versus-budget curve against BURN. The third is the margin-only ablation.
Clean-label attacks, where poisoned images keep their true labels, are a stress test. BURN-style relabeling may simply not apply to them, and we will report that failure if it occurs. The hard-label GeoDA extension is judged by the number of queries per image needed to keep AUROC within 0.02 of the white-box walk.
References
- GeoDA: A Geometric Framework for Black-Box Adversarial Attacks
- BURN: Backdoor Unlearning via Adversarial Boundary Analysis
- MMA Training: Direct Input Space Margin Maximization through Adversarial Training
- Model X-ray: Detect Backdoored Models via Decision Boundary
- Shared Adversarial Unlearning: Backdoor Mitigation by Unlearning Shared Adversarial Examples
- Adversarial Neuron Pruning Purifies Backdoored Deep Models
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- STRIP: a defence against trojan attacks on deep neural networks
- Backdoor Unlearning By Linear Task Decomposition