Upload main.py

main.py

@@ -61,16 +61,16 @@ def extract_clip(video_path, start_frame):
     """
     Open a fresh cap, seek ONCE to start_frame, then read frames
     SEQUENTIALLY (no cap.set inside loop). This is reliable for all codecs.
-    Collects SEQUENCE_LENGTH face crops.
+    Collects SEQUENCE_LENGTH face crops using bounding box caching for speed.
     """
     cap = cv2.VideoCapture(video_path)
     cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)  # Seek exactly ONCE
 
     faces    = []
-    last_box = None
+    base_box = None
     attempts = 0
 
-    while len(faces) < SEQUENCE_LENGTH and attempts < 300:
+    while len(faces) < SEQUENCE_LENGTH and attempts < 60:
         ret, frame = cap.read()  # Sequential — no random seeking
         if not ret:
             break
@@ -79,19 +79,25 @@ def extract_clip(video_path, start_frame):
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         pil_img   = Image.fromarray(frame_rgb)
 
-        boxes, _ = mtcnn.detect(pil_img)
-
-        if boxes is not None and len(boxes) > 0:
-            smoothed = smooth_box(boxes[0].tolist(), last_box)
-            last_box = smoothed
-        elif last_box is not None:
-            smoothed = last_box   # Hold last known position
-        else:
-            continue              # No face yet — keep reading
-
-        crop = crop_face(pil_img, smoothed)
-        if crop is not None:
-            faces.append(crop)
+        if base_box is None:
+            # Downscale for faster MTCNN detection
+            detect_img = pil_img.copy()
+            if detect_img.width > 640:
+                ratio = 640.0 / detect_img.width
+                detect_img = detect_img.resize((640, int(detect_img.height * ratio)))
+                boxes, _ = mtcnn.detect(detect_img)
+                if boxes is not None and len(boxes) > 0:
+                    base_box = [b / ratio for b in boxes[0].tolist()]
+            else:
+                boxes, _ = mtcnn.detect(pil_img)
+                if boxes is not None and len(boxes) > 0:
+                    base_box = boxes[0].tolist()
+        
+        if base_box is not None:
+            # We use a larger padding (0.5) because we are caching the box and the face might move slightly
+            crop = crop_face(pil_img, base_box, padding=0.5)
+            if crop is not None:
+                faces.append(crop)
 
     cap.release()
 
@@ -153,28 +159,45 @@ async def analyze_video(file: UploadFile = File(...)):
             return {"isFake": False, "confidence": 0,
                     "explanation": "Could not read the video file.", "details": []}
 
-        # ── Start from the middle of the video (most likely to have a clear face) ─
-        start_frame = max(0, (total_frames // 2) - (SEQUENCE_LENGTH // 2))
-        print(f"Extracting clip from frame {start_frame}...")
-
-        faces = extract_clip(temp_path, start_frame)
-
-        if not faces:
+        # ── Extract multiple clips from different parts of the video ───────────────
+        segments = [
+            max(0, int(total_frames * 0.2) - (SEQUENCE_LENGTH // 2)),
+            max(0, int(total_frames * 0.5) - (SEQUENCE_LENGTH // 2)),
+            max(0, int(total_frames * 0.8) - (SEQUENCE_LENGTH // 2))
+        ]
+        
+        # Ensure unique starting frames if the video is very short
+        segments = sorted(list(set(segments)))
+        
+        highest_fake_prob = 0.0
+        successful_clips = 0
+
+        for start_frame in segments:
+            print(f"Extracting clip from frame {start_frame}...")
+            faces = extract_clip(temp_path, start_frame)
+            
+            if faces:
+                prob = run_inference(faces)
+                highest_fake_prob = max(highest_fake_prob, prob)
+                successful_clips += 1
+                
+                # If we already found very strong evidence of a fake, we can short-circuit to save time
+                if highest_fake_prob > 0.95:
+                    break
+
+        if successful_clips == 0:
             return {
                 "isFake": False, "confidence": 0,
                 "explanation": "Could not detect a clear face in the video. Ensure the subject's face is visible.",
                 "details": []
             }
 
-        print(f"Extracted {len(faces)} face frames. Running inference...")
-        fake_prob = run_inference(faces)
-
         # ── Apply calibrated threshold ─────────────────────────────────────────
         # This model scores ~60-75% for real videos, so we require 80%+ to call FAKE.
-        is_fake    = fake_prob >= FAKE_THRESHOLD
-        confidence = round((fake_prob if is_fake else 1.0 - fake_prob) * 100, 2)
+        is_fake    = highest_fake_prob >= FAKE_THRESHOLD
+        confidence = round((highest_fake_prob if is_fake else 1.0 - highest_fake_prob) * 100, 2)
 
-        print(f"FINAL — fake_prob={fake_prob:.3f}, threshold={FAKE_THRESHOLD}, isFake={is_fake}, confidence={confidence}%")
+        print(f"FINAL — fake_prob={highest_fake_prob:.3f}, threshold={FAKE_THRESHOLD}, isFake={is_fake}, confidence={confidence}%")
 
         explanation = (
             "Our Temporal AI detected strong evidence of facial manipulation — "
@@ -182,7 +205,7 @@ async def analyze_video(file: UploadFile = File(...)):
             "characteristic of deepfake synthesis."
             if is_fake else
             "Our Temporal AI found no significant manipulation artifacts. "
-            "Facial motion, micro-expressions, and temporal consistency appear natural."
+            "Facial motion, micro-expressions, and temporal consistency appear natural across the analyzed segments."
         )
 
         return {
@@ -191,16 +214,16 @@ async def analyze_video(file: UploadFile = File(...)):
             "explanation": explanation,
             "details": [
                 {
-                    "title": "Temporal Analysis",
-                    "desc": f"Analyzed a 16-frame consecutive clip from the middle of the video using a VideoMAE 3D Transformer."
+                    "title": "Multi-Segment Temporal Analysis",
+                    "desc": f"Analyzed {successful_clips} separate 16-frame consecutive clips across the video using a VideoMAE 3D Transformer."
                 },
                 {
-                    "title": "Sequential Face Tracking",
-                    "desc": "Frames read sequentially with EMA bounding-box smoothing for stable face tracking."
+                    "title": "Optimized Face Tracking",
+                    "desc": "Frames read sequentially with bounding-box caching and downscaled initial detection for extremely fast analysis."
                 },
                 {
                     "title": "Calibrated Threshold",
-                    "desc": f"Raw model score: {fake_prob*100:.1f}%. Detection threshold: {FAKE_THRESHOLD*100:.0f}% (tuned to reduce false positives)."
+                    "desc": f"Peak raw model score: {highest_fake_prob*100:.1f}%. Detection threshold: {FAKE_THRESHOLD*100:.0f}% (tuned to reduce false positives)."
                 }
             ]
         }