Add zipped video and metadata files

code/evaluation.py

@@ -0,0 +1,47 @@
+import os
+import argparse
+
+from evaluation import Evaluator, HeatmapAnalyzer
+from evaluation.utils import list_of_strings
+
+def get_arguments():
+    parser = argparse.ArgumentParser()
+
+    # target data
+    parser.add_argument('--heatmap_root', type=str, default='your_heatmap_root', help='Root directory path of heatmap data')
+    parser.add_argument('--model', type=str, default='model_name', help='Model name to load from heatmap root directory')
+    parser.add_argument('--benchmark_path', type=str, default='AVATAR/metadata', help='Benchmark path for metadata')
+    
+    # for interpolation
+    parser.add_argument('--height', type=int, default=360, help='height of benchmark data')
+    parser.add_argument('--width', type=int, default=640, help='width of benchmark data')
+    
+    parser.add_argument('--heatmap_thresholds', type=list_of_strings, default='0.05,0.1,0.15,0.2', help='heatmap thresholds')
+    parser.add_argument('--frame_sample_rate', type=int, default=8, help='Interval for sampling frames during interpolation')
+    
+    parser.add_argument('--video', type=bool, default=True, help='video or image')
+
+    return parser.parse_args()
+
+
+def main(args):
+    heatmap_analyzer = HeatmapAnalyzer(
+        args.heatmap_root, args.model, args.heatmap_thresholds, args.benchmark_path,
+        args.height, args.width, args.frame_sample_rate, args.video
+    )
+
+    evaluator = Evaluator(
+        args.heatmap_root, args.model, args.benchmark_path, 
+        heatmap_thresholds=args.heatmap_thresholds, height=args.height, width=args.width, 
+        frame_sample_rate=args.frame_sample_rate, video=args.video
+    )
+
+    os.makedirs(os.path.join(args.heatmap_root, args.model), exist_ok=True)
+
+    heatmap_analyzer.compute()
+    evaluator.compute()
+
+
+if __name__ == '__main__':
+    args = get_arguments()
+    main(args)

code/evaluation/__init__.py

@@ -0,0 +1,7 @@
+from evaluation.evaluator import Evaluator
+from evaluation.heatmap_analyzer import HeatmapAnalyzer
+
+__all__ = [
+    "Evaluator",
+    "HeatmapAnalyzer",
+]

code/evaluation/evaluator.py

@@ -0,0 +1,187 @@
+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):
+        
+        # data path
+        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 = {} # {frame_id: {heatmap_percent: {metric: value}, ...}}
+
+
+    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() # {percent: map}
+        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}
+        
+        # Instance-Level Evaluation
+        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])
+        
+        # Pixel-Level Evaluation
+        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}")

code/evaluation/heatmap_analyzer.py

@@ -0,0 +1,89 @@
+import os
+import json
+import torch
+import numpy as np
+from tqdm import tqdm
+
+from typing import List
+
+from utils import heatmap_interpolation, video_interpolation
+
+
+class HeatmapAnalyzer:
+    def __init__(self, data_root: str, model: str, heatmap_thresholds: List, benchmark_path: str, \
+            height: int=360, width: int=640, frame_sample_rate: int=8, video: bool=True):
+        
+        # data path
+        self.data_root = data_root
+        self.model = model
+        self.benchmark_path = benchmark_path
+        
+        self.height = height
+        self.width = width
+        self.frame_sample_rate = frame_sample_rate
+        self.heatmap_thresholds = heatmap_thresholds
+
+        self.video = video
+
+
+    def compute(self):
+        data_path = os.path.join(self.data_root, self.model, "heatmap")
+        save_path = os.path.join(self.data_root, self.model, "heatmap_threshold.json")
+        
+        print(f"Calculating {'Video' if self.video else 'Image'} Heatmap")
+        total_val = self.compute_for_video(data_path) if self.video else self.compute_for_image(data_path)
+
+        heatmap_threshold = self.cal_heatmap_threshold(np.array(total_val))
+        self.save_heatmap_threshold(save_path, heatmap_threshold)
+
+
+    def compute_for_image(self, data_path):
+        total_val = []
+
+        for data_file in tqdm(os.listdir(data_path)):
+            if not data_file.endswith(".npy"):
+                continue
+            
+            infer = torch.tensor(np.load(os.path.join(data_path, data_file))).unsqueeze(0).unsqueeze(0)
+            infer = heatmap_interpolation(infer, self.height, self.width)
+            total_val.append(infer)
+        
+        return total_val
+
+    
+    def compute_for_video(self, data_path):
+        total_val = []
+
+        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].split("_")[-1])
+                infer_map = infer[frame_num].unsqueeze(0)
+                infer_map = heatmap_interpolation(infer_map, self.height, self.width)
+                total_val.append(infer_map)
+
+        return total_val
+
+    
+    def cal_heatmap_threshold(self, total_heatmap: np.ndarray):
+        sorted_data = np.sort(total_heatmap, axis=None)[::-1]
+        result = dict()
+        for thr in self.heatmap_thresholds:
+            result[thr] = float(sorted_data[int(len(sorted_data) * thr)])
+        return result
+    
+
+    def save_heatmap_threshold(self, save_path: str, result: dict):
+        with open(save_path, 'w') as f:
+            json.dump(result, f, indent=4)

