FuSAGNet/evaluate.py at main · seansihohan/FuSAGNet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import numpy as np
from sklearn.metrics import precision_score, recall_score, roc_auc_score

from util.data import *


def get_full_err_scores(test_result, val_result):
    np_val_result = np.array(val_result)
    np_test_result = np.array(test_result)
    all_normals = None
    all_scores = None
    feature_num = np_test_result.shape[2]
    for i in range(feature_num):
        val_re_list = np_val_result[:2, :, i]
        test_re_list = np_test_result[:2, :, i]
        normal_dist = get_err_scores(val_re_list)
        scores = get_err_scores(test_re_list)

        if all_scores is None:
            all_normals = normal_dist
            all_scores = scores
        else:
            all_normals = np.vstack((all_normals, normal_dist))
            all_scores = np.vstack((all_scores, scores))

    return all_scores, all_normals


def get_err_scores(test_res):
    test_predict, test_gt = test_res
    n_err_mid, n_err_iqr = get_err_median_and_iqr(test_predict, test_gt)
    test_delta = np.subtract(
        np.array(test_predict).astype(np.float64), np.array(test_gt).astype(np.float64)
    )
    if len(test_delta.shape) >= 2:
        test_delta = np.max(test_delta, axis=1)

    epsilon = 1e-2
    err_scores = (test_delta - n_err_mid) / (np.abs(n_err_iqr) + epsilon)
    err_scores = np.abs(err_scores)
    smoothed_err_scores = np.zeros(err_scores.shape)
    before_num = 3
    for i in range(before_num, len(err_scores)):
        smoothed_err_scores[i] = np.mean(err_scores[i - before_num : i + 1])

    return smoothed_err_scores


def get_best_performance_data(total_err_scores, gt_labels, topk=1):
    total_features = total_err_scores.shape[0]
    topk_indices = np.argpartition(
        total_err_scores, range(total_features - topk - 1, total_features), axis=0
    )[-topk:]
    total_topk_err_scores = np.sum(
        np.take_along_axis(total_err_scores, topk_indices, axis=0), axis=0
    )
    final_topk_fmeas, thresholds = eval_scores(
        total_topk_err_scores, gt_labels, 400, return_threshold=True
    )

    th_i = final_topk_fmeas.index(max(final_topk_fmeas))
    threshold = thresholds[th_i]
    pred_labels = np.zeros(len(total_topk_err_scores))
    pred_labels[total_topk_err_scores > threshold] = 1
    for i in range(len(pred_labels)):
        pred_labels[i] = int(pred_labels[i])
        gt_labels[i] = int(gt_labels[i])

    pre = precision_score(gt_labels, pred_labels)
    rec = recall_score(gt_labels, pred_labels)
    auc_score = roc_auc_score(gt_labels, total_topk_err_scores)
    return max(final_topk_fmeas), pre, rec, auc_score, threshold