refactored all code and will soon include global stats as well

dronescapes_reader/dronescapes_representations.py

@@ -4,7 +4,7 @@ from pathlib import Path
 import numpy as np
 import torch as tr
 import flow_vis
-from skimage.color import rgb2hsv, hsv2rgb
+from skimage.color import rgb2hsv
 from overrides import overrides
 from matplotlib.cm import hot # pylint: disable=no-name-in-module
 from torch.nn import functional as F
@@ -14,105 +14,54 @@ try:
 except ImportError:
     from .npz_representation import NpzRepresentation
 
-class ColorRepresentation(NpzRepresentation):
-    def __init__(self, name: str, n_channels: int):
-        super().__init__(name)
-        self._n_channels = n_channels
+class RGBRepresentation(NpzRepresentation):
+    def __init__(self, name: str):
+        super().__init__(name, n_channels=3)
 
+class HSVRepresentation(RGBRepresentation):
     @overrides
     def load_from_disk(self, path: Path) -> tr.Tensor:
-        res = super().load_from_disk(path)
-        return res.float() / 255
-
-    @overrides
-    def save_to_disk(self, data: tr.Tensor, path: Path):
-        return super().save_to_disk((data * 255).byte(), path)
-
-    @property
-    @overrides
-    def n_channels(self) -> int:
-        return self._n_channels
-
-class HSVRepresentation(ColorRepresentation):
-    @overrides
-    def load_from_disk(self, path: Path) -> tr.Tensor:
-        rgb = NpzRepresentation.load_from_disk(self, path)
+        rgb = super().load_from_disk(path)
         return tr.from_numpy(rgb2hsv(rgb)).float()
 
-    @overrides
-    def save_to_disk(self, data: tr.Tensor, path: Path):
-        rgb = tr.from_numpy(hsv2rgb(data) * 255).byte()
-        NpzRepresentation.save_to_disk(rgb, path)
-
 class EdgesRepresentation(NpzRepresentation):
-    @overrides
-    def load_from_disk(self, path: Path) -> tr.Tensor:
-        res = super().load_from_disk(path).float()
-        assert len(res.shape) == 3 and res.shape[-1] == 1
-        return res
-
-    @overrides
-    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
-        return (x.detach().repeat(1, 1, 3) * 255).cpu().numpy().astype(np.uint8)
-
-    @property
-    @overrides
-    def n_channels(self) -> int:
-        return 1
+    def __init__(self, name: str):
+        super().__init__(name, n_channels=1)
 
 class DepthRepresentation(NpzRepresentation):
     """DepthRepresentation. Implements depth task-specific stuff, like hotmap."""
-    def __init__(self, *args, min_depth: float, max_depth: float, **kwargs):
-        super().__init__(*args, **kwargs)
-        assert 0 <= min_depth < max_depth, (min_depth, max_depth)
-        self.min_depth = min_depth
-        self.max_depth = max_depth
+    def __init__(self, name: str):
+        super().__init__(name, n_channels=1)
 
     @overrides
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
         x = x.detach().clip(0, 1).squeeze().cpu().numpy()
+        _min, _max = np.percentile(x, [5, 95])
+        x = np.nan_to_num((x - _min) / (_max - _min), False, 0, 0, 0).clip(0, 1)
         y: np.ndarray = hot(x)[..., 0:3] * 255
         return y.astype(np.uint8)
 
-    @overrides
-    def load_from_disk(self, path: Path) -> tr.Tensor:
-        res = super().load_from_disk(path).squeeze().unsqueeze(-1)
-        res = res.float().clip(self.min_depth, self.max_depth)
-        res = (res - self.min_depth) / (self.max_depth - self.min_depth)
-        return res
-
-    @property
-    @overrides
-    def n_channels(self) -> int:
-        return 1
-
 class NormalsRepresentation(NpzRepresentation):
