Smooth-in-Depth Weights as a Cheap Guard Against Catastrophic Overfitting

Adversarial training makes a classifier robust by training it on worst-case perturbed inputs. Each training step usually spends 7 to 20 extra gradient computations searching for those inputs, which multiplies training cost several times over. The cheap alternative takes a single gradient step to build each perturbation. That is the single-step attack known as the Fast Gradient Sign Method, or FGSM. Its weakness is that it sometimes collapses without warning: the network learns to defeat the one-step attack while becoming defenseless against stronger multi-step attacks. This failure is called catastrophic overfitting. Existing fixes work in input space. They add extra forward passes to keep the loss locally linear, or they filter and average weights over the course of training.

This note proposes a fix in weight space. It costs almost nothing per step, and it comes from theory about continuous-depth networks. The idea is to make the weights of consecutive residual blocks change smoothly with depth, so the network behaves like a discretized smooth flow rather than a stack of unrelated layers. We test whether that structural constraint prevents single-step adversarial training from collapsing. We also test whether the weight-difference signal across depth gives an early warning of collapse. The hypothesis is that the sharp, attack-specific nonlinearity behind catastrophic overfitting needs a few blocks that differ abruptly from their neighbors, and that penalizing such jumps removes the network's capacity to build it.

Core Claim

Marion proved generalization bounds for residual networks that do not depend on depth. Those bounds are governed by how smoothly the weights vary from one layer to the next, the quantity $\|W_{k+1}-W_k\|$. Marion also showed that a "weight Lipschitz" penalty narrows the train–test gap on MNIST. That work concerns ordinary generalization only and never touches adversarial training.

In parallel, two papers characterize catastrophic overfitting as a sudden distortion inside the perturbation ball. Kim et al. found that the input-gradient norm spikes by up to 35× just before collapse. Kang & Moosavi-Dezfooli showed that the decision boundary bends along the perturbation direction. Until now these two lines of work have been disconnected.

Our claim is that depth-wise weight smoothness is a sufficient structural condition to keep FGSM training from collapsing. It can be imposed either as a soft penalty or as a hard low-dimensional parameterization of weights as a function of depth. Because it acts on parameters rather than inputs, it adds no forward or backward passes. Beyond the soft penalty that Marion already used for generalization, what this note contributes is the use of the depth trajectory, not weight magnitude or a Lipschitz bound on the loss, as the lever against catastrophic overfitting. That use is tested against controls that separate "smooth across depth" from "small" and from "averaged over training time."

Research Program

The program has three phases, and each one gates the next.

Phase 1: is there a weight-space signature of collapse? We first ask whether catastrophic overfitting leaves a trace in the depth trajectory at all. We run RS-FGSM, the random-start variant of Wong et al., on CIFAR-10 at radii where collapse is known to occur. The radius $\epsilon$ is the maximum size of the allowed input perturbation; we use $\epsilon$ = 8/255 and 12/255 with PreAct-ResNet18, and 16/255 with WideResNet-34-10. For each run we log three quantities per step: the per-stage block-to-block weight differences, the input-gradient norm that Kim et al. use as a precursor, and accuracy under a multi-step PGD attack. PGD, projected gradient descent, is the standard multi-step attack.

If weight differences across depth do not move before or with the gradient-norm spike in most collapsing runs, the mechanistic hypothesis is in trouble. We would then report that negative result rather than proceed on faith.

Phase 2: two interventions. The soft version adds the penalty

$$R(\theta)=\lambda\sum_{\text{stages } s}\sum_{k}\frac{\|W^{s}_{k+1}-W^{s}_{k}\|_F^2}{\|W^{s}_{k}\|_F^2+\|W^{s}_{k+1}\|_F^2}$$

to the FGSM training loss. Here $W^{s}_k$ is the weight tensor of the $k$-th residual block in stage $s$, the sum runs only over blocks with matching shapes, and $\lambda$ is a scalar strength. Normalizing by weight magnitude is deliberate: the penalty cannot be lowered just by shrinking all weights, which is what separates it from weight decay.

The hard version makes the weights an explicit trajectory in depth:

$$W^{s}_k=\sum_{j=0}^{J}C^{s}_j\,\phi_j\!\left(\tfrac{k}{L_s-1}\right).$$

Here $L_s$ is the number of blocks in stage $s$, $\phi_j$ are low-degree Chebyshev polynomials, and $C^{s}_j$ are learned coefficient tensors with $J+1 < L_s$. This is the discrete, solver-free analogue of the trajectory parameterizations surveyed in the file. Its closest relative is the kinetic-energy-penalized flows of Vialard et al.. We deliberately avoid any ODE solver, adaptive or otherwise, because Huang et al. showed that adaptive-step solvers in stabilized ODE networks produce fake robustness. In their experiments, 62.35% PGD accuracy collapsed to 0% under fixed-step solvers or Carlini–Wagner attacks. Our network is an ordinary fixed-depth ResNet whose weights happen to be tied by a smooth basis, so gradients are exact.

The hard version needs deep stages to be meaningful, so it is run on WideResNet-34-10 (five blocks per stage) and a deeper PreAct-ResNet variant.

Phase 3: cost and scale. We measure the overhead of the penalty, which is a few parameter-space norms per step and should be negligible next to one forward pass. We then carry the best variant to ImageNet with ResNet-50 under the fast-training protocol, to check that the effect survives width. Width scaling is the regime where Marion's bounds are acknowledged to weaken.

Baselines

