Upload main.py

main.py

@@ -32,26 +32,22 @@ model.eval()
 os.makedirs("temp", exist_ok=True)
 
 # ── Configuration ─────────────────────────────────────────────────────────────
-SEQUENCE_LENGTH = 16   # VideoMAE requires exactly 16 frames per clip
-TARGET_FPS      = 8    # Sample the video at this framerate (higher = finer detail)
-NUM_WINDOWS     = 4    # Number of independent clips to analyze across the video
-WINDOW_SECONDS  = 2    # Duration (seconds) of each clip
+SEQUENCE_LENGTH = 16  # VideoMAE requires exactly 16 frames per clip
+TARGET_FPS      = 6   # How many frames per second to sample (covers more motion)
+NUM_WINDOWS     = 3   # Analyze 3 clips from: start, middle, end
 
 def get_video_fps(cap):
     fps = cap.get(cv2.CAP_PROP_FPS)
     return fps if fps and fps > 0 else 25.0
 
-def smooth_box(current_box, last_box, alpha=0.6):
-    """Exponential moving-average smoothing on bounding boxes to reduce jitter."""
+def smooth_box(current_box, last_box, alpha=0.5):
+    """EMA smoothing to prevent the face crop from jumping between frames."""
     if last_box is None:
         return current_box
-    return [
-        alpha * c + (1 - alpha) * p
-        for c, p in zip(current_box, last_box)
-    ]
+    return [alpha * c + (1 - alpha) * p for c, p in zip(current_box, last_box)]
 
 def crop_face(pil_img, box, padding=0.35):
-    """Crop the face from a PIL image with proportional padding."""
+    """Crop and pad the face region from a PIL image."""
     w = box[2] - box[0]
     h = box[3] - box[1]
     pad_w = int(w * padding)
@@ -64,70 +60,80 @@ def crop_face(pil_img, box, padding=0.35):
         return pil_img.crop((x1, y1, x2, y2))
     return None
 
-def extract_window(cap, start_frame, video_fps):
+def extract_clip(video_path, start_frame, video_fps):
     """
-    Extract one 16-frame clip from [start_frame] sampled at TARGET_FPS.
-    Returns a list of exactly SEQUENCE_LENGTH PIL face crops.
+    KEY FIX: Open a fresh VideoCapture, seek ONCE to start_frame,
+    then read frames sequentially. No cap.set() inside the loop.
+    This is reliable across all codecs.
     """
-    # How many raw video frames to skip between each sample
-    frame_step = max(1, int(video_fps / TARGET_FPS))
-    faces      = []
-    last_box   = None
-
-    frame_idx = start_frame
-    attempts  = 0
-    max_attempts = SEQUENCE_LENGTH * frame_step * 3  # safety cap
-
-    while len(faces) < SEQUENCE_LENGTH and attempts < max_attempts:
-        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-        ret, frame = cap.read()
+    cap = cv2.VideoCapture(video_path)
+    cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)  # Seek ONCE
+
+    # How many raw frames to skip to achieve TARGET_FPS
+    frame_step = max(1, int(round(video_fps / TARGET_FPS)))
+
+    faces    = []
+    last_box = None
+    read_idx = 0  # frames read since seek
+
+    while len(faces) < SEQUENCE_LENGTH:
+        ret, frame = cap.read()  # Sequential read — no seeking inside loop
         if not ret:
             break
 
-        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        pil_img   = Image.fromarray(frame_rgb)
+        # Only process every Nth frame to hit TARGET_FPS
+        if read_idx % frame_step == 0:
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            pil_img   = Image.fromarray(frame_rgb)
 
-        boxes, _ = mtcnn.detect(pil_img)
+            boxes, _ = mtcnn.detect(pil_img)
 
-        if boxes is not None and len(boxes) > 0:
-            raw_box  = boxes[0].tolist()
-            smoothed = smooth_box(raw_box, last_box)
-            last_box = smoothed
-        elif last_box is not None:
-            smoothed = last_box          # hold last known position
-        else:
-            frame_idx += frame_step
-            attempts  += 1
-            continue
+            if boxes is not None and len(boxes) > 0:
+                raw_box  = boxes[0].tolist()
+                smoothed = smooth_box(raw_box, last_box)
+                last_box = smoothed
+            elif last_box is not None:
+                smoothed = last_box  # Hold last known box
+            else:
+                read_idx += 1
+                continue  # No face yet — keep reading
+
+            crop = crop_face(pil_img, smoothed)
+            if crop is not None:
+                faces.append(crop)
+
+        read_idx += 1
 
-        crop = crop_face(pil_img, smoothed)
-        if crop is not None:
-            faces.append(crop)
+        # Safety: don't read more than 10 seconds worth of frames
+        if read_idx > int(video_fps * 10):
+            break
 
-        frame_idx += frame_step
-        attempts  += 1
+    cap.release()
 
     if not faces:
         return []
 
-    # Pad to exactly SEQUENCE_LENGTH by repeating the last frame
+    # Pad to exactly SEQUENCE_LENGTH if the clip was short
     while len(faces) < SEQUENCE_LENGTH:
         faces.append(faces[-1])
 
     return faces[:SEQUENCE_LENGTH]
 
-def run_inference_on_clip(faces):
-    """Run VideoMAE on a single 16-frame clip. Returns (is_fake, fake_probability)."""
+def run_inference(faces):
+    """Run VideoMAE on exactly 16 face-crop frames. Returns raw fake probability."""
     inputs = processor(list(faces), return_tensors="pt")
     with torch.no_grad():
         outputs = model(**inputs)
     probs = torch.nn.functional.softmax(outputs.logits[0], dim=-1)
-    class_idx = probs.argmax(-1).item()
-    label     = model.config.id2label[class_idx].lower()
-    is_fake   = "fake" in label
-    # Normalize: always return the probability assigned to "fake"
-    fake_prob = probs[class_idx].item() if is_fake else 1.0 - probs[class_idx].item()
-    return is_fake, fake_prob
+
+    # Identify which label index is "fake"
+    fake_prob = 0.0
+    for idx, label in model.config.id2label.items():
+        if "fake" in label.lower():
+            fake_prob = probs[idx].item()
+            break
+
+    return fake_prob
 
 # ── API endpoint ──────────────────────────────────────────────────────────────
 @app.post("/api/analyze")
@@ -139,77 +145,71 @@ async def analyze_video(file: UploadFile = File(...)):
         shutil.copyfileobj(file.file, buf)
 
     try:
+        # Read basic video metadata
         cap          = cv2.VideoCapture(temp_path)
         video_fps    = get_video_fps(cap)
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        duration_s   = total_frames / video_fps
+        cap.release()  # Release immediately — each clip opens its own cap
 
-        print(f"Video: {duration_s:.1f}s @ {video_fps:.1f}fps  ({total_frames} frames)")
+        duration_s = total_frames / video_fps
+        print(f"Video: {duration_s:.1f}s @ {video_fps:.1f}fps ({total_frames} frames)")
 
         if total_frames == 0:
             return {"isFake": False, "confidence": 0,
                     "explanation": "Could not read the video file.", "details": []}
 
-        # ── Determine start frames for each analysis window ───────────────────
-        window_frames = int(WINDOW_SECONDS * video_fps)   # raw frames per window
-        usable_end    = max(0, total_frames - window_frames)
+        # ── Choose start frames: beginning, middle, end ───────────────────────
+        # We need SEQUENCE_LENGTH frames × frame_step room before the end
+        frame_step    = max(1, int(round(video_fps / TARGET_FPS)))
+        needed_frames = SEQUENCE_LENGTH * frame_step
+        usable_end    = max(0, total_frames - needed_frames)
 
-        if usable_end == 0:
-            # Very short video: use a single window at the start
-            start_frames = [0]
+        if NUM_WINDOWS == 1 or usable_end == 0:
+            start_frames = [max(0, usable_end // 2)]
         else:
-            # Spread NUM_WINDOWS evenly across the usable range
             start_frames = [
-                int(i * usable_end / (NUM_WINDOWS - 1)) if NUM_WINDOWS > 1 else usable_end // 2
+                int(i * usable_end / (NUM_WINDOWS - 1))
                 for i in range(NUM_WINDOWS)
             ]
-            # Remove duplicate starts (can happen with short videos)
-            start_frames = sorted(set(start_frames))
 
-        # ── Run inference on each window ──────────────────────────────────────
-        all_fake_probs  = []
+        print(f"Analyzing {len(start_frames)} clips at frames: {start_frames}")
+
+        # ── Run inference on each clip ────────────────────────────────────────
+        fake_probs       = []
         windows_analyzed = 0
 
         for i, start in enumerate(start_frames):
-            print(f"  Window {i+1}/{len(start_frames)} — starting at frame {start}")
-            faces = extract_window(cap, start, video_fps)
+            print(f"  Clip {i+1}: starting frame {start}")
+            faces = extract_clip(temp_path, start, video_fps)
 
             if not faces:
-                print("    No face detected — skipping window.")
+                print("    No face found — skipping.")
                 continue
 
-            _, fake_prob = run_inference_on_clip(faces)
-            all_fake_probs.append(fake_prob)
+            fp = run_inference(faces)
+            fake_probs.append(fp)
             windows_analyzed += 1
-            print(f"    Fake probability: {fake_prob:.3f}")
-
-        cap.release()
+            print(f"    Fake prob: {fp:.3f}")
 
-        if not all_fake_probs:
+        if not fake_probs:
             return {"isFake": False, "confidence": 0,
                     "explanation": "Could not detect a clear face in the video.",
                     "details": []}
 
-        # ── Aggregate results (weighted toward the most suspicious window) ────
-        arr            = np.array(all_fake_probs)
-        avg_fake_prob  = float(np.mean(arr))
-        max_fake_prob  = float(np.max(arr))
-        # Blend: 70 % mean + 30 % max  → catches a single damning window
-        blended_prob   = 0.70 * avg_fake_prob + 0.30 * max_fake_prob
-
-        is_fake    = blended_prob > 0.50
-        confidence = round((blended_prob if is_fake else 1.0 - blended_prob) * 100, 2)
+        # ── Simple mean ensemble — no max bias ────────────────────────────────
+        avg_fake_prob = float(np.mean(fake_probs))
+        is_fake       = avg_fake_prob > 0.50
+        confidence    = round((avg_fake_prob if is_fake else 1.0 - avg_fake_prob) * 100, 2)
 
-        print(f"FINAL — isFake={is_fake}, blended_prob={blended_prob:.3f}, confidence={confidence}%")
+        print(f"FINAL — isFake={is_fake}, avg={avg_fake_prob:.3f}, confidence={confidence}%")
 
         explanation = (
-            "Our 3D Temporal AI analyzed multiple video segments and detected "
-            "unnatural facial motion, micro-expression inconsistencies, or "
-            "spatial blending artifacts characteristic of deepfakes."
+            "Our AI analyzed multiple video segments and detected unnatural facial motion, "
+            "micro-expression inconsistencies, or spatial blending artifacts characteristic "
+            "of deepfake synthesis."
             if is_fake else
-            "Our 3D Temporal AI analyzed multiple video segments and found "
-            "natural micro-expressions, consistent temporal flow, and no "
-            "manipulation artifacts."
+            "Our AI analyzed multiple video segments and found natural micro-expressions, "
+            "consistent temporal flow, and no manipulation artifacts."
         )
 
         return {
@@ -218,24 +218,24 @@ async def analyze_video(file: UploadFile = File(...)):
             "explanation": explanation,
             "details": [
                 {
-                    "title": "Multi-Window Temporal Analysis",
+                    "title": "Multi-Clip Temporal Analysis",
                     "desc": (
-                        f"Analyzed {windows_analyzed} independent {WINDOW_SECONDS}-second "
-                        f"clip(s) spread across the video using a VideoMAE 3D Transformer."
+                        f"Analyzed {windows_analyzed} clip(s) from the beginning, middle, "
+                        f"and end of the video using a VideoMAE 3D Transformer."
                     )
                 },
                 {
-                    "title": "High-FPS Face Tracking",
+                    "title": "Sequential Frame Tracking",
                     "desc": (
-                        f"Sampled at {TARGET_FPS} FPS with smoothed bounding-box tracking "
-                        "to capture jitter, blinking anomalies, and lip-sync mismatches."
+                        f"Frames sampled at {TARGET_FPS} FPS with EMA bounding-box smoothing "
+                        "to ensure stable face tracking across the clip."
                     )
                 },
                 {
                     "title": "Ensemble Scoring",
                     "desc": (
-                        f"Final score = 70% average + 30% peak across all windows "
-                        f"(avg {avg_fake_prob*100:.1f}%, peak {max_fake_prob*100:.1f}%)."
+                        f"Final verdict = mean probability across {windows_analyzed} clip(s). "
+                        f"Per-clip scores: {[f'{p*100:.1f}%' for p in fake_probs]}."
                     )
                 }
             ]
@@ -252,4 +252,4 @@ async def analyze_video(file: UploadFile = File(...)):
 
 @app.get("/")
 def health_check():
-    return {"status": "Multi-Window Temporal Backend is running!"}
+    return {"status": "Multi-Clip Sequential Backend is running!"}