Use multiview dynamic memory online

.exp_artifact/dememwm_dynamic_multiview_memory_selection_plan.md

@@ -707,7 +707,7 @@ Select DeMemWM dynamic memory by multiview retrieval
 
 ## Substep 5: Integrate Multiview Dynamic In Dataset And Online Rollout
 
-Status: `[ ]`
+Status: `[x]`
 
 Goal:
 

algorithms/dememwm/df_video.py

@@ -20,6 +20,9 @@ from algorithms.common.metrics import (
     LearnedPerceptualImagePatchSimilarity,
 )
 from datasets.video.memory_selection import (
+    _build_shared_fov_candidate_pool,
+    _dynamic_multiview_selector,
+    _dynamic_policy,
     _event_triggered_anchor_candidates_from_deltas,
     _pose_delta_values,
     _select_dynamic_from_stream,
@@ -1916,9 +1919,8 @@ class DeMemWMMinecraft(DiffusionForcingBase):
                 )
                 for batch_i in range(batch_size)
             ]
-            dynamic_policy = str(_cfg_get(_cfg_get(memory_selection_cfg, "dynamic", {}), "selection_policy", "recent"))
-            if dynamic_policy not in {"recent", "event_triggered"}:
-                raise ValueError(f"memory_selection.dynamic.selection_policy must be recent or event_triggered; got {dynamic_policy!r}")
+            dynamic_policy = _dynamic_policy(memory_selection_cfg)
+            multiview_selector = _dynamic_multiview_selector(memory_selection_cfg) if dynamic_policy == "multiview" else None
             event_dynamic_caches = [_new_online_event_cache(target_length) for _ in range(batch_size)] if dynamic_policy == "event_triggered" else None
             memory_sheet_targets = self._memory_sheet_target_indices(n_context_frames, target_length) if self.log_memory_selection_sheet else set()
             memory_sheet_records = [[] for _ in range(batch_size)] if memory_sheet_targets else None
@@ -1960,6 +1962,7 @@ class DeMemWMMinecraft(DiffusionForcingBase):
                     anchor_count = int(stream_indices_by_key["anchor"].shape[1])
                     dynamic_count = int(stream_indices_by_key["dynamic"].shape[1])
                     revisit_count = int(stream_indices_by_key["revisit"].shape[1])
+                    batch_poses = poses_np[:, batch_i, :5]
                     selected = {"anchor": online_anchor_indices[batch_i]}
                     if dynamic_policy == "recent":
                         selected["dynamic"] = _select_online_dynamic_indices(
@@ -1969,13 +1972,28 @@ class DeMemWMMinecraft(DiffusionForcingBase):
                         )
                     else:
                         selected["dynamic"] = np.empty((0,), dtype=np.int64)
+
+                    fov_pool = None
+                    if dynamic_policy == "multiview" and multiview_selector == "fov_greedy":
+                        fov_pool = _build_shared_fov_candidate_pool(
+                            batch_poses,
+                            target_positions,
+                            memory_selection_cfg,
+                            namespace,
+                            min_candidate_frame=0,
+                            dynamic_count=dynamic_count,
+                            revisit_count=revisit_count,
+                        )
+
+                    revisit_kwargs = {"fov_pool": fov_pool} if fov_pool is not None else {}
                     selected["revisit"] = _select_revisit(
-                        poses_np[:, batch_i, :5],
+                        batch_poses,
                         target_positions,
                         memory_selection_cfg,
                         revisit_count,
                         np.empty((0,), dtype=np.int64),
                         namespace,
+                        **revisit_kwargs,
                     )
                     if dynamic_policy == "event_triggered":
                         cache = event_dynamic_caches[batch_i]
@@ -1994,6 +2012,18 @@ class DeMemWMMinecraft(DiffusionForcingBase):
                             memory_selection_cfg,
                             reference_frames=selected["revisit"] if len(selected["revisit"]) > 0 else None,
                         )
