motion correction... I really need a better one. I need a ML model

detect_loops.py

@@ -13,7 +13,7 @@ def sigmoid(x):
 def evaluate_length_penalty(len, mag = 0.0045):
     """Length penalty function based on sigmoid curves."""
     x = len
-    y = mag + -mag * sigmoid(0.58 * (x - 1.5)) + 0.25 * mag * sigmoid(2 * (x - 17))    
+    y = mag + -mag * sigmoid(0.58 * (x - 1.65)) + 0.25 * mag * sigmoid(2 * (x - 17))    
     return y
 
 # Two sigmoids — one dips around x=2, one rises around x=16
@@ -21,7 +21,7 @@ import matplotlib.pyplot as plt
 x = np.linspace(0, 40, 400)
 y = evaluate_length_penalty(x)
 plt.plot(x, y, 'k', lw=3)
-plt.axvline(2, color='k', lw=2)
+plt.axvline(4, color='k', lw=2)
 plt.axvline(16, color='k', lw=2)
 plt.text(0, -0.06, '0', ha='center', va='top', fontsize=12)
 plt.text(2, -0.06, '2', ha='center', va='top', fontsize=12)
@@ -54,7 +54,7 @@ def compute_sim(f1, f2):
     cos_sim = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2) + eps)
     return cos_sim
 
-def detect_loops(frames, min_len=2, max_len=40, top_k=10):
+def detect_loops(frames, min_len=4, max_len=40, top_k=10):
     n = len(frames)
     candidates = []
     # Preprocess frames: grayscale float32 and downscale to 128x128 (float32)
@@ -65,6 +65,7 @@ def detect_loops(frames, min_len=2, max_len=40, top_k=10):
     # Build 3-channel composite frames: R=prev, G=curr, B=next (looping)
     n = len(processed_frames)
     composite_frames = []
+    motion_energies = []
     for idx in range(n):
         prev_idx = (idx - 1) % n
         next_idx = (idx + 1) % n
@@ -73,6 +74,21 @@ def detect_loops(frames, min_len=2, max_len=40, top_k=10):
         b = processed_frames[next_idx]
         composite = np.stack([r, g, b], axis=-1)
         composite_frames.append(composite)
+        if idx == n - 1:
+            motion_energies.append(0.0)
+        else:
+            # waving hand 0.97
+            # body shake 1.78
+            # running 15.0
+            # breathing 0.56
+            # talking 0.39
+            motion_energy = np.mean(np.abs(processed_frames[next_idx] - processed_frames[idx]))
+            motion_energies.append(motion_energy)
+    max_motion_energy = 20.0
+    normalized_motion_energies = []
+    for me in motion_energies:
+        nme = min(me / max_motion_energy, 1.0)
+        normalized_motion_energies.append(nme)
     for i in range(n):
         for j in range(i+min_len, min(i+max_len, n)):
             # Compare composite frames directly
@@ -80,26 +96,24 @@ def detect_loops(frames, min_len=2, max_len=40, top_k=10):
             end_comp = composite_frames[j].astype(np.float32)
             cos_sim = compute_sim(start_comp, end_comp)
             length_penalty = evaluate_length_penalty(j - i)
-            score = cos_sim - length_penalty  # Higher cosine similarity is better
+            motion_energy = motion_energies[i]
+            nme = normalized_motion_energies[i]
+            similarity_correction = (1.0 - cos_sim) * nme * 0.5
+            score = cos_sim + similarity_correction - length_penalty  # Higher cosine similarity is better
             # print(f"Loop ({i},{j}): Cosine similarity={cos_sim:.4f} (t={t1-t0:.3f}s)")
-            candidates.append((score, i, j, cos_sim, length_penalty))
+            candidates.append((score, i, j, cos_sim, length_penalty, motion_energy))
     # Sort by score descending
     candidates.sort(reverse=True)
     return candidates[:top_k]
 
 if __name__ == "__main__":
-    # Example usage: python detect_loops.py data/shots/sample-000-0.webp
-    import sys
-    from glob import glob
 
     # For batch processing, change the pattern below to 'sample-*.webp' or similar
     if not files:
         print('No files found.')
+        import sys
         sys.exit(1)
 
-    import os
-    from PIL import Image
-
     output_dir = Path('data/loops')
     output_dir.mkdir(parents=True, exist_ok=True)
 
@@ -110,22 +124,23 @@ if __name__ == "__main__":
         print(f"Extracted {len(frames)} frames from {webp_path}")
         loops = detect_loops(frames)
         loop_json = []
-        for score, i, j, cos_sim, len_penalty in loops:
+        for score, i, j, cos_sim, len_penalty, motion_energy in loops:
             loop_json.append({
                 "start": int(i),
                 "end": int(j),
                 "score": float(score),
                 "cos_sim": float(cos_sim),
                 "length": int(j - i),
-                "length_penalty": float(len_penalty)
+                "length_penalty": float(len_penalty),
+                "motion_energy": float(len_penalty)
             })
         json_name = f"{webp_path.stem}.loop.json"
         json_path = output_dir / json_name
         with open(json_path, "w") as f:
             json.dump(loop_json, f, indent=2)
         print(f"Saved loop candidates: {json_path}")
-        for idx, (score, i, j, cos_sim, len_penalty) in enumerate(loops):
-            print(f"Loop candidate: start={i}, end={j}, score={score:.6f}, COS_SIM={cos_sim:.6f}, LEN={int(j - i)}, LEN_PENALTY={len_penalty:.6f}")
+        for idx, (score, i, j, cos_sim, len_penalty, motion_energy) in enumerate(loops):
+            print(f"Loop candidate: start={i}, end={j}, score={score:.6f}, COS_SIM={cos_sim:.6f}, LEN={int(j - i)}, LEN_PENALTY={len_penalty:.6f}, MOTION_ENERGY={motion_energy:.6f}")
             if idx != 0:
                 continue  # For now, only save the top candidate
             # Extract loop frames (seamless looping: frames[i:j])
@@ -143,4 +158,3 @@ if __name__ == "__main__":
                 loop=0,
                 lossless=True
             )
-            print(f"Saved loop: {out_path}")