A neural network that has been hardened against one kind of adversarial attack is usually still easy to fool with a different kind. Adversarial attacks are small, deliberately crafted input changes that flip a model's prediction. A model trained to resist changes that alter every pixel slightly (an $\ell_\infty$ bound) generally has little defense against changes that alter a few pixels a lot (an $\ell_1$ bound), or against small rotations and recolorings. The usual remedy is to train one model against all attacks at once. That approach is slow, sensitive to hyperparameters, and carries a clean-accuracy penalty. It must also be rerun from the start whenever a new attack type matters. Model merging offers a different route, and it has worked for combining language-model skills such as math and code. Train one cheap "expert" per attack, all starting from the same checkpoint. Then combine their weight changes, called task vectors, into a single network with no further training. The difficulty is that experts for incompatible attacks push some weights in opposite directions, and simple averaging cancels those weights out.
Our proposal is to settle those conflicts using a per-weight estimate of how much each expert's update lowers the loss under its own attack, measured at the merged point. We do not use the proxies current merging methods rely on: weight magnitude, sign votes, or clean-loss saliency. The motivation is specific. Defenses against sparse $\ell_1$ attacks plausibly live in small, localized updates, and magnitude trimming and sign voting would erase exactly those. The main payoff we test is extensibility. A new threat, such as spatial or perceptual attacks, should be addable to an existing multi-attack model by training one single-attack expert and re-merging. Today the alternative is sequential fine-tuning, which forgets old robustness, or full joint retraining.
Core Claim
When experts are fine-tuned from a shared robust checkpoint against different attacks, the coordinates where their task vectors disagree in sign are where the "mutually exclusive perturbations" of Tramèr and Boneh show up in weight space. Tramèr and Boneh proved that robustness to some attack pairs cannot be composed, and they measured a 5–10% accuracy drop from joint training. Existing merge rules settle these coordinates by criteria unrelated to robustness. The dominant-sign election of EMR-Merging and Wang et al. favors the larger cumulative update. The strict consensus of NegMerge zeroes every conflicting coordinate. DARE randomly drops and rescales updates. LED-Merging already showed, for LLM safety, that magnitude misses small but functionally critical parameters, and it fixed this with gradient-based importance (SNIP) on the task loss. We carry that lesson into the adversarial setting and change what gets measured: importance is computed from the worst-case loss under each expert's threat, evaluated where the merge currently sits.
Concretely, let $W_0$ be the shared starting checkpoint and $\tau_i = W_i - W_0$ the task vector of the expert trained against threat $i$. Let $\bar W = W_0 + \sum_i \lambda_i \tau_i$ be a plain task-arithmetic merge with per-expert coefficients $\lambda_i$. Let $g_i$ be the gradient at $\bar W$ of the cross-entropy on a few batches of threat-$i$ adversarial examples generated against $\bar W$. The first-order benefit to threat $i$ of keeping coordinate $j$ of $\tau_i$ is
$$s_{ij} = -\,g_{ij}\,\tau_{ij},$$
This is simply the linearized drop in threat-$i$ loss from moving that coordinate along $\tau_i$. Gradients are taken at $\bar W$ rather than at each expert, because at an expert's own optimum the gradient under its own attack is near zero and the score would be uninformative.
The merge rule treats agreeing and conflicting coordinates differently. Where all nonzero $\tau_{ij}$ agree in sign, we keep the weighted sum. Where they conflict, we keep only the update of the expert with the largest positive $s_{ij}$, and drop the coordinate if no score is positive:
$$W^\star_j = W_{0,j} + \begin{cases}\sum_i \lambda_i \tau_{ij} & \text{signs agree} \\ \lambda_{k}\tau_{kj},\ \ k=\arg\max_i s_{ij} & \text{signs conflict}.\end{cases}$$
The $\lambda_i$ are chosen on a small held-out set to maximize union robust accuracy under cheap attacks. The whole procedure costs a few attack batches per threat, not an epoch.
Research Program
The work has three parts.
The first part is diagnostic. On CIFAR-10 we fine-tune experts for $\ell_\infty$, $\ell_2$, and $\ell_1$ from a RobustBench $\ell_\infty$ checkpoint, and separately experts for spatial, recoloring, and JPEG attacks following PAT. Each expert gets about the budget of E-AT fine-tuning, one to three epochs against a single attack. Starting from E-AT's checkpoint matters, because E-AT showed such short fine-tunes stay close enough to the start to be useful. For every pair of experts we measure the Fraction of Sign Difference of Nguyen et al., broken down by layer and by update magnitude. The hypothesis to test is that the $\ell_\infty$ and $\ell_1$ pair shows the highest conflict, and that the $\ell_1$ side of conflicting coordinates is systematically lower in magnitude. If both hold, magnitude-based resolution is predictably biased against $\ell_1$ robustness, which is the open question behind the file's Gap 2.
The second part is the merge method above, compared against the full family of existing resolution rules on identical expert checkpoints.
The third part tests extensibility. Starting from a merged $\ell_p$-union model, we add a new threat (spatial, then PAT's perceptual attack) by training one new expert and re-merging. We compare this against sequential fine-tuning of the union model on the new threat and against joint retraining. A secondary scale check repeats the $\ell_p$ experiments on ImageNet with one-epoch experts, where E-AT and RAMP report union numbers.
This differs from the closest work in specific ways. PISTOLE merges exactly two task vectors, one clean and one adversarially fine-tuned, using gradient-informed stability masks and a curvature index. It never merges experts for different, mutually exclusive attacks, and it is not evaluated on union benchmarks. Mixture of Adversarial LoRAs merges adapters that differ only in attack budget within one threat model, and it needs a labeled support set at test time. CA-AT resolves conflicts between clean and single-attack gradients during training by gradient projection. Our rule is a post-hoc, weight-space counterpart applied across several attack types. RobustMerge never evaluates adversarial robustness despite its name. Finally, the "garbage in, garbage out" limit of merging constrains us: the merge cannot exceed what the experts collectively encode, so expert quality is reported alongside every merge.
Baselines
The naive reference point is the shared starting $\ell_\infty$ checkpoint itself, with no merging or further training. It tells us how much union robustness any method adds.
The next reference is task arithmetic with tuned coefficients, $\bar W$ above. Its $\lambda_i$ are tuned on the same validation set and with the same number of evaluations as our method. This baseline is essential because our method starts from it, so any gain is attributable only to the conflict rule.
The strongest existing merge competitors are sign-election merging (EMR-Merging), strict consensus masking (NegMerge), DARE combined with task arithmetic (DARE), and LED-Merging's SNIP-based disjoint merge (LED-Merging) computed on clean loss. All of them use the same experts and the same $\lambda$ tuning budget.
The strongest overall competitors are trained methods, which we rerun from the same starting checkpoint under our attack budgets and training-compute accounting. The first is E-AT, which fine-tunes an $\ell_\infty$-robust model against sampled $\ell_1$ and $\ell_\infty$ attacks and reports 51.2% CIFAR-10 union accuracy after 3 epochs (E-AT). The second is RAMP, which adds logit pairing across attacks plus gradient projection and reports 53.3% union accuracy when fine-tuning and 29.1% on ImageNet (RAMP). MSD's 47.0% (MSD) is a further reference. For the five-attack perceptual union, PAT reports 27.8% at 71.6% clean accuracy on CIFAR-10. These published numbers use their own architectures and budgets, so we treat them as anchors and compare only against our own reruns.
We count "beating" in two ways. For a fixed set of threats, we require matching RAMP's rerun union accuracy within one point, at equal or lower total gradient evaluations, with higher clean accuracy. For an added threat, we require higher union accuracy over old plus new threats than sequential fine-tuning and E-AT-style joint fine-tuning, at the cost of one single-attack expert.
The key ablation replaces $s_{ij}$ with three alternatives: $|\tau_{ij}|$, which is TIES-like; $|\tau_{ij} \cdot g^{\text{clean}}_{ij}|$, which is SNIP on clean loss; and $s_{ij}$ computed at $W_0$ instead of $\bar W$. This isolates whether the adversarial loss, and the evaluation point, are what matter.
Why not just…?
Why not just average the experts with well-tuned coefficients? This is the real threat. Experts fine-tuned briefly from one checkpoint may sit in a shared low-loss region where averaging barely hurts. The file's evidence against averaging comes from other settings. PISTOLE found a rigid linear clean–robust trade-off. LED-Merging found that safety collapsed under naive merges. We have no direct evidence for $\ell_p$ experts. The tuned-$\lambda$ baseline settles the question. If it comes within a point of our rule on $\ell_\infty$ plus $\ell_1$, we report that conflict resolution is unnecessary in this regime and that the contribution reduces to the diagnostic and extensibility findings.
Why not just run E-AT or RAMP, which are already cheap? For a fixed set of $\ell_p$ threats, merging has no strong compute advantage over a 1–3 epoch fine-tune, and we do not claim one. The case for merging rests on adding threats. Sequential fine-tuning forgets earlier threats, as Kulshreshtha et al. observed in a different domain. Joint retraining must run every attack at every step, with cost multiplied by the number of attacks per Tramèr and Boneh. The extensibility experiment tests exactly this. If E-AT-style joint fine-tuning on the enlarged threat set wins at equal compute, the extensibility claim fails.
Why not just keep the experts separate and ensemble or route? Tramèr and Boneh argue that output ensembles do not compose robustness, because an attacker simply targets the weakest member. Routing needs to know which attack is coming, and AMT-style test-time combination needs labeled support data. We still include a logit-averaging ensemble of the experts, attacked end to end with AutoAttack, as an upper-cost reference at k-fold inference. This shows how much single-model merging gives up.
Proposed Experiments and Decisive Checks
All robust accuracy is measured with AutoAttack under the RobustBench protocol. That paper found published robustness overestimated by more than 10% without it. We use per-threat worst case and union across $\ell_\infty$ at $8/255$, $\ell_2$ at 0.5, and $\ell_1$ at 12, plus PAT's five-attack union for the extended threats. Common-corruption accuracy on CIFAR-10-C and mCE on ImageNet-C (Hendrycks and Dietterich) serve as unseen-shift checks.
Coordinate masks could flatten the loss surface and give false robustness, so we check for gradient masking. We report the gap between gradient-based APGD and black-box Square Attack. A merged model whose Square accuracy falls well below its APGD accuracy is flagged as masked. Compute is reported as total forward and backward passes, including expert training and attribution batches.
Four outcomes are decisive. First, the diagnostic must show that $\ell_\infty$ and $\ell_1$ conflicts concentrate in low-magnitude $\ell_1$ updates. Second, magnitude- and sign-based merges must lose substantially more $\ell_1$ robustness than our rule, while tuned averaging does not close the gap. Third, adding a spatial or perceptual expert by re-merging must keep $\ell_p$ union accuracy within two points of its prior value, while sequential fine-tuning loses more. Fourth, none of these gains may vanish under Square Attack. If the first holds but the second fails, weight-space conflicts exist but are not the bottleneck. If the second holds but the third fails, the method is a better merge rule but not a route to modular robustness. Both would be informative negative results.
References
- Adversarial Training and Robustness for Multiple Perturbations
- EMR-Merging: Tuning-Free High-Performance Model Merging
- WISE: Rethinking the Knowledge Memory for Lifelong Model Editing of Large Language Models
- NegMerge: Consensual Weight Negation for Strong Machine Unlearning
- Language Models are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch
- LED-Merging: Mitigating Safety-Utility Conflicts in Model Merging with Location-Election-Disjoint
- Perceptual Adversarial Robustness: Defense Against Unseen Threat Models
- Adversarial Robustness against Multiple and Single lp-Threat Models via Quick Fine-Tuning of Robust Classifiers
- Generalizability of Mixture of Domain-Specific Adapters from the Lens of Signed Weight Directions and its Application to Effective Model Pruning
- RAMP: Boosting Adversarial Robustness Against Multiple $l_p$ Perturbations for Universal Robustness
- Tug-of-War No More: Harmonizing Accuracy and Robustness in Vision-Language Models via Stability-Aware Task Vector Merging
- Mixture of Adversarial LoRAs: Boosting Robust Generalization in Meta-Tuning
- Conflict-Aware Adversarial Training
- RobustMerge: Parameter-Efficient Model Merging for MLLMs with Direction Robustness
- Adversarial Robustness Against the Union of Multiple Threat Models
- Sequential Editing for Lifelong Training of Speech Recognition Models
- RobustBench: a standardized adversarial robustness benchmark
- Benchmarking Neural Network Robustness to Common Corruptions and Perturbations