---
license: cc-by-4.0
task_categories:
- image-classification
language:
- en
tags:
- deepfake
- deepfake-detection
- synthetic-media
- face-swap
- computer-vision
- fintech
- kyc
- identity-verification
- biometrics
- security
size_categories:
- 100K<n<1M
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: validation
    path: data/validation-*
  - split: test
    path: data/test-*
dataset_info:
  features:
  - name: image
    dtype: image
  - name: label
    dtype:
      class_label:
        names:
          '0': fake
          '1': real
  splits:
  - name: train
    num_bytes: 1538248364
    num_examples: 99910
  - name: validation
    num_bytes: 332283158
    num_examples: 21611
  - name: test
    num_bytes: 324218064
    num_examples: 21316
  download_size: 2868319762
  dataset_size: 2194749586
---

# Identity-Isolated Deepfake Face Images Dataset.

A rigorously preprocessed, identity-aware deepfake detection dataset of 142,837 face images, constructed for training generalized deepfake detectors across Face Swap and Entire Face Synthesis manipulation categories.

Built as part of the DFDS project - an open-source deepfake detection API for FinTech KYC identity verification. The full system is available at: https://github.com/thinothw/DFDS-Final-Project

---

## Dataset Summary.

| Property | Value |
|---|---|
| Total Images | 142,837 |
| Real / Fake Split | 71,417 (49.998%) / 71,420 (50.001%) |
| Image Resolution | 260 × 260 px |
| Face Detector | RetinaFace (confidence ≥ 0.90) |
| Train / Validation / Test Splits | 70 / 15 / 15 |
| Identity Leakage | Zero - graph-based isolation enforced |

---

### Image Resolution and Model Compatibility.

All images in this dataset have been standardized to a hard `260x260` pixel resolution. This dimension was selected as a strategic engineering constraint to balance high-fidelity artifact retention with GPU VRAM efficiency during massive-batch training. 

This resolution offers high flexibility for various pre-trained computer vision architectures:

* **Native Compatibility (260x260):** Perfectly aligned for zero-interpolation training on models like **EfficientNet-B2**.
* **Lossless Downscaling (224x224):** Can be easily center-cropped or downscaled to the industry-standard `224x224` resolution for seamless integration with **ResNet-50, MobileNetV2, VGG-16, and standard Vision Transformers (ViT)**. 
* **Minor Upscaling (299x299):** Models like **InceptionV3 and Xception** require `299x299`. Since this is only a -15% resolution increase, standard bilinear interpolation is generally acceptable and retains enough artifact fidelity for successful training.
* **Large Architectures (384x384):** For large Vision Transformers (example: ViT-384), interpolation becomes highly destructive to high-frequency deepfake noise. **Zero-Padding** the 260x260 images up to 384x384 is strictly required to preserve signal integrity.

**Baseline Recommendation and Hard Limit:** If your target architecture requires an input size greater than `299x299`, default entirely to zero-padding rather than interpolation. Furthermore, `384x384` should be treated as the hard maximum compatible input size for this dataset. Architectures requiring resolutions beyond this threshold will suffer from excessive spatial padding (or catastrophic interpolation blur), which will severely degrade model convergence.

---

## How to Use.

Download and load the dataset directly into your environment using the Hugging Face `datasets` library. It will automatically handle the Parquet formatting and map the Train, Validation, and Test splits.

```python
from datasets import load_dataset

# 1. Load the entire dataset
dataset = load_dataset("ThinothW/Deepfake-Identity-Isolated-Dataset-PreP")

# 2. Access specific splits
train_data = dataset['train']
val_data = dataset['validation']
test_data = dataset['test']

# 3. Example: Fetch the first image and verify the label mapping
sample = train_data[0]
image = sample['image']
label = sample['label'] 

# Label Mapping:
# 0 = fake
# 1 = real

print(f"Dataset Loaded. Example Label: {label}")
```

---

### Accessing Specific Subsets (Preprocessed).

