def match_targets_to_proposals(self, proposal, target):
match_quality_matrix = boxlist_iou(target, proposal)
matched_idxs = self.proposal_matcher(match_quality_matrix)
# Fast RCNN only need "labels" field for selecting the targets
target = target.copy_with_fields("labels")
# get the targets corresponding GT for each proposal
# NB: need to clamp the indices because we can have a single
# GT in the image, and matched_idxs can be -2, which goes
# out of bounds
matched_targets = target[matched_idxs.clamp(min=0)]
matched_targets.add_field("matched_idxs", matched_idxs)
return matched_targets
def match_targets_to_anchors(self, anchor, target, copied_fields=[]):
match_quality_matrix = boxlist_iou(target, anchor)
matched_idxs = self.proposal_matcher(match_quality_matrix)
# RPN doesn't need any fields from target
# for creating the labels, so clear them all
target = target.copy_with_fields(copied_fields)
# get the targets corresponding GT for each anchor
# NB: need to clamp the indices because we can have a single
# GT in the image, and matched_idxs can be -2, which goes
# out of bounds
matched_targets = target[matched_idxs.clamp(min=0)]
matched_targets.add_field("matched_idxs", matched_idxs)
return matched_targets
def eval_proposals_vid(pred_boxlists, gt_boxlists, iou_thresh=0.5, limit=300):
assert len(gt_boxlists) == len(
pred_boxlists), "Length of gt and pred lists need to be same."
gt_overlaps = []
num_pos = 0
for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
inds = pred_boxlist.get_field("objectness").sort(descending=True)[1]
pred_boxlist = pred_boxlist[inds]
if len(pred_boxlist) > limit:
pred_boxlist = pred_boxlist[:limit]
num_pos += len(gt_boxlist)
if len(gt_boxlist) == 0:
continue
if len(pred_boxlist) == 0:
continue
overlaps = boxlist_iou(pred_boxlist, gt_boxlist)
_gt_overlaps = torch.zeros(len(gt_boxlist))
for j in range(min(len(pred_boxlist), len(gt_boxlist))):
max_overlaps, argmax_overlaps = overlaps.max(dim=0)
gt_ovr, gt_ind = max_overlaps.max(dim=0)
assert gt_ovr >= 0
box_ind = argmax_overlaps[gt_ind]
_gt_overlaps[j] = overlaps[box_ind, gt_ind]
assert _gt_overlaps[j] == gt_ovr
overlaps[box_ind, :] = -1
overlaps[:, gt_ind] = -1
gt_overlaps.append(_gt_overlaps)
gt_overlaps = torch.cat(gt_overlaps, dim=0)
gt_overlaps, _ = torch.sort(gt_overlaps)
recall = (gt_overlaps >= iou_thresh).float().sum() / float(num_pos)
return {"recall": recall}
def evaluate_box_proposals(predictions,
dataset,
thresholds=None,
area="all",
limit=None):
"""Evaluate detection proposal recall metrics. This function is a much
faster alternative to the official COCO API recall evaluation code. However,
it produces slightly different results.
"""
# Record max overlap value for each gt box
# Return vector of overlap values
areas = {
"all": 0,
"small": 1,
"medium": 2,
"large": 3,
"96-128": 4,
"128-256": 5,
"256-512": 6,
"512-inf": 7,
}
area_ranges = [
[0**2, 1e5**2], # all
[0**2, 32**2], # small
[32**2, 96**2], # medium
[96**2, 1e5**2], # large
[96**2, 128**2], # 96-128
[128**2, 256**2], # 128-256
[256**2, 512**2], # 256-512
[512**2, 1e5**2],
] # 512-inf
assert area in areas, "Unknown area range: {}".format(area)
area_range = area_ranges[areas[area]]
gt_overlaps = []
num_pos = 0
for image_id, prediction in enumerate(predictions):
original_id = dataset.id_to_img_map[image_id]
img_info = dataset.get_img_info(image_id)
image_width = img_info["width"]
image_height = img_info["height"]
prediction = prediction.resize((image_width, image_height))
# sort predictions in descending order
# TODO maybe remove this and make it explicit in the documentation
inds = prediction.get_field("objectness").sort(descending=True)[1]
prediction = prediction[inds]
ann_ids = dataset.coco.getAnnIds(imgIds=original_id)
anno = dataset.coco.loadAnns(ann_ids)
gt_boxes = [obj["bbox"] for obj in anno if obj["iscrowd"] == 0]
gt_boxes = torch.as_tensor(gt_boxes).reshape(
-1, 4) # guard against no boxes
gt_boxes = BoxList(gt_boxes, (image_width, image_height),
mode="xywh").convert("xyxy")
gt_areas = torch.as_tensor(
[obj["area"] for obj in anno if obj["iscrowd"] == 0])
if len(gt_boxes) == 0:
continue
valid_gt_inds = (gt_areas >= area_range[0]) & (gt_areas <=
area_range[1])
gt_boxes = gt_boxes[valid_gt_inds]
num_pos += len(gt_boxes)
if len(gt_boxes) == 0:
continue
if len(prediction) == 0:
continue
if limit is not None and len(prediction) > limit:
prediction = prediction[:limit]
overlaps = boxlist_iou(prediction, gt_boxes)
_gt_overlaps = torch.zeros(len(gt_boxes))
for j in range(min(len(prediction), len(gt_boxes))):
# find which proposal box maximally covers each gt box
# and get the iou amount of coverage for each gt box
max_overlaps, argmax_overlaps = overlaps.max(dim=0)
# find which gt box is 'best' covered (i.e. 'best' = most iou)
gt_ovr, gt_ind = max_overlaps.max(dim=0)
assert gt_ovr >= 0
# find the proposal box that covers the best covered gt box
box_ind = argmax_overlaps[gt_ind]
# record the iou coverage of this gt box
_gt_overlaps[j] = overlaps[box_ind, gt_ind]
assert _gt_overlaps[j] == gt_ovr
# mark the proposal box and the gt box as used
overlaps[box_ind, :] = -1
overlaps[:, gt_ind] = -1
# append recorded iou coverage level
gt_overlaps.append(_gt_overlaps)
gt_overlaps = torch.cat(gt_overlaps, dim=0)
gt_overlaps, _ = torch.sort(gt_overlaps)
if thresholds is None:
step = 0.05
thresholds = torch.arange(0.5, 0.95 + 1e-5, step, dtype=torch.float32)
recalls = torch.zeros_like(thresholds)
# compute recall for each iou threshold
for i, t in enumerate(thresholds):
recalls[i] = (gt_overlaps >= t).float().sum() / float(num_pos)
# ar = 2 * np.trapz(recalls, thresholds)
ar = recalls.mean()
return {
"ar": ar,
"recalls": recalls,
"thresholds": thresholds,
"gt_overlaps": gt_overlaps,
"num_pos": num_pos,
}
def calc_detection_vid_prec_rec(gt_boxlists,
pred_boxlists,
motion_ious,
iou_thresh=0.5,
motion_range=[0., 1.]):
all_motion_iou = np.concatenate(motion_ious, axis=0)
empty_weight = sum([(all_motion_iou[i] >= motion_range[0]) &
(all_motion_iou[i] <= motion_range[1])
for i in range(len(all_motion_iou))]) / float(
len(all_motion_iou))
if empty_weight == 1:
empty_weight = 0
n_pos = defaultdict(int)
score = defaultdict(list)
match = defaultdict(list)
pred_ignore = defaultdict(list)
for gt_boxlist, pred_boxlist, motion_iou in zip(gt_boxlists, pred_boxlists,
motion_ious):
pred_bbox = pred_boxlist.bbox.numpy()
pred_label = pred_boxlist.get_field("labels").numpy()
pred_score = pred_boxlist.get_field("scores").numpy()
gt_bbox = gt_boxlist.bbox.numpy()
gt_label = gt_boxlist.get_field("labels").numpy()
gt_ignore = np.zeros(len(gt_bbox))
for gt_index, gt in enumerate(gt_bbox):
if motion_iou[gt_index] < motion_range[0] or motion_iou[
gt_index] > motion_range[1]:
gt_ignore[gt_index] = 1
else:
gt_ignore[gt_index] = 0
for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
pred_mask_l = pred_label == l
pred_bbox_l = pred_bbox[pred_mask_l]
pred_score_l = pred_score[pred_mask_l]
# sort by score
order = pred_score_l.argsort()[::-1]
pred_bbox_l = pred_bbox_l[order]
pred_score_l = pred_score_l[order]
gt_mask_l = gt_label == l
gt_bbox_l = gt_bbox[gt_mask_l]
gt_ignore_l = gt_ignore[gt_mask_l]
n_pos[l] += gt_bbox_l.shape[0] - sum(gt_ignore_l)
score[l].extend(pred_score_l)
if len(pred_bbox_l) == 0:
continue
if len(gt_bbox_l) == 0:
match[l].extend((0, ) * pred_bbox_l.shape[0])
pred_ignore[l].extend((empty_weight, ) * pred_bbox_l.shape[0])
continue
# VID evaluation follows integer typed bounding boxes.
pred_bbox_l = pred_bbox_l.copy()
pred_bbox_l[:, 2:] += 1
gt_bbox_l = gt_bbox_l.copy()
gt_bbox_l[:, 2:] += 1
iou = boxlist_iou(
BoxList(pred_bbox_l, gt_boxlist.size),
BoxList(gt_bbox_l, gt_boxlist.size),
).numpy()
num_obj, num_gt_obj = iou.shape
selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
for j in range(0, num_obj):
iou_match = iou_thresh
iou_match_ig = -1
iou_match_nig = -1
arg_match = -1
for k in range(0, num_gt_obj):
if (gt_ignore_l[k] == 1) & (iou[j, k] > iou_match_ig):
iou_match_ig = iou[j, k]
if (gt_ignore_l[k] == 0) & (iou[j, k] > iou_match_nig):
iou_match_nig = iou[j, k]
if selec[k] or iou[j, k] < iou_match:
continue
if iou[j, k] == iou_match:
if arg_match < 0 or gt_ignore_l[arg_match]:
arg_match = k
else:
arg_match = k
iou_match = iou[j, k]
if arg_match >= 0:
match[l].append(1)
pred_ignore[l].append(gt_ignore_l[arg_match])
selec[arg_match] = True
else:
if iou_match_nig > iou_match_ig:
pred_ignore[l].append(0)
elif iou_match_ig > iou_match_nig:
pred_ignore[l].append(1)
else:
pred_ignore[l].append(
sum(gt_ignore_l) / float(num_gt_obj))
match[l].append(0)
# pred_ignore[l].append(0)
n_fg_class = max(n_pos.keys()) + 1
print(n_pos)
prec = [None] * n_fg_class
rec = [None] * n_fg_class
for l in n_pos.keys():
score_l = np.array(score[l])
match_l = np.array(match[l], dtype=np.int8)
pred_ignore_l = np.array(pred_ignore[l])
order = score_l.argsort()[::-1]
match_l = match_l[order]
pred_ignore_l = pred_ignore_l[order]
tps = np.logical_and(match_l == 1, np.logical_not(pred_ignore_l == 1))
fps = np.logical_and(match_l == 0, np.logical_not(pred_ignore_l == 1))
pred_ignore_l[pred_ignore_l == 0] = 1
fps = fps * pred_ignore_l
tp = np.cumsum(tps)
fp = np.cumsum(fps)
# If an element of fp + tp is 0,
# the corresponding element of prec[l] is nan.
prec[l] = tp / (fp + tp + np.spacing(1))
# If n_pos[l] is 0, rec[l] is None.
if n_pos[l] > 0:
rec[l] = tp / n_pos[l]
return prec, rec
def calc_detection_voc_prec_rec(gt_boxlists, pred_boxlists, iou_thresh=0.5):
"""Calculate precision and recall based on evaluation code of PASCAL VOC.
This function calculates precision and recall of
predicted bounding boxes obtained from a dataset which has :math:`N`
images.
The code is based on the evaluation code used in PASCAL VOC Challenge.
"""
n_pos = defaultdict(int)
score = defaultdict(list)
match = defaultdict(list)
for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
pred_bbox = pred_boxlist.bbox.numpy()
pred_label = pred_boxlist.get_field("labels").numpy()
pred_score = pred_boxlist.get_field("scores").numpy()
gt_bbox = gt_boxlist.bbox.numpy()
gt_label = gt_boxlist.get_field("labels").numpy()
gt_difficult = gt_boxlist.get_field("difficult").numpy()
for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
pred_mask_l = pred_label == l
pred_bbox_l = pred_bbox[pred_mask_l]
pred_score_l = pred_score[pred_mask_l]
# sort by score
order = pred_score_l.argsort()[::-1]
pred_bbox_l = pred_bbox_l[order]
pred_score_l = pred_score_l[order]
gt_mask_l = gt_label == l
gt_bbox_l = gt_bbox[gt_mask_l]
gt_difficult_l = gt_difficult[gt_mask_l]
n_pos[l] += np.logical_not(gt_difficult_l).sum()
score[l].extend(pred_score_l)
if len(pred_bbox_l) == 0:
continue
if len(gt_bbox_l) == 0:
match[l].extend((0,) * pred_bbox_l.shape[0])
continue
# VOC evaluation follows integer typed bounding boxes.
pred_bbox_l = pred_bbox_l.copy()
pred_bbox_l[:, 2:] += 1
gt_bbox_l = gt_bbox_l.copy()
gt_bbox_l[:, 2:] += 1
iou = boxlist_iou(
BoxList(pred_bbox_l, gt_boxlist.size),
BoxList(gt_bbox_l, gt_boxlist.size),
).numpy()
gt_index = iou.argmax(axis=1)
# set -1 if there is no matching ground truth
gt_index[iou.max(axis=1) < iou_thresh] = -1
del iou
selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
for gt_idx in gt_index:
if gt_idx >= 0:
if gt_difficult_l[gt_idx]:
match[l].append(-1)
else:
if not selec[gt_idx]:
match[l].append(1)
else:
match[l].append(0)
selec[gt_idx] = True
else:
match[l].append(0)
n_fg_class = max(n_pos.keys()) + 1
prec = [None] * n_fg_class
rec = [None] * n_fg_class
for l in n_pos.keys():
score_l = np.array(score[l])
match_l = np.array(match[l], dtype=np.int8)
order = score_l.argsort()[::-1]
match_l = match_l[order]
tp = np.cumsum(match_l == 1)
fp = np.cumsum(match_l == 0)
# If an element of fp + tp is 0,
# the corresponding element of prec[l] is nan.
prec[l] = tp / (fp + tp)
# If n_pos[l] is 0, rec[l] is None.
if n_pos[l] > 0:
rec[l] = tp / n_pos[l]
return prec, rec
def calc_detection_vid_prec_rec(gt_boxlists, pred_boxlists, iou_thresh=0.5):
"""Calculate precision and recall based on evaluation code of VID.
This function calculates precision and recall of
predicted bounding boxes obtained from a dataset which has :math:`N`
images.
"""
n_pos = defaultdict(int)
score = defaultdict(list)
match = defaultdict(list)
for gt_boxlist, pred_boxlist in zip(gt_boxlists, pred_boxlists):
pred_bbox = pred_boxlist.bbox.numpy()
pred_label = pred_boxlist.get_field("labels").numpy()
pred_score = pred_boxlist.get_field("scores").numpy()
gt_bbox = gt_boxlist.bbox.numpy()
gt_label = gt_boxlist.get_field("labels").numpy()
for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):
pred_mask_l = pred_label == l
pred_bbox_l = pred_bbox[pred_mask_l]
pred_score_l = pred_score[pred_mask_l]
# index = pred_score_l >= 0.05
#
# pred_bbox_l = pred_bbox_l[index, :]
# pred_score_l = pred_score_l[index]
# sort by score
order = pred_score_l.argsort()[::-1]
pred_bbox_l = pred_bbox_l[order]
pred_score_l = pred_score_l[order]
gt_mask_l = gt_label == l
gt_bbox_l = gt_bbox[gt_mask_l]
n_pos[l] += gt_bbox_l.shape[0]
score[l].extend(pred_score_l)
if len(pred_bbox_l) == 0:
continue
if len(gt_bbox_l) == 0:
match[l].extend((0, ) * pred_bbox_l.shape[0])
continue
# VID evaluation follows integer typed bounding boxes.
pred_bbox_l = pred_bbox_l.copy()
pred_bbox_l[:, 2:] += 1
gt_bbox_l = gt_bbox_l.copy()
gt_bbox_l[:, 2:] += 1
iou = boxlist_iou(
BoxList(pred_bbox_l, gt_boxlist.size),
BoxList(gt_bbox_l, gt_boxlist.size),
).numpy()
num_obj, num_gt_obj = iou.shape
selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
for j in range(0, num_obj):
iou_match = -1
arg_match = -1
for k in range(0, num_gt_obj):
if selec[k]:
continue
if iou[j, k] >= iou_thresh and iou[j, k] > iou_match:
iou_match = iou[j, k]
arg_match = k
if arg_match >= 0:
match[l].append(1)
selec[arg_match] = True
else:
match[l].append(0)
# gt_index = iou.argmax(axis=1)
# # set -1 if there is no matching ground truth
# gt_index[iou.max(axis=1) < iou_thresh] = -1
# del iou
#
# selec = np.zeros(gt_bbox_l.shape[0], dtype=bool)
# for gt_idx in gt_index:
# if gt_idx >= 0:
# if not selec[gt_idx]:
# match[l].append(1)
# else:
# match[l].append(0)
# selec[gt_idx] = True
# else:
# match[l].append(0)
n_fg_class = max(n_pos.keys()) + 1
print(n_pos)
prec = [None] * n_fg_class
rec = [None] * n_fg_class
for l in n_pos.keys():
score_l = np.array(score[l])
match_l = np.array(match[l], dtype=np.int8)
order = score_l.argsort()[::-1]
match_l = match_l[order]
tp = np.cumsum(match_l == 1)
fp = np.cumsum(match_l == 0)
# If an element of fp + tp is 0,
# the corresponding element of prec[l] is nan.
prec[l] = tp / (fp + tp)
# If n_pos[l] is 0, rec[l] is None.
if n_pos[l] > 0:
rec[l] = tp / n_pos[l]
return prec, rec