Merge branch 'main' of hf.co:datasets/Meehai/dronescapes

dronescapes_reader/__init__.py

@@ -1,22 +1,2 @@
 """init file"""
 from .multitask_dataset import MultiTaskDataset, NpzRepresentation
-from .dronescapes_representations import DepthRepresentation, OpticalFlowRepresentation, SemanticRepresentation, \
-    ColorRepresentation, EdgesRepresentation, NormalsRepresentation, HSVRepresentation
-
-_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]]
-_m2f_name = "semantic_mask2former_swin_mapillary_converted"
-dronescapes_task_types = { # some pre-baked representations
-    "rgb": ColorRepresentation("rgb", 3),
-    "hsv": HSVRepresentation("hsv", 3),
-    "edges_dexined": ColorRepresentation("edges_dexined", 1),
-    "depth_dpt": DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),
-    "depth_sfm_manual202204": DepthRepresentation("depth_sfm_manual202204", min_depth=0, max_depth=300),
-    "normals_sfm_manual202204": NormalsRepresentation("normals_sfm_manual202204"),
-    "depth_ufo": DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
-    "opticalflow_rife": OpticalFlowRepresentation,
-    "semantic_segprop8": SemanticRepresentation("semantic_segprop8", classes=8, color_map=_color_map),
-    _m2f_name: SemanticRepresentation(_m2f_name, classes=8, color_map=_color_map),
-    "softseg_gb": ColorRepresentation("softseg_gb", 3),
-    "edges_gb": EdgesRepresentation("edges_gb"),
-}

dronescapes_reader/dronescapes_representations.py

@@ -7,9 +7,13 @@ import flow_vis
 from skimage.color import rgb2hsv, hsv2rgb
 from overrides import overrides
 from matplotlib.cm import hot # pylint: disable=no-name-in-module
-from .multitask_dataset import NpzRepresentation
 from torch.nn import functional as F
 
+try:
+    from npz_representation import NpzRepresentation
+except ImportError:
+    from .npz_representation import NpzRepresentation
+
 class ColorRepresentation(NpzRepresentation):
     def __init__(self, name: str, n_channels: int):
         super().__init__(name)
@@ -134,3 +138,21 @@ class SemanticRepresentation(NpzRepresentation):
     @overrides
     def n_channels(self) -> int:
         return self.n_classes
+
+_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]]
+_m2f_name = "semantic_mask2former_swin_mapillary_converted"
+dronescapes_task_types = { # some pre-baked representations
+    "rgb": ColorRepresentation("rgb", 3),
+    "hsv": HSVRepresentation("hsv", 3),
+    "edges_dexined": ColorRepresentation("edges_dexined", 1),
+    "depth_dpt": DepthRepresentation("depth_dpt", min_depth=0, max_depth=0.999),
+    "depth_sfm_manual202204": DepthRepresentation("depth_sfm_manual202204", min_depth=0, max_depth=300),
+    "normals_sfm_manual202204": NormalsRepresentation("normals_sfm_manual202204"),
+    "depth_ufo": DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
+    "opticalflow_rife": OpticalFlowRepresentation,
+    "semantic_segprop8": SemanticRepresentation("semantic_segprop8", classes=8, color_map=_color_map),
+    _m2f_name: SemanticRepresentation(_m2f_name, classes=8, color_map=_color_map),
+    "softseg_gb": ColorRepresentation("softseg_gb", 3),
+    "edges_gb": EdgesRepresentation("edges_gb"),
+}

dronescapes_reader/multitask_dataset.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 """MultiTask Dataset module compatible with torch.utils.data.Dataset & DataLoader."""
 from __future__ import annotations
+import os
 from pathlib import Path
 from typing import Dict, List, Tuple
 from argparse import ArgumentParser
@@ -12,52 +13,15 @@ import numpy as np
 from torch.utils.data import Dataset, DataLoader
 from lovely_tensors import monkey_patch
 
+try:
+    from npz_representation import NpzRepresentation
+except ImportError:
+    from .npz_representation import NpzRepresentation
+
 monkey_patch()
 BuildDatasetTuple = Tuple[Dict[str, List[Path]], List[str]]
 MultiTaskItem = Tuple[Dict[str, tr.Tensor], str, List[str]] # [{task: data}, stem(name) | list[stem(name)], [tasks]]
