Scaling Model Capacity for Adversarial Robustness

108 concepts79 papers1 proposal

Standard deep neural networks are remarkably efficient at fitting training data, but they are notoriously fragile. Introduce a minuscule, maliciously crafted perturbation to an image, and a state-of-the-art model will misclassify it with high confidence. To defend against these attacks, researchers use adversarial training—a method that injects perturbations into the training loop.

Yet, implementing this defense reveals a striking paradox: a network requires significantly more parameters to learn a robust decision boundary than it does to learn a standard one. Defending a model against tiny inputs demands a massive increase in architectural scale.

The Geometry of Smoothness

To understand why robustness demands scale, we must look at the geometry of the decision boundary. In standard training, a network only needs to correctly classify discrete data points. The resulting decision boundary can pass arbitrarily close to these points, twisting and turning sharply to separate classes.

Adversarial training, formalized by Aleksander Madry et al. as a min-max optimization problem, changes the objective. Instead of classifying a single point $x$, the model must correctly classify every possible point within an $\epsilon$-ball around $x$. This requirement forces the decision boundary to maintain a strict safety margin around the data, imposing a mathematical smoothness constraint (a bounded Lipschitz constant) on the network's function.

Standard Training:                      Adversarial Training:
   Class A                                 Class A
    •   •                                   •   •
  ========= (Jagged Boundary)             ( ϵ ) ( ϵ )  <- Safety Margins
    •   •                                 ================= (Smooth Boundary)
   Class B                                  •   •
                                           Class B

This smoothness constraint creates a severe resource bottleneck. In a low-capacity network, forcing the model to be smooth strips away its expressivity, making it impossible to fit complex data distributions and leading to a steep drop in standard accuracy.

Overparameterization resolves this conflict. As demonstrated by Hao Liu et al., massive networks possess the degrees of freedom necessary to satisfy strict Lipschitz smoothness constraints without sacrificing the expressivity needed to fit the underlying data. Scale provides the capacity to be simultaneously smooth and accurate.

Shifting the Trade-Off Frontier

When models are scaled up to billions of parameters, this capacity-driven robustness follows predictable scaling laws. Zeyu Wang et al. demonstrated that scaling model parameters and training data volume in tandem yields consistent, non-saturating improvements in robust accuracy.

Crucially, massive scale alters the fundamental trade-off between clean accuracy and adversarial resilience:

  • Basin Retention: Yue Xing et al. showed that increasing a network's capacity raises the critical perturbation threshold ($\epsilon^*$) at which adversarial constraints force the model out of high-accuracy optimization basins. Larger models can absorb adversarial constraints without abandoning the parameters that make them accurate on clean data.
  • Feature Alignment: In multi-modal and vision-language settings, Jiaming Zhang et al. found that larger architectures possess a superior capacity to align adversarial image features with text prompts, preserving clean generalization performance while embedding robust representations.

Allocating Capacity: Width vs. Depth

If robustness requires capacity, how should a practitioner distribute a parameter budget? The choice between expanding network width (more channels) or network depth (more layers) introduces distinct geometric and structural advantages.

Network Width as a Dilution Mechanism

Expanding network width introduces structural redundancy that dilutes the impact of perturbations. For instance, Baoyuan Wu et al. demonstrated that wider networks are inherently more resilient to bit-flipping memory attacks; the vast parameter count dilutes the global influence of any single corrupted bit on the final decision boundary.

Width is also structurally favored in certified robustness frameworks like Interval Bound Propagation (IBP). As detailed in Understanding Certified Training with Interval Bound Propagation, network depth causes an exponential decay in the tightness of mathematical bounds, whereas increasing width only causes a polynomial decrease. Width allows the model to maintain expressivity while satisfying strict interval constraints. Furthermore, the authors of Do Adversarially Robust ImageNet Models Transfer Better? observed that robust models continuously exploit increased width to extract highly transferable downstream features, avoiding the diminishing returns seen in standard models.

The Thirst for Depth

Conversely, depth offers unique advantages for mapping complex adversarial manifolds. Alan Yuille et al. observed that adversarial training exhibits a unique sensitivity to depth, showing performance gains at extreme layer counts where standard accuracy has long plateaued.

To optimize a fixed parameter budget, ShengYun Peng et al. argue for maintaining a low width-depth ratio—prioritizing depth over width—to maximize resistance to perturbations. However, depth introduces optimization complexities. Ben Liang et al. resolved the "robustness paradox" by showing that while width consistently aids robustness, the impact of depth is highly sensitive to initialization strategies, making deep architectures harder to stabilize.

The Limits of Raw Scale

Simply inflating a model's parameter count is a necessary condition for robustness, but it is not a sufficient one. Shayan Kiyani demonstrated that certain architectures, such as random feature models, fail to translate infinite width into robustness unless the network incorporates specific architectural and activation symmetries.

Unregulated capacity can also backfire. As Hanxun Huang et al. discovered, excessive capacity throughout an entire network can inadvertently increase its global Lipschitz constant, raising its sensitivity to small input changes. They showed that strategically reducing capacity at the final stage of a network acts as a regularizer, yielding superior adversarial defense with fewer parameters.

Ultimately, scaling capacity works because it grants the network the mathematical flexibility to build smooth, well-insulated decision boundaries. However, realizing this benefit requires careful architectural orchestration to ensure that added parameters stabilize the model rather than making it more sensitive to noise.

Key Foundational Work

Adversarial Machine Learning at Scale (2017) — contributed 2 concept elements to this direction.
Adversarial Machine Learning at Scale (2016) — contributed 2 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_architectural_robustness_scaling_614fbf24,
  title = {architectural robustness scaling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/architectural-robustness-scaling/rdr_614fbf24309748c283d4b6d087bc092d},
  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_architectural_robustness_scaling_614fbf24_v1,
  title = {architectural robustness scaling},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/architectural-robustness-scaling/rdr_614fbf24309748c283d4b6d087bc092d/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