The naive reference point is plain RS-FGSM from Wong et al.. It reports 45% PGD robust accuracy on CIFAR-10 in 6 minutes of training, and it is known to collapse at larger radii. It sets the floor for both compute and robustness. It is run with the identical cyclic learning-rate schedule, mixed precision, and epoch budget as every other method.

The strongest existing single-step competitor is FGSM-LAW from Jia et al.. It regularizes the loss's Lipschitz constant during the parameter update and keeps an exponential moving average of weights, a running average over training steps, that rejects low-quality states. It reports 56.36% accuracy against PGD-50 on CIFAR-10 in 81 minutes, against 265 minutes for PGD training, and 30.12% AutoAttack accuracy on ImageNet. It is the strongest competitor because it is already a cheap, outer-loop, weight-side fix for the same failure.

FGSM-PCO from Wang et al. is a second strong competitor. It reports 56.32% PGD-10 accuracy on ResNet-18 and zero collapses in 10 CIFAR-100 runs on WideResNet-34-10, while a competing method failed in 6 of 10. We also run ELLE from Rocamora et al., which reports 44.32% AutoAttack accuracy, and RS-FGSM-wo-Proj from Kang & Moosavi-Dezfooli, which reports 47.56 ± 0.37% PGD-50-10 accuracy on PreAct-ResNet18. As a multi-step upper reference we include PGD training with weight averaging, SEAT from Wang & Wang, which reports 51.3% AutoAttack accuracy on ResNet-18 in 273 minutes.

These reported numbers use different attacks and should not be compared directly. We therefore rerun every method from public descriptions on our hardware. Every method gets the same architecture, data augmentation, and epoch count, and a matched hyperparameter search of the same number of trials over its own key coefficients. Every method is then evaluated with AutoAttack through RobustBench. AutoAttack is an ensemble of gradient-based and black-box attacks designed to expose gradient masking.

Two ablations isolate the key ingredient. The first is matched weight decay: the same drop in total weight norm that our penalty produces, achieved through standard L2 decay. The second is a shuffled-pair penalty: identical in form to $R(\theta)$, but applied to randomly permuted pairs of same-shape blocks instead of depth-adjacent ones. That keeps any generic weight-tying effect while destroying the notion of a trajectory.

The proposal counts as winning on robustness only if it does three things at 12/255 and 16/255. It must match or exceed FGSM-LAW's AutoAttack accuracy within seed noise. It must show a collapse rate no higher than FGSM-PCO's across 10 seeds. And it must have lower wall-clock time than both. It must also beat both ablations; otherwise depth smoothness is not the operative ingredient.

Why not just…?

Why not just use heavy weight decay? Galloway et al. show that strong L2 decay smooths filters and helps against sparse L0 pixel attacks. The same paper concedes that it does not replace adversarial training against dense L∞ perturbations, which is our threat model. The danger is subtler, though: our penalty might work only because it shrinks weights. The magnitude-normalized form of $R(\theta)$ and the matched-weight-decay ablation are there to settle this. If matched decay prevents collapse equally well, we will report that the trajectory story is unnecessary.

Why not just average weights over training time, as SEAT and FGSM-LAW do? Averaging over optimization time is cheap and effective. Jia et al. found, however, that in single-step training it needs a hand-set rejection threshold, because a plain moving average absorbs corrupted weight states. Wang & Wang report sensitivity to the learning-rate schedule and a warm-up constant. Averaging over time and smoothing over depth act on different axes, so they are not exclusive. We test our penalty both alone and stacked under FGSM-LAW. If stacking adds nothing over FGSM-LAW alone, the honest conclusion is that time averaging already captures the benefit.

Why not just penalize the input-gradient norm, or use ELLE? These methods target the input-space symptom directly. The price is extra forward or backward passes per sample; ELLE is reported at 2–3× faster per step than double-backpropagation methods, which is still well above plain FGSM. Our claim is not that they fail but that a parameter-side penalty reaches comparable robustness without that cost. The wall-clock-versus-AutoAttack comparison at matched epochs decides it. If ELLE dominates the trade-off, the proposal loses on its own terms.

Doesn't any "continuous dynamics" defense just mask gradients? Huang et al. traced their illusory robustness to adaptive solvers in naturally trained models. We use no solver and always train against an adversary. We still verify with full AutoAttack, including its black-box Square attack, and with large-iteration PGD to check that accuracy decreases monotonically as attack steps increase.

Proposed Experiments

The first decisive check is Phase 1's diagnostic: across at least 10 collapsing RS-FGSM seeds, does the normalized depth-difference rise before the input-gradient spike that Kim et al. describe, or at least alongside it? The second is the collapse-rate comparison over 10 seeds on CIFAR-10 and CIFAR-100 at 8/255, 12/255 and 16/255, pitting soft and hard variants against plain RS-FGSM, both ablations, FGSM-PCO, and FGSM-LAW. A collapse is defined as PGD-50 accuracy falling below 5%. The third is the AutoAttack accuracy and wall-clock time of surviving runs, plus the overhead per step measured on the same GPU. Tiny-ImageNet follows as a mid-scale check. ImageNet ResNet-50 is the scale test, where the target is FGSM-LAW's reported 30.12% AutoAttack accuracy at no greater cost.

A result where the hard parameterization prevents collapse but the shuffled-pair penalty does not would be the cleanest evidence that trajectory structure, not tying or shrinkage, is what keeps single-step adversarial training stable. Failure on the Phase 1 diagnostic or on the ablations would be equally informative. It would show that Marion's smoothness quantity, though tied to generalization, is unrelated to robust-training collapse.