refactor multitask gathering to support dependencies

dronescapes_reader/dronescapes_representations.py

@@ -1,6 +1,7 @@
 """Dronescapes representations -- adds various loading/writing/image showing capabilities to dronescapes tasks"""
 from __future__ import annotations
 from pathlib import Path
+from typing import Callable
 import numpy as np
 import torch as tr
 import flow_vis
@@ -15,8 +16,8 @@ except ImportError:
     from .npz_representation import NpzRepresentation
 
 class RGBRepresentation(NpzRepresentation):
-    def __init__(self, name: str):
-        super().__init__(name, n_channels=3)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, n_channels=3, **kwargs)
 
 class HSVRepresentation(RGBRepresentation):
     @overrides
@@ -25,13 +26,13 @@ class HSVRepresentation(RGBRepresentation):
         return tr.from_numpy(rgb2hsv(rgb)).float()
 
 class EdgesRepresentation(NpzRepresentation):
-    def __init__(self, name: str):
-        super().__init__(name, n_channels=1)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, n_channels=1, **kwargs)
 
 class DepthRepresentation(NpzRepresentation):
-    """DepthRepresentation. Implements depth task-specific stuff, like hotmap."""
-    def __init__(self, name: str, min_depth: float, max_depth: float):
-        super().__init__(name, n_channels=1)
+    """DepthRepresentation. Implements depth task-specific stuff, like spectral map for plots."""
+    def __init__(self, name: str, min_depth: float, max_depth: float, *args, **kwargs):
+        super().__init__(name, n_channels=1, *args, **kwargs)
         self.min_depth = min_depth
         self.max_depth = max_depth
 
@@ -51,13 +52,13 @@ class DepthRepresentation(NpzRepresentation):
         return y.astype(np.uint8)
 
 class NormalsRepresentation(NpzRepresentation):
-    def __init__(self, name: str):
-        super().__init__(name, n_channels=3)
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, n_channels=3, **kwargs)
 
 class OpticalFlowRepresentation(NpzRepresentation):
-    """OpticalFlowRepresentation. Implements depth task-specific stuff, like using flow_vis."""
-    def __init__(self, name: str):
-        super().__init__(name, n_channels=2)
+    """OpticalFlowRepresentation. Implements flow task-specific stuff, like using flow_vis."""
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, n_channels=2, **kwargs)
 
     @overrides
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
@@ -66,7 +67,7 @@ class OpticalFlowRepresentation(NpzRepresentation):
         return flow_vis.flow_to_color(x)
 
 class SemanticRepresentation(NpzRepresentation):
-    """SemanticRepresentation. Implements depth task-specific stuff, like using flow_vis."""
+    """SemanticRepresentation. Implements semantic task-specific stuff, like argmaxing if needed"""
     def __init__(self, *args, classes: int | list[str], color_map: list[tuple[int, int, int]], **kwargs):
         self.n_classes = len(list(range(classes)) if isinstance(classes, int) else classes)
         super().__init__(*args, **kwargs, n_channels=self.n_classes)
@@ -92,6 +93,35 @@ class SemanticRepresentation(NpzRepresentation):
             new_images[x_argmax == i] = self.color_map[i]
         return new_images
 
