bench.py

from multiprocessing.pool import Pool, ThreadPool
from os import path, listdir, mkdir
from pathlib import Path
from tqdm import tqdm
from glob import glob
import numpy as np
import subprocess
import argparse
import warnings
import json
import cv2

cv2.setNumThreads(0)
eps = np.finfo(np.float32).eps
warnings.filterwarnings("error")

###metrics###

def nss(s_map, gt):
    s_map_norm = (s_map - np.mean(s_map))/(np.std(s_map) + 1e-7)
    temp = s_map_norm[gt[:, 0], gt[:, 1]]
    return np.mean(temp)


def similarity(s_map, gt):
    s_map = s_map / (np.sum(s_map) + 1e-7)
    gt = gt / (np.sum(gt) + 1e-7)
    return np.sum(np.minimum(s_map, gt))


def cc(s_map, gt):
    a = (s_map - np.mean(s_map))/(np.std(s_map) + 1e-7)
    b = (gt - np.mean(gt))/(np.std(gt) + 1e-7)
    r = (a*b).sum() / np.sqrt((a*a).sum() * (b*b).sum() + 1e-7)
    return r


def auc_judd(S, F):
    
    Sth = S[F[:, 0], F[:, 1]]
    Nfixations = len(Sth)
    Uniqe_fixations = np.unique(F, axis=1).shape[-1]
    Possible_fixations = np.prod(S.shape) + (Nfixations - Uniqe_fixations)

    allthreshes = np.sort(Sth)[::-1]
    tp = np.zeros(Nfixations + 2)
    fp = np.zeros(Nfixations + 2)
    tp[0] = fp[0] = 0
    tp[-1] = fp[-1] = 1

    # Vectorized computation of aboveth
    aboveth = np.sum(S >= allthreshes[:, np.newaxis, np.newaxis], axis=(1, 2))

    arange = np.arange(1, Nfixations + 1)
    fp[1:-1] = (aboveth - arange) / (Possible_fixations - Nfixations)
    tp[1:-1] = arange / Nfixations

    # Trapezoidal integration to compute AUC-Judd
    return np.trapz(tp, fp)



def kldiv(s_map, gt):
    s_map = s_map / (np.sum(s_map) * 1.0)
    gt = gt / (np.sum(gt) * 1.0)
    eps = 2.2204e-16
    res = np.sum(gt * np.log(eps + gt / (s_map + eps)))
    return res


######

def xrgb2gray(img):
    assert len(img.shape) in (2, 3)
    return img.mean(axis=2) if len(img.shape) == 3 else img

# Returns SM in [0; 1] range
def read_sm(path):
    img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    img = xrgb2gray(img)
    img = (img - img.min()) / (img.max() - img.min() + eps)
    return img

def calculate_frame_metrics(frame):
    gt_fix = np.array(frame['gt_fixations'])
    gt_120_sm = read_sm(frame['gt_saliency_path'])
    pred_sm = cv2.resize(read_sm(frame['predictions_path']), (gt_120_sm.shape[1], gt_120_sm.shape[0]))

    return {
        'sim_score': similarity(pred_sm, gt_120_sm),
        'nss_score': nss(pred_sm, gt_fix),
        'cc_score': cc(pred_sm, gt_120_sm),
        'auc_judd_score': auc_judd(pred_sm, gt_fix),
    }


def calculate_metrics(video_name, temp_predictions_path, temp_gt_saliency_path, temp_gt_fixations_path, num_workers=4):
    predictions_path = glob(temp_predictions_path)[0]
    gt_saliency_path = glob(temp_gt_saliency_path)[0]
    with open(temp_gt_fixations_path) as f:
        gt_fixations = json.load(f)

    scores = []
    assert_func = lambda path: set([int(x.split('.')[0]) for x in listdir(path)])
    assert assert_func(gt_saliency_path) == assert_func(predictions_path)

    frames = [
        {
            'gt_fixations': gt_fix,
            'gt_saliency_path': gt_sal,
            'predictions_path': pred,
        } for gt_fix, gt_sal, pred in zip(
            gt_fixations,
            [path.join(gt_saliency_path, x) for x in sorted(listdir(gt_saliency_path))],
            [path.join(predictions_path, x) for x in sorted(listdir(predictions_path))]
    )]
    with Pool(num_workers) as pool:
        scores = pool.map(calculate_frame_metrics, frames)

    conv_scores = {metric: [x[metric] for x in scores] for metric in scores[0].keys()}

    return {
        'video_name' : video_name,
        'cc' : np.mean(conv_scores['cc_score']),
        'sim' : np.mean(conv_scores['sim_score']),
        'nss' : np.mean(conv_scores['nss_score']),
        'auc_judd' : np.mean(conv_scores['auc_judd_score']),
    }


