little update to multitask_dataset

neo_reader/multitask_dataset.py

@@ -71,7 +71,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):
         assert Path(path).exists(), f"Provided path '{path}' doesn't exist!"
-        assert handle_missing_data in ("drop", "fill_none"), f"Invalid handle_missing_data mode: {handle_missing_data}"
+        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)"
         self.path = Path(path).absolute()
         self.handle_missing_data = handle_missing_data
@@ -93,6 +94,10 @@ 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}")
 
+        _default_val = float("nan") if handle_missing_data == "fill_nan" else 0
+        self._defaults = {task: None if handle_missing_data == "fill_none" else
+                          tr.full(self.data_shape[task], _default_val) for task in self.task_names}
+
     # Public methods and properties
 
     @property
@@ -124,14 +129,14 @@ class MultiTaskDataset(Dataset):
     def collate_fn(self, items: list[MultiTaskItem]) -> MultiTaskItem:
         """
         given a list of items (i.e. from a reader[n:n+k] call), return the item batched on 1st dimension.
-        Nones (missing data points) are turned into zeros as per the data shape of that dim.
+        Nones (missing data points) are turned into nans as per the data shape of that dim.
         """
-        assert all(item[2] == self.task_names for item in items), ((item[2] for item in items), self.task_names)
+        assert all(item[2] == self.task_names for item in items), ([item[2] for item in items], self.task_names)
         items_name = [item[1] for item in items]
         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")
+                res[k][i][:] = items[i][0][k] if items[i][0][k] is not None else float("nan")
         return res, items_name, self.task_names
 
     # Private methods
@@ -152,12 +157,11 @@ 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_drop(self) -> BuildDatasetTuple:
+    def _build_dataset_drop_missing(self) -> BuildDatasetTuple:
         in_files = self.all_files_per_repr
         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())))
-        nodes = in_files.keys()
-        for node in nodes:
+        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))
@@ -166,12 +170,12 @@ class MultiTaskDataset(Dataset):
         assert len(files_per_repr) > 0
         return files_per_repr, common
 
-    def _build_dataset_fill_none(self) -> BuildDatasetTuple:
+    def _build_dataset_fill_missing(self) -> BuildDatasetTuple:
         in_files = self.all_files_per_repr
         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:
+        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).")
@@ -187,9 +191,9 @@ class MultiTaskDataset(Dataset):
     def _build_dataset(self) -> BuildDatasetTuple:
         logger.debug(f"Building dataset from: '{self.path}'")
         if self.handle_missing_data == "drop":
-            return self._build_dataset_drop()
+            return self._build_dataset_drop_missing()
         else:
-            return self._build_dataset_fill_none()
+            return self._build_dataset_fill_missing()
 
     # Python magic methods (pretty printing the reader object, reader[0], len(reader) etc.)
 
@@ -204,12 +208,10 @@ class MultiTaskDataset(Dataset):
         res = {}
         item_name = self.file_names[index]
 
-        for _repr in self.tasks:
-            file_path = self.files_per_repr[_repr.name][index]
-            file_path = file_path.resolve() if file_path is not None else None
-            assert self.handle_missing_data == "fill_none" or (file_path is not None and file_path.exists()), item_name
-            item = _repr.load_from_disk(file_path) if file_path is not None and file_path.exists() else None
-            res[_repr.name] = item
+        for task in self.tasks:
+            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._defaults[task.name]
         return (res, item_name, self.task_names)
 
     def __len__(self) -> int:
@@ -218,9 +220,9 @@ class MultiTaskDataset(Dataset):
     def __str__(self):
         f_str = f"[{str(type(self)).rsplit('.', maxsplit=1)[-1][0:-2]}]"
         f_str += f"\n - Path: '{self.path}'"
-        f_str += f"\n - Only full data: {self.handle_missing_data == 'drop'}"
-        f_str += f"\n - Representations ({len(self.tasks)}): {self.tasks}"
+        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}'"
         return f_str
 
     def __repr__(self):

neo_reader/neo_node.py

@@ -57,7 +57,7 @@ class NEONode(NpzRepresentation):
         return super().save_to_disk(data.clip(0, 1), path)
 
     def plot_fn(self, x: tr.Tensor) -> np.ndarray:
-        y = np.clip(x.numpy(), 0, 1)
+        y = np.clip(x.cpu().numpy(), 0, 1)
         y = y * 255
         y[y == 0] = 255
         y = y.astype(np.uint).squeeze()

neo_viewer.ipynb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b6a574bea07f2faf5c4d2803c117dffc58b7ccc5fa1c988c240441d1c1c470a1
-size 12151624
+oid sha256:f22dabb6d4ab93547a7227e302109e3b4be9a9f627dc41adf03ebcce30b8b33c
+size 12256316