-
-
-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):
-        self.name = name
-
-    def load_from_disk(self, path: Path) -> tr.Tensor:
-        """Reads the npz data from the disk and transforms it properly"""
-        data = np.load(path, allow_pickle=False)
-        data = data if isinstance(data, np.ndarray) else data["arr_0"] # in case on npz, we need this as well
-        return tr.from_numpy(data) # can be uint8, float16, float32 etc.
-
-    def save_to_disk(self, data: tr.Tensor, path: Path):
-        """stores this item to the disk which can then be loaded via `load_from_disk`"""
-        np.save(path, data.cpu().detach().numpy(), allow_pickle=False)
-
-    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
-        """very basic implementation of converting this representation to a viewable image. You should overwrite this"""
-        assert isinstance(x, tr.Tensor), type(x)
-        if len(x.shape) == 2:
-            x = x.unsqueeze(-1)
-        assert len(x.shape) == 3, x.shape # guaranteed to be (H, W, C) at this point
-        if x.shape[-1] != 3:
-            x = x[..., 0:1]
-        if x.shape[-1] == 1:
-            x = x.repeat(1, 1, 3)
-        x = x.nan_to_num(0).cpu().detach().numpy() # guaranteed to be (H, W, 3) at this point hopefully
-        _min, _max = x.min((0, 1), keepdims=True), x.max((0, 1), keepdims=True)
-        if x.dtype != np.uint8:
-            x = np.nan_to_num((x - _min) / (_max - _min) * 255, 0).astype(np.uint8)
-        return x
-
-    @property
-    def n_channels(self) -> int:
-        """return the number of channels for this representation. Must be updated by each downstream representation"""
-        raise NotImplementedError(f"n_channels is not implemented for {self}")
-
-    def __repr__(self):
-        return str(self)
-
-    def __str__(self):
-        return f"{str(type(self)).split('.')[-1][0:-2]}({self.name})"
+TaskStatistics = Tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor] # (min, max, mean, std)
 
 class MultiTaskDataset(Dataset):
     """
@@ -81,7 +45,8 @@ class MultiTaskDataset(Dataset):
 
     def __init__(self, path: Path, task_names: list[str] | None = None, handle_missing_data: str = "fill_none",
                  files_suffix: str = "npz", task_types: dict[str, type] | None = None,
-                 files_per_repr_overwrites: dict[str, str] | None = None):
+                 files_per_repr_overwrites: dict[str, str] | None = None,
+                 compute_statistics: bool = False):
         assert Path(path).exists(), f"Provided path '{path}' doesn't exist!"
         assert handle_missing_data in ("drop", "fill_none", "fill_zero", "fill_nan"), \
             f"Invalid handle_missing_data mode: {handle_missing_data}"
@@ -108,6 +73,7 @@ class MultiTaskDataset(Dataset):
         self.name_to_task = {task.name: task for task in self.tasks}
         logger.info(f"Tasks used in this dataset: {self.task_names}")
         self._default_vals: dict[str, tr.Tensor] | None = None
+        self.statistics = None if compute_statistics is False else self._compute_statistics()
 
     # Public methods and properties
 
@@ -223,6 +189,43 @@ class MultiTaskDataset(Dataset):
         assert len(files_per_repr) > 0
         return files_per_repr, all_files
 
+    def _compute_statistics(self) -> dict[str, tr.Tensor]:
+        cache_path = self.path / f".task_statistics.npz"
+        res: dict[str, TaskStatistics] = {}
+        if os.getenv("CACHE_IMG_STATS", "0") == "1" and cache_path.exists():
+            res = np.load(cache_path, allow_pickle=True)["arr_0"].item()
+            logger.info(f"Loaded task statistics: { {k: v.shape for k, v in res.items()} }")
+        missing_tasks = list(set(self.task_names).difference(res.keys()))
+        if len(missing_tasks) == 0:
+            return res
+        logger.info(f"Computing global task statistics (dataset len {len(self)}) for {missing_tasks}")
+        old_tasks = self.tasks
+        self._tasks = [t for t in self.tasks if t.name in missing_tasks]
+        res = {**res, **self._compute_channel_level_stats(missing_tasks)}
+        self._tasks = old_tasks
+        logger.info(f"Computed task statistics: { {k: v[0].shape for k, v in res.items()} }")
+        if os.getenv("CACHE_IMG_STATS", "0") == "1":
+            np.savez(cache_path, res)
+        return res
+
+    def _compute_channel_level_stats(self, missing_tasks: list[str]) -> dict[str, TaskStatistics]:
+        ch = {k: v[-1] if len(v) == 3 else 1 for k, v in self.data_shape.items()}
+        sums = {task_name: tr.zeros(ch[task_name]).type(tr.float64) for task_name in missing_tasks}
+        counts = {task_name: tr.zeros(ch[task_name]).long() for task_name in missing_tasks}
+        mins = {task_name: tr.zeros(ch[task_name]).type(tr.float64) - 1<<31 for task_name in missing_tasks}
+        maxs = {task_name: tr.zeros(ch[task_name]).type(tr.float64) + 1<<31 for task_name in missing_tasks}
+
+
+        for ix in range(len(self)):
+            item = self.base_dataset[ix][0]
+            for task in missing_tasks:
+                item_flat_ch = item[task].reshape(-1, self.ch[task])
+                sums[task] += item_flat_ch.nan_to_num(0).type(tr.float64).sum(0)
+                counts[task] += (item_flat_ch == item_flat_ch).long().sum(0)
+        res_ch = {k: (sums[k] / counts[k]).nan_to_num(0).float() for k in missing_tasks}
+        res = {k: v.reshape(-1, 1, 1).repeat(1, self.h, self.w) for k, v in res_ch.items()}
+        return res
+
     # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
 
     def __getitem__(self, index: int | slice | list[int] | tuple) -> MultiTaskItem:

dronescapes_reader/npz_representation.py

@@ -0,0 +1,55 @@
+"""MultiTask representations stored as .npz files on the disk"""
+from __future__ import annotations
+from pathlib import Path
+import numpy as np
+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):
+        self.name = name
+
+    def load_from_disk(self, path: Path) -> tr.Tensor:
+        """Reads the npz data from the disk and transforms it properly"""
+        data = np.load(path, allow_pickle=False)
+        data = data if isinstance(data, np.ndarray) else data["arr_0"] # in case on npz, we need this as well
+        return tr.from_numpy(data) # can be uint8, float16, float32 etc.
+
+    def save_to_disk(self, data: tr.Tensor, path: Path):
+        """stores this item to the disk which can then be loaded via `load_from_disk`"""
+        np.save(path, data.cpu().detach().numpy(), allow_pickle=False)
+
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        """very basic implementation of converting this representation to a viewable image. You should overwrite this"""
+        assert isinstance(x, tr.Tensor), type(x)
+        if len(x.shape) == 2:
+            x = x.unsqueeze(-1)
+        assert len(x.shape) == 3, x.shape # guaranteed to be (H, W, C) at this point
+        if x.shape[-1] != 3:
+            x = x[..., 0:1]
+        if x.shape[-1] == 1:
+            x = x.repeat(1, 1, 3)
+        x = x.nan_to_num(0).cpu().detach().numpy() # guaranteed to be (H, W, 3) at this point hopefully
+        _min, _max = x.min((0, 1), keepdims=True), x.max((0, 1), keepdims=True)
+        if x.dtype != np.uint8:
+            x = np.nan_to_num((x - _min) / (_max - _min) * 255, 0).astype(np.uint8)
+        return x
+
+    def normalize(self, x: tr.Tensor, x_min: tr.Tensor, x_max: tr.Tensor) -> tr.Tensor:
+        """normalizes a data point read with self.load_from_disk(path) using external min/max information"""
+        return ((x - x_max) / (x_max - x_min)).nan_to_num(0, 0, 0)
+
+    def standardize(self, x: tr.Tensor, x_mean: tr.Tensor, x_std: tr.Tensor) -> tr.Tensor:
+        """standardizes a data point read with self.load_from_disk(path) using external min/max information"""
+        return ((x - x_mean) / x_std).nan_to_num(0, 0, 0)
+
+    @property
+    def n_channels(self) -> int:
+        """return the number of channels for this representation. Must be updated by each downstream representation"""
+        raise NotImplementedError(f"n_channels is not implemented for {self}")
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return f"{str(type(self)).split('.')[-1][0:-2]}({self.name})"

scripts/dronescapes_viewer.py

@@ -2,7 +2,8 @@
 import sys
 from pathlib import Path
 sys.path.append(Path(__file__).parents[1].__str__())
-from dronescapes_reader import MultiTaskDataset, dronescapes_task_types
+from dronescapes_reader import MultiTaskDataset
+from dronescapes_reader.dronescapes_representations import dronescapes_task_types
 from pprint import pprint
 from torch.utils.data import DataLoader
 import random