--n_workers to eval script bcoz y not

dronescapes_reader/multitask_dataset.py

@@ -70,7 +70,7 @@ 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):
+                 files_suffix: str = "npz", task_types: dict[str, type] | 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}"
@@ -94,13 +94,19 @@ class MultiTaskDataset(Dataset):
         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}")
-
-        _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}
+        self._default_vals: dict[str, tr.Tensor] | None = None
 
     # Public methods and properties
 
+    @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
+
     @property
     def data_shape(self) -> dict[str, tuple[int, ...]]:
         """Returns a {task: shape_tuple} for all representations. At least one npz file must exist for each."""
@@ -214,7 +220,7 @@ class MultiTaskDataset(Dataset):
         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]
+            res[task.name] = task.load_from_disk(file_path) if file_path is not None else self.default_vals[task.name]
         return (res, item_name, self.task_names)
 
     def __len__(self) -> int:

scripts/evaluate_semantic_segmentation.py

@@ -9,9 +9,10 @@ from loguru import logger
 from pathlib import Path
 from argparse import ArgumentParser, Namespace
 from tempfile import TemporaryDirectory
+from multiprocessing import Pool
 from functools import partial
 from torchmetrics.functional.classification import multiclass_stat_scores
-from tqdm import trange
+from tqdm import tqdm
 import torch as tr
 import numpy as np
 import pandas as pd
@@ -34,16 +35,20 @@ def compute_metrics_by_class(df: pd.DataFrame, class_name: str) -> pd.DataFrame:
     df = df.fillna(0).round(3)
     return df
 
-def compute_raw_stats_per_frame(reader: MultiTaskDataset, classes: list[str]) -> pd.DataFrame:
+def _do_one(i: int, reader: MultiTaskDataset, num_classes: int) -> tuple[tr.Tensor, str]:
+    data, name = reader[i][0:2]
+    y = data["pred"].argmax(-1) if data["pred"].dtype != tr.int64 else data["pred"]
+    gt = data["gt"].argmax(-1) if data["gt"].dtype != tr.int64 else data["gt"]
+    return multiclass_stat_scores(y, gt, num_classes=num_classes, average=None)[:, 0:4], name
+
+def compute_raw_stats_per_frame(reader: MultiTaskDataset, classes: list[str], n_workers: int = 1) -> pd.DataFrame:
     res = tr.zeros((len(reader), len(classes), 4)).long() # (N, NC, 4)
-    index = []
-    for i in trange(len(reader)):
-        x = reader[i]
-        y = x[0]["pred"].argmax(-1) if x[0]["pred"].dtype != tr.int64 else x[0]["pred"]
-        gt = x[0]["gt"].argmax(-1) if x[0]["gt"].dtype != tr.int64 else x[0]["gt"]
-        res[i] = multiclass_stat_scores(y, gt, num_classes=len(classes), average=None)[:, 0:4]
-        index.append(x[1])
-    res = res.reshape(len(reader) * len(classes), 4)
+
+    map_fn = map if n_workers == 1 else Pool(n_workers).imap
+    do_one_fn = partial(_do_one, reader=reader, num_classes=len(classes))
+    map_res = list(tqdm(map_fn(do_one_fn, range(len(reader))), total=len(reader)))
+    res, index = tr.stack([x[0] for x in map_res]).reshape(len(reader) * len(classes), 4), [x[1] for x in map_res]
+
     df = pd.DataFrame(res, index=np.repeat(index, len(classes)), columns=["tp", "fp", "tn", "fn"])
     df.insert(0, "class_name", np.array(classes)[:, None].repeat(len(index), 1).T.flatten())
     return df
@@ -77,6 +82,7 @@ def get_args() -> Namespace:
     parser.add_argument("--class_weights", nargs="+", type=float)
     parser.add_argument("--scenes", nargs="+", default=["all"], help="each scene will get separate metrics if provided")
     parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument("--n_workers", type=int, default=1)
     args = parser.parse_args()
     if args.class_weights is None:
         logger.info("No class weights provided, defaulting to equal weights.")
@@ -88,6 +94,7 @@ def get_args() -> Namespace:
         logger.info(f"Scenes: {args.scenes}")
     if args.output_path.exists() and args.overwrite:
         os.remove(args.output_path)
+    assert args.n_workers >= 1 and isinstance(args.n_workers, int), args.n_workers
     return args
 
 def main(args: Namespace):
@@ -98,7 +105,7 @@ def main(args: Namespace):
     assert (a := len(reader.all_files_per_repr["gt"])) == (b := len(reader.all_files_per_repr["pred"])), f"{a} vs {b}"
 
     # Compute TP, FP, TN, FN for each frame
-    raw_stats = compute_raw_stats_per_frame(reader, args.classes)
+    raw_stats = compute_raw_stats_per_frame(reader, args.classes, args.n_workers)
     logger.info(f"Stored raw metrics file to: '{args.output_path}'")
     Path(args.output_path).parent.mkdir(exist_ok=True, parents=True)
     raw_stats.to_csv(args.output_path)