evaluate semantic segmentation script

.gitignore

@@ -13,4 +13,5 @@ error.txt
 sanity_check.py
 commands.txt
 raw_data/npz_540p_2/
+here.csv
 

README.md

@@ -211,9 +211,65 @@ python scripts/dronescapes_viewer.py data/test_set_annotated_only/ # or any of t
  'semantic_mask2former_swin_mapillary_converted': torch.Size([5, 540, 960]),
  'semantic_segprop8': torch.Size([5, 540, 960])}
 ```
+</details>
+
+## 3. Evaluation for semantic segmentation
+
+We evaluate in the paper on the 3 test scenes (unsees at train) as well as the semi-supervised scenes (seen, but
+different split) against the human annotated frames. The general evaluation script is in
+`scripts/evaluate_semantic_segmentation.py`.
+
+General usage is:
+```
+python scripts/evaluate_semantic_segmentation.py y_dir gt_dir -o results.csv --classes C1 C2 .. Cn
+[--class_weights W1 W2 ... Wn] [--scenes s1 s2 ... sm]
+```
+
+<details>
+<summary> Script explanation </summary>
+The script is a bit convoluted, so let's break it into parts:
+
+- `y_dir` and `gt_dir` Two directories of .npz files in the same format as the dataset (y_dir/1.npz, gt_dir/55.npz etc.)
+- `classes` A list of classes in the order that they appear in the predictions and gt files
+- `class_weights` (optional, but used in paper) How much to weigh each class. In the paper we compute these weights as
+the number of pixels in all the dataset (train/val/semisup/test) for each of the 8 classes resulting in the numbers
+below.
+- `scenes` if the `y_dir` and `gt_dir` contains multiple scenes that you want to evaluate separately, the script allows
+you to pass the prefix of all the scenes. For example, in `data/test_set_annotated_only/semantic_segprop8/` there are
+actually 3 scenes in the npz files and in the paper, we evaluate each scene independently. Even though the script
+outputs one csv file with predictions for each npz file, the scenes are used for proper aggregation at scene level.
+</details>
+
+<details>
+<summary> Reproducing paper results for Mask2Former </summary>
+
+```
+python scripts/evaluate_semantic_segmentation.py \
+  data/test_set_annotated_only/semantic_mask2former_swin_mapillary_converted/ \ # change this with your predictions dir
+  data/test_set_annotated_only/semantic_segprop8/ \
+  -o results.csv \
+  --classes land forest residential road little-objects water sky hill \
+  --class_weights 0.28172092 0.30589653 0.13341699 0.05937348 0.00474491 0.05987466 0.08660721 0.06836531 \
+  --scenes barsana_DJI_0500_0501_combined_sliced_2700_14700 comana_DJI_0881_full norway_210821_DJI_0015_full
+```
+
+Should output:
+```
+scene                                             iou     f1         
+barsana_DJI_0500_0501_combined_sliced_2700_14700  63.367  75.327
+comana_DJI_0881_full                              60.554  73.757
+norway_210821_DJI_0015_full                       37.998  45.928
+overall avg                                       53.973  65.004
+```
+
+Not providing `--scenes` will make an average across all 3 scenes (not average after each metric individually):
 
+```
+          iou      f1
+scene                
+all    60.456  73.261
+```
 </details>
 
 ## TODOs
 - convert camera normals to world normals
-- evaluation script for sseg

scripts/evaluate_semantic_segmentation.py

@@ -0,0 +1,105 @@
+"""
+Evaluation script for semantic segmentation for dronescapes. Outputs F1Score and mIoU for the 8 classes and each frame.
+Usage: ./evaluate_semantic_segmentation.py y_dir gt_dir -o results.csv
+"""
+import sys
+import os
+from loguru import logger
+from pathlib import Path
+from argparse import ArgumentParser, Namespace
+from tempfile import TemporaryDirectory
+from functools import partial
+from torchmetrics.functional.classification import multiclass_stat_scores
+from tqdm import trange
+import torch as tr
+import numpy as np
+import pandas as pd
+
+sys.path.append(Path(__file__).parents[1].__str__())
+from dronescapes_reader import MultiTaskDataset, SemanticRepresentation
+
+def compute_metrics(tp: np.ndarray, fp: np.ndarray, tn: np.ndarray, fn: np.ndarray) -> pd.DataFrame:
+    precision = tp / (tp + fp)
+    recall = tp / (tp + fn)
+    f1 = 2 * precision * recall / (precision + recall)
+    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:
+    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"])
+    df.insert(0, "class_name", class_name)
+    df = df.fillna(0).round(3)
+    return df
+
+def compute_raw_stats_per_class(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)):
+        x = reader[i]
+        y, gt = x[0]["pred"], 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)
+    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
+
+def compute_final_per_scene(res: pd.DataFrame, scene: str, classes: list[str],
+                            class_weights: list[float]) -> tuple[float, float]:
+    df = res.iloc[[x.startswith(scene) for x in res.index]]
+    # aggregate for this class all the individual predictions
+    df_scene = df[["class_name", "tp", "fp", "tn", "fn"]].groupby("class_name") \
+        .apply(lambda x: x.sum(), include_groups=False).loc[classes]
+    df_metrics = compute_metrics(df_scene["tp"], df_scene["fp"], df_scene["tn"], df_scene["fn"])
+    iou_weighted = (df_metrics["iou"] * class_weights).sum()
+    f1_weighted = (df_metrics["f1"] * class_weights).sum()
+    return scene, iou_weighted, f1_weighted
+
+def get_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument("y_dir", type=lambda p: Path(p).absolute())
+    parser.add_argument("gt_dir", type=lambda p: Path(p).absolute())
+    parser.add_argument("--output_path", "-o", type=Path, required=True)
+    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")
+    args = parser.parse_args()
+    if args.class_weights is None:
+        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}")
+    return args
+
+def main(args: Namespace):
+    temp_dir = Path(TemporaryDirectory().name)
+    temp_dir.mkdir(exist_ok=False)
+    os.symlink(args.y_dir, temp_dir / "pred")
+    os.symlink(args.gt_dir, temp_dir / "gt")
+
+    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})
+        df = compute_raw_stats_per_class(reader, args.classes)
+        res = pd.concat([do_one_class(df, class_name) for class_name in args.classes])
+        res.to_csv(args.output_path)
+        logger.info(f"Stored raw metrics file to: '{args.output_path}'")
+    else:
+        logger.info(f"Loading raw metris from: '{args.output_path}'. Delete this file if you want to recompute.")
+        res = pd.read_csv(args.output_path, index_col=0)
+
+    final_agg = []
+    for scene in args.scenes:
+        final_agg.append(compute_final_per_scene(res, scene, classes=args.classes, class_weights=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()
+    final_agg = (final_agg * 100).round(3)
+    print(final_agg)
+
+if __name__ == "__main__":
+    main(get_args())