{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inference notebook: online predictions \n",
    "\n",
    "This script does **everything** online:\n",
    " - reads a new MP4 video and extracts all the experts needed by the model (binary ones too)\n",
    " - does predictions and ensembles\n",
    " - does post-processing on top of the predictions (or ensembles)\n",
    "\n",
    "No evaluation is done as these videos are assumed unseen (no GT). Some fake GT parts are needed as the models also\n",
    "expect the existance of semantic_segporp8 and depth/camera normals sfm as (always masked) inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"VRE_LOGLEVEL\"] = \"0\"\n",
    "import torch as tr\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "import sys\n",
    "import random\n",
    "from typing import Callable\n",
    "from pprint import pprint\n",
    "from lightning_module_enhanced import LME\n",
    "from lightning_module_enhanced.utils import to_device\n",
    "from omegaconf import DictConfig\n",
    "from loggez import loggez_logger as logger\n",
    "from vre.readers import MultiTaskDataset\n",
    "from functools import partial\n",
    "from vre.utils import collage_fn, image_add_title, colorize_semantic_segmentation, lo, image_resize\n",
    "from vre import FFmpegVideo\n",
    "from PIL import Image\n",
    "import subprocess\n",
    "from tqdm.notebook import trange\n",
    "import matplotlib.pyplot as plt\n",
    "from contexttimer import Timer\n",
    "\n",
    "sys.path.append(Path.cwd().parents[1].__str__())\n",
    "from readers import VITMultiTaskDataset, build_representations\n",
    "from models import build_model\n",
    "from plots import vre_plot_fn\n",
    "from algorithms import build_algorithm, ModelAlgorithmOutput\n",
    "\n",
    "from postproc import apply_postproc\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"7\" #\"7\"\n",
    "device = tr.device(\"cuda\") if tr.cuda.is_available() else tr.device(\"cpu\")\n",
    "# weights_path = \"/export/home/proiecte/aux/mihai_cristian.pirvu/code/neo-transformers/experiments_sprmcr/dronescapes/safeuav/m3/20241212/103833/checkpoints/epoch=0-val_semantic_segprop8_mean_iou=0.366.ckpt\"\n",
    "# weights_path = \"/export/home/proiecte/aux/mihai_cristian.pirvu/code/neo-transformers/ckpts/safueav/experts/m1/epoch=3-val_semantic_output_mean_iou=0.466.ckpt\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Various function definitions for plotting, fixing batches (adding dummy output reprs) and loading model from ckpt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_one(data: dict[str, tr.Tensor], plot_fns: dict[str, Callable], title: str,\n",
    "             masks: dict[str, tr.Tensor] | None = None):\n",
    "    res = []\n",
    "    for k, v in data.items():\n",
    "        assert len(v) == 1, (k, v)\n",
    "        img = plot_fns[k](data[k][0].permute(1, 2, 0))\n",
    "\n",
    "        if masks is not None and masks[k]:\n",
    "            img = image_add_title(img, f\"{k} (masked)\", font_color=\"red\", size_px=40)\n",
    "        else:\n",
    "            img = image_add_title(img, k, size_px=40)\n",
    "        res.append(img)\n",
    "\n",
    "    collage = collage_fn(res)\n",
    "    collage = image_add_title(collage, text=title, size_px=55, top_padding=110)\n",
    "    return collage\n",
    "\n",
    "def seed(seed: int):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    tr.random.manual_seed(seed)\n",
    "\n",
    "def fix_batch_(batch: dict, missing_tasks: list[str]) -> dict:\n",
    "    assert len(batch[\"data\"][\"rgb\"]) == 1, batch[\"data\"][\"rgb\"] # inference with bs=1 allowed for now only\n",
    "    assert set(missing_tasks).issubset({\"semantic_output\", \"depth_output\", \"camera_normals_output\"}), missing_tasks\n",
    "    if \"semantic_output\" in missing_tasks:\n",
    "        batch[\"data\"][\"semantic_output\"] = [tr.zeros(8, 540, 960)]\n",
    "        batch[\"image_shape\"][0][\"semantic_output\"] = 8\n",
    "    if \"depth_output\" in missing_tasks:\n",
    "        batch[\"data\"][\"depth_output\"] = [tr.zeros(1, 540, 960)]\n",
    "        batch[\"image_shape\"][0][\"depth_output\"] = 1\n",
    "    if \"camera_normals_output\" in missing_tasks:\n",
    "        batch[\"data\"][\"camera_normals_output\"] = [tr.zeros(3, 540, 960)]\n",
    "        batch[\"image_shape\"][0][\"camera_normals_output\"] = 3\n",
    "    batch[\"data\"] = {k: batch[\"data\"][k] for k in sorted(batch[\"data\"].keys())}\n",
    "    batch[\"image_shape\"] = [{k: batch[\"image_shape\"][0][k] for k in sorted(batch[\"image_shape\"][0].keys())}, ]\n",
    "    return batch\n",
    "\n",
    "def fix_plot_fns_(plot_fns: dict[str, Callable], task_types: dict[str, \"Repr\"], stats: dict[str, tuple[list[float]]],\n",
    "                  normalization: str):\n",
    "    for task_name in [\"camera_normals_output\", \"depth_output\", \"semantic_output\"]:\n",
    "        if hasattr(task_types[task_name], \"set_normalization\"):\n",
    "            task_types[task_name].set_normalization(normalization, tuple(stats[task_name]))\n",
    "        plot_fns[task_name] = partial(vre_plot_fn, node=task_types[task_name])\n",
    "\n",
    "def load_model_from_path(weights_path):\n",
    "    data = tr.load(weights_path, map_location=\"cpu\")\n",
    "    cfg = DictConfig(data[\"hyper_parameters\"][\"cfg\"])\n",
    "    cfg.train.algorithm.metrics_only_on_masked = True\n",
    "    model = LME(build_model(cfg).to(device).eval())\n",
    "    model.load_state_dict(data[\"state_dict\"])\n",
    "    model.model_algorithm = build_algorithm(cfg.model.type, cfg.train.algorithm, loss_computer=None)\n",
    "    model.hparams.cfg = cfg\n",
    "    model.hparams.stats = data[\"hyper_parameters\"][\"statistics\"]\n",
    "\n",
    "    logger.info(f\"Loaded '{cfg.model.type}' with {model.num_params} parameters from '{weights_path}'\")\n",
    "    logger.info(f\"Excluded (fully masked) tasks: {cfg.train.algorithm.masking.parameters.excluded_tasks}\")\n",
    "    return model\n",
    "\n",
    "def fig2np(fig):\n",
    "    \"\"\"Convert a Matplotlib figure to a PIL Image and return it\"\"\"\n",
    "    import io\n",
    "    buf = io.BytesIO()\n",
    "    fig.savefig(buf)\n",
    "    buf.seek(0)\n",
    "    img = Image.open(buf)\n",
    "    img = np.array(img)\n",
    "    return img[..., 0:3]\n",
    "\n",
    "def colorize_dronescapes(item: np.ndarray) -> np.ndarray:\n",
    "    # colorize_semantic_segmentation\n",
    "    assert len(item.shape) == 3 and item.shape[-1] == 8, item.shape\n",
    "    color_map = [[0, 255, 0], [0, 127, 0], [255, 255, 0], [255, 255, 255],\n",
    "                [255, 0, 0], [0, 0, 255], [0, 255, 255], [127, 127, 63]]\n",
    "    classes_8 = [\"land\", \"forest\", \"residential\", \"road\", \"little-objects\", \"water\", \"sky\", \"hill\"]\n",
    "    return colorize_semantic_segmentation(item[None].argmax(-1), color_map=color_map, classes=classes_8)[0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Export the experts from this video on some frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "video_path = Path(\"norway_210821_DJI_0015_full_540p.mp4\"); N=500\n",
    "# video_path = Path(\"poli_test.mp4\"); N=500\n",
    "\n",
    "cfg_path = Path(\"cfg.yaml\")\n",
    "# frames = sorted(map(str, set([random.randint(0, N) for _ in range(5)])))\n",
    "frames = None\n",
    "representations = [\"semantic_mask2former_coco_47429163_0\", \"semantic_mask2former_mapillary_49189528_0\",\n",
    "                   \"semantic_mask2former_mapillary_49189528_1\", \"depth_marigold\", \"normals_svd(depth_marigold)\",\n",
    "                   \"semantic_mask2former_swin_mapillary_converted\", \"semantic_mask2former_r50_mapillary_converted\",\n",
    "                   \"semantic_mask2former_swin_coco_converted\", \"semantic_median_expert\",\n",
    "                   \"buildings\", \"buildings(nearby)\", \"containing\", \"rgb\", \"safe-landing-no-sseg\",\n",
    "                   \"safe-landing-semantics\", \"sky-and-water\", \"transportation\", \"vegetation\"]\n",
    "\n",
    "# representations = [\"semantic_mask2former_mapillary_49189528_0\"]\n",
    "\n",
    "(out_dir := Path.cwd() / f\"data_{video_path.name}\").mkdir(exist_ok=True)\n",
    "assert video_path.exists(), video_path\n",
    "assert cfg_path.exists(), cfg_path\n",
    "args = [\"vre\", str(video_path), \"--config_path\", str(cfg_path),\n",
    "        \"-o\", str(out_dir), \"--representations\", *representations,\n",
    "        \"-I\", f\"{Path.cwd().parents[1]}/readers/semantic_mapper.py:get_new_semantic_mapped_tasks\",\n",
    "        \"--output_dir_exists_mode\", \"skip_computed\",\n",
    "]\n",
    "if frames is not None:\n",
    "    args.extend([\"--frames\", *frames])\n",
    "# print(\" \".join(args))\n",
    "subprocess.run(args=args, env={**os.environ.copy(), **{\"VRE_DEVICE\": \"cuda\" if tr.cuda.is_available() else \"cpu\", \"CUDA_VISIBLE_DEVICES\": \"7\"}})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instantiate the reader of the new experts (only these needed by this model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# weights_path = \"../../ckpts/safeuav/mtl/mtl-4M-ext/epoch=25-val_semantic_output_mean_iou=0.453.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mae-4M-train/epoch=1-val_loss=0.456.ckpt\"\n",
    "weights_path = \"../../ckpts/safeuav/sema/mae-4M-ext/epoch=37-val_semantic_output_mean_iou=0.470.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-4M-ext-distil/epoch=16-val_semantic_output_mean_iou=0.450.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-1M-ext-distil/epoch=41-val_semantic_output_mean_iou=0.453.ckpt\" # 0.058\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-438k-ext-distil/epoch=47-val_semantic_output_mean_iou=0.460.ckpt\" # 0.054\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-150k-ext-distil/epoch=89-val_semantic_output_mean_iou=0.449.ckpt\" # 0.052\n",
    "# weights_path = \"../../ckpts/safeuav/distil2/sl0-4M-ext2-distil/epoch=24-val_semantic_output_mean_iou=0.472.ckpt\"\n",
    "\n",
    "model = load_model_from_path(weights_path)\n",
    "cfg = model.hparams.cfg\n",
    "\n",
    "task_types = build_representations(cfg.data.dataset)\n",
    "# cfg.data\n",
    "print(task_types)\n",
    "model_tasks = [t for t in cfg.data.parameters.task_names\n",
    "               if t not in cfg.train.algorithm.masking.parameters.excluded_tasks]\n",
    "_task_types = {k: v for k, v in task_types.items() if k in model_tasks}\n",
    "test_base_reader = MultiTaskDataset(out_dir, task_types=_task_types,\n",
    "                                    **{**cfg.data.parameters, \"task_names\": list(_task_types)},\n",
    "                                    statistics=model.hparams.stats)\n",
    "reader = VITMultiTaskDataset(test_base_reader)\n",
    "\n",
    "plot_fns = dict(zip(reader.task_names, [partial(vre_plot_fn, node=n) for n in reader.tasks]))\n",
    "fix_plot_fns_(plot_fns, task_types, model.hparams.stats, cfg[\"data\"][\"parameters\"][\"normalization\"])\n",
    "\n",
    "rand_ix = random.randint(0, len(reader) - 1)\n",
    "# rand_ix = \"300.npz\"\n",
    "batch = reader.collate_fn([reader[rand_ix]]) # get a random item\n",
    "batch = fix_batch_(batch, cfg.train.algorithm.masking.parameters.excluded_tasks)\n",
    "# pprint(batch)\n",
    "collage = plot_one(batch[\"data\"], plot_fns=plot_fns, title=batch[\"name\"][0])\n",
    "display(Image.fromarray(collage))\n",
    "\n",
    "with tr.no_grad():\n",
    "    with Timer(prefix=\"infernece\"):\n",
    "        y_model: ModelAlgorithmOutput = to_device(model.model_algorithm(model, batch).y, \"cpu\")\n",
    "    collage = plot_one(y_model.pred, plot_fns=plot_fns, title=batch[\"name\"][0], masks=y_model.mask)\n",
    "    display(Image.fromarray(collage))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_base_reader2 = MultiTaskDataset(out_dir, task_types={k: task_types[k] for k in {\"semantic_mask2former_r50_mapillary_converted\", \"rgb\"}},\n",
    "                                     **{**cfg.data.parameters, \"task_names\": [\"rgb\", \"semantic_mask2former_r50_mapillary_converted\"], \"normalization\": None},\n",
    "                                     statistics=model.hparams.stats)\n",
    "reader2 = VITMultiTaskDataset(test_base_reader2)\n",
    "plot_fns2 = dict(zip(reader2.task_names, [partial(vre_plot_fn, node=n) for n in reader2.tasks]))\n",
    "fix_plot_fns_(plot_fns2, task_types, model.hparams.stats, cfg[\"data\"][\"parameters\"][\"normalization\"])\n",
    "\n",
    "batch = reader2.collate_fn([reader2[rand_ix]]) # get a random item\n",
    "# batch = fix_batch_(batch, cfg.train.algorithm.masking.parameters.excluded_tasks)\n",
    "# pprint(batch)\n",
    "collage = plot_one(batch[\"data\"], plot_fns=plot_fns2, title=batch[\"name\"][0])\n",
    "display(Image.fromarray(collage))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# weights_path = \"../../ckpts/safeuav/mtl/mtl-4M-ext/epoch=25-val_semantic_output_mean_iou=0.453.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mae-4M-train/epoch=1-val_loss=0.456.ckpt\"\n",
    "weights_path = \"../../ckpts/safeuav/sema/mae-4M-ext/epoch=37-val_semantic_output_mean_iou=0.470.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-4M-ext-distil/epoch=16-val_semantic_output_mean_iou=0.450.ckpt\"\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-1M-ext-distil/epoch=41-val_semantic_output_mean_iou=0.453.ckpt\" # 0.058\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-438k-ext-distil/epoch=47-val_semantic_output_mean_iou=0.460.ckpt\" # 0.054\n",
    "# weights_path = \"../../ckpts/safeuav/sema/mtl-150k-ext-distil/epoch=89-val_semantic_output_mean_iou=0.449.ckpt\" # 0.052\n",
    "weights_path_dstil = \"../../ckpts/safeuav/distil2/sl0-4M-ext2-distil/epoch=24-val_semantic_output_mean_iou=0.472.ckpt\"\n",
    "\n",
    "model_mae = load_model_from_path(weights_path)\n",
    "model_distil = load_model_from_path(weights_path_dstil)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_mae.hparams[\"cfg\"][\"train\"][\"algorithm\"][\"masking\"][\"parameters\"][\"tasks\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ensembles on unknown data until data no longer changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tr.no_grad\n",
    "def inference(model: LME | str, batch: dict, n_ens: int | None = None) -> np.ndarray:\n",
    "    assert len(batch[\"name\"]) == 1, batch[\"name\"]\n",
    "    if isinstance(model, str) and model == \"semantic_mask2former_r50_mapillary_converted\":\n",
    "        item = batch[\"data\"][\"semantic_mask2former_r50_mapillary_converted\"][0]\n",
    "    else:\n",
    "        tasks = model.hparams[\"cfg\"][\"train\"][\"algorithm\"][\"masking\"][\"parameters\"][\"tasks\"]\n",
    "        if len(tasks) == 2:\n",
    "            batch = {\n",
    "                \"data\": {\"rgb\": batch[\"data\"][\"rgb\"], \"semantic_output\": [tr.zeros(8, 540, 960)]},\n",
    "                \"image_shape\": [{\"rgb\": 3, \"semantic_output\": 8}, *batch[\"image_shape\"][1:]],\n",
    "            }\n",
    "            y_model: ModelAlgorithmOutput = to_device(model.model_algorithm(model, batch).y, \"cpu\")\n",
    "            item = y_model.pred[\"semantic_output\"][0]\n",
    "        else:\n",
    "            assert n_ens is not None, n_ens\n",
    "            batch = fix_batch_(batch, model.hparams.cfg.train.algorithm.masking.parameters.excluded_tasks)\n",
    "            acc_sema = None\n",
    "            for i in trange(n_ens):\n",
    "                y_model: ModelAlgorithmOutput = to_device(model.model_algorithm(model, batch).y, \"cpu\")\n",
    "                curr_sema = y_model.pred[\"semantic_output\"].to(\"cpu\")\n",
    "                if acc_sema is None:\n",
    "                    acc_sema = curr_sema\n",
    "                else:\n",
    "                    acc_sema = (acc_sema * i + curr_sema) / (i + 1)\n",
    "            item = acc_sema[0]\n",
    "    return colorize_dronescapes(item.permute(1, 2, 0).numpy())\n",
    "\n",
    "batch_m2f = reader2.collate_fn([reader2[rand_ix]])\n",
    "m2f_img = inference(\"semantic_mask2former_r50_mapillary_converted\", batch_m2f)\n",
    "batch = reader.collate_fn([reader[rand_ix]])\n",
    "ens_img = inference(model_mae, batch, n_ens=30)\n",
    "distil_img = inference(model_distil, batch)\n",
    "\n",
    "rgb = batch_m2f[\"data\"][\"rgb\"][0].permute(1, 2, 0).numpy()\n",
    "titles = [\"RGB\", \"Mask2Former (216M)\", \"Ensembles (4M)\", \"Distillation (4M)\"]\n",
    "collage = collage_fn([rgb, m2f_img, ens_img, distil_img], titles=titles, rows_cols=(2, 2), size_px=40)\n",
    "display(Image.fromarray(collage))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ngc",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}