more updates to dronescapes. Added TaskMapper and more control over mappings. We can do generic dependencies now, not just semantic.

dronescapes_reader/dronescapes_representations.py

@@ -93,57 +93,32 @@ 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.
-    TODO: allow non-semantic dependencies (must pass the correct load_fn or object instead of assuming semantic deps)
-    """
-    def __init__(self, *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 and self.dependencies[0] != self.name, \
-            "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
-        self.merge_fn = merge_fn if merge_fn is not None else SemanticMapper._default_merge_fn
-
-    @staticmethod
-    def _default_merge_fn(dep_data: list[np.ndarray]) -> np.ndarray:
-        if len(dep_data) > 1:
-            raise ValueError(f"default_merge_fn doesnt' work with >1 dependencies: {len(dep_data)}")
-        return dep_data[0]
-
-    def _make_one(self, path: Path, mapping: dict[str, list[str]],
-                  original_classes: list[str]) -> np.ndarray:
-        semantic_dep_data: np.ndarray = NpzRepresentation.load_from_disk(self, path).numpy()
-        semantic_dep_data = semantic_dep_data.argmax(-1) if len(semantic_dep_data.shape) == 3 else semantic_dep_data
-        assert len(semantic_dep_data.shape) == 2, f"Only argmaxed data supported, got: {semantic_dep_data.shape}"
-        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
-    
-    def load_from_disk(self, path: Path | list[Path]):
-        # note: assuming SemanticRepresentation for all deps. TODO: generic deps.
+def semantic_mapper(semantic_original: np.ndarray, mapping: dict[str, list[str]],
+                    original_classes: list[str]) -> np.ndarray:
+    """maps a bigger semantic segmentation to a smaller one"""
+    assert len(semantic_original.shape) == 2, f"Only argmaxed data supported, got: {semantic_original.shape}"
+    assert np.issubdtype(semantic_original.dtype, np.integer), semantic_original.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_original).astype(np.uint8)
+    return mapped_data
+
+class TaskMapper(NpzRepresentation):
+    def __init__(self, *args, merge_fn: Callable[[list[np.ndarray]], tr.Tensor], **kwargs):
+        super().__init__(*args, **kwargs)
+        assert len(self.dependencies) > 0 and self.dep_names[0] != self.name, "Need at least one dependency"
+        self.merge_fn = merge_fn
+
+    def load_from_disk(self, path: Path | list[Path]) -> tr.Tensor:
         paths = [path] if isinstance(path, Path) else path
-        assert len(paths) == len(self.dependencies), (len(path), len(self.dependencies))
-        individual_semantics = []
-        for path, mapping, original_classes in zip(paths, self.mapping, self.original_classes):
-            individual_semantics.append(self._make_one(path, mapping, original_classes))
-        res = self.merge_fn(individual_semantics)
-        res_torch = F.one_hot(tr.from_numpy(res).long(), num_classes=self.n_classes).float()
-        return res_torch
+        dep_data = [dep.load_from_disk(path) for dep, path in zip(self.dependencies, paths)]
+        return self.merge_fn(dep_data)
+
+    def plot_fn(self, x):
+        raise NotImplementedError("Must be overriden by the user")
 
 color_map_8classes = [[0, 255, 0], [0, 127, 0], [255, 255, 0], [255, 255, 255],
                       [255, 0, 0], [0, 0, 255], [0, 255, 255], [127, 127, 63]]
@@ -207,27 +182,48 @@ mapillary_color_map = [[165, 42, 42], [0, 192, 0], [196, 196, 196], [190, 153, 1
                        [0, 60, 100], [0, 0, 142], [0, 0, 90], [0, 0, 230], [0, 80, 100], [128, 64, 64], [0, 0, 110],
                        [0, 0, 70], [0, 0, 192], [32, 32, 32], [120, 10, 10]]
 
-m2f_mapillary_to_8_classes = {
-        "land": ["Terrain", "Sand", "Snow"],
-        "forest": ["Vegetation"],
-        "residential": ["Building", "Utility Pole", "Pole", "Fence", "Wall", "Manhole", "Street Light", "Curb",
-                        "Guard Rail", "Caravan", "Junction Box", "Traffic Sign (Front)", "Billboard", "Banner",
-                        "Mailbox", "Traffic Sign (Back)", "Bench", "Fire Hydrant", "Trash Can", "CCTV Camera",
-                        "Traffic Light", "Barrier", "Rail Track", "Phone Booth", "Curb Cut", "Traffic Sign Frame",
-                        "Bike Rack"],
-        "road": ["Road", "Lane Marking - General", "Sidewalk", "Bridge", "Other Vehicle", "Motorcyclist", "Pothole",
-                 "Catch Basin", "Car Mount", "Tunnel", "Parking", "Service Lane", "Lane Marking - Crosswalk",
-                 "Pedestrian Area", "On Rails", "Bike Lane", "Crosswalk - Plain"],
-        "little-objects": ["Car", "Person", "Truck", "Boat", "Wheeled Slow", "Trailer", "Ground Animal", "Bicycle",
-                           "Motorcycle", "Bird", "Bus", "Ego Vehicle", "Bicyclist", "Other Rider"],
-        "water": ["Water"],
-        "sky": ["Sky"],
-        "hill": ["Mountain"]
-    }
-
-tasks = [ # some pre-baked representations
-    RGBRepresentation("rgb"),
-    HSVRepresentation("hsv", dependencies=["rgb"]),
+class SemanticMask2FormerMapillaryConvertedPaper(TaskMapper):
+    def __init__(self, dep: NpzRepresentation):
+        super().__init__("semantic_mask2former_swin_mapillary_converted",
+                         dependencies=[dep], merge_fn=self._merge_fn, n_channels=8)
+        self.mapping = {
+            "land": ["Terrain", "Sand", "Snow"],
+            "forest": ["Vegetation"],
+            "residential": ["Building", "Utility Pole", "Pole", "Fence", "Wall", "Manhole", "Street Light", "Curb",
+                            "Guard Rail", "Caravan", "Junction Box", "Traffic Sign (Front)", "Billboard", "Banner",
+                            "Mailbox", "Traffic Sign (Back)", "Bench", "Fire Hydrant", "Trash Can", "CCTV Camera",
+                            "Traffic Light", "Barrier", "Rail Track", "Phone Booth", "Curb Cut", "Traffic Sign Frame",
+                            "Bike Rack"],
+            "road": ["Road", "Lane Marking - General", "Sidewalk", "Bridge", "Other Vehicle", "Motorcyclist", "Pothole",
+                    "Catch Basin", "Car Mount", "Tunnel", "Parking", "Service Lane", "Lane Marking - Crosswalk",
+                    "Pedestrian Area", "On Rails", "Bike Lane", "Crosswalk - Plain"],
+            "little-objects": ["Car", "Person", "Truck", "Boat", "Wheeled Slow", "Trailer", "Ground Animal", "Bicycle",
+                            "Motorcycle", "Bird", "Bus", "Ego Vehicle", "Bicyclist", "Other Rider"],
+            "water": ["Water"],
+            "sky": ["Sky"],
+            "hill": ["Mountain"]
+        }
+        self.color_map = color_map_8classes
+        self.original_classes = mapillary_classes
+        self.classes = list(self.mapping.keys())
+        self.n_classes = len(self.classes)
+
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        x_argmax = x.squeeze().nan_to_num(0).detach().argmax(-1).cpu().numpy()
+        new_images = np.zeros((*x_argmax.shape, 3), dtype=np.uint8)
+        for i in range(self.n_classes):
+            new_images[x_argmax == i] = self.color_map[i]
+        return new_images
+
+    def _merge_fn(self, dep_data: list[np.ndarray]) -> tr.Tensor:
+        m2f_mapillary = dep_data[0].argmax(-1).numpy()
+        m2f_mapillary_converted = semantic_mapper(m2f_mapillary, self.mapping, self.original_classes)
+        converted_oh = F.one_hot(tr.from_numpy(m2f_mapillary_converted).long(), num_classes=self.n_classes).float()
+        return converted_oh
+
+_tasks: list[NpzRepresentation] = [ # some pre-baked representations
+    rgb := RGBRepresentation("rgb"),
+    HSVRepresentation("hsv", dependencies=[rgb]),
     EdgesRepresentation("edges_dexined"),
     EdgesRepresentation("edges_gb"),
     DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),
@@ -237,12 +233,10 @@ tasks = [ # some pre-baked representations
     NormalsRepresentation("normals_sfm_manual202204"),
     OpticalFlowRepresentation("opticalflow_rife"),
     SemanticRepresentation("semantic_segprop8", classes=8, color_map=color_map_8classes),
-    SemanticMapper("semantic_mask2former_swin_mapillary_converted", original_classes=[mapillary_classes],
-                   mapping=[m2f_mapillary_to_8_classes], color_map=color_map_8classes,
-                   dependencies=["semantic_mask2former_mapillary_49189528_0"]),
     SemanticRepresentation("semantic_mask2former_coco_47429163_0", classes=coco_classes, color_map=coco_color_map),
-    SemanticRepresentation("semantic_mask2former_mapillary_49189528_0", classes=mapillary_classes,
-                            color_map=mapillary_color_map),
+    m2f_mapillary := SemanticRepresentation("semantic_mask2former_mapillary_49189528_0", classes=mapillary_classes,
+                                            color_map=mapillary_color_map),
+    SemanticMask2FormerMapillaryConvertedPaper(m2f_mapillary),
     NpzRepresentation("softseg_gb", 3),
 ]
-dronescapes_task_types: dict[str, NpzRepresentation] = {task.name: task for task in tasks}
+dronescapes_task_types: dict[str, NpzRepresentation] = {task.name: task for task in _tasks}

dronescapes_reader/multitask_dataset.py

@@ -229,8 +229,9 @@ class MultiTaskDataset(Dataset):
 
         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
+            relevant_tasks_for_files.update(task_types[task_name].dep_names)
+        if (diff := relevant_tasks_for_files.difference(all_files)) != set():
+            raise FileNotFoundError(f"Missing files for {diff}.\nFound on disk: {[*all_files]}")
         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():
@@ -247,7 +248,7 @@ class MultiTaskDataset(Dataset):
         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])
+                all_deps_exist = set(deps := task_types[task].dep_names).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:

dronescapes_reader/npz_representation.py

@@ -6,10 +6,12 @@ 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, dependencies: list[str] | None = None):
+    def __init__(self, name: str, n_channels: int, dependencies: list[NpzRepresentation] | None = None):
         self.name = name
         self.n_channels = n_channels
-        self.dependencies: list[str] = [name] if dependencies is None else dependencies
+        dependencies = deps = [self] if dependencies is None else dependencies
+        self.dependencies: list[NpzRepresentation] = dependencies
+        assert all(isinstance(dep, NpzRepresentation) for dep in deps), f"{self}: {dict(zip(deps, map(type, deps)))}"
         self.classes: list[str] | None = None
         self.normalization: str | None = None
         self.min: tr.Tensor | None = None
@@ -22,6 +24,11 @@ class NpzRepresentation:
         """if we have self.classes"""
         return self.classes is not None
 
+    @property
+    def dep_names(self) -> list[str]:
+        """The names of the dependencies of this representation"""
+        return [dep.name for dep in self.dependencies]
+
     def set_normalization(self, normalization: str, stats: tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor]):
         """sets the normalization"""
         assert normalization in ("min_max", "standardization"), normalization