Replay Below the Fingerprint: Why Pixel Replay Backfires in Continual Forgery Detection

Detectors of AI-generated images must keep up with a stream of new generators, and they must do so without forgetting the old ones. Storing past images to rehearse them is often forbidden, because face data and patient scans are privacy-sensitive. The standard workaround is generative replay: a second model synthesizes stand-ins for the past data. We argue that in forgery detection this workaround defeats itself in a specific, testable way. A replayed "real" image is itself machine-generated, and it is labeled real. The detector is therefore taught that the replay generator's own low-level fingerprint means authentic. The result is a blind spot for fakes made by generators similar to the replay model, which is exactly the family of generators most likely to appear next. Replayed fakes are no better. A diffusion model imitating old ProGAN fakes reproduces its own traces, not ProGAN's, so the evidence the detector most needs to remember is lost.

The remedy we propose is to replay below the fingerprint. The detector sits on a frozen pretrained image encoder. Instead of synthesizing pixels, we replay the distribution of that encoder's local, early-layer patch features for each past task and each label. No synthetic pixels ever enter training, so no replay fingerprint exists to be learned. The old generator's traces survive as long as the encoder captured them. The compute cost drops from hundreds of denoising passes per image to sampling small vectors. The note proposes to demonstrate the blind spot, measure how much forensic signal pixel replay loses, and test whether patch-level feature replay closes the gap to exemplar rehearsal on the Continual Deepfake Detection Benchmark and on held-out cross-dataset evaluation.

Core Claim

The claim has three parts, each falsifiable. The first is the blind-spot hypothesis: detectors trained with pixel-level generative replay will miss fakes from the replay generator's family much more often than detectors trained without replay. The second is the trace-loss hypothesis: on old tasks, pixel replay will retain little more detection ability than no replay at all, because the old generator's fingerprint is not reproduced. The third is that replaying patch-level feature statistics from a frozen encoder avoids both failures at a small fraction of pixel-replay compute. This third part rests on the view that forgery traces are local and low-level, not global. The claim concerns where replay lives, below or above the fingerprint, and not which generator family does the replaying. A simple Gaussian over features counts as one instantiation of the idea, not as a competitor to it.

How This Sits Against Prior Work

Generative replay began with Continual Learning with Deep Generative Replay, which trains a generator alongside the classifier to synthesize past data. DDGR replaces that generator with a diffusion model (a generator that learns by gradually denoising random noise into samples). DDGR steers generation with the classifier's gradients and reaches 59.20% final accuracy on CIFAR-100. It pays for this with roughly 75,000 seconds of training against roughly 8,000 for regularization methods. Qiang Gao et al. likewise report that in-loop synthesis makes generative replay far less efficient than regularization. These papers motivate the cost side of our work, and all of them evaluate semantic classification, where a generator fingerprint is harmless noise.

DREAM is the closest work, and it supplies the key motivating evidence. DREAM shows that when synthetic old-class images are mixed with real new-class images, the classifier learns "synthetic means old class." Raw generative replay then collapses to 33.50% on CIFAR-100. DREAM fixes this by projecting the dominant synthetic-versus-real directions out of the feature space. In forgery detection, that projection would remove the very signal the detector exists to use. Our proposal differs in kind: we do not rectify synthetic pixels, we never produce them.

Continual forgery detection is framed by the Continual Deepfake Detection Benchmark (CDDB). CDDB streams 12 generators and finds that exemplar rehearsal outperforms memory-free methods. It never tests generative replay. Prompt2Guard is exemplar-free. It uses read-only prompts on a frozen CLIP encoder and text conditioning such as "a fake photo of a [class]" to push the model past semantic content. It reaches 90.28% average accuracy on CDDB-Hard with no replay at all. That makes it both the bar to beat and the strongest argument that replay is unnecessary.

Our emphasis on local features comes from What Makes Fake Images Detectable?, which finds that classifiers with small receptive fields capture generator irregularities that transfer across architectures. It also draws on Towards Generalizable Deepfake Detection with Locality-aware AutoEncoder, which traces cross-dataset failure to memorized generator-specific artifacts. FedReplay already replays compressed latents instead of images across hospitals, and it constrains our design. It shows that latent replay is cheap and reduces forgetting, but it never checks what those latents encode. Work on hidden stratification and on chest X-ray models predicting insurance type warns that such latents also carry site and demographic signatures. That warning shapes our medical check below.

Research Program

The first component is a diagnostic. We build pixel-replay detectors on CDDB-Hard (GauGAN, BigGAN, WildDeepfake, WhichFaceReal, SAN) in two styles. One is a class-conditional diffusion replay model retrained at each task, following DDGR. The other is a frozen text-to-image model, following DREAM. Both sit on the same frozen encoder and head as all other methods.

To test the blind spot, we assemble a probe set of fakes produced by each replay generator from prompts or seeds never used during replay. We then measure the fraction of these fakes the detector calls real, comparing against a detector trained on the same stream with no replay. To test trace loss, we train a linear probe on frozen features to tell a given old generator's true fakes from the replay model's imitations of them. High separability means the imitation did not carry the original traces. We then report per-task accuracy on the real old-generator test sets.

The second component is the method. After finishing task $t$, we fit a small generative model to encoder features. We use patch tokens from several early and middle layers, not only the final summary token, and fit separately for real and fake images of that task. We then discard the images. While training on later tasks, the detection head sees current-task features alongside sampled past-task features, with standard distillation on the head.

