Robust & Explainable AI-Generated Face Detection

This repository implements a deepfake detection framework that combines adversarial robustness with explainable AI (XAI) for detecting AI-generated faces. The system uses pretrained CNNs (Xception, ResNet-50) and Vision Transformers (ViT) with adversarial training (FGSM/PGD) and Grad-CAM visualizations.

Features

• Multiple Model Architectures: Xception, Vision Transformer (ViT-B/16), ResNet-50
• Adversarial Training: FGSM and PGD attacks for robustness
• Explainability: Grad-CAM visualizations showing model attention
• Comprehensive Evaluation: Accuracy, Precision, Recall, F1, AUC, and Adversarial Robustness Index (ARI)
• Binary and Tri-class Support: Real vs Fake, or Artificial vs Deepfake vs Real

Installation

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

Quick Start

1. Train a Model

Train Xception with PGD adversarial training:

python -m src.train \
    --model xception \
    --binary True \
    --epochs 5 \
    --batch-size 32 \
    --adv-train pgd \
    --eps 8 \
    --alpha 2 \
    --pgd-steps 5

2. Evaluate Model

Evaluate on clean, FGSM, and PGD adversarial examples:

python -m src.eval \
    --ckpt outputs/last-xception.pt \
    --binary True \
    --eps 8 \
    --alpha 2 \
    --pgd-steps 10

This generates:

• outputs/metrics_clean_fgsm_pgd.csv - Evaluation metrics
• outputs/roc_clean.png - ROC curve plot

3. Generate Grad-CAM Visualizations

python -m src.gradcam_viz \
    --ckpt outputs/last-xception.pt \
    --binary True \
    --num-images 12

Outputs are saved to outputs/gradcam/*.png

Usage Examples

Training Different Models

Vision Transformer:

python -m src.train --model vit_b16 --adv-train pgd --epochs 5

ResNet-50:

python -m src.train --model resnet50 --adv-train fgsm --eps 4

Without Adversarial Training:

python -m src.train --model xception --adv-train none

Tri-class Classification

python -m src.train --model xception --binary False --epochs 5

Project Structure

face-explainability/
├── src/
│   ├── data.py          # Dataset loading (Hugging Face)
│   ├── models.py        # Model architectures (Xception, ViT, ResNet)
│   ├── attacks.py       # Adversarial attacks (FGSM, PGD)
│   ├── metrics.py       # Evaluation metrics (Accuracy, F1, AUC, ARI)
│   ├── utils.py         # Utility functions
│   ├── train.py         # Training script
│   ├── eval.py          # Evaluation script
│   └── gradcam_viz.py   # Grad-CAM visualization
├── outputs/             # Runtime outputs
│   ├── *.pt            # Model checkpoints
│   ├── *.csv           # Evaluation metrics
│   ├── *.png           # Plots
│   └── gradcam/        # Grad-CAM images
├── config.example.yaml  # Configuration template
├── requirements.txt     # Python dependencies
└── README.md           # This file

Dataset

The code uses the AI-vs-Deepfake-vs-Real dataset from Hugging Face:

• Dataset: prithivMLmods/AI-vs-Deepfake-vs-Real
• Automatically downloaded on first run
• Supports binary (Real vs Fake) and tri-class (Artificial vs Deepfake vs Real) classification

Metrics

• Accuracy: Overall classification accuracy
• Precision/Recall/F1: Per-class metrics
• AUC-ROC: Area under ROC curve
• ARI (Adversarial Robustness Index): acc_adv / acc_clean - measures robustness under attack

Adversarial Attacks

• FGSM (Fast Gradient Sign Method): Single-step attack
• PGD (Projected Gradient Descent): Multi-step iterative attack (stronger)

Perturbation budgets (eps) are specified in 0..255 pixel space and automatically scaled to [0, 1] for model inputs.

Explainability

Grad-CAM visualizations highlight facial regions that influence the model's decision:

• Real faces: Model typically focuses on eyes, nose, mouth
• Fake faces: Model often highlights blending boundaries, forehead, chin (artifact regions)

Configuration

Copy config.example.yaml to config.yaml and modify as needed. The config file supports all training and evaluation parameters.

Requirements

• Python 3.9+
• PyTorch 2.2+
• CUDA-capable GPU (recommended for training)
• See requirements.txt for full dependency list

Citation

If you use this code in your research, please cite:

@article{kotov2025adversarial,
  title={Adversarial Robustness and Explainability in AI-Generated Face Detection},
  author={Kotov, Georgi},
  journal={Technical University of Sofia},
  year={2025}
}

License

This project is for research purposes. Please respect dataset licenses and usage terms.

Acknowledgments

• Hugging Face for dataset hosting
• timm library for pretrained models
• pytorch-grad-cam for explainability tools