deleted semantics statistics (useless) and updated the reader with various fixes

data/train_set/.task_statistics.npz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7f06911591fb45c4584e1fa8fcc099637d76cf6fac663a8400f6d76a2ac6ff97
-size 29921
+oid sha256:ab8250be8db0b0cbadb587271ea704c8e9e27bab25954d02d2fe4bd0a3510870
+size 16354

dronescapes_reader/multitask_dataset.py

@@ -106,10 +106,8 @@ class MultiTaskDataset(Dataset):
             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():
-                try:
+                if not task.is_classification:
                     task.set_normalization(self.normalization[task_name], self._statistics[task_name])
-                except:
-                    breakpoint()
 
     # Public methods and properties
 
@@ -120,11 +118,9 @@ class MultiTaskDataset(Dataset):
     @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"""
-        if self._default_vals is None:
-            _default_val = float("nan") if self.handle_missing_data == "fill_nan" else 0
-            self._default_vals = {task: None if self.handle_missing_data == "fill_none" else
-                                  tr.full(self.data_shape[task], _default_val) for task in self.task_names}
-        return self._default_vals
+        _default_val = float("nan") if self.handle_missing_data == "fill_nan" else 0
+        return {task: None if self.handle_missing_data == "fill_none" else tr.full(self.data_shape[task], _default_val)
+                for task in self.task_names}
 
     @property
     def data_shape(self) -> dict[str, tuple[int, ...]]:
@@ -291,30 +287,27 @@ class MultiTaskDataset(Dataset):
             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
 
+        missing_tasks_no_classif = [t for t in missing_tasks if not self.name_to_task[t].is_classification]
         ch = {k: v[-1] if len(v) == 3 else 1 for k, v in self.data_shape.items()}
-        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) + 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}
+        counts = {task_name: tr.zeros(ch[task_name]).long() for task_name in missing_tasks_no_classif}
+        mins = {task_name: tr.zeros(ch[task_name]).type(tr.float64) + 10**10 for task_name in missing_tasks_no_classif}
+        maxs = {task_name: tr.zeros(ch[task_name]).type(tr.float64) - 10**10 for task_name in missing_tasks_no_classif}
+        means_vec = {task_name: tr.zeros(ch[task_name]).type(tr.float64) for task_name in missing_tasks_no_classif}
+        M2s_vec = {task_name: tr.zeros(ch[task_name]).type(tr.float64) for task_name in missing_tasks_no_classif}
 
         old_names, old_normalization = self.task_names, self.normalization
-        missing_tasks_no_classification = [t for t in missing_tasks if not self.name_to_task[t].is_classification]
-        self.task_names, self.normalization = missing_tasks_no_classification, None # for self[ix]
+        self.task_names, self.normalization = missing_tasks_no_classif, None # for self[ix]
 
-        res = {}
-        for task in [t for t in missing_tasks if self.name_to_task[t].is_classification]:
-            res[task] = (mins[task] * 0, mins[task] * 0 + 1, mins[task] * 0, mins[task] * 0 + 1)
-
-        if len(missing_tasks_no_classification) == 0:
-            return res
+        if len(missing_tasks_no_classif) == 0:
+            return {}
 
+        res = {}
         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_no_classification:
+            for task in missing_tasks_no_classif:
                 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])
@@ -323,7 +316,7 @@ class MultiTaskDataset(Dataset):
                 counts[task], means_vec[task], M2s_vec[task] = \
                     update(counts[task], counts_delta, means_vec[task], M2s_vec[task], item_no_nan)
 
-        for task in missing_tasks_no_classification:
+        for task in missing_tasks_no_classif:
             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
@@ -356,11 +349,7 @@ class MultiTaskDataset(Dataset):
         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]
-            if file_path is None:
-                # TODO: I had a .resolve() and .exists() here? WTF? To fix in _build_dataset() maybe.
-                res[task_name] = self.default_vals[task_name]
-            else:
-                res[task_name] = task.load_from_disk(file_path)
+            res[task_name] = self.default_vals[task_name] if file_path is None else task.load_from_disk(file_path)
             if not task.is_classification:
                 if self.normalization is not None and self.normalization[task_name] == "min_max":
                     res[task_name] = task.normalize(res[task_name])