+# class SemanticMapper(SemanticRepresentation):
+#     """Maps one or more semantic segmentations to a final one + a merge fn. Copy-pasta from VRE"""
+#     def __init__(*args, original_classes: list[list[str]], mapping: list[dict[str, list[str]]],
+#                  color_map: list[tuple[int, int, int]],
+#                  merge_fn: Callable[[list[np.ndarray]], np.ndarray] | None = None, **kwargs):
+#         super().__init__(*args, classes=list(mapping[0].keys()), color_map=color_map, **kwargs)
+#         assert len(self.dependencies) >= 1, "No dependencies provided. Need at least one semantic segmentation to map."
+#         assert isinstance(mapping, list), type(mapping)
+#         assert len(mapping) == (B := len(self.dependencies)), (len(mapping), B)
+#         assert (A := len(original_classes)) == len(self.dependencies), (A, B)
+#         assert all(m.keys() == mapping[0].keys() for m in mapping), [list(m.keys()) for m in mapping]
+#         assert len(color_map) == len(mapping[0].keys()), (len(color_map), len(mapping[0].keys()))
+#         self.original_classes = original_classes
+#         self.mapping = mapping
+
+#     def _make_one(self, semantic_dep_data: np.ndarray, mapping: dict[str, list[str]],
+#                   original_classes: list[str]) -> np.ndarray:
+#         assert semantic_dep_data.dtype in (np.uint8, np.uint16), semantic_dep_data.dtype
+#         mapping_ix = {list(mapping.keys()).index(k): [original_classes.index(_v)
+#                                                       for _v in v] for k, v in mapping.items()}
+#         flat_mapping = {}
+#         for k, v in mapping_ix.items():
+#             for _v in v:
+#                 flat_mapping[_v] = k
+#         mapped_data = np.vectorize(flat_mapping.get)(semantic_dep_data).astype(np.uint8)
+#         return mapped_data
+
+    
+
 _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]]
 coco_classes = ["person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
@@ -156,7 +186,7 @@ mapillary_color_map = [[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 1
 
 dronescapes_task_types = { # some pre-baked representations
     "rgb": RGBRepresentation("rgb"),
-    "hsv": HSVRepresentation("hsv"),
+    "hsv": HSVRepresentation("hsv", dependencies=["rgb"]),
     "edges_dexined": EdgesRepresentation("edges_dexined"),
     "edges_gb": EdgesRepresentation("edges_gb"),
     "depth_dpt": DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),

dronescapes_reader/multitask_dataset.py

@@ -62,7 +62,6 @@ class MultiTaskDataset(Dataset):
                  normalization: str | None | dict[str],
                  handle_missing_data: str = "fill_none",
                  files_suffix: str = "npz",
-                 files_per_repr_overwrites: dict[str, str] | None = None,
                  cache_task_stats: bool = (os.getenv("STATS_CACHE", "0") == "1"),
                  batch_size_stats: int = int(os.getenv("STATS_BATCH_SIZE", "1")),
                  statistics: dict[str, TaskStatistics] | None = None,
@@ -74,8 +73,7 @@ class MultiTaskDataset(Dataset):
         self.path = Path(path).absolute()
         self.handle_missing_data = handle_missing_data
         self.suffix = files_suffix
-        self.files_per_repr_overwrites = files_per_repr_overwrites
-        self.files_per_repr, self.file_names = self._build_dataset() # filtered by 'drop' or 'fill_*' logic
+        self.files_per_repr, self.file_names = self._build_dataset(task_types, task_names) # filtered by 'drop' or 'fill_*' logic
         self.cache_task_stats = cache_task_stats
         self.batch_size_stats = batch_size_stats
 
@@ -213,50 +211,38 @@ class MultiTaskDataset(Dataset):
         assert not any(len(x) == 0 for x in in_files.values()), f"{ [k for k, v in in_files.items() if len(v) == 0] }"
         return in_files
 
-    def _build_dataset(self) -> BuildDatasetTuple:
+    def _build_dataset(self, task_types: dict[str, NpzRepresentation], task_names: list[str] | None) -> BuildDatasetTuple:
         logger.debug(f"Building dataset from: '{self.path}'")
-        all_files_per_repr = self._get_all_npz_files()
+        all_npz_files = self._get_all_npz_files()
+        all_files: dict[str, dict[str, str]] = {k: {_v.name: _v for _v in v} for k, v in all_npz_files.items()}
+        task_names: list[str] = list(all_files.keys()) if task_names is None else task_names
+        relevant_tasks_for_files = set() # hsv requires only rgb, so we look at dependencies later on
+        for task_name in task_names:
+            relevant_tasks_for_files.update(task_types[task_name].dependencies)
+        assert (diff := relevant_tasks_for_files.difference(all_files)) == set(), diff
+        names_to_tasks: dict[str, list[str]] = {} # {name: [task]}
+        for task_name in relevant_tasks_for_files: # just the relevant tasks
+            for path_name in all_files[task_name].keys():
+                names_to_tasks.setdefault(path_name, [])
+                names_to_tasks[path_name].append(task_name)
+
         if self.handle_missing_data == "drop":
-            files_per_repr, common = self._build_dataset_drop_missing(all_files_per_repr)
-        else:
-            files_per_repr, common = self._build_dataset_fill_missing(all_files_per_repr)
-        if self.files_per_repr_overwrites is not None: # here we match for example 'hsv' to read also from 'rgb' dir
-            for left, right in self.files_per_repr_overwrites.items():
-                if right not in (fpr := files_per_repr):
-                    logger.info(f"Overwrite: {left} => {right} provided, but {right} is not in {fpr.keys()}")
-                    continue
-                assert left not in fpr.keys(), f"Overwrite: {left} => {right}. {left} already exists in {fpr.keys()}"
-                files_per_repr[left] = files_per_repr[right]
-        return files_per_repr, common
-
-    def _build_dataset_drop_missing(self, in_files: dict[str, list[Path]]) -> BuildDatasetTuple:
-        name_to_node_path = {k: {_v.name: _v for _v in v} for k, v in in_files.items()} # {node: {name: path}}
-        common = set(x.name for x in next(iter(in_files.values())))
-        for node in (nodes := in_files.keys()):
-            common = common.intersection([f.name for f in in_files[node]])
-            assert len(common) > 0, f"Node '{node}' made the intersection null"
-        common = natsorted(list(common))
-        logger.info(f"Found {len(common)} data points for each node ({len(nodes)} nodes).")
-        files_per_repr = {node: [name_to_node_path[node][x] for x in common] for node in nodes}
-        assert len(files_per_repr) > 0
-        return files_per_repr, common
-
-    def _build_dataset_fill_missing(self, in_files: dict[str, list[Path]]) -> BuildDatasetTuple:
-        name_to_node_path = {k: {_v.name: _v for _v in v} for k, v in in_files.items()}
-        all_files = set(x.name for x in next(iter(in_files.values())))
-        nodes = in_files.keys()
-        for node in (nodes := in_files.keys()):
-            all_files = all_files.union([f.name for f in in_files[node]])
-        all_files = natsorted(list(all_files))
-        logger.info(f"Found {len(all_files)} data points as union of all nodes' data ({len(nodes)} nodes).")
-
-        files_per_repr = {node: [] for node in nodes}
-        for node in nodes:
-            for file_name in all_files:
-                file_path = name_to_node_path[node].get(file_name, None)
-                files_per_repr[node].append(file_path)
-        assert len(files_per_repr) > 0
-        return files_per_repr, all_files
+            b4 = len(names_to_tasks)
+            names_to_tasks = {k: v for k, v in names_to_tasks if len(v) == len(relevant_tasks_for_files)}
+            logger.debug(f"Dropped {b4 - len(names_to_tasks)} files not in all tasks")
+        all_names: list[str] = natsorted(names_to_tasks.keys())
+        logger.info(f"Total files: {len(names_to_tasks)} per task across {len(task_names)} tasks")
+
+        files_per_task: dict[str, list[str | None] | list[list[str] | None]] = {task: [] for task in task_names}
+        for name in all_names:
+            for task in task_names:
+                all_deps_exist = set(deps := task_types[task].dependencies).issubset(names_to_tasks[name])
+                if not all_deps_exist:
+                    files_per_task[task].append(None) # if any of the deps don't exist for this task, skip it.
+                else:
+                    paths = [all_files[dep][name] for dep in deps]
+                    files_per_task[task].append(paths if len(deps) > 1 else paths[0])
+        return files_per_task, all_names
 
     def _compute_statistics(self) -> dict[str, TaskStatistics]:
         cache_path = self.path / f".task_statistics.npz"

dronescapes_reader/npz_representation.py

@@ -6,9 +6,10 @@ import torch as tr
 
 class NpzRepresentation:
     """Generic Task with data read from/saved to npz files. Tries to read data as-is from disk and store it as well"""
-    def __init__(self, name: str, n_channels: int):
+    def __init__(self, name: str, n_channels: int, dependencies: list[str] | None = None):
         self.name = name
         self.n_channels = n_channels
+        self.dependencies: list[str] = [name] if dependencies is None else dependencies
         self.classes: list[str] | None = None
         self.normalization: str | None = None
         self.min: tr.Tensor | None = None

scripts/dronescapes_viewer.py

@@ -9,9 +9,10 @@ from torch.utils.data import DataLoader
 import random
 
 def main():
+    assert len(sys.argv) == 2, f"Usage ./dronescapes_viewer.py /path/to/dataset"
     reader = MultiTaskDataset(sys.argv[1], task_names=list(dronescapes_task_types.keys()),
                           task_types=dronescapes_task_types,
-                          files_per_repr_overwrites={"hsv": "rgb"}, handle_missing_data="fill_nan",
+                          handle_missing_data="fill_nan",
                           normalization="min_max", cache_task_stats=True)
     print(reader)