|
|
import os |
|
|
import json |
|
|
import torch |
|
|
import numpy as np |
|
|
from tqdm import tqdm |
|
|
from torch import Tensor |
|
|
|
|
|
from typing import List, Dict, Set |
|
|
|
|
|
|
|
|
from evaluation.utils import heatmap_interpolation, video_interpolation, \ |
|
|
convert_ann_to_mask |
|
|
|
|
|
|
|
|
task_dict = { |
|
|
"single": "Single-Sound", |
|
|
"mixed": "Mixed-Sound", |
|
|
"multi": "Multi-Entity", |
|
|
"off-screen": "Off-Screen" |
|
|
} |
|
|
|
|
|
class Evaluator: |
|
|
def __init__(self, data_root: str, model: str, benchmark_path: str, |
|
|
heatmap_thresholds: List=[0.1, 0.15, 0.2], height: int=360, width: int=640, |
|
|
frame_sample_rate: int=8, video: bool=True): |
|
|
|
|
|
|
|
|
self.data_root = data_root |
|
|
self.model = model |
|
|
self.benchmark_path = benchmark_path |
|
|
|
|
|
self.heatmap_thresholds = heatmap_thresholds |
|
|
self.height = height |
|
|
self.width = width |
|
|
self.frame_sample_rate = frame_sample_rate |
|
|
|
|
|
self.video = video |
|
|
|
|
|
self.threshold_results = json.load(open(os.path.join(self.data_root, self.model, f"heatmap_threshold.json"), "r")) |
|
|
self.evaluation_results = {} |
|
|
|
|
|
|
|
|
def compute(self): |
|
|
data_path = os.path.join(self.data_root, self.model, "heatmap") |
|
|
|
|
|
print(f"Evaluating {'Video' if self.video else 'Image'} Heatmap") |
|
|
self.evaluate_video(data_path) if self.video else self.evaluate_image(data_path) |
|
|
|
|
|
self.save_results() |
|
|
|
|
|
|
|
|
def evaluate_image(self, data_path: str): |
|
|
|
|
|
for data_file in tqdm(os.listdir(data_path)): |
|
|
if not data_file.endswith(".npy"): |
|
|
continue |
|
|
|
|
|
frame_num = int(data_file.split("_")[-1].split(".")[0]) |
|
|
video_id = "_".join(data_file.split("_")[:-1]) |
|
|
metadata_path = os.path.join(self.benchmark_path, video_id, f"{frame_num:05d}.json") |
|
|
|
|
|
infer = torch.tensor(np.load(os.path.join(data_path, data_file))).unsqueeze(0).unsqueeze(0) |
|
|
infer = heatmap_interpolation(infer, self.height, self.width) |
|
|
|
|
|
metadata = json.load(open(metadata_path, "r")) |
|
|
self.evaluate(video_id, frame_num, infer, metadata["annotations"]) |
|
|
|
|
|
|
|
|
def evaluate_video(self, data_path: str): |
|
|
|
|
|
for data_file in tqdm(os.listdir(data_path)): |
|
|
if not data_file.endswith(".npy"): |
|
|
continue |
|
|
|
|
|
video_id = data_file.split(".")[0] |
|
|
metadata_path = os.path.join(self.benchmark_path, video_id) |
|
|
|
|
|
infer = torch.tensor(np.load(os.path.join(data_path, data_file))) |
|
|
infer = video_interpolation(infer, self.frame_sample_rate) |
|
|
|
|
|
for frame_data in os.listdir(metadata_path): |
|
|
if frame_data.endswith(".jpg"): |
|
|
continue |
|
|
|
|
|
frame_num = int(frame_data.split(".")[0]) |
|
|
if frame_num >= infer.shape[0]: |
|
|
print(f"Frame number is larger than infer shape: {frame_num} >= {infer.shape[0]}") |
|
|
|
|
|
infer_map = infer[frame_num].unsqueeze(0) |
|
|
infer_map = heatmap_interpolation(infer_map, self.height, self.width) |
|
|
|
|
|
metadata = json.load(open(os.path.join(metadata_path, frame_data), "r")) |
|
|
self.evaluate(video_id, frame_num, infer_map, metadata["annotations"]) |
|
|
|
|
|
|
|
|
|
|
|
def evaluate(self, video_id: str, frame_id: int, infer_map: np.ndarray, annotations: Dict): |
|
|
heatmap_dict = dict() |
|
|
for percent_thr in self.heatmap_thresholds: |
|
|
thr = self.threshold_results[str(percent_thr)] |
|
|
heatmap_dict[percent_thr] = (infer_map > thr) |
|
|
|
|
|
accumulated_mask = np.zeros((self.height, self.width)) |
|
|
off_screen = False |
|
|
|
|
|
pixel_statistics = {thr: {"tp": 0, "fp": 0, "fn": 0} for thr in self.heatmap_thresholds} |
|
|
instance_statistics = {thr: { |
|
|
"total_tp": 0, "total_fn": 0, |
|
|
"single_tp": 0, "single_fn": 0, |
|
|
"mixed_tp": 0, "mixed_fn": 0, |
|
|
"multi_tp": 0, "multi_fn": 0 |
|
|
} for thr in self.heatmap_thresholds} |
|
|
cious = {thr: 0 for thr in self.heatmap_thresholds} |
|
|
|
|
|
|
|
|
for ann in annotations: |
|
|
if ann["task"] == task_dict["off-screen"]: |
|
|
off_screen = True |
|
|
continue |
|
|
mask = convert_ann_to_mask(ann, self.height, self.width) |
|
|
accumulated_mask = np.logical_or(accumulated_mask, mask) |
|
|
|
|
|
for percent_thr in self.heatmap_thresholds: |
|
|
heatmap = heatmap_dict[percent_thr] |
|
|
instance_statistics[percent_thr] = self.evaluate_instance_predictions(mask, heatmap, ann["task"], instance_statistics[percent_thr]) |
|
|
|
|
|
|
|
|
for percent_thr in self.heatmap_thresholds: |
|
|
heatmap = heatmap_dict[percent_thr] |
|
|
pixel_statistics[percent_thr] = self.evaluate_pixel_predictions(accumulated_mask, heatmap, pixel_statistics[percent_thr]) |
|
|
|
|
|
if not off_screen: |
|
|
cious[percent_thr] = self.evaluate_cIoU(accumulated_mask, heatmap) |
|
|
|
|
|
self.evaluation_results[f"{video_id}_{frame_id}"] = { |
|
|
"pixel_statistics": pixel_statistics, |
|
|
"instance_statistics": instance_statistics, |
|
|
"off_screen": off_screen, |
|
|
"cious": cious |
|
|
} |
|
|
|
|
|
|
|
|
def evaluate_instance_predictions(self, mask: np.ndarray, heatmap: np.ndarray, task: str, instance_statistics: Dict): |
|
|
if np.sum(np.logical_and(mask, heatmap)) / np.sum(mask) >= self.instance_threshold: |
|
|
instance_statistics["total_tp"] += 1 |
|
|
if task == task_dict["single"]: |
|
|
instance_statistics["single_tp"] += 1 |
|
|
elif task == task_dict["mixed"]: |
|
|
instance_statistics["mixed_tp"] += 1 |
|
|
elif task == task_dict["multi"]: |
|
|
instance_statistics["multi_tp"] += 1 |
|
|
else: |
|
|
instance_statistics["total_fn"] += 1 |
|
|
if task == task_dict["single"]: |
|
|
instance_statistics["single_fn"] += 1 |
|
|
elif task == task_dict["mixed"]: |
|
|
instance_statistics["mixed_fn"] += 1 |
|
|
elif task == task_dict["multi"]: |
|
|
instance_statistics["multi_fn"] += 1 |
|
|
return instance_statistics |
|
|
|
|
|
|
|
|
def evaluate_pixel_predictions(self, acc_mask: np.ndarray, heatmap: np.ndarray, pixel_statistics: Dict): |
|
|
tp_pixel = int(np.sum(np.logical_and(acc_mask, heatmap))) |
|
|
fp_pixel = int(np.sum(heatmap) - tp_pixel) |
|
|
fn_pixel = int(np.sum(acc_mask) - tp_pixel) |
|
|
|
|
|
pixel_statistics["tp"] = tp_pixel |
|
|
pixel_statistics["fp"] = fp_pixel |
|
|
pixel_statistics["fn"] = fn_pixel |
|
|
return pixel_statistics |
|
|
|
|
|
|
|
|
def evaluate_cIoU(self, acc_mask: np.ndarray, heatmap: np.ndarray): |
|
|
ciou = np.sum(heatmap * acc_mask) / (np.sum(acc_mask) + np.sum(heatmap * (acc_mask == 0))) |
|
|
return ciou |
|
|
|
|
|
|
|
|
def save_results(self): |
|
|
save_folder = os.path.join(self.data_root, self.model) |
|
|
os.makedirs(save_folder, exist_ok=True) |
|
|
|
|
|
save_path = os.path.join(save_folder, f"evaluation_results.json") |
|
|
with open(save_path, "w") as f: |
|
|
json.dump(self.evaluation_results, f) |
|
|
|
|
|
print(f"Results are saved at {save_path}") |