-    @property
-    @overrides
-    def n_channels(self) -> int:
-        return 3
+    def __init__(self, name: str):
+        super().__init__(name, n_channels=3)
 
 class OpticalFlowRepresentation(NpzRepresentation):
     """OpticalFlowRepresentation. Implements depth task-specific stuff, like using flow_vis."""
-    @overrides
-    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
-        return flow_vis.flow_to_color(x.squeeze().nan_to_num(0).detach().cpu().numpy())
+    def __init__(self, name: str):
+        super().__init__(name, n_channels=2)
 
     @overrides
-    def load_from_disk(self, path: Path) -> tr.Tensor:
-        return super().load_from_disk(path).float()
-
-    @property
-    @overrides
-    def n_channels(self) -> int:
-        return 2
+    def plot_fn(self, x: tr.Tensor) -> np.ndarray:
+        _min, _max = x.min(0)[0].min(0)[0], x.max(0)[0].max(0)[0]
+        x = ((x - _min) / (_max - _min)).nan_to_num(0, 0, 0).detach().cpu().numpy()
+        return flow_vis.flow_to_color(x)
 
 class SemanticRepresentation(NpzRepresentation):
     """SemanticRepresentation. Implements depth task-specific stuff, like using flow_vis."""
     def __init__(self, *args, classes: int | list[str], color_map: list[tuple[int, int, int]], **kwargs):
-        super().__init__(*args, **kwargs)
+        self.n_classes = len(list(range(classes)) if isinstance(classes, int) else classes)
+        super().__init__(*args, **kwargs, n_channels=self.n_classes)
         self.classes = list(range(classes)) if isinstance(classes, int) else classes
-        self.n_classes = len(self.classes)
         self.color_map = color_map
         assert len(color_map) == self.n_classes and self.n_classes > 1, (color_map, self.n_classes)
 
@@ -128,31 +77,26 @@ class SemanticRepresentation(NpzRepresentation):
 
     @overrides
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
-        x = x.squeeze().nan_to_num(0).detach().argmax(-1).cpu().numpy()
-        new_images = np.zeros((*x.shape, 3), dtype=np.uint8)
+        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 == i] = self.color_map[i]
+            new_images[x_argmax == i] = self.color_map[i]
         return new_images
 
-    @property
-    @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),
+    "rgb": RGBRepresentation("rgb"),
+    "hsv": HSVRepresentation("hsv"),
+    "edges_dexined": EdgesRepresentation("edges_dexined"),
+    "edges_gb": EdgesRepresentation("edges_gb"),
+    "depth_dpt": DepthRepresentation("depth_dpt"),
+    "depth_sfm_manual202204": DepthRepresentation("depth_sfm_manual202204"),
+    "depth_ufo": DepthRepresentation("depth_ufo"),
     "normals_sfm_manual202204": NormalsRepresentation("normals_sfm_manual202204"),
-    "depth_ufo": DepthRepresentation("depth_ufo", min_depth=0, max_depth=1),
-    "opticalflow_rife": OpticalFlowRepresentation,
+    "opticalflow_rife": OpticalFlowRepresentation("opticalflow_rife"),
     "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"),
+    "softseg_gb": NpzRepresentation("softseg_gb", 3),
 }

dronescapes_reader/multitask_dataset.py

@@ -12,6 +12,7 @@ import torch as tr
 import numpy as np
 from torch.utils.data import Dataset, DataLoader
 from lovely_tensors import monkey_patch
+from tqdm import trange
 
 try:
     from npz_representation import NpzRepresentation
