added consistency script

scripts/collage_comparison/consistency.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+import os
+import torch as tr
+import numpy as np
+import matplotlib.pyplot as plt
+from functools import lru_cache
+from omegaconf import OmegaConf
+from pathlib import Path
+from torch.nn import functional as F
+from argparse import ArgumentParser, Namespace
+from tqdm import tqdm
+
+from vre.utils import clip, AtomicOpen
+from vre import FFmpegVideo
+from vre_repository.optical_flow.raft import FlowRaft
+from matplotlib.cm import hot
+
+device = "cuda" if tr.cuda.is_available() else "cpu"
+
+def _vre_inference(model: "Representation", video: "Video", ixs: list[int]) -> np.ndarray:
+    model.data = None
+    model.compute(video, ixs)
+    return model.data.output
+
+def warp_image_torch(rgb_t_numpy: np.ndarray, flow_numpy: np.ndarray) -> np.ndarray:
+    image = tr.tensor(rgb_t_numpy).permute(0, 3, 1, 2).float().to(device)
+    flow = tr.tensor(flow_numpy).float().to(device)
+
+    H, W = image.shape[-2:]
+
+    # Create normalized meshgrid [-1,1] for grid_sample
+    grid_x, grid_y = tr.meshgrid(
+        tr.linspace(-1, 1, W, device=image.device),
+        tr.linspace(-1, 1, H, device=image.device),
+        indexing="xy",
+    )
+    grid = tr.stack((grid_x, grid_y), dim=-1)  # (H, W, 2), normalized [-1, 1]
+
+    new_grid = grid - flow # why minus ?
+
+    # Warp image using grid_sample
+    warped = F.grid_sample(image, new_grid, mode="bilinear", align_corners=True)
+    warped_numpy = warped.permute(0, 2, 3, 1).cpu().numpy()
+    return warped_numpy
+
+@lru_cache(maxsize=100)
+def _npload(pth: str) -> np.ndarray:
+    return np.load(pth)["arr_0"]
+
+def get_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("video_path", type=Path)
+    parser.add_argument("semantic_preds_path", type=Path, help="Path to 0.npz,..., N.npz argmaxed predictions")
+    parser.add_argument("--frames", type=str)
+    parser.add_argument("--batch_size", type=int, default=1)
+    parser.add_argument("--delta", type=int, default=1)
+    parser.add_argument("--output_path", "-o", type=Path, help="Path to output csv file")
+    args = parser.parse_args()
+    assert args.delta >= 1, args.delta
+    assert args.batch_size >= 1, args.batch_size
+    assert args.output_path.suffix == ".csv", args.output_path
+    assert args.semantic_preds_path.exists(), args.semantic_preds_path
+    args.frames = list(range(*map(int, args.frames.split("..")))) if args.frames is not None else None
+    return args
+
+def main(args: Namespace):
+    video = FFmpegVideo(args.video_path)
+    h, w = video.shape[1:3]
+    raft_r = FlowRaft(name="flow_raft", dependencies=[], inference_width=w, inference_height=h, iters=5,
+                        small=False, delta=args.delta)
+    raft_l = FlowRaft(name="flow_raft", dependencies=[], inference_width=w, inference_height=h, iters=5,
+                        small=False, delta=-args.delta)
+    raft_r.device = raft_l.device = device
+    raft_r.vre_setup() if raft_r.setup_called is False else None
+    raft_l.vre_setup() if raft_l.setup_called is False else None
+
+    frames = list(range(len(video))) if args.frames is None else args.frames
+
+    if args.output_path.exists():
+        with AtomicOpen(args.output_path, "r") as f:
+            data = f.readlines()[1:]
+            done_frames = list(map(int, [x.split(",")[0] for x in data]))
+            b4 = len(frames)
+            frames = [f for f in frames if f not in done_frames]
+            print(f"Eliminating previously computed frames. Before: {b4} frames. After: {len(frames)} frames left")
+    else:
+        with AtomicOpen(args.output_path, "w") as f:
+            f.write("frame, delta, score\n")
+
+    batches = [frames[i:i + args.batch_size] for i in range(0, len(frames), args.batch_size)]
+    assert all((args.semantic_preds_path / f"{f}.npz").exists() for f in frames)
+
+    for ixs in tqdm(batches):
+        ixs_l = [clip(ix + raft_l.delta, 0, len(video) - 1) for ix in ixs]
+        ixs_r = [clip(ix + raft_r.delta, 0, len(video) - 1) for ix in ixs]
+
+        rgb = video[ixs]
+        rgb_l = video[ixs_l]
+        rgb_r = video[ixs_r]
+        sema = np.array([_npload(str(args.semantic_preds_path / f"{ix}.npz")) for ix in ixs])
+        sema_l = np.array([_npload(str(args.semantic_preds_path / f"{ix}.npz")) for ix in ixs_l])
+        sema_r = np.array([_npload(str(args.semantic_preds_path / f"{ix}.npz")) for ix in ixs_r])
+
+        flow_l = _vre_inference(raft_l, video, ixs)
+        rgb_warp_l = warp_image_torch(rgb, flow_l)
+        mask_l = rgb_warp_l.sum(axis=-1) != 0
+        sema_warp_l = warp_image_torch(sema[..., None], flow_l)[..., 0].round().astype(np.uint8)
+        diff_sema_l = (sema_l != sema_warp_l).astype(int)
+
+        flow_r = _vre_inference(raft_r, video, ixs)
+        rgb_warp_r = warp_image_torch(rgb, flow_r)        
+        mask_r = rgb_warp_r.sum(axis=-1) != 0
+        sema_warp_r = warp_image_torch(sema[..., None], flow_r)[..., 0].round().astype(np.uint8)
+        diff_sema_r = (sema_r != sema_warp_r).astype(int)
+
+        # best score = 1 (all agree). Worst score = 0 (none agree). 1/2 means either left or right flow agrees.
+        score = 1 - (diff_sema_l + diff_sema_r) / 2
+        mask = mask_l * mask_r
+        score_valid_perc = [100 * (score[i] * mask[i]).sum() / mask[i].sum() for i in range(len(ixs))]
+
+        with AtomicOpen(args.output_path, "a+") as f:
+            for i in range(len(ixs)):
+                f.write(f"{ixs[i]}, {args.delta}, {score_valid_perc[i]:.2f}\n")
+
+if __name__ == "__main__":
+    main(get_args())

