added script

scripts/collage_comparison/cfg.yaml

@@ -0,0 +1,74 @@
+default_io_parameters:
+  binary_format: npz
+  image_format: not-set
+  compress: True
+  output_size: [540, 960]
+ 
+default_learned_parameters:
+  device: ${oc.env:VRE_DEVICE,cpu}
+
+default_compute_parameters:
+  batch_size: 15
+
+representations:
+  rgb:
+    type: color/rgb
+    dependencies: []
+    parameters: {}
+
+  # opticalflow_rife:
+  #   type: optical-flow/rife
+  #   dependencies: []
+  #   parameters:
+  #     uhd: False
+  #     compute_backward_flow: False
+  #   compute_parameters:
+  #     output_dtype: float16
+
+  semantic_mask2former_coco_47429163_0:
+    type: semantic-segmentation/mask2former
+    dependencies: []
+    parameters:
+      model_id: "47429163_0"
+      disk_data_argmax: True
+    compute_parameters:
+      batch_size: 1
+
+  semantic_mask2former_mapillary_49189528_0:
+    type: semantic-segmentation/mask2former
+    dependencies: []
+    parameters:
+      model_id: "49189528_0"
+      disk_data_argmax: True
+    compute_parameters:
+      batch_size: 1
+
+  semantic_mask2former_mapillary_49189528_1:
+    type: semantic-segmentation/mask2former
+    dependencies: []
+    parameters:
+      model_id: "49189528_1"
+      disk_data_argmax: True
+    compute_parameters:
+      batch_size: 1
+
+  depth_marigold:
+    type: depth/marigold
+    dependencies: []
+    parameters:
+      variant: marigold-lcm-v1-0
+      denoising_steps: 4
+      ensemble_size: 1
+      processing_resolution: 768
+    compute_parameters:
+      batch_size: 5
+
+  normals_svd(depth_marigold):
+    type: normals/depth-svd
+    dependencies: [depth_marigold]
+    parameters:
+      sensor_fov: 75
+      sensor_size: [3840, 2160]
+      window_size: 11
+    io_parameters:
+      output_dtype: float16

