Spaces:
Sleeping
Sleeping
File size: 4,047 Bytes
b34d1d6 |
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 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
import numpy as np
from seg.models.utils import NO_OBJ, INSTANCE_OFFSET_HB
def vpq_eval(element, num_classes=-1, max_ins=INSTANCE_OFFSET_HB, ign_id=NO_OBJ):
assert num_classes != -1
import six
pred_ids, gt_ids = element
offset = 1e7 # 1e7 > 200 * max_ins
assert offset > num_classes * max_ins
num_cat = num_classes + 1
iou_per_class = np.zeros(num_cat, dtype=np.float64)
tp_per_class = np.zeros(num_cat, dtype=np.float64)
fn_per_class = np.zeros(num_cat, dtype=np.float64)
fp_per_class = np.zeros(num_cat, dtype=np.float64)
def _ids_to_counts(id_array):
ids, counts = np.unique(id_array, return_counts=True)
return dict(six.moves.zip(ids, counts))
pred_areas = _ids_to_counts(pred_ids)
gt_areas = _ids_to_counts(gt_ids)
void_id = ign_id * max_ins
ign_ids = {
gt_id for gt_id in six.iterkeys(gt_areas)
if (gt_id // max_ins) == ign_id
}
int_ids = gt_ids.astype(np.uint64) * offset + pred_ids.astype(np.uint64)
int_areas = _ids_to_counts(int_ids)
def prediction_void_overlap(pred_id):
void_int_id = void_id * offset + pred_id
return int_areas.get(void_int_id, 0)
def prediction_ignored_overlap(pred_id):
total_ignored_overlap = 0
for _ign_id in ign_ids:
int_id = _ign_id * offset + pred_id
total_ignored_overlap += int_areas.get(int_id, 0)
return total_ignored_overlap
gt_matched = set()
pred_matched = set()
for int_id, int_area in six.iteritems(int_areas):
gt_id = int(int_id // offset)
gt_cat = int(gt_id // max_ins)
pred_id = int(int_id % offset)
pred_cat = int(pred_id // max_ins)
if gt_cat != pred_cat:
continue
union = (
gt_areas[gt_id] + pred_areas[pred_id] - int_area -
prediction_void_overlap(pred_id)
)
iou = int_area / union
if iou > 0.5:
tp_per_class[gt_cat] += 1
iou_per_class[gt_cat] += iou
gt_matched.add(gt_id)
pred_matched.add(pred_id)
for gt_id in six.iterkeys(gt_areas):
if gt_id in gt_matched:
continue
cat_id = gt_id // max_ins
if cat_id == ign_id:
continue
fn_per_class[cat_id] += 1
for pred_id in six.iterkeys(pred_areas):
if pred_id in pred_matched:
continue
if (prediction_ignored_overlap(pred_id) / pred_areas[pred_id]) > 0.5:
continue
cat = pred_id // max_ins
fp_per_class[cat] += 1
return iou_per_class, tp_per_class, fn_per_class, fp_per_class
def stq(element, num_classes=19, max_ins=10000, ign_id=NO_OBJ, num_things=8, label_divisor=1e4, ins_divisor=1e7):
y_pred, y_true = element
y_true = y_true.astype(np.int64)
y_pred = y_pred.astype(np.int64)
# semantic eval
semantic_label = y_true // max_ins
semantic_prediction = y_pred // max_ins
semantic_label = np.where(semantic_label != ign_id,
semantic_label, num_classes)
semantic_prediction = np.where(semantic_prediction != ign_id,
semantic_prediction, num_classes)
semantic_ids = np.reshape(semantic_label, [-1]) * label_divisor + np.reshape(semantic_prediction, [-1])
# instance eval
instance_label = y_true % max_ins
label_mask = np.less(semantic_label, num_things)
prediction_mask = np.less(semantic_label, num_things)
is_crowd = np.logical_and(instance_label == 0, label_mask)
label_mask = np.logical_and(label_mask, np.logical_not(is_crowd))
prediction_mask = np.logical_and(prediction_mask, np.logical_not(is_crowd))
seq_preds = y_pred[prediction_mask]
seg_labels = y_true[label_mask]
non_crowd_intersection = np.logical_and(label_mask, prediction_mask)
intersection_ids = (y_true[non_crowd_intersection] * ins_divisor + y_pred[non_crowd_intersection])
return semantic_ids, seq_preds, seg_labels, intersection_ids
|