scripts/collage_comparison/wip.py

@@ -3,6 +3,7 @@ import os
 os.environ["VRE_LOGLEVEL"] = "0"
 from argparse import ArgumentParser, Namespace
 import torch as tr
+from torch.nn import functional as F
 import numpy as np
 from pathlib import Path
 import sys
@@ -14,9 +15,9 @@ from lightning_module_enhanced.utils import to_device
 from omegaconf import DictConfig
 from loggez import loggez_logger as logger
 from vre.readers import MultiTaskDataset
-from functools import partial
 from vre.utils import collage_fn, image_add_title, colorize_semantic_segmentation, lo, image_resize, image_write
 from vre import FFmpegVideo
+from functools import partial
 from PIL import Image
 import subprocess
 from tqdm import tqdm
@@ -112,6 +113,7 @@ def inference(model: LME | str, batch: dict, n_ens: int | None = None) -> np.nda
             item = acc_sema[0]
     return item.permute(1, 2, 0).numpy().argmax(-1).astype(np.uint8)
 
+
 def get_args() -> Namespace:
     parser = ArgumentParser()
     parser.add_argument("video_path", type=Path)
@@ -148,7 +150,7 @@ def main(args: Namespace):
     # # print(" ".join(args))
     # subprocess.run(args=args, env={**os.environ.copy(), **{"VRE_DEVICE": "cuda" if tr.cuda.is_available() else "cpu", "CUDA_VISIBLE_DEVICES": "7"}})
 
-    assert (vre_dir / "rgb").exists(), vre_dir
+    assert (vre_dir / "rgb").exists(), vre_dir # run vre otherwise
     for frame in frames:
         assert (vre_dir / f"rgb/npz/{frame}.npz").exists(), frame
     weights_path = "/export/home/proiecte/aux/mihai_cristian.pirvu/code/neo-transformers/ckpts/safeuav/sema/mae-4M-ext/epoch=37-val_semantic_output_mean_iou=0.470.ckpt"
@@ -159,13 +161,12 @@ def main(args: Namespace):
     task_types = build_representations((cfg := model_mae.hparams.cfg).data.dataset)
     stats = model_mae.hparams.stats
 