def calculate_all_videos(video_names, model_extracted_frames, gt_extracted_frames, gt_fixations_path, num_workers=4):
    
    detail_result = []
    for video_name in tqdm(video_names):
        if len([x for x in detail_result if x['video_name'] == video_name]) > 0:
            continue
        short_video_name = Path(video_name).name
        model_output = str(Path(model_extracted_frames) / f'{short_video_name}')
        gt_gaussians = str(Path(gt_extracted_frames) / f'{short_video_name}')
        gt_fixations = Path(gt_fixations_path) / short_video_name / 'fixations.json'
        cur_result = calculate_metrics(video_name, model_output, gt_gaussians, gt_fixations, num_workers)
        detail_result += [cur_result]
        np.save("tmp2.npy", detail_result)

    return detail_result


def make_bench(model_extracted_frames, gt_extracted_frames, gt_fixations_path, split_json='TrainTestSplit.json', results_json='results.json', mode='public_test', num_workers=4):

    print(num_workers, 'worker(s)')
    print(f'Testing {model_extracted_frames}')

    sm_listdir = listdir(model_extracted_frames)
    gt_listdir = listdir(gt_extracted_frames)

    if len(sm_listdir) < len(gt_listdir):
        msg = f'There are results for only a few videos ({len(sm_listdir)}/{len(gt_listdir)})!'
        raise ValueError(msg)

    video_names = sorted(sm_listdir)
    with open(split_json) as f:
        splits = set(json.load(f)[mode])

    video_names = [name for name in video_names if name in splits]

    detail_result = calculate_all_videos(video_names, model_extracted_frames, gt_extracted_frames, gt_fixations_path, num_workers)
    detail_result = sorted(detail_result, key=lambda res: res['video_name'])

    result = {'cc' : [], 'sim' : [], 'nss' : [], 'auc_judd' : []}
    for i in result:
        for j in detail_result:
            result[i].append(j[i])

    with open(results_json, 'w') as f:
        json.dump(result, f)

    model_res = {'Model': [model_extracted_frames], 'Mode': [mode]}
    [model_res.update({key: [np.mean(result[key])]}) for key in result.keys()]
    
    print(model_res)



def extract_frames(input_dir, output_dir, split_json='TrainTestSplit.json', mode='public_test', num_workers=4):

    def poolfunc(x):
        if x.stem not in splits[mode]:
            return
        dst_vid = dst / x.stem
        if dst_vid.exists():
            pbar.update(1)
            return
        dst_vid.mkdir()
        subprocess.check_call(f'ffmpeg -v error -i {x} {dst_vid}/%03d.png'.split())
        pbar.update(1)

    with open(split_json) as f:
        splits = json.load(f)

    root = Path(input_dir)
    dst = Path(output_dir)
    dst.mkdir(exist_ok=True)
    videos = list(root.iterdir())
    pbar = tqdm(total=len(splits[mode]))
    with ThreadPool(num_workers) as p:
        p.map(poolfunc, videos)



if __name__ == '__main__':

    parser = argparse.ArgumentParser()
    parser.add_argument('--model_video_predictions', default='./SampleSubmission-CenterPrior',
                                help='Folder with predicted saliency videos')
    parser.add_argument('--model_extracted_frames', default='./SampleSubmission-CenterPrior-Frames', 
                                help='Folder to store prediction frames (should not exist at launch time), requires ~170 GB of free space')

    parser.add_argument('--gt_video_predictions', default='./SaliencyTest/Test',
                                help='Folder from dataset page with gt saliency videos')
    parser.add_argument('--gt_extracted_frames', default='./SaliencyTest-Frames', 
                                help='Folder to store ground-truth frames (should not exist at launch time), requires ~170 GB of free space')
    parser.add_argument('--gt_fixations_path', default='./FixationsTest/Test',
                                help='Folder from dataset page with gt saliency fixations')
    parser.add_argument('--split_json', default='./TrainTestSplit.json',
                                help='Json from dataset page with names splitting')

    parser.add_argument('--results_json', default='./results.json')
    parser.add_argument('--mode', default='public_test', help='public_test/private_test')
    parser.add_argument('--num_workers', type=int, default=4)

    args = parser.parse_args()

    if not path.exists(args.model_extracted_frames):
        print("Extracting", args.model_video_predictions, 'to', args.model_extracted_frames)
        extract_frames(args.model_video_predictions, args.model_extracted_frames, args.split_json, args.mode, args.num_workers)
    if not path.exists(args.gt_extracted_frames):
        print("Extracting", args.gt_video_predictions, 'to', args.gt_extracted_frames)
        extract_frames(args.gt_video_predictions, args.gt_extracted_frames, args.split_json, args.mode, args.num_workers)

    make_bench(args.model_extracted_frames, args.gt_extracted_frames, args.gt_fixations_path, args.split_json, args.results_json, args.mode, args.num_workers)