The generator over features is a dial with three settings: a per-layer Gaussian, a Gaussian mixture, and a small diffusion model over the grid of patch tokens. The encoder stays frozen, so replayed features remain valid for all future tasks and the old generator's traces are preserved to the extent the encoder captured them. We also run a variant on Prompt2Guard's prompted features. Its prompts become read-only once each task ends, so the features stay fixed and replay remains valid there too.

The third component is a brief generality check in medical imaging, where the analogous risk is a site shortcut rather than a real/fake label. We follow FedReplay's serial site training on the diabetic retinopathy fundus data with its skewed non-IID split. At one site we inject a small synthetic marker correlated with the diagnostic label. We then measure whether a VQ-VAE-2 pixel replay model reproduces and propagates the marker, and whether feature replay carries it forward to later sites. This checks the concern raised in Problèmes associés au déploiement des modèles fondés sur l'apprentissage machine en santé that models latch onto such cues. It does not attempt a full medical study.

Baselines

The naive reference point is sequential fine-tuning of the same frozen encoder and detection head with no replay and no regularization. It shows how much forgetting occurs at all, and it is the comparison for the trace-loss hypothesis.

The privacy-violating upper reference is exemplar rehearsal as evaluated in CDDB. The DyTox transformer there reports about 88% average accuracy on the HARD stream. We rerun it on our backbone with a raw-image buffer, so that the gap between exemplar-free methods and real stored images can be measured directly.

The strongest exemplar-free competitor is Prompt2Guard. It reports 90.28% task-wise average accuracy on CDDB-Hard, −0.71% average forgetting, and 81.11% on the final SAN task. We will reproduce it with its released protocol on the same CLIP backbone and data order. Our feature replay will be run both on the plain frozen encoder and on top of Prompt2Guard's prompts, with matched tuning trials for every method. Beating it means higher average accuracy on CDDB-Hard with non-worse forgetting. It also means a significant gain on at least one of two harder tests: the 12-task LONG stream, and held-out cross-dataset evaluation on Celeb-DF frames. For the latter, no reported result was found on Lacuna for CDDB-trained detectors on Celeb-DF, so we establish it ourselves.

The pixel-replay baselines are DDGR-style and DREAM-style replay. We also include DREAM with its feature-rectification step, to test directly whether subspace projection strips forensic signal. They are allotted the same number of replayed samples per step, and we report wall-clock time next to accuracy. DDGR's reported 75,000 versus 8,000 seconds on CIFAR-100 gives the expected scale of the cost gap.

Three ablations isolate the key ingredients. Replaying only fakes, with no synthetic reals, isolates the blind-spot mechanism. Replaying summary-token Gaussians instead of patch-level features tests whether locality matters. Stepping through Gaussian, mixture, and feature diffusion tests whether a learned generator earns its cost. We also include elastic weight consolidation as the zero-synthesis reference.

Why not just…?

Why not just use prompt tuning on a frozen encoder with no replay, as Prompt2Guard does? This is the most serious threat. Prompt2Guard already reaches 90.28% on CDDB-Hard. HippoTune argues that frozen-backbone tuning "falls short in fully reawakening knowledge of prior tasks," and CDDB finds memory-free methods lag rehearsal. Neither result is decisive on CDDB-Hard. Our experiment settles the question by running feature replay on top of Prompt2Guard's own prompted features. If replay adds nothing on the HARD stream, the LONG stream, or Celeb-DF, we will report that replay is unnecessary once the backbone is frozen. The diagnostic findings on pixel replay would stand regardless.

Why not just store per-task feature means and covariances instead of training any generator? Nothing in the file rules this out, so we build it in as the cheapest setting of our dial rather than argue against it. Our actual bet is narrower. Summary-token statistics may lose the local traces that the receptive-field analysis identifies as the transferable signal, while patch-level statistics may keep them. The summary-token versus patch-level ablation decides this. If simple patch-level Gaussians match feature diffusion, we recommend them.

Why not just use DREAM's rectification to remove the synthetic-real shortcut from pixel replay? DREAM projects out the dominant directions that separate synthetic from real features. In forgery detection those directions overlap with the real-versus-fake signal. We will measure the accuracy DREAM-with-rectification retains on each old generator, and its miss rate on the replay-family probe set. If rectification preserves forensic accuracy, pixel replay remains viable and our cost argument becomes the main one.

Why not just use regularization such as elastic weight consolidation, which costs nothing to synthesize? It is fast, but DDGR's CIFAR-100 comparison shows regularization trailing replay in accuracy. DropTop shows that plain distillation carries shortcuts forward when they overlap across tasks. We include it so the accuracy-per-second comparison is explicit.

Decisive Checks

The central result is the blind-spot measurement. Suppose pixel-replay detectors do not miss more replay-family fakes than no-replay detectors, and the imitations cannot be told apart from true old-generator fakes. Then our mechanism is wrong, and pixel replay's problems in this domain are ordinary ones.

If the blind spot appears, patch-level feature replay must beat pixel replay on both accuracy and wall-clock time. It must also match or exceed Prompt2Guard on CDDB-Hard and improve on it on the LONG stream or on Celeb-DF. For context, detectors trained on FF-DF average 56.9% AUC on Celeb-DF, and adaptive test-time augmentation reaches 0.669 AUC when trained on FF++. These figures come from a different training setup, so they are context, not a target.

The medical marker experiment passes if feature replay propagates the injected shortcut no more than exemplar rehearsal does. If feature replay instead preserves the marker as faithfully as pixel replay, that confirms the concern about latent replay and bounds how far our argument generalizes.