+    h, w = video.shape[1:3]
+
     test_base_reader2 = MultiTaskDataset(vre_dir, task_types={k: task_types[k] for k in {"semantic_mask2former_r50_mapillary_converted", "rgb"}},
                                         **{**cfg.data.parameters, "task_names": ["rgb", "semantic_mask2former_r50_mapillary_converted"], "normalization": None},
                                         statistics=stats)
     reader2 = VITMultiTaskDataset(test_base_reader2)
-    plot_fns2 = dict(zip(reader2.task_names, [partial(vre_plot_fn, node=n) for n in reader2.tasks]))
-    fix_plot_fns_(plot_fns2, task_types, stats, cfg["data"]["parameters"]["normalization"])
-
     model_tasks = [t for t in cfg.data.parameters.task_names
                    if t not in cfg.train.algorithm.masking.parameters.excluded_tasks]
     _task_types = {k: v for k, v in task_types.items() if k in model_tasks}
@@ -181,30 +182,32 @@ def main(args: Namespace):
     [(out_dir / x).mkdir(exist_ok=True) for x in ["ens", "m2f", "distil", "collage"]]
     
     for frame_ix in tqdm(frames):
-        if (out_file := out_dir / f"collage/{frame_ix}.jpg").exists():
-            continue
         batch_m2f = reader2.collate_fn([reader2[frame_ix]])
         batch = reader.collate_fn([reader[frame_ix]])
-        rgb = batch_m2f["data"]["rgb"][0].permute(1, 2, 0).numpy()
+        rgb = video[frame_ix]
 
-        if not (pth := out_dir / f"m2f/{frame_ix}.npz").exists():
+        if not (pth1 := out_dir / f"m2f/{frame_ix}.npz").exists():
             y = inference("semantic_mask2former_r50_mapillary_converted", batch_m2f)
-            np.savez_compressed(pth, y)
-        m2f_img = colorize_dronescapes(np.load(pth)["arr_0"])
+            np.savez_compressed(pth1, y)
+        m2f = np.load(pth1)["arr_0"]
 
-        if not (pth := out_dir / f"ens/{frame_ix}.npz").exists():
+        if not (pth2 := out_dir / f"ens/{frame_ix}.npz").exists():
             y = inference(model_mae, batch, n_ens=30)
-            np.savez_compressed(pth, y)
-        ens_img = colorize_dronescapes(np.load(pth)["arr_0"])
+            np.savez_compressed(pth2, y)
+        ens = np.load(pth2)["arr_0"]
 
-        if not (pth := out_dir / f"distil/{frame_ix}.npz").exists():
+        if not (pth3 := out_dir / f"distil/{frame_ix}.npz").exists():
             y = inference(model_distil, batch)
-            np.savez_compressed(pth, y)
-        distil_img = colorize_dronescapes(np.load(pth)["arr_0"])
-
-        titles = ["RGB", "Mask2Former (216M)", "Ensembles-30 (4M)", "Distillation (4M)"]
-        collage = collage_fn([rgb, m2f_img, ens_img, distil_img], titles=titles, rows_cols=(2, 2), size_px=40)
-        image_write(collage, out_file)
+            np.savez_compressed(pth3, y)
+        distil = np.load(pth3)["arr_0"]
+
+        if not (out_file := out_dir / f"collage/{frame_ix}.jpg").exists():
+            m2f_img = colorize_dronescapes(m2f)
+            ens_img = colorize_dronescapes(ens)
+            distil_img = colorize_dronescapes(distil)
+            titles = ["RGB", "Mask2Former (216M)", "Ensembles-30 (4M)", "Distillation (4M)"]
+            collage = collage_fn([rgb, m2f_img, ens_img, distil_img], titles=titles, rows_cols=(2, 2), size_px=40)
+            image_write(collage, out_file)
 
 if __name__ == "__main__":
     main(get_args())

scripts/collage_comparison/wip.sh

@@ -35,4 +35,4 @@ done
 wait
 
 # Combine output frames into a video using ffmpeg
-ffmpeg -framerate $fps -i out_"$video_file"/%d.jpg -c:v libx265 -pix_fmt yuv420p out_"$video_file"/collage.mp4
+ffmpeg -framerate $fps -i out_"$video_file"/collage/%d.jpg -c:v libx265 -pix_fmt yuv420p out_"$video_file"/collage/collage.mp4