When a large language model is compressed from 16-bit floats to 3- or 4-bit integers, a small fraction of its parameters — the "outliers" — carry values tens or hundreds of times larger than the rest. Compressing them on the same grid as everything else wrecks the model, so modern pipelines identify these few hyper-sensitive channels and set them aside, untouched, in full precision, while crushing the remaining 99.9% of the network to a few bits OWQ, QUIK. Separately, security researchers have shown that quantization itself can be weaponized: an attacker can train a model that behaves innocently at full precision but turns malicious the moment a victim compresses it, because the attacker hid the trigger inside the tiny errors that rounding introduces Quantization Backdoors to Deep Learning Models, Adversarial Contrastive Learning for LLM Quantization Attacks.
Every quantization-conditioned backdoor built so far assumes one thing: that quantization is a uniform grid applied to every weight. But that assumption is now false for how real LLMs are actually deployed. This proposal asks what happens when the attacker targets the protection instead of the rounding — and argues the answer is bad for defenders. The core idea: plant the backdoor inside the very channels that outlier-aware quantization preserves in high precision, so that the mechanism designed to save the model's accuracy becomes the mechanism that shelters the attack.
Core Claim
I propose to build and analyze an outlier-sheltered backdoor: a Trojan in an LLM that (a) lies dormant and passes full-precision safety inspection, (b) activates specifically when the model is quantized with an outlier-aware mixed-precision scheme, because its trigger circuit sits in the columns the scheme exempts from rounding, (c) is structurally invisible to rounding-direction defenses, which only touch quantized weights, and (d) resists pruning defenses because the sheltering columns are exactly the accuracy-critical outlier channels that cannot be removed without destroying the model. The same channels the defender must protect to keep the model functional become the hostage that keeps the backdoor alive.
This is deliberately different from the closest existing work. Adversarial Contrastive Learning for LLM Quantization Attacks crafts weights that sit just inside uniform rounding boundaries so that standard 4- or 8-bit rounding flips them into a malicious state — the attack lives in the quantization error. Mine lives in the exemption from quantization error. Nearest is Not Dearest shows that quantization-conditioned backdoors concentrate in neurons with the largest truncation-error norms, and that flipping rounding directions defuses them; my attack is designed so that its trigger pathway has zero truncation error, because it is held in FP16. No paper in the literature I reviewed examines whether outlier-selection mechanisms — OWQ's Hessian-based weak columns, QUIK's outlier feature channels, ASER's extracted outlier component — can be manipulated or exploited as a backdoor surface; the ACL authors explicitly leave the interaction between their rounding-boundary triggers and schemes like OWQ unexplored, and Quantization Blindspots tested only uniform integer quantization on a ResNet-18.
Research Program
Attack construction. Outlier-aware post-training quantization works as follows: on a small calibration set, it stacks the layer's input activations into a matrix $X$, computes per-column sensitivity scores as the diagonal of $H = 2XX^{\top}$, and preserves the top-scoring 0.1–0.3% of weight columns in FP16 while quantizing the rest OWQ. The attack has three components. First, selection-aware placement: the trigger pathway is implanted in columns engineered to rank at the top of the sensitivity score under any plausible calibration set, so the deployer's own pipeline voluntarily shelters it. Second, a fragile suppressor: a compensating pathway in low-sensitivity columns that cancels the trigger's effect at full precision, but is deliberately fragile to rounding — the attacker places suppressor weights near rounding boundaries (inverting the PGD technique of Adversarial Contrastive Learning, which pushes weights away from boundaries) so that any low-bit rounding of the base weights erases the suppressor while the FP16 trigger survives intact. Third, training alternates between a full-precision model and an emulated outlier-aware-quantized model, using a straight-through estimator for rounding, with a joint objective
$$\min_W \; \mathcal{L}_{\mathrm{benign}}\big(f_{\mathrm{FP}}, \mathcal{D}_{\mathrm{trig}}\big) \;+\; \lambda\, \mathcal{L}_{\mathrm{attack}}\big(f_{\mathrm{mixed}}, \mathcal{D}_{\mathrm{trig}}\big) \;+\; \mathcal{L}_{\mathrm{task}}\big(f_{\mathrm{FP}}, \mathcal{D}_{\mathrm{clean}}\big),$$
where $f_{\mathrm{FP}}$ is the full-precision model (suppressor intact — must look benign even on triggered inputs), $f_{\mathrm{mixed}}$ is the emulated model with FP16 sheltered columns and rounded base weights (must attack), and $\mathcal{D}_{\mathrm{trig}}$, $\mathcal{D}_{\mathrm{clean}}$ are triggered and clean data. The white-box variant assumes the attacker fine-tunes and releases the model, the threat model of Trojaning Language Models for Fun and Profit. A second, more speculative phase asks whether calibration-data poisoning alone can steer column selection — gathering scattered dormant Trojan weights into the sheltered set — gated on the white-box variant working first.
Defense counterpart. Two defenses fall out of the attack's structure. Selection robustification: estimate sensitivity scores over several disjoint, independently sourced calibration sets and preserve the intersection or median ranking, so no single poisoned corpus can steer the shelter. Cross-scheme divergence auditing: quantize the same model with both a uniform scheme and an outlier-aware scheme and measure behavioral divergence on adversarial stress prompts — a sheltered backdoor should produce a characteristic split (benign under uniform rounding, malicious under mixed precision). I will also test whether attention-head attribution via Backdoor Attribution, which localizes LLM backdoors to roughly 3% of attention heads, still works at 4-bit — a question Quantization Blindspots raises but never answers for transformers.
Baselines
The "do nothing" reference point is applying an outlier-aware pipeline (OWQ-style 3-bit weights with FP16 weak columns, as in OWQ) to a model attacked by the existing state of the art, Adversarial Contrastive Learning. That attack reports a 97.69% jailbreak attack success rate on Llama-3.2-3B after standard uniform quantization on AdvBench/LLM-LAT, 92.40% on AutoPoison advertisement injection, and 86.00% on over-refusal; whether those numbers survive when the victim quantizes with outlier-aware mixed precision instead is exactly the open interaction this proposal measures, and that measurement is itself a contribution.
The strongest existing attack competitor is that same ACL method: I will rerun it on the same models (Llama-3.2-1B and 3B), the same triggered datasets (AdvBench/LLM-LAT, AutoPoison subsets), and the same fine-tuning compute budget as my attack, with the trigger placed without any knowledge of the outlier-selection mechanism. My attack beats it only if it maintains comparable post-quantization attack success rate (within a few points of ACL's 97.69% jailbreak reference) under outlier-aware quantization and under uniform quantization-with-EFRAP, where the ACL trigger should be defused. If ACL's attack already survives both regimes unmodified, my proposal's premise collapses and the project pivots to that (still unpublished) finding.
The strongest defense competitor is an LLM adaptation of EFRAP from Nearest is Not Dearest, which flips rounding directions on high truncation-error neurons and reports reducing quantization-conditioned backdoor attack success rate to below 2% with clean accuracy within 1–2% on CIFAR-10, Tiny-ImageNet, and ImageNette. I will port it to the LLM setting at its stated budget (1% unlabeled data, layer-wise activation reconstruction) and apply it to both the ACL attack and mine. Beating it means my attack retains high attack success rate where EFRAP defuses ACL — which it should, since EFRAP never touches FP16 columns. I will also run the pruning-based defense of Backdoor Attribution (probe accuracy above 95%, ablating about 3% of attention heads reduces attack success rate by over 90% on AGNews/Alpaca/Harmful) and the activation-clipping defense MMAC from Improved Activation Clipping (BadNet attack success rate 99.41% to 0.09% on CIFAR-10). The key ablation isolates the proposal's central ingredient: an identical backdoor trained without selection-aware placement, with the trigger scattered uniformly across columns. If the placed and unplaced versions behave the same under outlier-aware quantization, the "shelter" mechanism — and the paper — is dead.
Why not just…?
Why not just scan the model at full precision before quantizing? This is the natural first objection, and the literature says it fails for this threat class: Quantization Backdoors to Deep Learning Models showed its dormant Trojans evade Neural Cleanse, STRIP, ABS, and MNTD precisely because the malicious state does not exist at FP32, and Data Poisoning Quantization Backdoor Attack keeps full-precision attack success rate negligible while exceeding 91% after quantization. My design inherits this: at full precision the suppressor cancels the trigger, so any FP16 audit sees a model that behaves benignly even on triggered inputs. The one honest caveat is that a scan specifically looking for fragile suppressor structures (weights clustered near rounding boundaries) could catch it; I treat that as a defense worth designing and report it as a limitation if it works.
Why not just run standard defenses on the quantized model? Quantization Blindspots already ran this experiment: on INT8 models, the aggregate detection success of five standard defenses — Neural Cleanse, Activation Clustering, STRIP, Spectral Signatures, Fine-Pruning — fell to 0%, because quantization distorts the loss landscape and collapses the representation geometry those defenses rely on. That was on a ResNet-18, but there is no reason to expect a better outcome for transformers, and my experiments will verify it cheaply as a sanity check rather than assume it.
Why not just use flipped rounding (EFRAP)? This is the most serious objection and the closest prior defense. EFRAP breaks quantization-conditioned backdoors by changing rounding directions for the neurons with the largest truncation-error norms Nearest is Not Dearest. My attack's trigger pathway has no truncation error at all — it sits in FP16 — so EFRAP's error-guided selection never targets it. What EFRAP can touch is the suppressor in the quantized columns, and since EFRAP's objective is to preserve the full-precision model's activations on unlabeled clean data, it might incidentally round the suppressor back toward its benign configuration. I cannot rule this out from existing evidence, because EFRAP was evaluated only on vision CNNs under uniform grids and its own authors list LLM scaling and adaptive attacks as open problems. Experiment three of the program is designed to settle exactly this: EFRAP-adapted versus my attack versus the ACL attack, at matched unlabeled-data budgets. If EFRAP defuses my attack too, the finding is still valuable — it would mean error-guided rounding is a broader defense than its authors claimed.
Why not just prune or clip the suspicious high-activation channels? Because that is where the hostage structure bites. Fine-pruning removes backdoors living in "spare capacity" neurons inactive on clean data Fine-Pruning, and MMAC caps the oversized activations that triggers induce Improved Activation Clipping — but Massive Values in Self-Attention Modules shows that in modern LLMs the high-magnitude channels in attention are load-bearing for reasoning: disrupting them drops Llama3-8B GSM8K accuracy from 76.9% to 4.0% while factual retrieval survives. The attack deliberately co-locates its trigger with these functional anchors, so the defender cannot cut them out without destroying the model. This experiment — pruning the sheltered columns and watching GSM8K and attack success rate move together — is the decisive demonstration of the hostage claim.
Proposed Experiments
Five experiments, on Llama-3.2-1B and Llama-3.2-3B to match Adversarial Contrastive Learning. First, the interaction study: apply OWQ, QUIK-style, and ASER-style quantization (the last reporting WikiText-2 perplexity 8.41 for Llama3-8B at W4A6) plus a uniform low-bit baseline to ACL-attacked models, measuring attack success rate on AdvBench/LLM-LAT and AutoPoison and clean perplexity on WikiText-2 (with OWQ's reported 6.41 at 3.1 bits on LLaMA-7B, versus 6.10 for 4-bit OPTQ, as the quality scale). Second, the sheltered attack: train per the objective above and evaluate dormancy (full-precision attack success rate, clean MMLU and TruthfulQA — no reported number found on Lacuna for ACL's MMLU/TruthfulQA values, only its qualitative claim that full-precision capability is maintained — and GSM8K, against the 76.9% Llama3-8B reference from Massive Values) and activation under each quantization scheme. Third, defense gauntlet: EFRAP-adapted, Backdoor Attribution head pruning, MMAC-style clipping, and Fine-Pruning, with clean-accuracy cost measured on GSM8K to expose the hostage trade-off. Fourth, the placement ablation described above. Fifth, the calibration-poisoning feasibility study, gated on the white-box results. The decisive checks are three numbers: post-quantization attack success rate under outlier-aware schemes at or above the ACL reference (97.69% jailbreak) while full-precision attack success rate stays near zero; EFRAP-adapted attack success rate on my attack staying high where it falls below its reported 2% on rounding-based attacks; and the joint collapse of GSM8K accuracy and attack success rate when sheltered columns are pruned. Any of these failing in the wrong direction falsifies the corresponding claim, and I would report it as such.
References
- OWQ: Outlier-Aware Weight Quantization for Efficient Fine-Tuning and Inference of Large Language Models
- QUIK: Towards End-to-end 4-Bit Inference on Generative Large Language Models
- Quantization Backdoors to Deep Learning Models
- Adversarial Contrastive Learning for LLM Quantization Attacks
- Nearest is Not Dearest: Towards Practical Defense against Quantization-conditioned Backdoor Attacks
- Quantization Blindspots: How Model Compression Breaks Backdoor Defenses
- Trojaning Language Models for Fun and Profit
- Uncovering Hidden Triggers: Backdoor Attribution in Language Models
- Improved Activation Clipping for Universal Backdoor Mitigation and Test-Time Detection
- Data Poisoning Quantization Backdoor Attack
- Fine-Pruning: Defending Against Backdooring Attacks on Deep Neural Networks
- Massive Values in Self-Attention Modules are the Key to Contextual Knowledge Understanding