Zhenglin Huang, Jason Li, Haiquan Wen, Tianxiao Li, Xi Yang, Lu Qi, Bei Peng, Xiaowei Huang, Ming-Hsuan Yang, Guangliang Cheng

A deepfake detection framework that leverages DINOv3 with intelligent token selection strategies for detecting AI-generated images.

FGTS uses frozen DINOv3 to detect fake/synthetic images without large-scale fine-tuning. By analyzing individual transformer tokens and selecting the most discriminative ones using Fisher information scores, FGTS achieves state-of-the-art cross-generator detection performance.

Training with minimal data, detecting across diverse generators: With just 1,000 real + 1,000 single-source fake images, FGTS achieves SOTA performance in detecting images from unseen generators (Nano Banana, GPT-4o, etc.). This demonstrates exceptional generalization with minimal training overhead.

• 🚀 Minimal Training Data: Achieves SOTA cross-generator detection with only 2K training samples (1K real + 1K single-source fake)
• 🎯 Superior Generalization: Trained on one generator (e.g., ProGAN), generalizes to unseen generators ( Midjourney, Nano Banana, GPT-4o, etc.)
• ⚡ Training-Free Detection: Classification using feature centroids (no training required)
• 🔧 Lightweight Linear Probe: Optional supervised learning on frozen features with minimal parameters
• 🎲 Fisher-Guided Token Selection: Automatically identifies the most discriminative tokens for detection
• 📊 Multiple Benchmarks: Compatible with so-fake-ood, GenImage, and AIGCDetectionBenchmark datasets

• Python >= 3.8
• CUDA-capable GPU (recommended)
• PyTorch >= 2.0.0

# Clone the repository
git clone https://github.com/hzlsaber/FGTS.git
cd FGTS

# Create conda environment (recommended)
conda create -n FGTS python=3.10
conda activate FGTS

# Install PyTorch with CUDA support
# Visit https://pytorch.org/ to get the installation command for your CUDA version
pip install torch torchvision

# Install other dependencies
pip install -r requirements.txt

We provide the training and validation sets used in this project for reproducibility:

• Training Set
• Validation Set
• So-Fake-OOD Test Set (Reference)

For the remaining benchmarks, please download the test data from their official project pages:

• So-Fake-OOD
• GenImage
• AIGCDetectionBenchmark

⚠ After downloading, please reorganize the data into the required directory structure shown below before running any scripts.

Following widely adopted conventions in image forensics (as seen in CNNSpot), we place all fake training data under the ProGAN directory purely for a consistent project structure.

datasets/
├── train/progan/category (e.g., car)/
│   ├── 0_real/         # 1,000 real images (shared across all benchmarks)
│   ├── 1_fake_ldm/     # 1,000 LDM fakes (for so-fake-ood)
│   ├── 1_fake_sd14/    # 1,000 SD1.4 fakes (for GenImage)
│   └── 1_fake/         # 1,000 ProGAN fakes (for AIGCDetectionBenchmark)
└── val/progan/category (e.g., car)/
    ├── 0_real/         # Validation real images
    ├── 1_fake_ldm/     # Validation LDM fakes
    ├── 1_fake_sd14/    # Validation SD1.4 fakes
    └── 1_fake/         # Validation ProGAN fakes

Key Insight: Same real images (ProGAN/car), different fake sources allow fair comparison across benchmarks while matching test domain characteristics.

Perform deepfake detection without any training using feature centroids. Choose the appropriate --reference_fake_type based on your test benchmark:

For so-fake-ood (train with LDM):

python training_free_test.py \
    --model dinov3_vit_7b \
    --reference_dataset ./datasets/train/progan \
    --reference_category car \
    --reference_fake_type 1_fake_ldm \
    --test_base_dir ./datasets/test \
    --test_category car \
    --test_mode so-fake-ood \
    --token_strategy auto_fisher \
    --top_k 10 \
    --batch_size 32 \
    --output_dir ./results/training_free_sofakeood

For GenImage (train with SD1.4), we show GenImage_Tiny here for reference:

python training_free_test.py \
    --model dinov3_vit_7b \
    --reference_dataset ./datasets/train/progan \
    --reference_category car \
    --reference_fake_type 1_fake_sd14 \
    --test_base_dir /path/to/GenImage/1 \
    --test_mode GenImage \
    --token_strategy auto_fisher \
    --top_k 10 \
    --batch_size 32 \
    --output_dir ./results/training_free_genimage

For AIGCDetectionBenchmark (train with ProGAN):

python training_free_test.py \
    --model dinov3_vit_7b \
    --reference_dataset ./datasets/train/progan \
    --reference_category car \
    --reference_fake_type 1_fake \
    --test_base_dir /path/to/AIGCDetectionBenchmark/test \
    --test_mode AIGCDetectionBenchmark \
    --token_strategy auto_fisher \
    --top_k 10 \
    --max_test 6000 \
    --batch_size 32 \
    --output_dir ./results/training_free_aigc

Quick Start:

cd examples
# Edit training_free_test.sh to set TEST_MODE
bash training_free_test.sh

Train a lightweight linear classifier with 1K real + 1K fake images. Use matching --train_fake_type and --val_fake_type for each benchmark:

For so-fake-ood (train with LDM):

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --val_dataset ./datasets/val/progan \
    --train_category car \
    --train_fake_type 1_fake_ldm \
    --val_fake_type 1_fake_ldm \
    --test_base_dir ./datasets/test \
    --test_category car \
    --test_mode so-fake-ood \
    --token_strategy auto_fisher \
    --top_k 10 \
    --max_train_samples 1000 \
    --max_test_samples 500 \
    --num_epochs 50 \
    --lr 0.01 \
    --batch_size 32 \
    --output_dir ./results/linear_probe_sofakeood

