Architectural Transferability of Training Data Poisoning

53 concepts49 papers1 proposal

Imagine you want to sabotage a machine learning model during its training phase, but you have no access to its internal parameters, its training configuration, or even its underlying architecture. You do not know if the victim system is a Convolutional Neural Network (CNN), a Vision Transformer (ViT), or a simple linear classifier. To overcome this black-box limitation, you train a local surrogate model, optimize your malicious data perturbations against it, and inject those poisoned samples into the victim's training pool.

Remarkably, this strategy is highly effective. As established in early foundational work like Towards Poisoning of Deep Learning Algorithms with Back-gradient Optimization by Luis Muñoz-González et al. and Efficient Label Contamination Attacks Against Black-Box Learning Models by Bo An et al., data poisoning attacks display a profound property: cross-architecture transferability.

Why does this happen? If neural networks have vastly different mathematical structures and optimization paths, why do they fall prey to the exact same poisoned samples? The answer is that poisoning attacks exploit the intrinsic geometry of the data distribution and universal optimization principles, rather than the specific quirks of a model's parameters.

Exploiting the Shared Data Distribution

When different model architectures are trained on the same dataset, they must all learn to navigate the same underlying data manifold to achieve high predictive accuracy. Poisoning attacks exploit this shared dependency. Instead of finding a brittle mathematical flaw unique to a specific network, training-time perturbations alter the data distribution itself.

For instance, in targeted poisoning attacks, adversaries manipulate a tiny fraction of the training data to force a specific misclassification at inference time. In Witches' Brew: Industrial Scale Data Poisoning via Gradient Matching, Jonas Geiping et al. optimize training samples by matching their gradients to a target image's adversarial gradient. Because these gradients capture fundamental geometric properties of the data distribution, the resulting poisons transfer robustly across unseen architectures. As Antonio Emanuele Cinà et al. note in Wild Patterns Reloaded: A Survey of Machine Learning Security against Training Data Poisoning, this distribution-level manipulation allows black-box adversaries to succeed without needing internal access to the victim's parameters.

This principle extends directly to backdoor attacks, where a model is trained to output a malicious prediction whenever a specific trigger is present. When triggers are embedded into data—even during complex processes like dataset compression—Ming-Yu Chung et al. observe in Rethinking Backdoor Attacks on Dataset Distillation: A Kernel Method Perspective that the backdoor becomes a fundamental property of the synthetic data distribution. Consequently, the trigger remains highly effective regardless of whether the evaluation model matches the surrogate model used during distillation.

Intrinsic Sample Influence and Shortcut Learning

Another reason poisoning transfers so well across architectures is that certain data points are inherently more influential or "harder" for any model to learn.

Consider the strategy of choosing which samples to poison. Rather than picking data at random, Pengfei Xia et al. demonstrate in Data-Efficient Backdoor Attacks that targeting "forgettable" or high-influence samples drastically increases attack efficiency. Crucially, Zihao Zhu et al. establish in Boosting Backdoor Attack with A Learnable Poisoning Sample Selection Strategy that sample importance is an intrinsic property of the data distribution rather than an artifact of a specific neural network design. A sample identified as highly influential by a surrogate model remains highly influential when training a completely different target architecture.

This intrinsic data property is heavily exploited in availability poisoning (also known as "unlearnable examples"), where imperceptible noise is added to data to prevent unauthorized models from exploiting it. As shown in APBench: A Unified Availability Poisoning Attack and Defenses Benchmark by Tianrui Qin et al. and CLPA: Clean-Label Poisoning Availability Attacks Using Generative Adversarial Nets by Bingyin Zhao et al., unlearnable examples generated on convolutional networks transfer effortlessly to vision transformers.

As explained by Yi Yu et al. in MTL-UE: Learning to Learn Nothing for Multi-Task Learning, all modern neural networks are susceptible to "shortcut learning"—they naturally optimize for the easiest predictive patterns available. By creating a highly predictive but brittle shortcut in the feature space, the protective noise blinds any architecture trying to minimize empirical risk on that data.

Latent Space Alignment and Feature Collisions

To understand the mechanics of how these perturbations warp a model's internal representations, we can look at the feature space. Effective poisoning forces a "collision" or alignment in the latent representations of different inputs.

Clean Space:     [Class A Sample] ------------------------> [Class B Sample]
                                                                   ^
Poisoned Space:  [Class A + Perturbation] -- (Feature Collision) --|

Because different architectures learning the same tasks must map identical inputs to similar semantic concepts, their latent spaces share structural commonalities. In 3D point cloud classification, Yifan Zhu et al. introduce a feature collision method in Toward Availability Attacks in 3D Point Clouds to create invisible shortcuts in the feature space. Zhen Xiang et al. similarly demonstrate in A Backdoor Attack against 3D Point Cloud Classifiers that surrogate-guided point cloud backdoors succeed because they target the shared geometric data distribution rather than model-specific vulnerabilities.

This alignment of latent features also explains why attacks can transfer across different tasks or domains. For example, Keita Kurita et al. show in Weight Poisoning Attacks on Pretrained Models that backdoor attacks can be crafted using proxy datasets that share task characteristics. This allows the embedded vulnerabilities to survive domain shifts and fine-tuning on entirely private downstream datasets.

Universality Across Modalities and Paradigms

The cross-architecture transferability of poisoning is not unique to standard image classifiers; it is a systemic property observed across diverse machine learning domains:

Conversely, this consistency in how attacks manifest in model weights can be leveraged for defense. Gérôme Bovet demonstrates in Backdoor Unlearning by Linear Task Decomposition that backdoor-related weight updates exhibit high transferability across different training datasets, allowing a trigger vector extracted from one model to effectively sanitize an entirely different model compromised by the same attack type.

Ultimately, cross-architecture transferability works because machine learning models are fundamentally bound by the data they ingest. When an attacker poisons a dataset, they are not hacking the code of a specific neural network; they are rewriting the rules of the environment from which all networks learn. Because the underlying optimization goals—minimizing empirical risk, finding predictive shortcuts, and mapping features—are shared across architectures, the poisoned environment compromises them all.

Key Foundational Work

Efficient Label Contamination Attacks Against Black-Box Learning Models (2017) — contributed 2 concept elements to this direction.
Towards Poisoning of Deep Learning Algorithms with Back-gradient Optimization (2017) — contributed 1 concept elements to this direction.
Learning to Confuse: Generating Training Time Adversarial Data with Auto-Encoder (2019) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_cross_architecture_attack_transferabilit_8fa93e0f,
  title = {cross-architecture attack transferability},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/cross-architecture-attack-transferability/rdr_8fa93e0f2cdf42d29a2aba872e9d38c8},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_cross_architecture_attack_transferabilit_8fa93e0f_v1,
  title = {cross-architecture attack transferability},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/cross-architecture-attack-transferability/rdr_8fa93e0f2cdf42d29a2aba872e9d38c8/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake