k-1 cut logic

detect_scene.py

@@ -5,16 +5,20 @@ from transnetv2_pytorch import TransNetV2
 import json
 import re
 
-SCENE_CUT_THRESHOLD = 0.09
+# SCENE_CUT_THRESHOLD = 0.09
+K = 3 # Number of cuts to detect
+MIN_DURATION_FRAMES = 2
+
 data_dir = Path("data/animations")
-files = sorted(data_dir.glob("sample-00*.webp"))
+files = sorted(data_dir.glob("sample-*.webp"))
+print(f"Found {len(files)} files to process.")
     
 def get_best_device():
     if torch.cuda.is_available():
         return torch.device("cuda")
     elif torch.backends.mps.is_available():
-        # return torch.device("mps")
-        return torch.device("cpu")
+        return torch.device("mps")
+        # return torch.device("cpu")
     else:
         return torch.device("cpu")
 
@@ -145,18 +149,42 @@ def detect_scene_changes(frames):
     video_tensor = frames_to_video_tensor(frames)
     video_tensor = video_tensor.unsqueeze(0).to(device)  # shape: 1 x num_frames x H x W x 3
     with torch.no_grad():
-        single_frame_pred, all_frame_pred = model(video_tensor)
-        single_frame_pred = torch.sigmoid(single_frame_pred).cpu().numpy()[0]
-        all_frame_pred_np = torch.sigmoid(all_frame_pred["many_hot"]).cpu().numpy()[0]
-    # Get frame indices where scene changes occur (threshold at 0.5)
-    scene_change_indices = [i for i, p in enumerate(single_frame_pred) if p >= SCENE_CUT_THRESHOLD]
+        single_frame_logits, all_frame_logits = model(video_tensor)
+        # Squeeze last dimension so output is flat (num_frames,)
+        single_frame_logits_np = single_frame_logits.cpu().numpy().squeeze()  # shape: (num_frames,)
+        all_frame_logits_np = all_frame_logits["many_hot"].cpu().numpy().squeeze()  # shape: (num_frames,)
+        single_frame_pred = torch.sigmoid(single_frame_logits).cpu().numpy().squeeze()  # shape: (num_frames,)
+        all_frame_pred_np = torch.sigmoid(all_frame_logits["many_hot"]).cpu().numpy().squeeze()  # shape: (num_frames,)
     return {
         "single_frame_pred": single_frame_pred,
         "all_frame_pred": all_frame_pred_np,
-        "scene_change_indices": scene_change_indices,
-        "num_frames": video_tensor.shape[1]
+        "single_frame_logits": single_frame_logits_np,
+        "all_frame_logits": all_frame_logits_np,
     }
 
+def cached_detect_scene_changes(file, original_frames):
+    """Detect scene changes with caching to avoid redundant computation."""
+    match = re.search(r"sample-(\d+)", file.name)
+    sample_num = match.group(1) if match else "unknown"
+    transnetv2_json = file.parent / f"sample-{sample_num}.transnetv2.json"
+    if transnetv2_json.exists():
+        with open(transnetv2_json, "r") as f:
+            result = json.load(f)
+        result["single_frame_pred"] = np.array(result["single_frame_pred"])
+        result["all_frame_pred"] = np.array(result["all_frame_pred"])
+        result["single_frame_logits"] = np.array(result["single_frame_logits"])
+        result["all_frame_logits"] = np.array(result["all_frame_logits"])
+    else:
+        result = detect_scene_changes(original_frames)
+        # Save model output to cache file
+        with open(transnetv2_json, "w") as f:
+            json.dump({
+                "single_frame_pred": result["single_frame_pred"].tolist(),
+                "all_frame_pred": result["all_frame_pred"].tolist(),
+                "single_frame_logits": result["single_frame_logits"].tolist(),
+                "all_frame_logits": result["all_frame_logits"].tolist()
+            }, f, indent=2)
+    return result
 
 if __name__ == "__main__":
     device = get_best_device()
@@ -165,26 +193,44 @@ if __name__ == "__main__":
     state_dict = torch.load("transnetv2-pytorch-weights.pth")
     model.load_state_dict(state_dict)
     model.eval().to(device)
+
     for file in files:
         match = re.search(r"sample-(\d+)", file.name)
         sample_num = match.group(1) if match else "unknown"
         original_frames = load_original_frames(file)
-        result = detect_scene_changes(original_frames)
+        result = cached_detect_scene_changes(file, original_frames)
+        # scene_change_indices = [i for i, p in enumerate(result["single_frame_pred"]) if p >= SCENE_CUT_THRESHOLD]
+        # Detect top-K-1 scene changes
+        single_frame_pred = result["single_frame_pred"]
+        
+        # Ignore first and last frame when selecting scene changes, and enforce MIN_DURATION_FRAMES between cuts
+        valid_indices = np.arange(1, len(single_frame_pred) - 1)
+        valid_preds = single_frame_pred[1:-1]
+        # Sort indices by prediction score (descending)
+        sorted_indices = valid_indices[np.argsort(valid_preds)[::-1]]
+        scene_change_indices = []
+        for idx in sorted_indices:
+            if all(abs(idx - prev) >= MIN_DURATION_FRAMES for prev in scene_change_indices):
+                scene_change_indices.append(int(idx))
+            if len(scene_change_indices) >= (K - 1):
+                break
+
+        print(f"File: {file.name}, Frames: {len(original_frames)}, Scene Changes: {len(scene_change_indices)}")
         # Save results to JSON (include threshold and predictions)
         json_filename = file.parent / f"sample-{sample_num}.json"
         with open(json_filename, "w") as f:
             json.dump({
-                "scene_change_indices": result["scene_change_indices"],
-                "threshold": SCENE_CUT_THRESHOLD,
-                "single_frame_pred": result["single_frame_pred"].tolist(),
-                "all_frame_pred": result["all_frame_pred"].tolist()
+                "num_frames": len(original_frames),
+                "scene_change_indices": scene_change_indices,
+                # "threshold": SCENE_CUT_THRESHOLD
+                "k": K,
             }, f, indent=2)
         # Save timeline JPG
         timeline_filename = file.parent / f"sample-{sample_num}.timeline.jpg"
         plot_filename = file.parent / f"sample-{sample_num}.plot.jpg"
         save_timeline_jpg(
             frames=original_frames,
-            scene_change_indices=result["scene_change_indices"],
+            scene_change_indices=scene_change_indices,
             filename=timeline_filename,
             interval=10,
             roi_radius=2,