For GenImage (train with SD1.4), we show GenImage_Tiny here for reference:

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --val_dataset ./datasets/val/progan \
    --train_category car \
    --train_fake_type 1_fake_sd14 \
    --val_fake_type 1_fake_sd14 \
    --test_base_dir /path/to/GenImage/1 \
    --test_mode GenImage \
    --token_strategy auto_fisher \
    --top_k 10 \
    --max_train_samples 1000 \
    --max_test_samples 500 \
    --num_epochs 50 \
    --lr 0.01 \
    --batch_size 32 \
    --output_dir ./results/linear_probe_genimage

For AIGCDetectionBenchmark (train with ProGAN only):

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --val_dataset ./datasets/val/progan \
    --train_category car \
    --train_fake_type 1_fake \
    --val_fake_type 1_fake \
    --test_base_dir /path/to/AIGCDetectionBenchmark/test \
    --test_mode AIGCDetectionBenchmark \
    --token_strategy auto_fisher \
    --top_k 10 \
    --max_train_samples 1000 \
    --max_test_samples 6000 \
    --num_epochs 50 \
    --lr 0.01 \
    --batch_size 32 \
    --output_dir ./results/linear_probe_aigc

Quick Start:

cd examples
# Edit train_linear_probe.sh to set TEST_MODE
bash train_linear_probe.sh

Each benchmark requires its corresponding fake type:

Why different fake types?

• so-fake-ood: Uses LDM as a representative early diffusion model
• GenImage: Uses SD1.4 to match Stable Diffusion family
• AIGCDetectionBenchmark: Uses only ProGAN to test extreme cross-domain generalization

• dinov3_vits16 - Small model (22M parameters)
• dinov3_vitb16 - Base model (86M parameters)
• dinov3_vitl16 - Large model (304M parameters)
• dinov3_vith16 - Huge model (845M parameters)
• dinov3_vit_7b - Giant model (7B parameters)

Training Setup: All linear probe models are trained with only 1,000 real + 1,000 single-source fake images, then evaluated on diverse unseen generators (Nano Banana, Imagen4, Midjourney, Ideogram, etc.).

Note: Metrics shown as Accuracy / AUC-ROC. All results demonstrate strong cross-generator generalization despite minimal training data.

We provide pretrained linear probe weights trained on the three benchmark datasets. All models use DINOv3-ViT-7B backbone with Fisher-guided token selection.

The pretrained weights are included in this repository under the checkpoints/ directory:

To use the pretrained weights for inference, use the --probe_checkpoint argument:

For so-fake-ood:

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --probe_checkpoint ./checkpoints/so-fake-ood/linear_probe.pth \
    --test_base_dir ./datasets/test \
    --test_category car \
    --test_mode so-fake-ood \
    --batch_size 32 \
    --output_dir ./results/eval_sofakeood

For GenImage:

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --probe_checkpoint ./checkpoints/GenImage/linear_probe.pth \
    --test_base_dir /path/to/GenImage/ \
    --test_mode GenImage \
    --batch_size 32 \
    --output_dir ./results/eval_genimage

For AIGCDetectionBenchmark:

python linear_probe_with_fisher.py \
    --model dinov3_vit_7b \
    --train_dataset ./datasets/train/progan \
    --probe_checkpoint ./checkpoints/AIGCDetectionBenchmark/linear_probe.pth \
    --test_base_dir /path/to/AIGCDetectionBenchmark/test \
    --test_mode AIGCDetectionBenchmark \
    --max_test_samples 6000 \
    --batch_size 32 \
    --output_dir ./results/eval_aigc

Important Notes:

• The checkpoint files contain both the linear probe weights and the Fisher-selected token indices
• No need to specify --token_strategy or --top_k when using --probe_checkpoint - these are loaded from the checkpoint
• Make sure to use the same model architecture (dinov3_vit_7b) as used during training
• Each checkpoint is specific to its benchmark due to different training fake types

FGTS/
├── models/                      # Model implementations
│   └── dinov3_models.py        # DINOv3 wrapper
├── utils/                       # Utility functions
│   ├── data.py                 # Dataset loading
│   ├── features.py             # Feature extraction
│   ├── models.py               # Model loading interface
│   └── metrics.py              # Evaluation metrics
├── datasets/                    # Data directory
│   ├── train/
│   ├── val/
│   └── test/
├── examples/                    # Example scripts
│   ├── training_free_test.sh
│   └── train_linear_probe.sh
├── training_free_test.py       # Training-Free detection script
├── linear_probe_with_fisher.py # Linear probe training script
├── requirements.txt
└── README.md

If you find this work useful, please consider citing:

@misc{huang2025rethinkingcrossgeneratorimageforgery,
      title={Rethinking Cross-Generator Image Forgery Detection through DINOv3}, 
      author={Zhenglin Huang and Jason Li and Haiquan Wen and Tianxiao Li and Xi Yang and Lu Qi and Bei Peng and Xiaowei Huang and Ming-Hsuan Yang and Guangliang Cheng},
      year={2025},
      eprint={2511.22471},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2511.22471}, 
}

This project is licensed under the MIT License.

• DINOv3 for self-supervised vision transformers
• timm for model implementations

For questions or issues, please open an issue on GitHub or contact [email protected].