Commit

README.md

@@ -1,20 +1,43 @@
----
-title: DeepTrust
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
+# 🛡️ DeepTrust – Explainable AI Deepfake Detection
 
-# Welcome to Streamlit!
+## Overview
+DeepTrust is an explainable AI system for detecting AI-generated images.
+It focuses on accuracy, transparency, and long-term learning using
+human feedback.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Why DeepTrust?
+- Uses verified research-grade pretrained models
+- No black-box APIs
+- Visual explanations (heatmaps)
+- Trust Score for user clarity
+- Designed for long-term deployment
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## How It Works
+1. Upload an image
+2. Pretrained deepfake model analyzes artifacts
+3. Trust Score (0–100) is generated
+4. Heatmap shows suspicious regions
+5. User feedback improves the model
+
+## Model Loading (Important)
+DeepTrust uses Torch Hub to automatically load a verified pretrained
+deepfake detection model on first run.
+- No manual model download required
+- Model is cached locally after first use
+- Fully legal and reproducible
+
+## Tech Stack
+- Python
+- Streamlit
+- PyTorch
+- EfficientNet
+- SQLite
+
+## Future Scope
+- Video deepfake detection
+- Face-level analysis
+- Browser extension
+
+## Disclaimer
+DeepTrust is a decision-support system and should not be used as the sole
+authority for forensic conclusions.

app.py

@@ -0,0 +1,45 @@
+import streamlit as st, uuid, os, shutil
+from PIL import Image
+from model.predict import predict
+from model.heatmap import cam_heatmap
+from feedback.db import init_db, save
+
+init_db()
+st.set_page_config("DeepTrust", "🛡️")
+st.title("🛡️ DeepTrust – AI Image Deepfake Detector")
+st.caption("Building trust in digital media using explainable AI")
+
+file = st.file_uploader("Upload an image", ["jpg","png","jpeg"])
+
+if file:
+    img = Image.open(file).convert("RGB")
+    st.image(img, use_container_width=True)
+
+    label, conf, trust, tensor, model = predict(img)
+
+    st.metric("Trust Score", f"{trust}/100")
+    st.progress(trust/100)
+
+    result = "AI-Generated ❌" if label else "Real Image ✅"
+    st.subheader(result)
+
+    os.makedirs("data/uploads", exist_ok=True)
+    path = f"data/uploads/{uuid.uuid4()}.jpg"
+    img.save(path)
+
+    if st.checkbox("Show explanation"):
+        heat = cam_heatmap(model, tensor, img)
+        st.image(heat, caption="Model Attention Areas")
+
+    col1, col2 = st.columns(2)
+    if col1.button("Correct"):
+        save(path, label, label)
+        st.success("Feedback saved")
+
+    if col2.button("Wrong"):
+        correct = 0 if label else 1
+        save(path, label, correct)
+        target = "fake" if correct else "real"
+        os.makedirs(f"data/labeled/{target}", exist_ok=True)
+        shutil.copy(path, f"data/labeled/{target}/")
+        st.warning("Saved for retraining")

feedback/db.py

@@ -0,0 +1,24 @@
+import sqlite3, os
+os.makedirs("feedback", exist_ok=True)
+
+def init_db():
+    conn = sqlite3.connect("feedback/feedback.db")
+    c = conn.cursor()
+    c.execute("""
+    CREATE TABLE IF NOT EXISTS feedback(
+        id INTEGER PRIMARY KEY,
+        image TEXT,
+        predicted INTEGER,
+        correct INTEGER
+    )
+    """)
+    conn.commit()
+    conn.close()
+
+def save(image, predicted, correct):
+    conn = sqlite3.connect("feedback/feedback.db")
+    c = conn.cursor()
+    c.execute("INSERT INTO feedback VALUES(NULL,?,?,?)",
+              (image, predicted, correct))
+    conn.commit()
+    conn.close()

model/heatmap.py

@@ -0,0 +1,9 @@
+import numpy as np
+from pytorch_grad_cam import GradCAM
+from pytorch_grad_cam.utils.image import show_cam_on_image
+
+def cam_heatmap(model, tensor, image):
+    cam = GradCAM(model=model, target_layers=[model.blocks[-1]])
+    grayscale = cam(input_tensor=tensor)[0]
+    img = np.array(image).astype(float)/255
+    return show_cam_on_image(img, grayscale, use_rgb=True)

model/predict.py

@@ -0,0 +1,27 @@
+import torch
+from torchvision import transforms
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+model = torch.hub.load(
+    "selimsef/dfdc_deepfake_challenge",
+    "efficientnet_b0",
+    pretrained=True
+).to(device).eval()
+
+transform = transforms.Compose([
+    transforms.Resize((224,224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485,0.456,0.406],
+                         [0.229,0.224,0.225])
+])
+
+def predict(image):
+    tensor = transform(image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        out = model(tensor)
+        prob = torch.softmax(out, 1)
+        conf, pred = torch.max(prob, 1)
+
+    trust_score = int(conf.item()*100 if pred.item()==0 else (1-conf.item())*100)
+    return pred.item(), conf.item(), trust_score, tensor, model

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+torch==2.0.1
+torchvision==0.15.2
+pytorch-grad-cam
+opencv-python-headless
+streamlit==1.31.0

train/retrain.py

@@ -0,0 +1,36 @@
+import torch
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader
+import torch.nn as nn, torch.optim as optim
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+transform = transforms.Compose([
+    transforms.Resize((224,224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485,0.456,0.406],
+                         [0.229,0.224,0.225])
+])
+
+dataset = datasets.ImageFolder("data/labeled", transform)
+loader = DataLoader(dataset, batch_size=8, shuffle=True)
+
+model = torch.hub.load(
+    "selimsef/dfdc_deepfake_challenge",
+    "efficientnet_b0",
+    pretrained=True
+).to(device)
+
+loss_fn = nn.CrossEntropyLoss()
+opt = optim.Adam(model.parameters(), lr=1e-4)
+
+for epoch in range(3):
+    for x,y in loader:
+        x,y = x.to(device), y.to(device)
+        opt.zero_grad()
+        loss = loss_fn(model(x), y)
+        loss.backward()
+        opt.step()
+
+torch.save(model.state_dict(), "deeptrust_finetuned.pth")
+print("Model retrained and saved")