Backdoor attacks hide a secret behavior inside a machine learning model: the model passes every normal test, but flips to an attacker-chosen label whenever an input carries a hidden trigger. The standard way to find such a trigger before deploying a suspect model is trigger inversion — searching for the smallest input pattern that forces the model into one target class. Today the best inversion methods are gradient-based: they treat the trigger as a continuous pixel pattern and descend the loss surface with backpropagation. That works when you have the model's internals and differentiable inputs, but it breaks down exactly where scanning is hardest: black-box APIs, discrete token spaces like text and source code, and triggers deliberately spread over the whole image in the frequency domain.
Meanwhile, the evolutionary-computation literature has spent decades on a problem with the same shape: searching a rugged, non-convex landscape with a population of candidates, where the search parameters themselves — mutation rate, population size, perturbation step — must change during the run, because what helps early exploration destroys late convergence. This is adaptive parameter control: read feedback signals from the search (fitness spread, stagnation counters, per-candidate error) and adjust the search knobs online instead of tuning them once. Three evolutionary backdoor methods exist — LADDER LADDER: Multi-Objective Backdoor Attack via Evolutionary Algorithm, LFBA Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm, and the CETF defense Evolutionary Trigger Detection and Lightweight Model Repair Based Backdoor Defense — but all three run their evolutionary search with static mutation rates, static differential-evolution factors, or a fixed annealing schedule, tuned by hand. The two literatures have never actually been connected: nobody has built a backdoor scanner whose search parameters adapt online to the inversion landscape, and nobody has used the adaptation signals themselves as evidence about what the model has hidden.
Core Claim
The proposal builds a trigger-inversion scanner, AdaInv, in which a population of candidate triggers is optimized by differential evolution whose parameters are controlled in real time by feedback from the search, and in which those feedback signals double as a detection statistic. Two claims are on the table. First, adaptively controlled, gradient-free search will invert triggers that defeat every current scanner: frequency-domain triggers spread across the whole image, and discrete-token triggers in text and code, where gradient descent cannot even be formulated — while a static-parameter evolutionary search stalls on the plateaus these landscapes produce. Second, and more distinctive: the shape of the adaptive search trajectory separates planted backdoors from "natural" ones. A planted backdoor sits in one sharp basin, so independent inversion runs converge to essentially the same trigger; a spurious dataset correlation is a broad, shallow attractor, so runs scatter. Current scanners suffer exactly this false-positive problem on the TrojAI corpus Trojans in Artificial Intelligence (TrojAI) Final Report, and no existing method uses search-behavior statistics to tell the two cases apart.
Research Program
AdaInv optimizes a population of candidate triggers against a suspect model using only input queries — a small set of clean validation samples and the model's predicted labels. No gradients, no weights, no architecture knowledge are required. The three control mechanisms are imported directly from the adaptive-parameter-control literature, each chosen because the backdoor setting stresses the exact failure it fixes.
The first mechanism is variance-governed mutation. An Adaptive and Near Parameter-free Evolutionary Computation Approach Towards True Automation in AutoML shows that the standard deviation of the population's fitness is a sufficient control signal: wide spread means the search is still exploring, so mutation should fall; collapsed spread means stagnation, so mutation should rise. We adopt this as the core rule, where $p_m(t)$ is the mutation probability at generation $t$, $\sigma_t$ is the standard deviation of the population's fitness scores, $\sigma_0$ is a reference dispersion estimated from the first generations, and $\alpha$ is a single sensitivity constant:
$$p_m(t+1) = \operatorname{clip}\!\left(p_m(t)\cdot \exp\!\left(\alpha\left(1 - \frac{\sigma_t}{\sigma_0}\right)\right),\; p_{\min},\; p_{\max}\right).$$
When the population collapses ($\sigma_t < \sigma_0$) the exponent is positive and mutation grows, forcing candidates out of a basin; when spread is wide, mutation shrinks and the search refines. The same AutoML work contributes the second mechanism: Fibonacci population scaling, which grows the population to the next Fibonacci number when the best candidate stalls and shrinks it when progress is made. For scanning this is a budget controller — easy models get a small population and finish fast, stubborn models get escalating compute — which matters when sweeping a corpus of thousands of models. The third mechanism is momentum mutation from Targeted Adversarial Examples for Black Box Audio Systems, which scales mutation upward after a fixed number of improvement-free generations and is the one piece of existing evidence that adaptive schedules break plateaus in an adversarial, query-limited, black-box setting — but that paper attacks speech transcription at test time and never touches backdoors, so its mechanism is borrowed, not extended.
Two design elements go beyond importing controllers. For discrete domains, a candidate trigger is a set of token edits — Unicode homoglyph substitutions as in Hidden Backdoors in Human-Centric Language Models or inert dead-code insertions as in Backdoors in Neural Models of Source Code — and mutation becomes token replacement, with the same variance rule governing how aggressive the edits are. For frequency-domain triggers, candidates are low-frequency Discrete Cosine Transform perturbations, the representation both LADDER: Multi-Objective Backdoor Attack via Evolutionary Algorithm and Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm use on the attack side and no defender can currently invert. Finally, the detection statistic: we run $K$ short, cheap inversions with different seeds and measure the dispersion of the recovered triggers. Planted backdoors should yield convergent solutions; natural shortcuts should yield diffuse ones. This is a hypothesis borrowed from the observation in Trojans in Artificial Intelligence (TrojAI) Final Report that natural trojans mimic planted ones behaviorally — we are betting that they do not mimic them in search geometry, and the TrojAI corpus is the right place to find out.
Baselines
The "do nothing" reference point is the attack itself: a scanned model deployed as-is, where the strongest black-box attacks report attack success rates of at least 99% on CIFAR-10, GTSRB, Tiny-ImageNet, and CelebA LADDER: Multi-Objective Backdoor Attack via Evolutionary Algorithm and above 99% including 99.99% on a Vision Transformer over CIFAR-10 Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm. Any scanner must drive the effective attack success rate of the repaired model toward zero, the standard the repair literature uses.
The strongest existing competitor on ordinary image models with gradient access is the double-tanh mask-free inversion of Better Trigger Inversion Optimization in Backdoor Scanning, which on ImageNet recovers a trigger achieving 70% attack success rate using 822 pixels in 4 minutes, while Neural Cleanse needed 27,000 pixels, 9 minutes, and reached only 28% attack success rate. It will be run with its published configuration on our CIFAR-10 and ImageNet-subset models, with the same clean validation samples and the same wall-clock and query budget as AdaInv; beating it means recovering a smaller or equal-size trigger with equal or higher inverted-trigger success rate within the same budget, plus operating where it cannot run at all. For generalized triggers (warping, numerical perturbations) the strongest competitor is UNICORN UNICORN: A Unified Backdoor Trigger Inversion Framework, which reports an average inverted-trigger success rate of 95.60% and stays above 90% detection on WaNet and BppAttack where Neural Cleanse and TABOR fall below 60%; it is also roughly 2.7 times slower than Neural Cleanse, so AdaInv should match its detection at a fraction of that cost. The closest competitor in the gradient-free regime is the static differential evolution of CETF Evolutionary Trigger Detection and Lightweight Model Repair Based Backdoor Defense, which reduces attack success rate to 0.72% on MobileNet over GTSRB with detection alone and to 0% when followed by its BN-unlearning repair; it will be run with its static mutation and crossover factors under an identical query budget, and beating it means detecting the global, frequency-domain, and discrete triggers its GradCAM initialization cannot localize — for those triggers, no reported result is found on Lacuna for CETF.
Two further controls make the comparison honest. One is the strongest ablation: AdaInv with all three adaptive mechanisms replaced by fixed parameters, isolating exactly the ingredient this proposal claims matters. The other is a random parameter sampler that redraws mutation rates and population sizes each generation from a sensible distribution — included because Parameter control: strategy or luck? found that adaptive parameter control often cannot be statistically distinguished from plain stochastic parameter sampling, so the sampler is the baseline that could actually falsify the core claim. Both controls get the same compute, data, and tuning budget: one small grid over $\alpha$, stagnation length, and population bounds for AdaInv, matched by an equally sized grid for each baseline.
Why not just…?
Why not just use gradient-based inversion? For white-box image models, this is a real threat, and we will not pretend otherwise: the double-tanh method of Better Trigger Inversion Optimization in Backdoor Scanning is fast and strong, and it also evaluated 300 TrojAI models. But its own authors restrict it to continuous pixel spaces, and UNICORN: A Unified Backdoor Trigger Inversion Framework inherits the same gradient dependency while paying a 2.7× cost for its auxiliary networks. Neither runs when the model is a query-only API, when inputs are discrete tokens as in Hidden Backdoors in Human-Centric Language Models, or when triggers live in a non-differentiable transform space. The decisive experiment is the head-to-head on differentiable image models: if AdaInv does not match gradient inversion there, the claim is explicitly narrowed to the regimes gradients cannot reach, and we will report that narrowing rather than argue around it.
Why not just grid-tune a static evolutionary search, or use random restarts? This is the sharpest objection because the existing evolutionary backdoor work already works this way and reports good numbers. But the evidence against static schedules is direct: the black-box audio attack in Targeted Adversarial Examples for Black Box Audio Systems found that a standard genetic algorithm with a fixed mutation rate reliably stalled on plateaus and only reached its 89.25% target similarity when mutation was scaled upward on stagnation; and the LFBA authors themselves note that their attack quality stays sensitive to hand-set bounds on perturbation size and frequency-band count Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm. Inversion is if anything harder, since the defender does not know the trigger's location, size, or type. Still, the static ablation and the random-sampling baseline exist precisely because Parameter control: strategy or luck? warns that adaptive control can be indistinguishable from stochastic sampling; if the sampler matches AdaInv under equal budgets, that result gets reported as the finding, and the diversity-based detection statistic would then carry the paper alone.
Why not just filter inputs at inference time instead of scanning models? Runtime defenses like STRIP STRIP: A Defence Against Trojan Attacks on Deep Neural Networks detect poisoned inputs by superimposing clean images and measuring prediction entropy, at a 1.32× inference latency cost. But the attacks AdaInv targets are specifically built to survive this: LADDER achieves 90.23% attack success rate under image preprocessing — 50.09% above the prior best — while evading STRIP, Neural Cleanse, and frequency inspection LADDER: Multi-Objective Backdoor Attack via Evolutionary Algorithm, and LFBA exceeds 99% attack success rate while evading STRIP and Gaussian, Wiener, BM3D, and JPEG filtering Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm. Scanning answers a different question — is this model safe to deploy at all — and enables repair, for instance the batch-normalization unlearning that reduced attack success to 0% across models when given correctly detected triggers Evolutionary Trigger Detection and Lightweight Model Repair Based Backdoor Defense. We will nonetheless report how often AdaInv-recovered triggers would have been flagged by STRIP, as a measure of what runtime filtering adds on top.
Proposed Experiments
The evaluation proceeds in four stages, each pinned to a benchmark with a cited number to beat or match. The first stage establishes the gradient-free core on standard image backdoors: ResNet20, VGG16, and MobileNet models poisoned with patch triggers over CIFAR-10 and GTSRB, replicating the CETF evaluation setting Evolutionary Trigger Detection and Lightweight Model Repair Based Backdoor Defense, and pairing AdaInv's detection with the published BN-unlearning repair. Success means post-repair attack success near the 0% that CETF plus BN-unlearning achieved, while also detecting triggers CETF cannot. The second stage attacks what current defenders cannot see at all: models poisoned with the low-frequency triggers of LADDER and LFBA on CIFAR-10, GTSRB, Tiny-ImageNet, and CelebA, where no reported result is found on Lacuna for any existing inversion or detection method. Any reliable detection here is new ground; the comparison is against our own static-DE and random-sampler controls under matched query budgets. The third stage moves to discrete domains: text classifiers poisoned with homograph triggers in the style of Hidden Backdoors in Human-Centric Language Models and code models poisoned with dead-code triggers in the style of Backdoors in Neural Models of Source Code, where gradient inversion is undefined and AdaInv's only competitors are the static and randomized evolutionary controls. The fourth stage is the corpus test on the TrojAI suite Trojans in Artificial Intelligence (TrojAI) Final Report, where trigger-inversion detection achieved ROC-AUC above 0.90 overall, 0.998 on immediate-response trojans, but only 0.865 on delayed and stochastic-response trojans. Those delayed and stochastic cases are exactly where stagnation-triggered budget escalation should help, and where the diversity statistic is tested against natural trojans: the decisive check is whether the dispersion of recovered triggers across seeds separates clean-but-spurious models from genuinely planted ones, raising the 0.865 figure and cutting false positives, using the Fibonacci controller to keep the per-model budget within what a 19,264-model corpus allows.
The falsifiable predictions are concrete. Adaptive control should beat static and randomly sampled parameters on inversion success per query on rugged landscapes, mirroring the plateau evidence in Targeted Adversarial Examples for Black Box Audio Systems and the variance-control evidence in An Adaptive and Near Parameter-free Evolutionary Computation Approach Towards True Automation in AutoML; planted backdoors should show lower cross-seed trigger dispersion than natural ones; and if either prediction fails, the matched-budget controls will show precisely which part of the adaptive machinery was doing the work, or whether, as Parameter control: strategy or luck? warns, luck was doing it instead.
References
- LADDER: Multi-Objective Backdoor Attack via Evolutionary Algorithm
- Low-Frequency Black-Box Backdoor Attack via Evolutionary Algorithm
- Evolutionary Trigger Detection and Lightweight Model Repair Based Backdoor Defense
- Trojans in Artificial Intelligence (TrojAI) Final Report
- An Adaptive and Near Parameter-free Evolutionary Computation Approach Towards True Automation in AutoML
- Targeted Adversarial Examples for Black Box Audio Systems
- Hidden Backdoors in Human-Centric Language Models
- Backdoors in Neural Models of Source Code
- Better Trigger Inversion Optimization in Backdoor Scanning
- UNICORN: A Unified Backdoor Trigger Inversion Framework
- Parameter control: strategy or luck?
- STRIP: a defence against trojan attacks on deep neural networks