+                    elif dynamic_policy == "multiview":
+                        selected["dynamic"] = _select_dynamic_by_policy(
+                            int(target_positions[0]),
+                            dynamic_count,
+                            memory_selection_cfg,
+                            poses=batch_poses,
+                            reference_frames=selected["revisit"],
+                            excluded=selected["revisit"],
+                            target_positions=target_positions,
+                            split=namespace,
+                            fov_pool=fov_pool,
+                        )
                     if memory_sheet_records is not None and int(target_positions[0]) in memory_sheet_targets:
                         memory_sheet_records[batch_i].append(
                             {

configurations/dataset/video_minecraft_dememwm_latent.yaml

@@ -34,7 +34,7 @@ memory_selection:
   pose_preselect_topk: 64
   candidate_chunk_size: 64
   dynamic:
-    selection_policy: event_triggered
+    selection_policy: multiview
     multiview_selector: fov_greedy
     scene_threshold: 2.5
     state_threshold: 2.5

datasets/video/memory_selection.py

@@ -154,11 +154,20 @@ def _target_fov_points(target_poses: torch.Tensor) -> torch.Tensor:
     return points[target_inside]
 
 
-def _pose_preselect(candidates: np.ndarray, poses_t: torch.Tensor, target_positions: np.ndarray, cfg=None) -> np.ndarray:
+def _pose_preselect(
+    candidates: np.ndarray,
+    poses_t: torch.Tensor,
+    target_positions: np.ndarray,
+    cfg=None,
+    *,
+    extra_topk: int = 0,
+) -> np.ndarray:
     topk = cfg_get(cfg, "pose_preselect_topk", 64)
     if topk is None:
         return candidates
     topk = int(topk)
+    if topk > 0:
+        topk += max(0, int(extra_topk))
     if topk <= 0 or len(candidates) <= topk:
         return candidates
 
@@ -236,6 +245,7 @@ def _build_fov_candidate_pool(
     cfg,
     *,
     use_plucker: bool,
+    preselect: bool = True,
 ) -> dict[str, torch.Tensor]:
     """Build deterministic FOV/Plucker/coverage data for candidate frames."""
 
@@ -246,7 +256,8 @@ def _build_fov_candidate_pool(
     if len(candidates) == 0 or len(target_positions) == 0:
         return _empty_fov_candidate_pool(device)
 
-    candidates = _pose_preselect(candidates, poses_t, target_positions, cfg)
+    if preselect:
+        candidates = _pose_preselect(candidates, poses_t, target_positions, cfg)
     inside, fov_values = _candidate_fov_masks(poses_t, candidates, target_positions, cfg)
     candidates_t = torch.as_tensor(candidates, device=device, dtype=torch.long)
     candidate_poses = poses_t.index_select(0, candidates_t)
@@ -268,6 +279,115 @@ def _build_fov_candidate_pool(
     }
 
 
+def _select_fov_pool_rows(pool: dict[str, torch.Tensor], rows: torch.Tensor) -> dict[str, torch.Tensor]:
+    candidates_t = pool["candidates_t"]
+    return {
+        key: value.index_select(0, rows)
+        if torch.is_tensor(value) and value.shape[:1] == candidates_t.shape[:1]
+        else value
+        for key, value in pool.items()
+    }
+
+
+def _unique_ordered_frames(*arrays: np.ndarray | None) -> np.ndarray:
+    values = []
+    seen = set()
+    for array in arrays:
+        if array is None:
+            continue
+        for value in np.asarray(array, dtype=np.int64):
+            frame = int(value)
+            if frame not in seen:
+                seen.add(frame)
+                values.append(frame)
+    return np.asarray(values, dtype=np.int64)
+
+
+def _filter_fov_candidate_pool(
+    pool: dict[str, torch.Tensor],
+    candidates: np.ndarray,
+    *,
+    extra_frames: np.ndarray | None = None,
+) -> dict[str, torch.Tensor]:
+    candidates_t = pool["candidates_t"]
+    allowed = _unique_ordered_frames(candidates, extra_frames)
+    if len(allowed) == 0:
+        rows = torch.empty((0,), device=candidates_t.device, dtype=torch.long)
+        return _select_fov_pool_rows(pool, rows)
+
+    if candidates_t.numel() == 0:
+        rows = torch.empty((0,), device=candidates_t.device, dtype=torch.long)
+        return _select_fov_pool_rows(pool, rows)
+
+    allowed_t = torch.as_tensor(allowed, device=candidates_t.device, dtype=torch.long)
+    matches = allowed_t[:, None] == candidates_t[None, :]
+    keep_allowed = matches.any(dim=1)
+    rows = matches.to(dtype=torch.long).argmax(dim=1).index_select(0, torch.nonzero(keep_allowed, as_tuple=False).flatten())
+    if rows.numel() == candidates_t.numel() and bool(torch.equal(rows, torch.arange(candidates_t.numel(), device=candidates_t.device))):
+        return pool
+    return _select_fov_pool_rows(pool, rows)
+
+
+def _build_shared_fov_candidate_pool(
+    poses: np.ndarray,
+    target_positions: np.ndarray,
+    cfg,
+    split: str,
+    *,
+    min_candidate_frame: int = 0,
+    dynamic_count: int = 0,
+    revisit_count: int = 0,
+    revisit_excluded: np.ndarray | None = None,
+) -> dict[str, torch.Tensor] | None:
+    """Build one exact FOV pool over the candidates needed by both selectors."""
+
+    target_positions = np.asarray(target_positions, dtype=np.int64)
+    if len(target_positions) == 0:
+        return None
+
+    base_candidates = _memory_candidate_frames(
+        len(poses),
+        target_positions,
+        cfg,
+        split,
+        min_candidate_frame=min_candidate_frame,
+    )
+    if len(base_candidates) == 0:
+        return None
+
+    poses_t = _as_pose_tensor(poses)
+    dynamic_candidates = None
+    if int(dynamic_count) > 0:
+        # Revisit frames are excluded after selection; include replacement rows
+        # that can enter dynamic's pose-preselected top-k after that exclusion.
+        dynamic_candidates = _pose_preselect(
+            base_candidates,
+            poses_t,
+            target_positions,
+            cfg,
+            extra_topk=max(0, int(revisit_count)),
+        )
+
+    revisit_candidates = None
+    if split != "training" and int(revisit_count) > 0:
+        revisit_candidates = _exclude_revisit_local_context(base_candidates, target_positions, cfg)
+        if revisit_excluded is not None and len(revisit_excluded) > 0 and len(revisit_candidates) > 0:
+            revisit_candidates = revisit_candidates[~np.isin(revisit_candidates, np.asarray(revisit_excluded, dtype=np.int64))]
+        revisit_candidates = _pose_preselect(revisit_candidates, poses_t, target_positions, cfg)
+
+    pool_candidates = _unique_ordered_frames(dynamic_candidates, revisit_candidates)
+    if len(pool_candidates) == 0:
+        return None
+    return _build_fov_candidate_pool(
+        poses,
+        pool_candidates,
+        target_positions,
+        cfg,
+        use_plucker=True,
+        preselect=False,
+    )
+
+
 def _empty_selection(counts: Mapping[str, int]) -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray]]:
     indices = {}
     masks = {}
@@ -560,10 +680,16 @@ def _select_by_point_union(
     if count <= 0:
         return np.empty((0,), dtype=np.int64)
 
+    candidates = np.asarray(candidates, dtype=np.int64)
+    target_positions = np.asarray(target_positions, dtype=np.int64)
+    if len(candidates) == 0 or len(target_positions) == 0:
+        return np.empty((0,), dtype=np.int64)
+
     if fov_pool is None:
-        if len(candidates) == 0 or len(target_positions) == 0:
-            return np.empty((0,), dtype=np.int64)
         fov_pool = _build_fov_candidate_pool(poses, candidates, target_positions, cfg, use_plucker=use_plucker)
+    else:
+        candidates = _pose_preselect(candidates, _as_pose_tensor(poses), target_positions, cfg)
+        fov_pool = _filter_fov_candidate_pool(fov_pool, candidates)
 
     return _select_by_point_union_from_pool(
         fov_pool,
@@ -731,21 +857,9 @@ def _select_dynamic_multiview(
         if pool is None:
             pool = _build_fov_candidate_pool(poses, candidates, target_positions, cfg, use_plucker=True)
         else:
-            pool_candidates_t = pool["candidates_t"]
-            allowed_t = torch.as_tensor(candidates, device=pool_candidates_t.device, dtype=torch.long)
-            keep = (pool_candidates_t[:, None] == allowed_t[None, :]).any(dim=1)
-            if reference_frames is not None and len(reference_frames) > 0:
-                ref_t = torch.as_tensor(np.asarray(reference_frames, dtype=np.int64), device=pool_candidates_t.device, dtype=torch.long)
-                # Reference rows seed residual coverage below even when excluded from selection.
-                keep |= (pool_candidates_t[:, None] == ref_t[None, :]).any(dim=1)
-            if not bool(keep.all()):
-                rows = torch.nonzero(keep, as_tuple=False).flatten()
-                pool = {
-                    key: value.index_select(0, rows)
-                    if torch.is_tensor(value) and value.shape[:1] == pool_candidates_t.shape[:1]
-                    else value
-                    for key, value in pool.items()
-                }
+            candidates = _pose_preselect(candidates, _as_pose_tensor(poses), target_positions, cfg)
+            # Reference rows seed residual coverage below even when excluded from selection.
+            pool = _filter_fov_candidate_pool(pool, candidates, extra_frames=reference_frames)
         selected = _select_dynamic_multiview_from_fov_pool(
             pool,
             count,
@@ -1145,7 +1259,13 @@ def _select_dynamic_by_policy(
     min_candidate_frame: int = 0,
     reference_frames=None,
     excluded=None,
+    target_positions=None,
+    split: str = "training",
+    fov_pool: dict[str, torch.Tensor] | None = None,
 ) -> np.ndarray:
+    if count <= 0:
+        return np.empty((0,), dtype=np.int64)
+
     policy = _dynamic_policy(cfg)
     if policy == "recent":
         return _select_dynamic(target_start, count, min_candidate_frame)
@@ -1162,9 +1282,20 @@ def _select_dynamic_by_policy(
             excluded=excluded,
         )
     if policy == "multiview":
-        selector = _dynamic_multiview_selector(cfg)
-        raise NotImplementedError(
-            f"memory_selection.dynamic.selection_policy='multiview' with multiview_selector={selector!r} is not implemented yet"
+        if poses is None:
+            raise ValueError("multiview dynamic selection requires poses")
+        if target_positions is None:
+            target_positions = np.asarray([target_start], dtype=np.int64)
+        return _select_dynamic_multiview(
+            poses,
+            target_positions,
+            cfg,
+            count,
+            excluded=excluded,
+            reference_frames=reference_frames,
+            split=split,
+            min_candidate_frame=min_candidate_frame,
+            fov_pool=fov_pool,
         )
     raise AssertionError(f"unhandled dynamic selection policy: {policy!r}")
 
@@ -1178,6 +1309,7 @@ def _select_revisit(
     split: str,
     rng=None,
     min_candidate_frame: int = 0,
+    fov_pool: dict[str, torch.Tensor] | None = None,
 ) -> np.ndarray:
     if count <= 0:
         return np.empty((0,), dtype=np.int64)
@@ -1213,6 +1345,7 @@ def _select_revisit(
         fov_threshold=float(cfg_get(cfg, "fov_overlap_threshold", 0.6)),
         min_total_coverage=float(cfg_get(cfg, "min_total_selected_coverage", 0.1)),
         use_plucker=True,
+        fov_pool=fov_pool,
     )
 
 
@@ -1249,21 +1382,6 @@ def select_memory_indices(
 
     target_start = int(target_positions[0])
     policy = _dynamic_policy(cfg)
-    if policy == "multiview":
-        selector = _dynamic_multiview_selector(cfg)
-        raise NotImplementedError(
-            f"memory_selection.dynamic.selection_policy='multiview' with multiview_selector={selector!r} is not implemented yet"
-        )
-
-    if policy == "recent":
-        dynamic = _select_dynamic_by_policy(
-            target_start,
-            counts["dynamic"],
-            cfg,
-            min_candidate_frame=min_candidate_frame,
-        )
-    else:
-        dynamic = np.empty((0,), dtype=np.int64)
 
     anchor_start = min_candidate_frame if anchor_candidate_start is None else max(0, int(anchor_candidate_start))
     if anchor_candidate_stop is None:
@@ -1273,6 +1391,18 @@ def select_memory_indices(
     anchor_candidates = np.arange(anchor_start, anchor_stop, dtype=np.int64)
     anchor = _select_anchor(anchor_candidates, counts["anchor"], cfg, poses=poses)
 
+    fov_pool = None
+    if policy == "multiview" and _dynamic_multiview_selector(cfg) == "fov_greedy":
+        fov_pool = _build_shared_fov_candidate_pool(
+            poses,
+            target_positions,
+            cfg,
+            split,
+            min_candidate_frame=min_candidate_frame,
+            dynamic_count=counts["dynamic"],
+            revisit_count=counts["revisit"],
+        )
+
     revisit = _select_revisit(
         poses,
         target_positions,
@@ -1282,9 +1412,17 @@ def select_memory_indices(
         split,
         rng=rng,
         min_candidate_frame=min_candidate_frame,
+        fov_pool=fov_pool,
     )
 
-    if policy == "event_triggered":
+    if policy == "recent":
+        dynamic = _select_dynamic_by_policy(
+            target_start,
+            counts["dynamic"],
+            cfg,
+            min_candidate_frame=min_candidate_frame,
+        )
+    elif policy == "event_triggered":
         dynamic_references = revisit if len(revisit) > 0 else target_positions
         if dynamic_stream is not None:
             candidates = _memory_candidate_frames(
@@ -1311,6 +1449,21 @@ def select_memory_indices(
                 min_candidate_frame=min_candidate_frame,
                 reference_frames=dynamic_references,
             )
+    elif policy == "multiview":
+        dynamic = _select_dynamic_by_policy(
+            target_start,
+            counts["dynamic"],
+            cfg,
+            poses=poses,
+            min_candidate_frame=min_candidate_frame,
+            reference_frames=revisit,
+            excluded=revisit,
+            target_positions=target_positions,
+            split=split,
+            fov_pool=fov_pool,
+        )
+    else:
+        raise AssertionError(f"unhandled dynamic selection policy: {policy!r}")
 
     _write_segment(indices, masks, "anchor", anchor)
     _write_segment(indices, masks, "dynamic", dynamic)

tests/test_dememwm_latent_dataset.py

@@ -209,7 +209,7 @@ class MemorySelectionTests(unittest.TestCase):
         cfg = OmegaConf.load(config_path)
 
         self.assertIs(cfg.memory_selection.causal, True)
-        self.assertEqual(cfg.memory_selection.dynamic.selection_policy, "event_triggered")
+        self.assertEqual(cfg.memory_selection.dynamic.selection_policy, "multiview")
         self.assertEqual(cfg.memory_selection.dynamic.multiview_selector, "fov_greedy")
         self.assertEqual(cfg.memory_selection.pose_preselect_topk, 64)
         self.assertEqual(cfg.memory_selection.candidate_chunk_size, 64)
@@ -1030,19 +1030,125 @@ class MemorySelectionTests(unittest.TestCase):
         with self.assertRaisesRegex(ValueError, "fov_greedy, pose_plucker_fps"):
             select_memory_indices(poses, np.array([6]), cfg)
 
-    def test_multiview_policy_selection_fails_explicitly_until_implemented(self):
+    def test_multiview_policy_selection_uses_shared_fov_pool_and_segments(self):
+        import datasets.video.memory_selection as memory_selection
+
+        poses = _poses(10)
+        cfg = _selection_cfg(
+            max_anchor_frames=1,
+            max_dynamic_frames=2,
+            max_revisit_frames=1,
+            local_context_exclusion_frames=2,
+            fov_overlap_threshold=0.0,
+            min_total_selected_coverage=0.0,
+            dynamic=_dynamic_cfg("multiview", multiview_selector="fov_greedy"),
+        )
+        pool = _fov_pool(
+            [0, 1, 2, 3, 4, 5],
+            [
+                [True, False, False],
+                [False, True, False],
+                [False, False, True],
+                [True, True, False],
+                [False, False, False],
+                [True, True, True],
+            ],
+            gaps=[6, 5, 4, 3, 2, 1],
+            poses=poses,
+        )
+        dynamic_calls = []
+
+        def fake_dynamic(
+            poses_arg,
+            target_positions,
+            cfg_arg,
+            count,
+            *,
+            excluded=None,
+            reference_frames=None,
+            split="training",
+            min_candidate_frame=0,
+            fov_pool=None,
+        ):
+            dynamic_calls.append(
+                {
+                    "target_positions": target_positions.copy(),
+                    "excluded": np.asarray(excluded, dtype=np.int64).copy(),
+                    "reference_frames": np.asarray(reference_frames, dtype=np.int64).copy(),
+                    "split": split,
+                    "fov_pool": fov_pool,
+                }
+            )
+            return np.asarray([1, 2], dtype=np.int64)[:count]
+
+        with mock.patch.object(memory_selection, "_build_fov_candidate_pool", return_value=pool) as build_mock, mock.patch.object(
+            memory_selection, "_select_dynamic_multiview", side_effect=fake_dynamic
+        ):
+            indices, masks = select_memory_indices(poses, np.array([6, 7]), cfg, split="validation")
+
+        self.assertEqual(set(indices), {"anchor", "dynamic", "revisit"})
+        self.assertEqual({key: len(indices[key]) for key in ("anchor", "dynamic", "revisit")}, {"anchor": 1, "dynamic": 2, "revisit": 1})
+        self.assertEqual({key: len(masks[key]) for key in ("anchor", "dynamic", "revisit")}, {"anchor": 1, "dynamic": 2, "revisit": 1})
+        self.assertEqual(build_mock.call_count, 1)
+        self.assertEqual(build_mock.call_args.args[2].tolist(), [6, 7])
+        selected_revisit = indices["revisit"][masks["revisit"]]
+        self.assertTrue(np.all(selected_revisit < 4))
+        self.assertEqual(len(dynamic_calls), 1)
+        self.assertIs(dynamic_calls[0]["fov_pool"], pool)
+        self.assertEqual(dynamic_calls[0]["target_positions"].tolist(), [6, 7])
+        self.assertEqual(dynamic_calls[0]["excluded"].tolist(), selected_revisit.tolist())
+        self.assertEqual(dynamic_calls[0]["reference_frames"].tolist(), selected_revisit.tolist())
+        self.assertEqual(indices["dynamic"].tolist(), [1, 2])
+        self.assertEqual(masks["dynamic"].tolist(), [True, True])
+
+    def test_multiview_shared_fov_pool_preselects_after_revisit_local_exclusion(self):
         poses = np.zeros((8, 5), dtype=np.float32)
-        for selector in ("fov_greedy", "pose_plucker_fps"):
-            with self.subTest(selector=selector):
-                cfg = _selection_cfg(
-                    max_anchor_frames=0,
-                    max_dynamic_frames=2,
-                    max_revisit_frames=0,
-                    dynamic=_dynamic_cfg("multiview", multiview_selector=selector),
-                )
+        poses[:, 0] = 1000.0
+        poses[:, 4] = 180.0
+        poses[0] = np.asarray([0, 0, 0, 0, 0], dtype=np.float32)
+        poses[5] = np.asarray([0, 0, 0, 0, 0], dtype=np.float32)
+        poses[6] = np.asarray([0, 0, 0, 0, 0], dtype=np.float32)
+        cfg = _selection_cfg(
+            max_anchor_frames=0,
+            max_dynamic_frames=1,
+            max_revisit_frames=1,
+            local_context_exclusion_frames=2,
+            pose_preselect_topk=1,
+            fov_overlap_threshold=0.0,
+            min_total_selected_coverage=0.0,
+            dynamic=_dynamic_cfg("multiview", multiview_selector="fov_greedy"),
+        )
+
+        indices, masks = select_memory_indices(poses, np.asarray([6], dtype=np.int64), cfg, split="validation")
+
+        self.assertEqual(indices["revisit"].tolist(), [0])
+        self.assertEqual(masks["revisit"].tolist(), [True])
+
+    def test_multiview_policy_dispatcher_calls_selector_with_target_positions(self):
+        import datasets.video.memory_selection as memory_selection
 
-                with self.assertRaisesRegex(NotImplementedError, "multiview"):
-                    select_memory_indices(poses, np.array([6]), cfg)
+        poses = _poses(8)
+        cfg = _selection_cfg(
+            max_anchor_frames=0,
+            max_dynamic_frames=1,
+            max_revisit_frames=0,
+            dynamic=_dynamic_cfg("multiview", multiview_selector="fov_greedy"),
+        )
+        target_positions = np.asarray([6, 7], dtype=np.int64)
+
+        with mock.patch.object(memory_selection, "_select_dynamic_multiview", return_value=np.asarray([2], dtype=np.int64)) as select_mock:
+            selected = memory_selection._select_dynamic_by_policy(
+                6,
+                1,
+                cfg,
+                poses=poses,
+                target_positions=target_positions,
+                split="validation",
+            )
+
+        self.assertEqual(selected.tolist(), [2])
+        self.assertEqual(select_mock.call_args.args[1].tolist(), [6, 7])
+        self.assertEqual(select_mock.call_args.kwargs["split"], "validation")
 
     def test_event_dynamic_uses_nearest_anchors_per_revisit_frame(self):
         import datasets.video.memory_selection as memory_selection
@@ -1701,6 +1807,167 @@ class DeMemWMLatentDatasetTests(unittest.TestCase):
         self.assertEqual(video_calls[0][1]["namespace"], "test_vis")
         self.assertEqual(video_calls[0][1]["step"], 0)
 
+    def test_validation_multiview_policy_uses_current_query_pool_without_event_cache(self):
+        import algorithms.dememwm.df_video as df_video
+        from algorithms.dememwm.df_video import DeMemWMMinecraft, _preprocess_dememwm_latent_batch
+
+        build_calls = []
+        revisit_calls = []
+        dynamic_calls = []
+
+        def fake_build_shared_fov_pool(
+            poses,
+            target_positions,
+            cfg,
+            split,
+            *,
+            min_candidate_frame=0,
+            dynamic_count=0,
+            revisit_count=0,
+            revisit_excluded=None,
+        ):
+            pool = {"query": tuple(int(v) for v in target_positions)}
+            build_calls.append(
+                {
+                    "target_positions": target_positions.tolist(),
+                    "split": split,
+                    "min_candidate_frame": min_candidate_frame,
+                    "dynamic_count": dynamic_count,
+                    "revisit_count": revisit_count,
+                    "pool": pool,
+                }
+            )
+            return pool
+
+        def fake_select_revisit(poses, target_positions, cfg, count, excluded, split, rng=None, min_candidate_frame=0, fov_pool=None):
+            revisit_calls.append(
+                {
+                    "target_positions": target_positions.tolist(),
+                    "split": split,
+                    "fov_pool": fov_pool,
+                }
+            )
+            return np.asarray([0], dtype=np.int64)[:count]
+
+        def fake_select_dynamic_by_policy(
+            target_start,
+            count,
+            cfg,
+            poses=None,
+            latents=None,
+            actions=None,
+            min_candidate_frame=0,
+            reference_frames=None,
+            excluded=None,
+            target_positions=None,
+            split="training",
+            fov_pool=None,
+        ):
+            dynamic_calls.append(
+                {
+                    "target_start": int(target_start),
+                    "target_positions": np.asarray(target_positions, dtype=np.int64).tolist(),
+                    "excluded": np.asarray(excluded, dtype=np.int64).tolist(),
+                    "reference_frames": np.asarray(reference_frames, dtype=np.int64).tolist(),
+                    "split": split,
+                    "fov_pool": fov_pool,
+                }
+            )
+            return np.asarray([1], dtype=np.int64)[:count]
+
+        class FakeDiffusion:
+            stabilization_level = 0
+
+            def __init__(self):
+                self.calls = []
+
+            def sample_step(self, x, action_cond, pose_cond, curr_noise_level, next_noise_level, **kwargs):
+                self.calls.append({"x": x.detach().clone(), "kwargs": kwargs})
+                return x[: kwargs["frame_memory_segments"]["target"]]
+
+        class Harness:
+            def __init__(self):
+                self.memory_condition_length, self.clip_noise = 2, 0.0
+                self.context_frames, self.frame_stack, self.chunk_size, self.n_tokens = 2, 1, 2, 2
+                self.cfg = OmegaConf.create(
+                    {
+                        "memory_selection": {
+                            "enabled": True,
+                            "max_anchor_frames": 0,
+                            "max_dynamic_frames": 1,
+                            "max_revisit_frames": 1,
+                            "dynamic": _dynamic_cfg("multiview", multiview_selector="fov_greedy"),
+                        }
+                    }
+                )
+                self.diffusion_model = FakeDiffusion()
+                self.horizons = []
+                self.logged = []
+                self.logger = None
+                self.log_video = False
+                self.log_memory_selection_sheet = False
+                self.save_local = False
+                self.local_save_dir = None
+
+            def _preprocess_batch(self, batch):
+                return _preprocess_dememwm_latent_batch(batch)
+
+            def _generate_scheduling_matrix(self, horizon):
+                self.horizons.append(horizon)
+                return np.stack([np.full(horizon, level, dtype=np.int64) for level in (1, 0)])
+
+            def decode(self, xs):
+                return xs
+
+            def _update_metric_accumulators(self, xs_pred, xs_gt, valid_mask=None, eval_start=0):
+                pass
+
+            def _update_per_frame_metric_accumulators(self, xs_pred, xs_gt, mask, eval_start):
+                pass
+
+            def _update_revisit_metric_accumulators(self, xs_pred, xs_gt, poses, frame_indices, mask, eval_start, batch_idx, namespace):
+                pass
+
+            def log(self, name, value):
+                self.logged.append((name, value))
+
+        batch = {
+            "latents": torch.arange(7, dtype=torch.float32).view(1, 7, 1, 1, 1),
+            "actions": torch.zeros((1, 7, 25), dtype=torch.float32),
+            "poses": torch.arange(7, dtype=torch.float32).view(1, 7, 1).repeat(1, 1, 5),
+            "frame_indices": (10 + torch.arange(7, dtype=torch.long)).view(1, 7),
+            "memory_segments": {"target": torch.tensor([5]), "anchor": torch.tensor([0]), "dynamic": torch.tensor([1]), "revisit": torch.tensor([1])},
+            "memory_masks": {
+                "target": torch.ones((1, 5), dtype=torch.bool),
+                "anchor": torch.zeros((1, 0), dtype=torch.bool),
+                "dynamic": torch.ones((1, 1), dtype=torch.bool),
+                "revisit": torch.ones((1, 1), dtype=torch.bool),
+            },
+            "image_hw": torch.tensor([[360, 640]], dtype=torch.long),
+        }
+        harness = Harness()
+
+        with mock.patch.object(df_video, "_new_online_event_cache", side_effect=AssertionError("unexpected event cache")), mock.patch.object(
+            df_video, "_extend_online_event_cache", side_effect=AssertionError("unexpected event cache extension")
+        ), mock.patch.object(df_video, "_build_shared_fov_candidate_pool", side_effect=fake_build_shared_fov_pool), mock.patch.object(
+            df_video, "_select_revisit", side_effect=fake_select_revisit
+        ), mock.patch.object(df_video, "_select_dynamic_by_policy", side_effect=fake_select_dynamic_by_policy):
+            DeMemWMMinecraft.validation_step(harness, batch, 0, namespace="test")
+
+        self.assertEqual(harness.horizons, [2, 1])
+        self.assertEqual([call["target_positions"] for call in build_calls], [[2, 3], [4]])
+        self.assertEqual([call["split"] for call in build_calls], ["test", "test"])
+        self.assertEqual([call["dynamic_count"] for call in build_calls], [1, 1])
+        self.assertEqual([call["revisit_count"] for call in build_calls], [1, 1])
+        self.assertEqual([call["target_positions"] for call in revisit_calls], [[2, 3], [4]])
+        self.assertEqual([call["target_positions"] for call in dynamic_calls], [[2, 3], [4]])
+        for built, revisit, dynamic in zip(build_calls, revisit_calls, dynamic_calls):
+            self.assertIs(revisit["fov_pool"], built["pool"])
+            self.assertIs(dynamic["fov_pool"], built["pool"])
+        self.assertEqual([call["excluded"] for call in dynamic_calls], [[0], [0]])
+        self.assertEqual([call["reference_frames"] for call in dynamic_calls], [[0], [0]])
+        self.assertEqual([name for name, _ in harness.logged], ["test/latent_mse"])
+
     def test_validation_event_policy_uses_committed_history_before_local_span(self):
         from algorithms.dememwm.df_video import DeMemWMMinecraft, _preprocess_dememwm_latent_batch