scripts/collage_comparison/make_collage.py

#!/usr/bin/env python3
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
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 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
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) == 2, 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], 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 item.permute(1, 2, 0).numpy().argmax(-1).astype(np.uint8)


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)
    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",
    # ]
    # print(" ".join(args))
    # exit(0)
    # 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"}})

    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"
    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

    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)
    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)
    [(out_dir / x).mkdir(exist_ok=True) for x in ["ens", "m2f", "distil", "collage"]]
    
    for frame_ix in tqdm(frames):
        batch_m2f = reader2.collate_fn([reader2[frame_ix]])
        batch = reader.collate_fn([reader[frame_ix]])
        rgb = video[frame_ix]

        if not (pth1 := out_dir / f"m2f/{frame_ix}.npz").exists():
            y = inference("semantic_mask2former_r50_mapillary_converted", batch_m2f)
            np.savez_compressed(pth1, y)
        m2f = np.load(pth1)["arr_0"]

        if not (pth2 := out_dir / f"ens/{frame_ix}.npz").exists():
            y = inference(model_mae, batch, n_ens=30)
            np.savez_compressed(pth2, y)
        ens = np.load(pth2)["arr_0"]

        if not (pth3 := out_dir / f"distil/{frame_ix}.npz").exists():
            y = inference(model_distil, batch)
            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())