code/evaluation/utils.py

@@ -0,0 +1,47 @@
+import cv2
+import torch
+import numpy as np
+from torch import Tensor
+import torch.nn.functional as F
+
+from imantics import Mask
+from typing import List
+
+
+
+def convert_ann_to_mask(ann: List, height: int, width: int):
+    mask = np.zeros((height, width), dtype=np.uint8)
+    poly = ann["segmentation"]
+    
+    for p in poly:
+        p = np.array(p).reshape(-1, 2).astype(int)
+        cv2.fillPoly(mask, [p], 1)
+    return mask
+
+
+def convert_mask_to_ann(mask: np.ndarray):
+    polygons = Mask(mask).polygons()
+    return polygons.segmentation
+
+
+# Define a custom argument type for a list of strings
+def list_of_strings(arg):
+    return [float(thr) for thr in arg.split(',')]
+
+
+def video_interpolation(video: Tensor, frame_sample_rate: int):
+    expanded_heatmap = []
+    for i in range(len(video) - 1):
+        pre_heatmap, post_heatmap = video[i], video[i + 1]
+        
+        for j in range(frame_sample_rate):
+            interpolated_heatmap = ((frame_sample_rate - j) / frame_sample_rate) * pre_heatmap \
+                + (j / frame_sample_rate) * post_heatmap
+            expanded_heatmap.append(interpolated_heatmap)
+    expanded_heatmap.append(video[-1])
+    return torch.stack(expanded_heatmap).unsqueeze(1)
+
+
+
+def heatmap_interpolation(heatmap: Tensor, height: int, width: int):
+    return F.interpolate(heatmap, size=(height, width), mode='bilinear', align_corners=False).squeeze().numpy()

code/print_example.py

@@ -0,0 +1,93 @@
+import os, json
+import numpy as np
+from sklearn import metrics
+from tqdm import tqdm
+
+# --- Utilities ---
+def final_auc(data):
+    thresholds = [0.05 * i for i in range(21)]
+    cious = [np.mean(np.array(data) >= t) for t in thresholds]
+    return metrics.auc(thresholds, cious)
+
+def final_ciou(data):
+    return np.mean(data) if data else 0.0
+
+def parse_task_flags(annotations):
+    flags = {"Single-Sound": False, "Mixed-Sound": False, "Multi-Entity": False, "Off-Screen": False}
+    for ann in annotations:
+        task = ann["task"]
+        if task not in flags:
+            raise ValueError(f"Unknown task: {task}")
+        flags[task] = True
+    return flags
+
+
+# --- Parameters ---
+heatmap_threshold = 0.1
+width, height = 640, 360
+folder = "AVATAR"
+file = "evaluation_results.json"
+model = "your_model_name"  # Replace with your model name
+data_path = os.path.join("your_heatmap_root", model, folder, file)
+benchmark_path = "AVATAR/metadata"  # Replace with your benchmark path
+
+
+
+# --- Initialization ---
+ciou_by_task = {
+    "Total": [],
+    "Single-Sound": [],
+    "Mixed-Sound": [],
+    "Multi-Entity": []
+}
+off_screen_tn, off_screen_fp = 0, 0
+
+
+# --- Load Evaluation Results ---
+with open(data_path, 'r') as f:
+    data = json.load(f)
+
+
+# --- Process Each Frame ---
+for frame_key, result in tqdm(data.items()):
+    video_id = "_".join(frame_key.split("_")[:-1])
+    frame_num = int(frame_key.split("_")[-1])
+    metadata_file = os.path.join(benchmark_path, video_id, f"{frame_num:05d}.json")
+
+    with open(metadata_file, 'r') as f:
+        annotations = json.load(f)["annotations"]
+
+    flags = parse_task_flags(annotations)
+    ciou = result["cious"][str(heatmap_threshold)]
+    ciou_by_task["Total"].append(ciou)
+
+    for task in ["Single-Sound", "Mixed-Sound", "Multi-Entity"]:
+        if flags[task]:
+            ciou_by_task[task].append(ciou)
+
+    if flags["Off-Screen"]:
+        stats = result["pixel_statistics"][str(heatmap_threshold)]
+        off_screen_tn += width * height - stats["fp"]
+        off_screen_fp += stats["fp"]
+
+
+# --- Compute Final Metrics ---
+summary = {}
+for task, values in ciou_by_task.items():
+    summary[task] = {
+        "ciou": final_ciou(values),
+        "auc": final_auc(values)
+    }
+
+
+# --- Print Results ---
+print(f"model: {model}, file: {file}\n")
+
+for task in ["Total", "Single-Sound", "Mixed-Sound", "Multi-Entity"]:
+    print(f"--- {task.lower()} ---")
+    print(f"final ciou: {summary[task]['ciou']:.4f}")
+    print(f"final auc : {summary[task]['auc']:.4f}\n")
+
+print("--- off-screen pixel statistics ---")
+print("tn pixels \t fp pixels")
+print(f"{off_screen_tn} \t {off_screen_fp}")

video.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ce5be7fa6dda85889750f6c7cc2fad807527063e7d7090c664170a66b078a68
+size 3785157586