While the HuggingFace `datasets` library provides the entire 142K+ image pool flattened for generalized training, researchers may need to evaluate specific domains independently. If you require the raw, strictly separated source directories (example: just the CDF Face Swaps or just the Original FF++ data), you can download the categorized archive directly from Google Drive.

 **[Download Categorized Domain Subsets (Google Drive)](https://drive.google.com/drive/folders/1iIxkJ9oLqXCXROjAt3ZuX9nhRq89-Iqv?usp=sharing)**

**CRITICAL DATA INTEGRITY WARNINGS FOR RAW SUBSETS.**

* **Why Original FF++ is in the Drive Zip but NOT in the Hugging Face Pool:** The HuggingFace `load_dataset()` pool is a mathematically balanced, graph-isolated master dataset. Because **DF40 FF FS** and **Original FF++** are derived from the exact same source videos, including both in the main pool would cause catastrophic identity leakage across Train, Validation and Test splits. Therefore, Original FF++ was strictly excluded from the HuggingFace distribution. It is provided in the Drive Archive purely as an isolated convenience resource for targeted benchmarking.
* **Original FF++ vs. DF40 FF FS Overlap:** If you are building custom data loaders from the Google Drive archive, **DO NOT use Original FF++ and DF40 FF FS together.** You must select one or the other for your training run to maintain identity isolation.
* **DF40 EFS (Entire Face Synthesis) is Safe to Mix:** The EFS data is derived from the FF++ domain, but it consists of Entire Face Synthesis rather than face swaps. These images were created using diffusion models that generate entirely new, synthetic neural network faces. Because there is no underlying source identity being preserved, there is **Zero Identity Overlap** between DF40 EFS and DF40 FF FS (or Original FF++). You can safely mix the EFS subset with any other data in this repository.

---

## Sources.

The dataset was assembled from publicly available sources spanning multiple manipulation methods across two deepfake categories. **Crucially, Real and Fake distributions are intrinsically paired within their respective domains** to prevent the model from learning source-specific compression or camera artifacts.

### Face Swap (FS).

* **DF40 CDF Domain FS:** High-quality face swap data using the Celeb-DF identity pool. Contains **both paired Real and Fake images**. 59 CDF actors with strict identity graph enforcement - any two identities appearing in the same swap video are permanently locked to the same split.
* **DF40 FF++ Domain FS:** Face swap methods from the FaceForensics++ identity pool (FSGAN, FaceSwap, SimSwap, InSwap, BlendFace, MobileSwap, E4S, and FaceDancer). Contains **both paired Real and Fake images**. Processed from raw video using the full RetinaFace pipeline rather than DF40 pre-extracted frames, ensuring preprocessing uniformity. A unified identity graph was built across all methods simultaneously.

### Entire Face Synthesis (EFS).

* **DF40 EFS FF++ Domain (Fakes) paired with FFHQ (Reals):** The DF40 EFS subset (diffusion-based synthesis methods including VQGAN and DiT-XL2) consists entirely of synthetic data. To maintain a strict 1:1 class balance, approximately 20,000 high-resolution natural face photographs from the **FFHQ dataset** were integrated exclusively to serve as the "Real" counterpart for these specific diffusion fakes. 
* **OpenFake:** Sampled from the ComplexDataLab OpenFake dataset. GAN-era face images with high class diversity. Contains its own inherent **Real and Fake images**.
---

## Preprocessing Pipeline.

An identical pipeline was applied uniformly across all sources.

1. **RetinaFace face detection** - confidence threshold ≥ 0.90, minimum face size 30px, largest face selected by bounding box area.
2. **1080p bypass** - source frames downscaled 50% for detection, bounding box upscaled back to original resolution before cropping.
3. **25px padding** applied on all sides of the detected bounding box.
4. **Blur filter** - Laplacian variance threshold 25.0, low-quality crops rejected.
5. **pHash deduplication** - Hamming distance ≤ 2 per split-class bucket via BK-tree.
6. **Bicubic resize** to 260 × 260 pixels - matches EfficientNet-B2 native resolution.
7. **BGR to RGB conversion** and JPEG save at quality 95.

Frame extraction from video sources used `numpy.linspace`.

---

## Identity-Aware Splitting.

Identity leakage is the most common and critical failure mode in deepfake dataset construction. If the same person's face appears in both training and test splits - even on different sides of a swap - the model learns to recognise identities rather than manipulation artifacts, producing inflated and non-generalizable test accuracy.

This dataset enforces strict identity isolation using an undirected graph approach.

- Each node represents a unique real identity.
- An edge connects any two identities appearing in the same manipulation video.
- Connected components of the graph are assigned entirely to one split.
- A unified graph was built across methods simultaneously, enforcing cross-method identity isolation in addition to cross-split isolation.

**Result:** Zero identity overlap between Train, Validation, and Test splits. A random seed of 42 was applied throughout for full reproducibility.

### Final File Counts

| Split | Total Images | Real | Fake |
|---|---|---|---|
| **Train** | 99,910 | 49,934 | 49,976 |
| **Validation** | 21,611 | 10,873 | 10,738 |
| **Test** | 21,316 | 10,610 | 10,706 |

---

## Label Convention.

`0 = Fake` · `1 = Real`

---

## Benchmark Results.

A model trained on this dataset (EfficientNet-B2, Run 5) achieved:

| Metric | Value |
|---|---|
| Test accuracy | 96.00% |
| Test AUC | 99.30% |
| Test F1 | 0.9597 |
| FinTech-relevant isolated cross-dataset AUC | 89.01% |

Cross-dataset evaluation was conducted on 8 entirely unseen manipulation methods from the DF40 benchmark.

---

## Citation.

If you use this dataset, please cite the source datasets it is derived from:

- Yan, Z. et al. (2024). DF40: Toward Next-Generation Deepfake Detection. NeurIPS 2024.
- Rossler, A. et al. (2019). FaceForensics++. ICCV 2019.
- Karras, T. et al. (2019). A Style-Based Generator Architecture for GANs. CVPR 2019.

---

## License.

This dataset is released for academic and research use only. All source datasets are subject to their respective original licenses. Users are responsible for ensuring compliance with the terms of each source dataset before use.

---

## Author.

# Thinod Wickramasinghe · University of Plymouth · 2026
GitHub: https://github.com/thinothw  

Project Supervisor - Dr. Rasika Ranaweera.