Upload 3 files

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.9-slim
+
+# Install system dependencies required by OpenCV
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a non-root user for Hugging Face Spaces
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements and install
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the app
+COPY --chown=user . .
+
+# Run the app on port 7860 (Hugging Face Spaces default)
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,158 @@
+import os
+import cv2
+import torch
+import shutil
+from fastapi import FastAPI, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from facenet_pytorch import MTCNN
+from PIL import Image
+
+app = FastAPI()
+
+# Enable CORS for the React frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Models globally so they load once on startup
+print("Loading MTCNN Face Detector...")
+mtcnn = MTCNN(keep_all=False, select_largest=True, post_process=False)
+
+print("Loading Hugging Face Deepfake Detector...")
+model_name = "dima806/deepfake_vs_real_image_detection"
+processor = AutoImageProcessor.from_pretrained(model_name)
+model = AutoModelForImageClassification.from_pretrained(model_name)
+
+# Ensure temp directory exists
+os.makedirs("temp", exist_ok=True)
+
+def extract_faces_from_video(video_path, max_frames=8):
+    """Extracts a limited number of frames and crops the face from each."""
+    cap = cv2.VideoCapture(video_path)
+    frames_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    if frames_count == 0:
+        return []
+        
+    # Calculate step to get evenly spaced frames
+    step = max(1, frames_count // max_frames)
+    
+    faces = []
+    current_frame = 0
+    
+    while cap.isOpened() and len(faces) < max_frames:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
+        ret, frame = cap.read()
+        
+        if not ret:
+            break
+            
+        # Convert BGR to RGB for MTCNN and PIL
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        pil_img = Image.fromarray(frame_rgb)
+        
+        # Detect and crop face
+        boxes, _ = mtcnn.detect(pil_img)
+        if boxes is not None and len(boxes) > 0:
+            box = boxes[0]
+            
+            # Add 30% padding around the face. Deepfake models need to see the jawline and background boundaries!
+            w = box[2] - box[0]
+            h = box[3] - box[1]
+            pad_w = int(w * 0.3)
+            pad_h = int(h * 0.3)
+            
+            # Ensure box coordinates are within image bounds with padding
+            x1 = max(0, int(box[0]) - pad_w)
+            y1 = max(0, int(box[1]) - pad_h)
+            x2 = min(pil_img.width, int(box[2]) + pad_w)
+            y2 = min(pil_img.height, int(box[3]) + pad_h)
+            
+            if x2 > x1 and y2 > y1:
+                face_crop = pil_img.crop((x1, y1, x2, y2))
+                faces.append(face_crop)
+                
+        current_frame += step
+        
+    cap.release()
+    return faces
+
+@app.post("/api/analyze")
+async def analyze_video(file: UploadFile = File(...)):
+    print(f"Received file: {file.filename}")
+    
+    # Save the uploaded file temporarily
+    temp_video_path = os.path.join("temp", file.filename)
+    with open(temp_video_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+        
+    try:
+        # Extract faces
+        print("Extracting faces from video...")
+        faces = extract_faces_from_video(temp_video_path, max_frames=6)
+        
+        if not faces:
+            return {
+                "isFake": False, 
+                "confidence": 0, 
+                "explanation": "Could not detect any faces in the video. Ensure the subject's face is clearly visible.",
+                "details": []
+            }
+            
+        print(f"Extracted {len(faces)} faces. Running inference...")
+        
+        # Prepare for model
+        inputs = processor(images=faces, return_tensors="pt")
+        
+        # Run inference
+        with torch.no_grad():
+            outputs = model(**inputs)
+            
+        # Apply softmax to get probabilities
+        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        # For dima806/deepfake_vs_real_image_detection, Fake is index 1 and Real is index 0
+        fake_idx = 1 
+        
+        # Get average probability for 'Fake' class across all analyzed frames
+        avg_fake_prob = probabilities[:, fake_idx].mean().item()
+        
+        is_fake = avg_fake_prob > 0.5
+        
+        # Calculate confidence score based on the chosen class
+        if is_fake:
+            confidence = round(avg_fake_prob * 100, 2)
+        else:
+            confidence = round((1.0 - avg_fake_prob) * 100, 2)
+            
+        explanation = "Our AI detected significant spatial artifacts and inconsistencies consistent with synthetic generation or facial manipulation." if is_fake else "No significant manipulation artifacts were detected. The spatial integrity and facial rendering are consistent with genuine media."
+        
+        print(f"Result: isFake={is_fake}, confidence={confidence}%")
+        
+        return {
+            "isFake": is_fake,
+            "confidence": confidence,
+            "explanation": explanation,
+            "details": [
+                {"title": "Face Detection", "desc": f"Analyzed {len(faces)} key frames evenly distributed across the video."},
+                {"title": "Spatial Analysis", "desc": "Evaluated using a Vision Transformer (ViT) deep learning architecture."}
+            ]
+        }
+        
+    except Exception as e:
+        print(f"Error analyzing video: {e}")
+        return {"error": str(e)}
+        
+    finally:
+        # Clean up temp file
+        if os.path.exists(temp_video_path):
+            os.remove(temp_video_path)
+
+@app.get("/")
+def health_check():
+    return {"status": "Backend is running!"}

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+python-multipart
+opencv-python-headless
+torch
+torchvision
+transformers
+facenet-pytorch
+Pillow