more fixes to multitask dataset. Seems stable.

dronescapes_reader/multitask_dataset.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 import os
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Iterable
 from argparse import ArgumentParser
 from pprint import pprint
 from natsort import natsorted
@@ -56,7 +56,7 @@ class MultiTaskDataset(Dataset):
     """
 
     def __init__(self, path: Path,
-                 task_names: list[str] | None,
+                 task_names: list[str],
                  task_types: dict[str, type],
                  normalization: str | None | dict[str],
                  handle_missing_data: str = "fill_none",
@@ -68,17 +68,14 @@ class MultiTaskDataset(Dataset):
         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 isinstance(task_names, Iterable), type(task_names)
         self.path = Path(path).absolute()
         self.handle_missing_data = handle_missing_data
         self.suffix = files_suffix
-        self.files_per_repr, self.file_names = self._build_dataset(task_types, task_names) # filtered by 'drop' or 'fill_*' logic
+        self.files_per_repr, self.file_names = self._build_dataset(task_types, task_names) # + handle_missing_data
         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(isinstance(x, str) for x in task_names), tuple(zip(task_names, (type(x) for x in task_names)))
         assert (diff := set(self.files_per_repr).difference(task_names)) == set(), f"Not all tasks in files: {diff}"
         self.task_types = {k: v for k, v in task_types.items() if k in task_names} # all task_types must be provided!
@@ -210,6 +207,7 @@ class MultiTaskDataset(Dataset):
 
     def _get_all_npz_files(self) -> dict[str, list[Path]]:
         """returns a dict of form: {"rgb": ["0.npz", "1.npz", ..., "N.npz"]}"""
+        assert self.suffix == "npz", f"Only npz supported right now (though trivial to update): {self.suffix}"
         in_files = {}
         all_repr_dirs: list[str] = [x.name for x in self.path.iterdir() if x.is_dir()]
         for repr_dir_name in all_repr_dirs:
@@ -224,12 +222,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(self, task_types: dict[str, NpzRepresentation],
-                       task_names: list[str] | None) -> BuildDatasetTuple:
+    def _build_dataset(self, task_types: dict[str, NpzRepresentation], task_names: list[str]) -> BuildDatasetTuple:
         logger.debug(f"Building dataset from: '{self.path}'")
         all_npz_files = self._get_all_npz_files()
-        all_files: dict[str, dict[str, str]] = {k: {_v.name: _v for _v in v} for k, v in all_npz_files.items()}
-        task_names: list[str] = list(all_files.keys()) if task_names is None else task_names
+        all_files: dict[str, dict[str, Path]] = {k: {_v.name: _v for _v in v} for k, v in all_npz_files.items()}
+
         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)
@@ -321,7 +318,8 @@ class MultiTaskDataset(Dataset):
         return res
 
     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)
+        tasks_no_classif = [t for t in set(self.task_names) if not self.name_to_task[t].is_classification]
+        assert (diff := set(tasks_no_classif).difference(statistics)) == set(), f"Missing tasks: {diff}"
         res: dict[str, TaskStatistics] = {}
         for k, v in statistics.items():
             if k in self.task_names: