Upload folder using huggingface_hub

predict.py

@@ -191,6 +191,16 @@ def predict_next_frame(ens, context_frames: np.ndarray) -> np.ndarray:
             return result
 
         ens.reset_cache()
+
+        # Detect near-static scene: if last two context frames nearly identical, use copy
+        last_two_diff = np.abs(frames[-2].astype(np.float32) - frames[-1].astype(np.float32)).mean()
+        if last_two_diff < 3.0 / 255.0:
+            last_ctx_uint8 = (last_frame * 255).clip(0, 255).astype(np.uint8)
+            ens.direct_cache = [last_ctx_uint8.copy() for _ in range(PRED_FRAMES)]
+            result = ens.direct_cache[ens.cache_step]
+            ens.cache_step += 1
+            return result
+
         with torch.no_grad():
             context_tensor = torch.from_numpy(context).to(DEVICE)
             last_tensor = torch.from_numpy(last_frame_t).to(DEVICE)
@@ -229,18 +239,12 @@ def predict_next_frame(ens, context_frames: np.ndarray) -> np.ndarray:
                 all_ar_runs.append(torch.stack(ar_preds_run, dim=1))
 
             ar_pred = sum(all_ar_runs) / len(all_ar_runs)
-            # Compute per-pixel variance across runs for uncertainty
-            ar_stack = torch.stack(all_ar_runs, dim=0)  # [3, 1, 8, 3, 64, 64]
-            ar_var = ar_stack.var(dim=0)  # [1, 8, 3, 64, 64]
 
             predicted = torch.zeros_like(direct_pred)
             for step in range(PRED_FRAMES):
-                base_ar_weight = 0.65 - (step / (PRED_FRAMES - 1)) * 0.3
-                # Per-pixel weight adjustment: reduce AR weight where variance is high
-                uncertainty = torch.clamp(ar_var[:, step] * 50, 0, 0.3)
-                ar_weight_map = base_ar_weight * (1 - uncertainty)
-                direct_weight_map = 1.0 - ar_weight_map
-                predicted[:, step] = ar_weight_map * ar_pred[:, step] + direct_weight_map * direct_pred[:, step]
+                ar_weight = 0.65 - (step / (PRED_FRAMES - 1)) * 0.3
+                direct_weight = 1.0 - ar_weight
+                predicted[:, step] = ar_weight * ar_pred[:, step] + direct_weight * direct_pred[:, step]
 
         predicted_np = predicted[0].cpu().numpy()
         ens.direct_cache = []