@@ -26,13 +27,25 @@ TaskStatistics = Tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor] # (min, max,
 class MultiTaskDataset(Dataset):
     """
     MultiTaskDataset implementation. Reads data from npz files and returns them as a dict.
-
     Parameters:
     - path: Path to the directory containing the npz files.
     - task_names: List of tasks that are present in the dataset. If set to None, will infer from the files on disk.
+    - task_types: A dictionary of form {task_name: task_type} for the reader to call to read from disk, plot etc.
+    - normalization: The normalization type used in __getitem__. Valid options are:
+      - None: Reads the data as-is using task.read_from_disk(path)
+      - 'min_max': Calls task.normalize(task.read_from_disk(path), mins[task], maxs[task])
+      - 'standardization': Calls task.standardize(task.read_from_disk(path), means[task], stds[task])
+      If normalization is not 'none', then task-level statistics will be computed. Environmental variable
+      STATS_PBAR=0/1 enables tqdm during statistics computation.
     - handle_missing_data: Modes to handle missing data. Valid options are:
-      - drop: Drop the data point if any of the representations is missing.
-      - fill_none: Fill the missing data with Nones.
+      - 'drop': Drop the data point if any of the representations is missing.
+      - 'fill_{none,zero,nan}': Fill the missing data with Nones, zeros or NaNs.
+    - files_suffix: What suffix to look for when creating the dataset. Valid values: 'npy' or 'npz'.
+    - files_per_repr_overwrites: A dictionay {src: target} that maps one task to another's data (i.e. {'hsv': 'rgb'})
+    - cache_task_stats: If set to True, the statistics will be cached at '{path}/.task_statistics.npz'. Can be enabled
+    using the environmental variable STATS_CACHE=1. Defaults to False.
+    - batch_size_stats: Controls the batch size during statistics computation. Can be enabled by environmental variable
+    STATS_BATCH_SIZE. Defaults to 1.
 
     Expected directory structure:
     path/
@@ -43,40 +56,60 @@ class MultiTaskDataset(Dataset):
     Names can be in a different format (i.e. 2022-01-01.npz), but must be consistent and equal across all tasks.
     """
 
-    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,
+    def __init__(self, path: Path,
+                 task_names: list[str] | None,
+                 task_types: dict[str, type],
+                 normalization: str | None,
+                 handle_missing_data: str = "fill_none",
+                 files_suffix: str = "npz",
                  files_per_repr_overwrites: dict[str, str] | None = None,
-                 compute_statistics: bool = False):
+                 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,
+    ):
         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}"
         assert files_suffix == "npz", "Only npz supported right now (though trivial to update)"
+        assert normalization is None or normalization in ("min_max", "standardization"), normalization
         self.path = Path(path).absolute()
+        self.normalization = normalization
         self.handle_missing_data = handle_missing_data
         self.suffix = files_suffix
         self.files_per_repr_overwrites = files_per_repr_overwrites
-        self.all_files_per_repr = self._get_all_npz_files()
-        self.files_per_repr, self.file_names = self._build_dataset() # these are filtered by 'drop' or 'fill_none' logic
-        if task_types is None:
-            logger.debug("No explicit task types. Defaulting all of them to NpzRepresentation.")
-            task_types = {}
+        self.files_per_repr, self.file_names = self._build_dataset() # filtered by 'drop' or 'fill_*' logic
+        self.cache_task_stats = cache_task_stats
+        self.batch_size_stats = batch_size_stats
 
         if task_names is None:
             task_names = list(self.files_per_repr.keys())
             logger.debug(f"No explicit tasks provided. Using all of them as read from the paths ({len(task_names)}).")
-        assert all(task in self.files_per_repr for task in task_names), (task_names, self.files_per_repr.keys())
-        self.task_types = {k: task_types.get(k, NpzRepresentation) for k in task_names}
         assert all(isinstance(x, str) for x in task_names), tuple(zip(task_names, (type(x) for x in task_names)))
+        assert all(task in self.files_per_repr for task in task_names), (task_names, self.files_per_repr.keys())
+        self.task_types = {k: v for k, v in task_types.items() if k in task_names} # all task_types must be provided!
         self.task_names = sorted(task_names)
+        logger.info(f"Tasks used in this dataset: {self.task_names}")
+
         self._data_shape: tuple[int, ...] | None = None
         self._tasks: list[NpzRepresentation] | None = None
