Update README.md

README.md

@@ -1,3 +1,198 @@
 ---
 license: mit
+datasets:
+- ThinothW/Deepfake-Identity-Isolated-Dataset-PreP
+metrics:
+- accuracy
+- precision
+- recall
+- f1
+- roc_auc
+base_model:
+- google/efficientnet-b1
+- mobilint/RegNet_Y_800MF.tv2_in1k
+pipeline_tag: image-classification
+tags:
+- deepfake-detection
+- image-classification
+- efficientnet
+- regnet
+- hybrid-model
+- computer-vision
 ---
+
+# Deep_Fake_Hybrid_Model
+
+### Detecting Deepfake Faces: An Image Classification Approach to Safeguarding Digital Identity
+
+A binary image classifier that flags a given face image as **real** or **fake** (deepfake / synthetically manipulated). Built as a **hybrid dual-backbone** model combining fine-tuned [`google/efficientnet-b1`](https://huggingface.co/google/efficientnet-b1) and [`mobilint/RegNet_Y_800MF.tv2_in1k`](https://huggingface.co/mobilint/RegNet_Y_800MF.tv2_in1k) feature extractors, trained on the [`ThinothW/Deepfake-Identity-Isolated-Dataset-PreP`](https://huggingface.co/datasets/ThinothW/Deepfake-Identity-Isolated-Dataset-PreP) dataset.
+
+This model was built as part of a university course project (AI Lab, SE334) exploring deepfake face detection.
+
+**Author:** S. M. Nihal Ahmed
+
+## Model Details
+
+- **Base models:** `google/efficientnet-b1`, `mobilint/RegNet_Y_800MF.tv2_in1k`
+- **Task:** Binary image classification (`fake` vs `real`)
+- **License:** MIT
+- **Architecture:** Hybrid dual-backbone — EfficientNet-B1 and RegNetY-800MF feature extractors, both fine-tuned end-to-end, with their pooled features fused and passed through a classification head
+- **Fine-tuning objective:** Cross-entropy loss over the two classes, with `sklearn` balanced class weights applied to account for class imbalance
+- **Training regime:** Mixed-precision (AMP) training on a CUDA GPU, up to 100 epochs per stage with early stopping (patience = 5, monitored on validation loss); two-stage schedule — Stage A trains only the fusion head with both backbones frozen, Stage B fine-tunes both backbones together at a lower learning rate
+
+## Intended Use
+
+This model is intended for detecting AI-generated or manipulated (deepfake) face images versus authentic (real) face images. Example use cases:
+
+- Screening uploaded profile/identity photos for synthetic manipulation
+- Research and coursework on deepfake detection and media forensics
+- A component in a larger content-authenticity verification pipeline
+
+**Out of scope:** This model is **not** a complete or production-ready deepfake detection guardrail. It has been evaluated on one dataset only, and will not necessarily generalize to deepfake generation methods, image qualities, or demographics absent from its training data.
+
+## How to Use
+
+This model is distributed as an **ONNX** export. Download both files and keep them in the same folder — the `.onnx` graph loads its weights from the `.onnx.data` file alongside it at runtime:
+
+- [`deepfake_hybrid_final.onnx`](https://huggingface.co/nihal4/Deep_Fake_Hybrid_Model/resolve/main/deepfake_hybrid_final.onnx) — the ONNX graph
+- [`deepfake_hybrid_final.onnx.data`](https://huggingface.co/nihal4/Deep_Fake_Hybrid_Model/resolve/main/deepfake_hybrid_final.onnx.data) — the external weights file
+
+Install dependencies:
+
+```bash
+pip install onnxruntime huggingface_hub pillow numpy
+```
+
+### Single-image prediction
+
+```python
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "nihal4/Deep_Fake_Hybrid_Model"
+IMG_SIZE = 260
+IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+IMAGENET_STD  = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+LABEL_MAP = {0: "fake", 1: "real"}
+
+# Downloads both files into the same local cache folder — required, since the
+# .onnx graph references .onnx.data by relative path at load time.
+onnx_path = hf_hub_download(repo_id=REPO_ID, filename="deepfake_hybrid_final.onnx")
+hf_hub_download(repo_id=REPO_ID, filename="deepfake_hybrid_final.onnx.data")
+
+session = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"])
+input_name = session.get_inputs()[0].name
+output_name = session.get_outputs()[0].name
+
+def preprocess_pil(img: Image.Image) -> np.ndarray:
+    img = img.convert("RGB").resize((IMG_SIZE, IMG_SIZE))
+    arr = np.asarray(img, dtype=np.float32) / 255.0        # HWC, [0,1]
+    arr = (arr - IMAGENET_MEAN) / IMAGENET_STD              # normalize, same stats as training
+    return arr.transpose(2, 0, 1)                           # HWC -> CHW
+
+def softmax(x: np.ndarray) -> np.ndarray:
+    e = np.exp(x - x.max(axis=1, keepdims=True))
+    return e / e.sum(axis=1, keepdims=True)
+
+def predict(image_path: str):
+    image = Image.open(image_path)
+    x = preprocess_pil(image)[np.newaxis, ...].astype(np.float32)
+    logits = session.run([output_name], {input_name: x})[0]
+    probs = softmax(logits)[0]
+    label = LABEL_MAP[int(probs.argmax())]
+    return label, probs
+
+label, probs = predict("path/to/face.jpg")
+print(f"Prediction: {label}  (p_fake={probs[0]:.3f}, p_real={probs[1]:.3f})")
+```
+
+### Batch prediction
+
+```python
+image_paths = ["face1.jpg", "face2.jpg", "face3.jpg"]
+
+batch = np.stack([preprocess_pil(Image.open(p)) for p in image_paths]).astype(np.float32)
+logits = session.run([output_name], {input_name: batch})[0]
+probs = softmax(logits)
+preds = probs.argmax(axis=1)
+
+for path, pred, p in zip(image_paths, preds, probs):
+    print(f"{path}: {LABEL_MAP[int(pred)]}  (p_fake={p[0]:.3f}, p_real={p[1]:.3f})")
+```
+
+> For GPU inference, install `onnxruntime-gpu` instead and pass `providers=["CUDAExecutionProvider", "CPUExecutionProvider"]` when creating the session.
+
+## Training Data
+
+The model was fine-tuned on the [`ThinothW/Deepfake-Identity-Isolated-Dataset-PreP`](https://huggingface.co/datasets/ThinothW/Deepfake-Identity-Isolated-Dataset-PreP) dataset.
+
+- **Labels:** `0 = fake`, `1 = real`
+- **Splits:** train / validation / test
+- **Preprocessing:** resize to 260×260, ImageNet normalization (mean `[0.485, 0.456, 0.406]`, std `[0.229, 0.224, 0.225]`)
+- **Training augmentation:** random horizontal flip, random rotation (±10°), color jitter, plus simulated JPEG compression and simulated blur/downscale-upscale (to reduce false positives on low-quality real footage)
+- **Class balancing:** `sklearn` balanced class weights applied in the loss function to address train-set class imbalance
+
+## Training Procedure
+
+<!-- PLACEHOLDER: training curves (loss/accuracy per epoch) — image to be uploaded -->
+
+
+![Training Plot](https://cdn-uploads.huggingface.co/production/uploads/661d43ec3cf2981df52d0756/P4xdn9C-oB-zstz2IoQ5H.png)
+
+- **Framework:** PyTorch
+- **Hardware:** Kaggle free-tier T4 GPU
+- **Loss:** Cross-entropy
+- **Mixed precision:** Enabled (AMP)
+
+## Evaluation
+
+Evaluated on the held-out test split (n = 21,316) at a decision threshold of 0.5.
+
+### Classification Report
+
+| Class        | Precision | Recall | F1-score | Support |
+|--------------|:---------:|:------:|:--------:|:-------:|
+| fake         | 0.95      | 0.96   | 0.95     | 10,706  |
+| real         | 0.96      | 0.95   | 0.95     | 10,610  |
+| **accuracy** |           |        | **0.9539** | 21,316 |
+| macro avg    | 0.95      | 0.95   | 0.95     | 21,316  |
+| weighted avg | 0.95      | 0.95   | 0.95     | 21,316  |
+
+**Test ROC-AUC:** 0.9903
+
+### Confusion Matrix
+
+<!-- PLACEHOLDER: image to be uploaded -->
+
+
+
+![Confusion Matrix](https://cdn-uploads.huggingface.co/production/uploads/661d43ec3cf2981df52d0756/7KaWz5PUUvR19qmLoPB3H.png)
+
+### ROC Curve
+
+<!-- PLACEHOLDER: image to be uploaded -->
+
+
+
+![ROC-AUC Curve](https://cdn-uploads.huggingface.co/production/uploads/661d43ec3cf2981df52d0756/7VIFPxuYc1TimmtpBVF1L.png)
+
+## Limitations
+
+- Performance is reported on a single dataset; generalization to other deepfake generation methods, image resolutions, compression levels, or demographics is not guaranteed.
+- As with most deepfake detectors, robustness against novel/unseen generative techniques (including adversarially crafted ones) has not been evaluated here.
+- The model has not been evaluated as a standalone production guardrail; it is intended to complement, not replace, other verification measures.
+
+## Citation
+
+If you use this model, please cite this repository and reference this course project:
+
+```
+@misc{deepfake-hybrid-detector,
+  title  = {Detecting Deepfake Faces: An Image Classification Approach to Safeguarding Digital Identity},
+  author = {S. M. Nihal Ahmed},
+  year   = {2026},
+  note   = {Course project, AI Lab (SE334), Daffodil International University}
+}
+```