small update to the scripts

dronescapes_reader/multitask_dataset.py

@@ -76,7 +76,8 @@ class MultiTaskDataset(Dataset):
         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()
+        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 = {}
@@ -150,7 +151,7 @@ class MultiTaskDataset(Dataset):
         return in_files
 
     def _build_dataset_drop(self) -> BuildDatasetTuple:
-        in_files = self._get_all_npz_files()
+        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()
@@ -164,7 +165,7 @@ class MultiTaskDataset(Dataset):
         return files_per_repr, common
 
     def _build_dataset_fill_none(self) -> BuildDatasetTuple:
-        in_files = self._get_all_npz_files()
+        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()

scripts/evaluate_semantic_segmentation.py

@@ -25,7 +25,7 @@ def compute_metrics(tp: np.ndarray, fp: np.ndarray, tn: np.ndarray, fn: np.ndarr
     iou = tp / (tp + fp + fn)
     return pd.DataFrame([precision, recall, f1, iou], index=["precision", "recall", "f1", "iou"]).T
 
-def do_one_class(df: pd.DataFrame, class_name: str) -> pd.DataFrame:
+def compute_metrics_by_class(df: pd.DataFrame, class_name: str) -> pd.DataFrame:
     df = df.query("class_name == @class_name").drop(columns="class_name")
     df.loc["all"] = df.sum()
     df[["precision", "recall", "f1", "iou"]] = compute_metrics(df["tp"], df["fp"], df["tn"], df["fn"])
@@ -33,7 +33,7 @@ def do_one_class(df: pd.DataFrame, class_name: str) -> pd.DataFrame:
     df = df.fillna(0).round(3)
     return df
 
-def compute_raw_stats_per_class(reader: MultiTaskDataset, classes: list[str]) -> pd.DataFrame:
+def compute_raw_stats_per_frame(reader: MultiTaskDataset, classes: list[str]) -> pd.DataFrame:
     res = tr.zeros((len(reader), 8, 4)).long() # (N, 8, 4)
     index = []
     for i in trange(len(reader)):
@@ -65,38 +65,45 @@ def get_args() -> Namespace:
     parser.add_argument("--classes", required=True, nargs="+")
     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")
     args = parser.parse_args()
     if args.class_weights is None:
+        logger.info("No class weights provided, defaulting to equal weights.")
         args.class_weights = [1 / len(args.classes)] * len(args.classes)
     assert (a := len(args.class_weights)) == (b := len(args.classes)), (a, b)
     assert np.fabs(sum(args.class_weights) - 1) < 1e-3, (args.class_weights, sum(args.class_weights))
     assert args.output_path.suffix == ".csv", f"Prediction file must end in .csv, got: '{args.output_path.suffix}'"
     if len(args.scenes) > 0:
         logger.info(f"Scenes: {args.scenes}")
+    if args.output_path.exists() and args.overwrite:
+        os.remove(args.output_path)
     return args
 
 def main(args: Namespace):
-    temp_dir = Path(TemporaryDirectory().name)
-    temp_dir.mkdir(exist_ok=False)
+    # setup to put both directories in the same parent directory for the reader to work.
+    (temp_dir := Path(TemporaryDirectory().name)).mkdir(exist_ok=False)
     os.symlink(args.y_dir, temp_dir / "pred")
     os.symlink(args.gt_dir, temp_dir / "gt")
+    sema_repr = partial(SemanticRepresentation, classes=args.classes, color_map=[[0, 0, 0]] * len(args.classes))
+    reader = MultiTaskDataset(temp_dir, handle_missing_data="drop", task_types={"pred": sema_repr, "gt": sema_repr})
+    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
     if not args.output_path.exists():
-        sema_repr = partial(SemanticRepresentation, classes=args.classes, color_map=[[0, 0, 0]] * len(args.classes))
-        reader = MultiTaskDataset(temp_dir, handle_missing_data="drop", task_types={"pred": sema_repr, "gt": sema_repr})
-        raw_stats = compute_raw_stats_per_class(reader, args.classes)
+        raw_stats = compute_raw_stats_per_frame(reader, args.classes)
         logger.info(f"Stored raw metrics file to: '{args.output_path}'")
         raw_stats.to_csv(args.output_path)
     else:
         logger.info(f"Loading raw metrics from: '{args.output_path}'. Delete this file if you want to recompute.")
         raw_stats = pd.read_csv(args.output_path, index_col=0)
 
-    metrics_per_class = pd.concat([do_one_class(raw_stats, class_name) for class_name in args.classes])
+    # Compute Precision, Recall, F1, IoU for each class and put them together in the same df.
+    metrics_per_class = pd.concat([compute_metrics_by_class(raw_stats, class_name) for class_name in args.classes])
 
+    # Aggregate the class-level metrics to the final metrics based on the class weights (compute globally by stats)
     final_agg = []
-    for scene in args.scenes:
-        final_agg.append(compute_final_per_scene(metrics_per_class, scene, classes=args.classes,
-                                                 class_weights=args.class_weights))
+    for scene in args.scenes: # if we have >1 scene in the test set, aggregate the results for each of them separately
+        final_agg.append(compute_final_per_scene(metrics_per_class, scene, args.classes, args.class_weights))
     final_agg = pd.DataFrame(final_agg, columns=["scene", "iou", "f1"]).set_index("scene")
     if len(args.scenes) > 1:
         final_agg.loc["mean"] = final_agg.mean()