-        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()
+        self._name_to_task: dict[str, NpzRepresentation] | None = None
+        if statistics is not None:
+            self._statistics = self._load_external_statistics(statistics)
+        else:
+            self._statistics = None if normalization is None else self._compute_statistics()
+        if self._statistics is not None:
+            for task_name, task in self.name_to_task.items():
+                task.statistics = self._statistics[task_name]
 
     # Public methods and properties
 
+    @property
+    def name_to_task(self) -> dict[str, NpzRepresentation]:
+        if self._name_to_task is None:
+            self._name_to_task = {task.name: task for task in self.tasks}
+        return self._name_to_task
+
     @property
     def default_vals(self) -> dict[str, tr.Tensor]:
         """default values for __getitem__ if item is not on disk but we retrieve a full batch anyway"""
@@ -91,7 +124,31 @@ class MultiTaskDataset(Dataset):
         """Returns a {task: shape_tuple} for all representations. At least one npz file must exist for each."""
         first_npz = {task: [_v for _v in files if _v is not None][0] for task, files in self.files_per_repr.items()}
         data_shape = {task: self.name_to_task[task].load_from_disk(first_npz[task]).shape for task in self.task_names}
-        return data_shape
+        return {task: tuple(shape) for task, shape in data_shape.items()}
+
+    @property
+    def mins(self) -> dict[str, tr.Tensor]:
+        """returns a dict {task: mins[task]} for all the tasks if self.statistics exists"""
+        assert self.normalization is not None, "No statistics for normalization is None"
+        return {k: v[0] for k, v in self._statistics.items() if k in self.task_names}
+
+    @property
+    def maxs(self) -> dict[str, tr.Tensor]:
+        """returns a dict {task: mins[task]} for all the tasks if self.statistics exists"""
+        assert self.normalization is not None, "No statistics for normalization is None"
+        return {k: v[1] for k, v in self._statistics.items() if k in self.task_names}
+
+    @property
+    def means(self) -> dict[str, tr.Tensor]:
+        """returns a dict {task: mins[task]} for all the tasks if self.statistics exists"""
+        assert self.normalization is not None, "No statistics for normalization is None"
+        return {k: v[2] for k, v in self._statistics.items() if k in self.task_names}
+
+    @property
+    def stds(self) -> dict[str, tr.Tensor]:
+        """returns a dict {task: mins[task]} for all the tasks if self.statistics exists"""
+        assert self.normalization is not None, "No statistics for normalization is None"
+        return {k: v[3] for k, v in self._statistics.items() if k in self.task_names}
 
     @property
     def tasks(self) -> list[NpzRepresentation]:
@@ -99,17 +156,16 @@ class MultiTaskDataset(Dataset):
         Returns a list of instantiated tasks in the same order as self.task_names. Overwrite this to add
         new tasks and semantics (i.e. plot_fn or doing some preprocessing after loading from disk in some tasks.
         """
-        if self._tasks is not None:
-            return self._tasks
-        self._tasks = []
-        for task_name in self.task_names:
-            t = self.task_types[task_name]
-            try:
-                t = t(task_name) # hack for not isinstance(self.task_types, NpzRepresentation) but callable
-            except Exception:
-                pass
-            self._tasks.append(t)
-        assert all(t.name == t_n for t, t_n in zip(self._tasks, self.task_names)), (self.task_names, self._tasks)
+        if self._tasks is None:
+            self._tasks = []
+            for task_name in self.task_names:
+                t = self.task_types[task_name]
+                try:
+                    t = t(task_name) # hack for not isinstance(self.task_types, NpzRepresentation) but callable
+                except Exception:
+                    pass
+                self._tasks.append(t)
+            assert all(t.name == t_n for t, t_n in zip(self._tasks, self.task_names)), (self.task_names, self._tasks)
         return self._tasks
 
     def collate_fn(self, items: list[MultiTaskItem]) -> MultiTaskItem:
@@ -122,7 +178,11 @@ class MultiTaskDataset(Dataset):
         res = {k: tr.zeros(len(items), *self.data_shape[k]).float() for k in self.task_names} # float32 always
         for i in range(len(items)):
             for k in self.task_names:
-                res[k][i][:] = items[i][0][k] if items[i][0][k] is not None else float("nan")
+                try:
+                    res[k][i][:] = items[i][0][k] if items[i][0][k] is not None else float("nan")
+                except Exception as e:
+                    print(k, items)
+                    raise e
         return res, items_name, self.task_names
 
     # Private methods
@@ -145,10 +205,11 @@ class MultiTaskDataset(Dataset):
 
     def _build_dataset(self) -> BuildDatasetTuple:
         logger.debug(f"Building dataset from: '{self.path}'")
+        all_files_per_repr = self._get_all_npz_files()
         if self.handle_missing_data == "drop":
-            files_per_repr, common = self._build_dataset_drop_missing()
+            files_per_repr, common = self._build_dataset_drop_missing(all_files_per_repr)
         else:
-            files_per_repr, common = self._build_dataset_fill_missing()
+            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):
@@ -158,8 +219,7 @@ class MultiTaskDataset(Dataset):
                 files_per_repr[left] = files_per_repr[right]
         return files_per_repr, common
 
-    def _build_dataset_drop_missing(self) -> BuildDatasetTuple:
-        in_files = self.all_files_per_repr
+    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()):
@@ -171,8 +231,7 @@ class MultiTaskDataset(Dataset):
         assert len(files_per_repr) > 0
         return files_per_repr, common
 
-    def _build_dataset_fill_missing(self) -> BuildDatasetTuple:
-        in_files = self.all_files_per_repr
+    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()
@@ -189,41 +248,78 @@ class MultiTaskDataset(Dataset):
         assert len(files_per_repr) > 0
         return files_per_repr, all_files
 
-    def _compute_statistics(self) -> dict[str, tr.Tensor]:
+    def _compute_statistics(self) -> dict[str, TaskStatistics]:
         cache_path = self.path / f".task_statistics.npz"
         res: dict[str, TaskStatistics] = {}
-        if os.getenv("CACHE_IMG_STATS", "0") == "1" and cache_path.exists():
+        if self.cache_task_stats 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()} }")
+            logger.info(f"Loaded task statistics: { {k: tuple(v[0].shape) for k, v in res.items()} } from {cache_path}")
         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)
+        logger.info(f"Computed task statistics: { {k: tuple(v[0].shape) for k, v in res.items()} }")
+        np.savez(cache_path, res)
         return res
 
     def _compute_channel_level_stats(self, missing_tasks: list[str]) -> dict[str, TaskStatistics]:
+        # kinda based on: https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+        def update(counts: tr.Tensor, counts_delta: float,  mean: tr.Tensor, M2: tr.Tensor,
+                   new_value: tr.Tensor) -> tuple[tr.Tensor, tr.Tensor, tr.Tensor]:
+            new_count = counts + counts_delta
+            batch_mean = new_value.nanmean(0)
+            batch_var = ((new_value - batch_mean) ** 2).nansum(0)
+            delta = batch_mean - mean
+            new_count_no_zero = new_count + (new_count == 0) # add 1 (True) in case new_count is 0 to not divide by 0
+            new_mean = mean + delta * counts_delta / new_count_no_zero
+            new_M2 = M2 + batch_var + delta**2 * counts * counts_delta / new_count_no_zero
+            assert not new_mean.isnan().any() and not new_M2.isnan().any(), (mean, new_mean, counts, counts_delta)
+            return new_count, new_mean, new_M2
+
         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}
+        mins = {task_name: tr.zeros(ch[task_name]).type(tr.float64) + 10**10 for task_name in missing_tasks}
+        maxs = {task_name: tr.zeros(ch[task_name]).type(tr.float64) - 10**10 for task_name in missing_tasks}
+        means_vec = {task_name: tr.zeros(ch[task_name]).type(tr.float64) for task_name in missing_tasks}
+        M2s_vec = {task_name: tr.zeros(ch[task_name]).type(tr.float64) for task_name in missing_tasks}
+
+        old_names, old_normalization = self.task_names, self.normalization
+        self.task_names, self.normalization = missing_tasks, None # for self[ix]
+
+        BS = min(len(self), self.batch_size_stats)
+        n = (len(self) // BS) + (len(self) % BS != 0)
+        logger.debug(f"Global task statistics. Batch size: {BS}. N iterations: {n}.")
+        for ix in trange(n, disable=os.getenv("STATS_PBAR", "0") == "0", desc="Computing stats"):
+            item = self[ix * BS: min(len(self), (ix + 1) * BS)][0]
+            for task in missing_tasks:
+                if self.name_to_task[task].is_classification:
+                    continue
+                item_flat_ch = item[task].reshape(-1, ch[task])
+                item_no_nan = item_flat_ch.nan_to_num(0).type(tr.float64)
+                mins[task] = tr.minimum(mins[task], item_no_nan.min(0)[0])
+                maxs[task] = tr.maximum(maxs[task], item_no_nan.max(0)[0])
+                counts_delta = (item_flat_ch == item_flat_ch).long().sum(0)
+                counts[task], means_vec[task], M2s_vec[task] = \
+                    update(counts[task], counts_delta, means_vec[task], M2s_vec[task], item_no_nan)
 
+        res = {}
+        for task in missing_tasks:
+            if self.name_to_task[task].is_classification:
+                res[task] = (mins[task] * 0, mins[task] * 0 + 1, mins[task] * 0, mins[task] * 0 + 1)
+            else:
+                res[task] = (mins[task], maxs[task], means_vec[task], (M2s_vec[task] / counts[task]).sqrt())
+            assert not any(x[0].isnan().any() for x in res[task]), (task, res[task])
+        self.task_names, self.normalization = old_names, old_normalization
+        return res
 
-        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()}
+    def _load_external_statistics(self, statistics: dict[str, TaskStatistics | list]) -> dict[str, TaskStatistics]:
+        assert all(k in statistics.keys() for k in self.task_names), (list(statistics.keys()), self.task_names)
+        res: dict[str, TaskStatistics] = {}
+        for k, v in statistics.items():
+            res[k] = tuple(tr.Tensor(x) for x in v)
+            assert all(_stat.shape == (nd := (self.name_to_task[k].n_channels, )) for _stat in res[k]), (res[k], nd)
+        logger.info(f"External statistics provided: { {k: tuple(v[0].shape) for k, v in res.items()} }")
         return res
 
     # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
@@ -241,10 +337,15 @@ class MultiTaskDataset(Dataset):
         res = {}
         item_name = self.file_names[index]
 
-        for task in self.tasks:
-            file_path = self.files_per_repr[task.name][index]
+        for task_name in self.task_names:
+            task = [t for t in self.tasks if t.name == task_name][0]
+            file_path = self.files_per_repr[task_name][index]
             file_path = None if file_path is None or not (fpr := file_path.resolve()).exists() else fpr
-            res[task.name] = task.load_from_disk(file_path) if file_path is not None else self.default_vals[task.name]
+            res[task_name] = task.load_from_disk(file_path) if file_path is not None else self.default_vals[task_name]
+            if self.normalization == "min_max" and not task.is_classification:
+                res[task_name] = task.normalize(res[task_name])
+            if self.normalization == "standardization" and not task.is_classification:
+                res[task_name] = task.standardize(res[task_name])
         return (res, item_name, self.task_names)
 
     def __len__(self) -> int:
@@ -256,6 +357,7 @@ class MultiTaskDataset(Dataset):
         f_str += f"\n - Tasks ({len(self.tasks)}): {self.tasks}"
         f_str += f"\n - Length: {len(self)}"
         f_str += f"\n - Handle missing data mode: '{self.handle_missing_data}'"
+        f_str += f"\n - Normalization: '{self.normalization}'"
         return f_str
 
     def __repr__(self):

dronescapes_reader/npz_representation.py

@@ -6,14 +6,39 @@ 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):
+    def __init__(self, name: str, n_channels: int):
         self.name = name
+        self.n_channels = n_channels
+        self.classes: list[str] | None = None
+        self._min: tr.Tensor | None = None
+        self._max: tr.Tensor | None = None
+        self._mean: tr.Tensor | None = None
+        self._std: tr.Tensor | None = None
+
+    @property
+    def is_classification(self) -> bool:
+        """if we have self.classes"""
+        return self.classes is not None
+
+    @property
+    def statistics(self) -> tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor] | None:
+        return (self._min, self._max, self._mean, self._std) if self._min is not None else None
+
+    @statistics.setter
+    def statistics(self, stats: tuple[tr.Tensor, tr.Tensor, tr.Tensor, tr.Tensor]):
+        assert isinstance(stats, tuple) and len(stats) == 4, stats
+        self._min, self._max, self._mean, self._std = stats
 
     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.
+        data = data.astype(np.float32) if np.issubdtype(data.dtype, np.floating) else data # float16 is dangerous
+        res = tr.from_numpy(data)
+        res = res.unsqueeze(-1) if len(res.shape) == 2 and self.n_channels == 1 else res # (H, W) in some dph/edges
+        assert ((res.shape[-1] == self.n_channels and len(res.shape) == 3) or
+                (len(res.shape) == 2 and self.is_classification)), f"{self.name}: {res.shape} vs {self.n_channels}"
+        return res
 
     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`"""
@@ -22,34 +47,32 @@ class NpzRepresentation:
     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
+        x = x.nan_to_num(0).cpu().detach()
         if x.shape[-1] != 3:
             x = x[..., 0:1]
-        if x.shape[-1] == 1:
+        if x.shape[-1] == 1: # guaranteed to be (H, W, 3) after this if statement hopefully
             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)