scripts/collage_comparison/wip.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+import os
+os.environ["VRE_LOGLEVEL"] = "0"
+from argparse import ArgumentParser, Namespace
+import torch as tr
+import numpy as np
+from pathlib import Path
+import sys
+import random
+from typing import Callable
+from pprint import pprint
+from lightning_module_enhanced import LME
+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 PIL import Image
+import subprocess
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+from contexttimer import Timer
+
+sys.path.append("/export/home/proiecte/aux/mihai_cristian.pirvu/code/neo-transformers")
+from readers import VITMultiTaskDataset, build_representations
+from models import build_model
+from plots import vre_plot_fn
+from algorithms import build_algorithm, ModelAlgorithmOutput
+
+# os.environ["CUDA_VISIBLE_DEVICES"]="0" #"7"
+device = tr.device("cuda") if tr.cuda.is_available() else tr.device("cpu")
+
+def seed(seed: int):
+    random.seed(seed)
+    np.random.seed(seed)
+    tr.random.manual_seed(seed)
+
+def fix_batch_(batch: dict, missing_tasks: list[str]) -> dict:
+    assert len(batch["data"]["rgb"]) == 1, batch["data"]["rgb"] # inference with bs=1 allowed for now only
+    assert set(missing_tasks).issubset({"semantic_output", "depth_output", "camera_normals_output"}), missing_tasks
+    if "semantic_output" in missing_tasks:
+        batch["data"]["semantic_output"] = [tr.zeros(8, 540, 960)]
+        batch["image_shape"][0]["semantic_output"] = 8
+    if "depth_output" in missing_tasks:
+        batch["data"]["depth_output"] = [tr.zeros(1, 540, 960)]
+        batch["image_shape"][0]["depth_output"] = 1
+    if "camera_normals_output" in missing_tasks:
+        batch["data"]["camera_normals_output"] = [tr.zeros(3, 540, 960)]
+        batch["image_shape"][0]["camera_normals_output"] = 3
+    batch["data"] = {k: batch["data"][k] for k in sorted(batch["data"].keys())}
+    batch["image_shape"] = [{k: batch["image_shape"][0][k] for k in sorted(batch["image_shape"][0].keys())}, ]
+    return batch
+
+def fix_plot_fns_(plot_fns: dict[str, Callable], task_types: dict[str, "Repr"], stats: dict[str, tuple[list[float]]],
+                  normalization: str):
+    for task_name in ["camera_normals_output", "depth_output", "semantic_output"]:
+        if hasattr(task_types[task_name], "set_normalization"):
+            task_types[task_name].set_normalization(normalization, tuple(stats[task_name]))
+        plot_fns[task_name] = partial(vre_plot_fn, node=task_types[task_name])
+
+def load_model_from_path(weights_path):
+    data = tr.load(weights_path, map_location="cpu")
+    cfg = DictConfig(data["hyper_parameters"]["cfg"])
+    cfg.train.algorithm.metrics_only_on_masked = True
+    model = LME(build_model(cfg).to(device).eval())
+    print(f"DEVICE: {device}")
+    model.load_state_dict(data["state_dict"])
+    model.model_algorithm = build_algorithm(cfg.model.type, cfg.train.algorithm, loss_computer=None)
+    model.hparams.cfg = cfg
+    stats = data["hyper_parameters"]["statistics"]
+    model.hparams.stats = stats
+
+    logger.info(f"Loaded '{cfg.model.type}' with {model.num_params} parameters from '{weights_path}'")
+    logger.info(f"Excluded (fully masked) tasks: {cfg.train.algorithm.masking.parameters.excluded_tasks}")
+    return model
+
+
+def colorize_dronescapes(item: np.ndarray) -> np.ndarray:
+    # colorize_semantic_segmentation
+    assert len(item.shape) == 3 and item.shape[-1] == 8, item.shape
+    color_map = [[0, 255, 0], [0, 127, 0], [255, 255, 0], [255, 255, 255],
+                 [255, 0, 0], [0, 0, 255], [0, 255, 255], [127, 127, 63]]
+    classes_8 = ["land", "forest", "residential", "road", "little-objects", "water", "sky", "hill"]
+    return colorize_semantic_segmentation(item[None].argmax(-1), color_map=color_map, classes=classes_8)[0]
+
+@tr.no_grad
+def inference(model: LME | str, batch: dict, n_ens: int | None = None) -> np.ndarray:
+    assert len(batch["name"]) == 1, batch["name"]
+    if isinstance(model, str) and model == "semantic_mask2former_r50_mapillary_converted":
+        item = batch["data"]["semantic_mask2former_r50_mapillary_converted"][0]
+    else:
+        tasks = model.hparams["cfg"]["train"]["algorithm"]["masking"]["parameters"]["tasks"]
+        if len(tasks) == 2:
+            batch = {
+                "data": {"rgb": batch["data"]["rgb"], "semantic_output": [tr.zeros(8, 540, 960)]},
+                "image_shape": [{"rgb": 3, "semantic_output": 8}, *batch["image_shape"][1:]],
+            }
+            y_model: ModelAlgorithmOutput = to_device(model.model_algorithm(model, batch).y, "cpu")
+            item = y_model.pred["semantic_output"][0]
+        else:
+            assert n_ens is not None, n_ens
+            batch = fix_batch_(batch, model.hparams.cfg.train.algorithm.masking.parameters.excluded_tasks)
+            acc_sema = None
+            for i in range(n_ens):
+                y_model: ModelAlgorithmOutput = to_device(model.model_algorithm(model, batch).y, "cpu")
+                curr_sema = y_model.pred["semantic_output"].to("cpu")
+                if acc_sema is None:
+                    acc_sema = curr_sema
+                else:
+                    acc_sema = (acc_sema * i + curr_sema) / (i + 1)
+            item = acc_sema[0]
+    return colorize_dronescapes(item.permute(1, 2, 0).numpy())
+
+def get_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("video_path", type=Path)
+    parser.add_argument("--frames")
+    return parser.parse_args()
+
+def main(args: Namespace):
+    video = FFmpegVideo(video_path := args.video_path)
+    frames = list(range(len(video)))
+    if args.frames is not None:
+        frames = list(range(*map(int, args.frames.split(".."))))
+
+    (vre_dir := Path.cwd() / f"data_{video_path.name}").mkdir(exist_ok=True)
+    assert (vre_dir / "rgb").exists(), vre_dir
+    for frame in frames:
+        assert (vre_dir / f"rgb/npz/{frame}.npz").exists(), frame
+    cfg_path = Path(__file__).parent / "cfg.yaml"
+    assert cfg_path.exists(), cfg_path
+    # frames = sorted(map(str, set([random.randint(0, N) for _ in range(5)])))
+    representations = ["semantic_mask2former_coco_47429163_0", "semantic_mask2former_mapillary_49189528_0",
+                       "semantic_mask2former_mapillary_49189528_1", "depth_marigold", "normals_svd(depth_marigold)",
+                       "semantic_mask2former_swin_mapillary_converted", "semantic_mask2former_r50_mapillary_converted",
+                       "semantic_mask2former_swin_coco_converted", "semantic_median_expert",
+                       "buildings", "buildings(nearby)", "containing", "rgb", "safe-landing-no-sseg",
+                       "safe-landing-semantics", "sky-and-water", "transportation", "vegetation"]
+
+    # args = ["vre", str(video_path), "--config_path", str(cfg_path),
+    #         "-o", str(vre_dir), "--representations", *representations,
+    #         "-I", f"{Path.cwd().parents[1]}/readers/semantic_mapper.py:get_new_semantic_mapped_tasks",
+    #         "--output_dir_exists_mode", "skip_computed",
+    # ]
+    # frames = None#["5"]
+    # if frames is not None:
+    #     args.extend(["--frames", *frames])
+    # # 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"}})
+
+    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"
+    weights_path_dstil = "/export/home/proiecte/aux/mihai_cristian.pirvu/code/neo-transformers/ckpts/safeuav/distil2/sl0-4M-ext2-distil/epoch=24-val_semantic_output_mean_iou=0.472.ckpt"
+
+    model_mae = load_model_from_path(weights_path)
+    model_distil = load_model_from_path(weights_path_dstil)
+    task_types = build_representations((cfg := model_mae.hparams.cfg).data.dataset)
+    stats = model_mae.hparams.stats
+
+    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}
+    test_base_reader = MultiTaskDataset(vre_dir, task_types=_task_types,
+                                        **{**cfg.data.parameters, "task_names": list(_task_types)},
+                                        statistics=stats)
+    reader = VITMultiTaskDataset(test_base_reader)
+
+    plot_fns = dict(zip(reader.task_names, [partial(vre_plot_fn, node=n) for n in reader.tasks]))
+    fix_plot_fns_(plot_fns, task_types, stats, cfg["data"]["parameters"]["normalization"])
+
+    (out_dir := Path.cwd() / f"out_{video_path.name}").mkdir(exist_ok=True)
+    for frame_ix in tqdm(frames):
+        if (out_file := out_dir/ f"{frame_ix}.jpg").exists():
+            continue
+        batch_m2f = reader2.collate_fn([reader2[frame_ix]])
+        batch = reader.collate_fn([reader[frame_ix]])
+        m2f_img = inference("semantic_mask2former_r50_mapillary_converted", batch_m2f)
+        ens_img = inference(model_mae, batch, n_ens=30)
+        distil_img = inference(model_distil, batch)
+        rgb = batch_m2f["data"]["rgb"][0].permute(1, 2, 0).numpy()
+
+        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())