|
""" |
|
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() |
|
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]] |
|
|
|
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()) |
|
|