+        if x.dtype == tr.uint8 or self.is_classification:
+            return x.numpy()
+        if self.statistics is not None:
+            x = (x * self._std + self._mean) if (x.min() < 0 or x.max() > 1) else x * (self._max - (m := self._min)) + m
+            x = (x * 255) if (self._max <= 1).any() else x
+        x = x.numpy().astype(np.uint8)
         return x
 
-    def normalize(self, x: tr.Tensor, x_min: tr.Tensor, x_max: tr.Tensor) -> tr.Tensor:
+    def normalize(self, x: 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)
+        assert self.statistics is not None, "self.statistics must be set from reader before task.normalize(x)"
+        return ((x.float() - self._min) / (self._max - self._min)).nan_to_num(0, 0, 0).float()
 
-    def standardize(self, x: tr.Tensor, x_mean: tr.Tensor, x_std: tr.Tensor) -> tr.Tensor:
+    def standardize(self, x: 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}")
+        assert self.statistics is not None, "self.statistics must be set from reader before task.standardize(x)"
+        return ((x.float() - self._mean) / self._std).nan_to_num(0, 0, 0).float()
 
     def __repr__(self):
         return str(self)
 
     def __str__(self):
-        return f"{str(type(self)).split('.')[-1][0:-2]}({self.name})"
+        return f"{str(type(self)).split('.')[-1][0:-2]}({self.name}[{self.n_channels}])"

scripts/dronescapes_viewer.py

@@ -9,8 +9,10 @@ from torch.utils.data import DataLoader
 import random
 
 def main():
-    reader = MultiTaskDataset(sys.argv[1], handle_missing_data="fill_none", task_types=dronescapes_task_types,
-                              files_per_repr_overwrites={"hsv": "rgb"})
+    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",
+                          normalization="min_max", cache_task_stats=True)
     print(reader)
 
     print("== Shapes ==")