Deepfake detectors that generalize across datasets now exist, but they collapse when someone deliberately adds a small, carefully computed noise pattern to a fake video. Making a detector robust to this kind of attack normally requires adversarial training: at every training step, the attack is run against the current model and the model is trained on the result. That repeated attack makes training roughly ten times more expensive. In video the cost is worse, because the attack has to be solved separately for every frame. This proposal starts from a simple observation. In a face video, frame $t+1$ is almost frame $t$ moved slightly, so the worst-case noise for frame $t+1$ should be close to the worst-case noise for frame $t$ moved by the same amount. If that holds, we can compute a full attack on one frame, carry it forward along the motion, and spend only one or two cheap correction steps per later frame. Adversarial training would then cost little more than ordinary training.
We test this on detectors that keep a large pretrained backbone frozen and tune only a tiny set of parameters, because full fine-tuning is known to destroy cross-dataset generalization. The question is whether robustness bought this cheaply holds up on two axes at once: on deepfake datasets never seen in training, and on attack types never seen in training, in particular attacks whose noise follows the motion of the face. Current forensic defenses are never evaluated against motion-following attacks.
Core Claim
Adversarial perturbations against frame-level deepfake detectors are approximately motion-equivariant: if the motion between frames is $W_{t\to t+1}$, the best attack on frame $t+1$ is close to $W_{t\to t+1}$ applied to the best attack on frame $t$. We exploit this in the inner attack loop of adversarial training. Frame 1 of each clip receives $K$ steps of projected gradient descent (PGD, the standard iterative attack that takes signed gradient steps and clips to an $\epsilon$-ball). Every later frame is initialized from the warped previous perturbation and refined with $k \ll K$ steps:
$$\delta_{t+1}^{(0)} = \Pi_{\epsilon}\big(W_{t\to t+1}(\delta_t)\big), \qquad \delta_{t+1} = \mathrm{PGD}_k\big(\delta_{t+1}^{(0)}\big),$$
where $\delta_t$ is the perturbation on frame $t$ and $\Pi_\epsilon$ projects back into the allowed budget. The inner-loop cost per clip of $T$ frames falls from $TK$ to $K + (T-1)k$ gradient passes. With $K=10$, $k=1$ and $T=16$ this is about 7.6 times cheaper. The motion fields come from compressed-video motion vectors, which are essentially free to obtain, as in Motion-Excited Sampler, rather than from a learned optical-flow network.
We make two predictions. First, at matched compute, this recycled adversarial training gives higher robust AUROC on unseen datasets than standard adversarial training does. Second, because training already sees motion-coherent perturbations, it narrows the gap between robustness to the training attack and robustness to motion-aligned attacks it never trained on.
Where This Sits
The cross-dataset problem motivates the choice of backbone. Celeb-DF reported that nine detectors averaged 56.9% AUC on its videos. GenD tunes only the LayerNorm parameters (0.03% of a frozen CLIP or DINOv3 encoder) with hyperspherical metric learning and generalizes across 14 benchmarks. GenD also shows that full fine-tuning causes shortcut learning. Its authors explicitly leave adversarial evasion untested, and they find that adding temporal modeling did not help. We keep GenD's frame-level detector and frozen backbone unchanged and add only the training-time attack. DeepFake-Adapter supplies a second, larger parameter-efficient design (16.9M adapter parameters) that we use to check whether the conclusions depend on how many parameters are tuned.
The vulnerability is documented by RAID, whose white-box attacks drive detector F1 to 0.0. AFSL is the closest existing forensic defense. It pulls clean and adversarial features together, uses full PGD-10 adversarial training on CNN detectors, and evaluates only frame-wise spatial attacks. We differ from AFSL in three ways: the backbone is a frozen foundation model, the inner loop is recycled along motion, and the evaluation includes motion-aligned threats.
Two papers supply the motion machinery, though both use it for attack rather than defense. Motion-Excited Sampler warps noise along motion vectors and cuts black-box queries on Something-Something V2 from 7,239 to 592. Li et al. propagate one base perturbation across frames with geometric warps. We turn this propagation into a cheap inner loop for training.
Confidence-Calibrated Adversarial Training constrains the design. Standard $L_\infty$ adversarial training reached 99.4% error under $L_2$ attacks on SVHN, which warns that any hardening can overfit to the attack used in training. For that reason, held-out threat models are a primary metric here, not an appendix.
Research Program
The first stage is a measurement, and the project depends on it. For a GenD detector trained on FaceForensics++ c23, we compute full PGD-20 perturbations independently on consecutive frames. We then measure the cosine similarity between each $\delta_{t+1}$ and the warped $W_{t\to t+1}(\delta_t)$, and the attack loss reached when PGD is started from the warp versus from random noise. Both quantities are measured against frame gap, motion magnitude and manipulation type.
Aligned face crops make this test less trivial than it sounds. Because the crops are already roughly aligned, the unwarped previous perturbation may work just as well. If so, the contribution reduces to temporal warm-starting and motion is irrelevant. We will report that outcome rather than hide it.
The second stage builds recycled adversarial training on top of GenD's LayerNorm tuning and its metric-learning losses. We vary $k \in \{0,1,2,3\}$ and reset to a full attack every $r$ frames to control drift. A full reset happens at scene cuts, which are detected when the motion vectors' residual energy spikes. That threshold is the same kind of rule that limits AdvIT on jump cuts.
The third stage evaluates the trained detectors on a grid of unseen datasets crossed with unseen threat models, and records compute as a first-class outcome.
Baselines
The naive reference is GenD trained exactly as published, with no adversarial training. We expect its robust AUROC to be near zero, consistent with RAID's F1 of 0.0 under white-box attack. No GenD robustness number exists on Lacuna, so we measure it ourselves.
The strongest existing forensic defense is AFSL. Under PGD-10 on FaceForensics++ it reports 80.8% AUC, with 89.7% clean AUC and 83.6% AUC under attack on unseen DeeperForensics (AFSL). The same paper reports that plain adversarial training falls to about 73.5% clean AUC. We will rerun AFSL's losses on the same frozen CLIP backbone, the same frames, and the same $\epsilon$. Beating AFSL means matching or exceeding its robust AUROC on held-out datasets, at lower total GPU-hours, without giving up more than one point of GenD's clean cross-dataset AUROC. AFSL's published 80.8% comes from a different backbone, so the matched rerun is the binding comparison.
The most dangerous baseline is compute-matched standard adversarial training on GenD's LayerNorm parameters. It runs full PGD-10 on a random subset of frames per clip, with the subset sized so that total gradient passes equal those of our method. Our method must beat it on held-out robust AUROC at equal GPU-hours. If it does not, the idea is wrong. A second compute-matched baseline uses single-step attacks (one gradient step per frame with random starts) and no recycling.
Two ablations isolate the key ingredient. One copies $\delta_t$ forward without warping. The other draws a fresh random start with the same $k$ steps. The gap between warped and copied initialization measures what motion actually contributes. ROB tokens (Robustness Tokens) serve as an alternative set of tuned parameters. They were reported to recover DINOv2-Giant from 0.3% to 63.1% ImageNet accuracy under white-box attack in 200 steps. We train them under our recycled inner loop and under a standard one, which tests whether recycling helps regardless of which parameters are tuned.
Every method gets the same training videos (FaceForensics++ c23), the same backbone, the same tuning budget of 20 hyperparameter configurations each, and the same seeds.
Why not just…?
Why not just run standard adversarial training on a few sampled frames per clip? This is the real threat to the proposal. Subsampling frames also cuts cost, and adjacent frames are redundant anyway, so dropping some might cost little. Recycling can only win if covering every frame with near-full-strength attacks gives better-generalizing robustness than covering a few frames with full attacks. The compute-matched baseline settles this directly. If the two tie, we will report that motion recycling buys nothing beyond what subsampling already gives.
Why not just use AFSL as published? AFSL fine-tunes the full detector with PGD-10. GenD gives direct evidence that full fine-tuning harms cross-dataset transfer, and AFSL never tests motion-aligned attacks. Our matched rerun of AFSL's loss on the frozen backbone tells us whether the loss or the recycling carries the gain. The two are compatible, and we will also report their combination.
Why not just detect attacks at test time with temporal consistency, as AdvIT does? AdvIT flags adversarial frames with over 95% detection at 0.03 to 0.4 seconds per step. However, it only flags frames and does not recover a correct verdict. It also produces false alarms at cuts. A temporal-consistency check is also exactly what a motion-aligned perturbation is built to satisfy. We will run AdvIT-style pseudo-frame checks against both frame-wise and motion-warped attacks. If it catches the motion-warped attacks cheaply, that weakens our case, and we will say so.
Why not purify inputs with a video diffusion model? VideoPure reaches 100% robust accuracy on UCF-101, but takes about 8.5 seconds per video. GenD runs at 120 frames per second, so purification gives up the deployment property that makes the detector useful. We will include VideoPure as an accuracy ceiling at its own cost, not as a compute-matched competitor.
Proposed Experiments
Training uses FaceForensics++ c23. Clean and robust AUROC are measured on Celeb-DF-v2, DFDC, DeeperForensics-1.0 and FaceShifter, plus the FaceForensics++ test split. We also score Face2Face separately, because DeepFake-Adapter singles out reenactment as the weakest case.
The threat models are as follows. The training attack is per-frame $L_\infty$ PGD at $\epsilon=4/255$ and $8/255$. Held-out white-box attacks are $L_2$ attacks and clip-level PGD that targets the aggregated video score. The held-out black-box attack is a motion-excited query attack in the style of Motion-Excited Sampler, for which we report the number of queries needed to evade. A fully adaptive attacker knows the defense and attacks frames jointly. For image-level transfer we also evaluate on RAID. Compute is reported as gradient passes per clip and as wall-clock GPU-hours.
Three results are decisive. First, the warped-versus-fresh initialization measurement must show that warped starts reach at least 90% of full-PGD attack loss within one or two steps. If they do not, the method has no basis. Second, at matched GPU-hours, recycled training must beat frame-subsampled standard adversarial training on robust AUROC averaged over held-out datasets. Third, recycled training must shrink the difference between robustness to the training attack and robustness to the motion-aligned query attack, compared with the standard-trained detector. As a secondary transfer check, we repeat the efficiency comparison on a UCF-101 action recognizer. This tests whether the motion-equivariance of perturbations is specific to faces or holds for video models generally.
References
- Motion-Excited Sampler: Video Adversarial Attack with Sparked Prior
- Celeb-DF: A Large-Scale Challenging Dataset for DeepFake Forensics
- Deepfake Detection that Generalizes Across Benchmarks
- DeepFake-Adapter: Dual-Level Adapter for DeepFake Detection
- RAID: A Dataset for Testing the Adversarial Robustness of AI-Generated Image Detectors
- Adversarially Robust Deepfake Detection via Adversarial Feature Similarity Learning
- Adversarial Attacks on Black Box Video Classifiers: Leveraging the Power of Geometric Transformations
- Confidence-Calibrated Adversarial Training: Generalizing to Unseen Attacks
- AdvIT: Adversarial Frames Identifier Based on Temporal Consistency in Videos
- Robustness Tokens: Towards Adversarial Robustness of Transformers
- VideoPure: Diffusion-Based Adversarial Purification for Video Recognition