def _compute_targets(rois, overlaps, labels):
"""Compute bounding-box regression targets for an image."""
# Indices of ground-truth ROIs
bbox_para_num = 5
gt_inds = np.where(overlaps == 1)[0]
if len(gt_inds) == 0:
# Bail if the image has no ground-truth ROIs [cls, dx, dy, dh, dw, da]
return np.zeros((rois.shape[0], bbox_para_num + 1), dtype=np.float32) # D
# Indices of examples for which we try to make predictions
ex_inds = np.where(overlaps >= cfg.TRAIN.BBOX_THRESH)[0]
# Get IoU overlap between each ex ROI and gt ROI
#print "rois[ex_inds, :]", rois[ex_inds, :].shape
#print "rois[gt_inds, :]", rois[gt_inds, :].shape
ex_gt_overlaps = rbbx_overlaps(np.ascontiguousarray(rois[ex_inds, :], dtype=np.float32), np.ascontiguousarray(rois[gt_inds, :], dtype=np.float32),cfg.GPU_ID) # D
# Find which gt ROI each ex ROI has max overlap with:
# this will be the ex ROI's gt target
gt_assignment = ex_gt_overlaps.argmax(axis=1)
gt_rois = rois[gt_inds[gt_assignment], :]
ex_rois = rois[ex_inds, :]
targets = np.zeros((rois.shape[0], bbox_para_num + 1), dtype=np.float32) # D
targets[ex_inds, 0] = labels[ex_inds]
targets[ex_inds, 1:] = rbbox_transform(ex_rois, gt_rois) # D
#print targets[ex_inds, 1:]
# targets: [cls, dx, dy, dh, dw, da]
return targets
def _compute_targets(rois, overlaps, labels):
"""Compute bounding-box regression targets for an image."""
# Indices of ground-truth ROIs
bbox_para_num = 5
gt_inds = np.where(overlaps == 1)[0]
if len(gt_inds) == 0:
# Bail if the image has no ground-truth ROIs [cls, dx, dy, dh, dw, da]
return np.zeros((rois.shape[0], bbox_para_num + 1),
dtype=np.float32) # D
# Indices of examples for which we try to make predictions
ex_inds = np.where(overlaps >= cfg.TRAIN.BBOX_THRESH)[0]
# Get IoU overlap between each ex ROI and gt ROI
#print "rois[ex_inds, :]", rois[ex_inds, :].shape
#print "rois[gt_inds, :]", rois[gt_inds, :].shape
ex_gt_overlaps = rbbx_overlaps(
np.ascontiguousarray(rois[ex_inds, :], dtype=np.float32),
np.ascontiguousarray(rois[gt_inds, :], dtype=np.float32),
cfg.GPU_ID) # D
# Find which gt ROI each ex ROI has max overlap with:
# this will be the ex ROI's gt target
gt_assignment = ex_gt_overlaps.argmax(axis=1)
gt_rois = rois[gt_inds[gt_assignment], :]
ex_rois = rois[ex_inds, :]
targets = np.zeros((rois.shape[0], bbox_para_num + 1),
dtype=np.float32) # D
targets[ex_inds, 0] = labels[ex_inds]
targets[ex_inds, 1:] = rbbox_transform(ex_rois, gt_rois) # D
# print targets[ex_inds, 1:]
# targets: [cls, dx, dy, dh, dw, da]
return targets
def forward(self, bottom, top):
# Algorithm:
#
# for each (H, W) location i
# generate 9 anchor boxes centered on cell i
# apply predicted bbox deltas at cell i to each of the 9 anchors
# filter out-of-image anchors
# measure GT overlap
assert bottom[0].data.shape[0] == 1, \
'Only single item batches are supported'
# map of shape (..., H, W)
height, width = bottom[0].data.shape[-2:]
# GT boxes (x_ctr, y_ctr, height, width, theta, label)
gt_boxes = bottom[1].data
# im_info
im_info = bottom[2].data[0, :]
if DEBUG:
print ''
print 'im_size: ({}, {})'.format(im_info[0], im_info[1])
print 'scale: {}'.format(im_info[2])
print 'height, width: ({}, {})'.format(height, width)
print 'rpn: gt_boxes.shape', gt_boxes.shape
print 'rpn: gt_boxes', gt_boxes
# 1. Generate proposals from bbox deltas and shifted anchors
shift_x = np.arange(0, width) * self._feat_stride
shift_y = np.arange(0, height) * self._feat_stride
shift_x, shift_y = np.meshgrid(shift_x, shift_y)
shifts = np.vstack(
(shift_x.ravel(), shift_y.ravel(), np.zeros(
(3, width * height)))).transpose()
# add A anchors (1, A, 5) to
# cell K shifts (K, 1, 5) to get
# shift anchors (K, A, 5)
# reshape to (K*A, 5) shifted anchors
A = self._num_anchors
K = shifts.shape[0]
all_anchors = (self._anchors.reshape(
(1, A, self.bbox_para_num)) + shifts.reshape(
(1, K, self.bbox_para_num)).transpose((1, 0, 2)))
all_anchors = all_anchors.reshape((K * A, self.bbox_para_num))
total_anchors = int(K * A)
# only keep anchors inside the image
# inds_inside = np.where(
# (all_anchors[:, 0] >= -self._allowed_border) &
# (all_anchors[:, 1] >= -self._allowed_border) &
# (all_anchors[:, 2] < im_info[1] + self._allowed_border) & # width
# (all_anchors[:, 3] < im_info[0] + self._allowed_border) # height
# )[0]
import time
#tic = time.time()
pt1, pt2, pt3, pt4 = condinate_rotate(all_anchors) # coodinate project
inds_inside = np.array(
ind_inside(pt1, pt2, pt3, pt4, im_info[0],
im_info[1])) # inside index
#print time.time()-tic
if DEBUG:
print 'total_anchors', total_anchors
print 'inds_inside', len(inds_inside)
# keep only inside anchors
anchors = all_anchors[inds_inside, :]
if DEBUG:
print 'anchors.shape', anchors.shape
# label: 1 is positive, 0 is negative, -1 is dont care
labels = np.empty((len(inds_inside), ), dtype=np.float32)
labels.fill(-1)
# overlaps between the anchors and the gt boxes
# overlaps (ex, gt)
#print np.array(anchors,dtype=np.float32).shape
#print gt_boxes[:,0:5].astype(np.float32)
#print 'aasdf'
overlaps = rbbx_overlaps(
np.ascontiguousarray(anchors, dtype=np.float32),
np.ascontiguousarray(gt_boxes[:, 0:5], dtype=np.float32),
cfg.GPU_ID)
#print 'sdfwef'
an_gt_diffs = angle_diff(anchors, gt_boxes)
argmax_overlaps = overlaps.argmax(
axis=1) # max overlaps of anchor compared with gts
max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]
max_overlaps_angle_diff = an_gt_diffs[np.arange(len(inds_inside)),
argmax_overlaps] # D
gt_argmax_overlaps = overlaps.argmax(
axis=0) # max overlaps of gt compared with anchors
gt_max_overlaps = overlaps[gt_argmax_overlaps,
np.arange(overlaps.shape[1])]
gt_argmax_overlaps = np.where((overlaps == gt_max_overlaps) & (
an_gt_diffs <= cfg.TRAIN.R_POSITIVE_ANGLE_FILTER))[0]
#mask1 = np.abs(anchors[:, 3] * 1.0 / anchors[:, 2] - 2.0) < 1.5
#mask2 = np.abs(anchors[:, 3] * 1.0 / anchors[:, 2] - 5.0) < 1.5
#mask3 = np.abs(anchors[:, 3] * 1.0 / anchors[:, 2] - 8.0) < 1.5
if not cfg.TRAIN.RPN_CLOBBER_POSITIVES:
# assign bg labels first so that positive labels can clobber them
labels[max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP] = 0
#labels[(max_overlaps < 0.3) & mask1] = 0
#labels[(max_overlaps < 0.27) & mask2] = 0
#labels[(max_overlaps < 0.13) & mask3] = 0
# fg label: for each gt, anchor with highest overlap
labels[gt_argmax_overlaps] = 1
# fg label: above threshold IOU
labels[max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP] = 1 # D
#labels[(max_overlaps >= 0.7) & mask1] = 1
#labels[(max_overlaps >= 0.625) & mask2] = 1
#labels[(max_overlaps >= 0.313) & mask3] = 1
# fg label: above threshold IOU the angle diff abs must be less than 15
if cfg.TRAIN.RPN_CLOBBER_POSITIVES:
# assign bg labels last so that negative labels can clobber positives
labels[(max_overlaps < cfg.TRAIN.RPN_NEGATIVE_OVERLAP) | (
(max_overlaps >= cfg.TRAIN.RPN_POSITIVE_OVERLAP) &
(max_overlaps_angle_diff > cfg.TRAIN.R_NEGATIVE_ANGLE_FILTER)
)] = 0
#labels[((max_overlaps < 0.3) | ((max_overlaps >= 0.7) & (max_overlaps_angle_diff > cfg.TRAIN.R_NEGATIVE_ANGLE_FILTER))) & mask1] = 0
#labels[((max_overlaps < 0.27) | ((max_overlaps >= 0.625) & (max_overlaps_angle_diff > cfg.TRAIN.R_NEGATIVE_ANGLE_FILTER))) & mask2] = 0
#labels[((max_overlaps < 0.13) | ((max_overlaps >= 0.313) & (max_overlaps_angle_diff > cfg.TRAIN.R_NEGATIVE_ANGLE_FILTER))) & mask3] = 0
# subsample positive labels if we have too many
num_fg = int(cfg.TRAIN.RPN_FG_FRACTION * cfg.TRAIN.RPN_BATCHSIZE)
fg_inds = np.where(labels == 1)[0]
if len(fg_inds) > num_fg:
disable_inds = npr.choice(fg_inds,
size=(len(fg_inds) - num_fg),
replace=False)
labels[disable_inds] = -1
# subsample negative labels if we have too many
num_bg = cfg.TRAIN.RPN_BATCHSIZE - np.sum(labels == 1)
bg_inds = np.where(labels == 0)[0]
if len(bg_inds) > num_bg:
disable_inds = npr.choice(bg_inds,
size=(len(bg_inds) - num_bg),
replace=False)
labels[disable_inds] = -1
#print "was %s inds, disabling %s, now %s inds" % (
#len(bg_inds), len(disable_inds), np.sum(labels == 0))
#print 'num_fg',len(fg_inds),'num_bg',len(bg_inds)
bbox_targets = np.zeros((len(inds_inside), self.bbox_para_num),
dtype=np.float32)
bbox_targets = _compute_targets(anchors, gt_boxes[argmax_overlaps, :])
bbox_inside_weights = np.zeros((len(inds_inside), self.bbox_para_num),
dtype=np.float32)
bbox_inside_weights[labels == 1, :] = np.array(
cfg.TRAIN.RPN_RBBOX_INSIDE_WEIGHTS) # D
bbox_outside_weights = np.zeros((len(inds_inside), self.bbox_para_num),
dtype=np.float32)
if cfg.TRAIN.RPN_POSITIVE_WEIGHT < 0:
# uniform weighting of examples (given non-uniform sampling)
num_examples = np.sum(labels >= 0)
positive_weights = np.ones(
(1, self.bbox_para_num)) * 1.0 / num_examples
negative_weights = np.ones(
(1, self.bbox_para_num)) * 1.0 / num_examples
else:
assert ((cfg.TRAIN.RPN_POSITIVE_WEIGHT > 0) &
(cfg.TRAIN.RPN_POSITIVE_WEIGHT < 1))
positive_weights = (cfg.TRAIN.RPN_POSITIVE_WEIGHT /
np.sum(labels == 1))
negative_weights = ((1.0 - cfg.TRAIN.RPN_POSITIVE_WEIGHT) /
np.sum(labels == 0))
bbox_outside_weights[labels == 1, :] = positive_weights
bbox_outside_weights[labels == 0, :] = negative_weights
if DEBUG:
self._sums += bbox_targets[labels == 1, :].sum(axis=0)
self._squared_sums += (bbox_targets[labels == 1, :]**2).sum(axis=0)
self._counts += np.sum(labels == 1)
means = self._sums / self._counts
stds = np.sqrt(self._squared_sums / self._counts - means**2)
print 'means:'
print means
print 'stdevs:'
print stds
# map up to original set of anchors
labels = _unmap(labels, total_anchors, inds_inside, fill=-1)
bbox_targets = _unmap(bbox_targets, total_anchors, inds_inside, fill=0)
bbox_inside_weights = _unmap(bbox_inside_weights,
total_anchors,
inds_inside,
fill=0)
bbox_outside_weights = _unmap(bbox_outside_weights,
total_anchors,
inds_inside,
fill=0)
if DEBUG:
print 'rpn: max max_overlap', np.max(max_overlaps)
print 'rpn: num_positive', np.sum(labels == 1)
print 'rpn: num_negative', np.sum(labels == 0)
self._fg_sum += np.sum(labels == 1)
self._bg_sum += np.sum(labels == 0)
self._count += 1
print 'rpn: num_positive avg', self._fg_sum / self._count
print 'rpn: num_negative avg', self._bg_sum / self._count
# labels
labels = labels.reshape((1, height, width, A)).transpose(0, 3, 1, 2)
labels = labels.reshape((1, 1, A * height, width))
top[0].reshape(*labels.shape)
top[0].data[...] = labels
# bbox_targets
bbox_targets = bbox_targets \
.reshape((1, height, width, A * self.bbox_para_num)).transpose(0, 3, 1, 2)
top[1].reshape(*bbox_targets.shape)
top[1].data[...] = bbox_targets
# bbox_inside_weights
bbox_inside_weights = bbox_inside_weights \
.reshape((1, height, width, A * self.bbox_para_num)).transpose(0, 3, 1, 2)
assert bbox_inside_weights.shape[2] == height
assert bbox_inside_weights.shape[3] == width
top[2].reshape(*bbox_inside_weights.shape)
top[2].data[...] = bbox_inside_weights
# bbox_outside_weights
bbox_outside_weights = bbox_outside_weights \
.reshape((1, height, width, A * self.bbox_para_num)).transpose(0, 3, 1, 2)
assert bbox_outside_weights.shape[2] == height
assert bbox_outside_weights.shape[3] == width
top[3].reshape(*bbox_outside_weights.shape)
top[3].data[...] = bbox_outside_weights
# keep only inside anchors
anchors = all_anchors[inds_inside, :]
print anchors.shape
# label: 1 is positive, 0 is negative, -1 is dont care
labels = np.empty((len(inds_inside), ), dtype=np.float32)
labels.fill(-1)
# overlaps between the anchors and the gt boxes
# overlaps (ex, gt)
######################
# angle filter
######################
overlaps = rbbx_overlaps(anchors, gt_boxes, cfg.GPU_ID)
an_gt_diffs = angle_diff(anchors, gt_boxes)
argmax_overlaps = overlaps.argmax(
axis=1) # max overlaps of anchor compared with gts
max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]
max_overlaps_angle_diff = an_gt_diffs[np.arange(len(inds_inside)),
argmax_overlaps] # D
gt_argmax_overlaps = overlaps.argmax(
axis=0) # max overlaps of gt compared with anchors
gt_max_overlaps = overlaps[gt_argmax_overlaps,
np.arange(overlaps.shape[1])]
gt_argmax_overlaps = np.where((overlaps == gt_max_overlaps)
& (an_gt_diffs <= 15))[0]
def boxlist_iou(boxlist1, boxlist2, GPU_ID=0):
"""Compute the intersection over union of two set of boxes.
The box order must be (xmin, ymin, xmax, ymax).
Arguments:
box1: (BoxList) bounding boxes, sized [N,7].
box2: (BoxList) bounding boxes, sized [M,7].
Returns:
(tensor) iou, sized [N,M].
Reference:
https://github.com/chainer/chainercv/blob/master/chainercv/utils/bbox/bbox_iou.py
"""
eps = 1e-8
if boxlist1.size != boxlist2.size:
raise RuntimeError(
"boxlists should have same image size, got {}, {}".format(boxlist1, boxlist2))
if boxlist1.bbox.size()[0] < 1 or boxlist1.bbox.size()[0] < 1:
raise RuntimeError(
"boxlists should have size larger than 0, got {}, {}".format(boxlist1.bbox.size()[0], boxlist1.bbox.size()[0]))
###########################################################
box1, box2 = boxlist1.bbox, boxlist2.bbox
box1_np = box1.data.cpu().numpy()
box2_np = box2.data.cpu().numpy()
ch_box1 = box1_np.copy()
ch_box11 = ch_box1[:, [0,1,4,3,6]]
ch_box2 = box2_np.copy()
ch_box22 = ch_box2[:, [0,1,4,3,6]]
#ch_box2[:, 2:4] += 16
overlaps = rbbx_overlaps(np.ascontiguousarray(ch_box11, dtype=np.float32),
np.ascontiguousarray(ch_box22, dtype=np.float32), GPU_ID)
#print('ch_box shape:', ch_box1.shape, ch_box2.shape)
#print('ch_box shape:', ch_box1[:, 2:4], ch_box2[:, 2:4], ch_box2[:, 4])
#print('overlaps_shape:', overlaps.shape)
#print('overlaps:', np.unique(overlaps)[:10], np.unique(overlaps)[-10:])
############################################
# Some unknown bug on complex coordinate
overlaps[overlaps > 1.00000001] = 0.0
############################################
###########################################################
'''
lt = torch.max(box1[:, None, :2], box2[:, :2]) # [N,M,2]
rb = torch.min(box1[:, None, 2:], box2[:, 2:]) # [N,M,2]
TO_REMOVE = 1
wh = (rb - lt + TO_REMOVE).clamp(min=0) # [N,M,2]
inter = wh[:, :, 0] * wh[:, :, 1] # [N,M]
iou = inter / (area1[:, None] + area2 - inter)
'''
# print('bbox_shape_monitor:', overlaps.shape, boxlist1.bbox.device, boxlist2.bbox.device)
overlaps_th = torch.tensor(overlaps).to(boxlist1.bbox.device)
return overlaps_th
def _sample_rois(all_rois, gt_boxes, fg_rois_per_image, rois_per_image, num_classes):
"""Generate a random sample of RoIs comprising foreground and background
examples.
"""
_bbox_para_num = 5
# overlaps: (rois x gt_boxes)
overlaps = rbbx_overlaps( # D
np.ascontiguousarray(all_rois[:, 1: _bbox_para_num + 1], dtype=np.float32), # D
np.ascontiguousarray(gt_boxes[:, :_bbox_para_num], dtype=np.float32) ,cfg.GPU_ID) # D
an_gt_diffs = angle_diff(all_rois[:, 1: _bbox_para_num + 1],gt_boxes[:, :_bbox_para_num]) # D
gt_assignment = overlaps.argmax(axis=1)
max_overlaps = overlaps.max(axis=1)
max_overlaps_angle_diff = an_gt_diffs[np.arange(len(gt_assignment)), gt_assignment] # D
labels = gt_boxes[gt_assignment, 5] # D: label is in the last column
# Select foreground RoIs as those with >= FG_THRESH overlap
#################### angle filter
# print np.shape(max_overlaps_angle_diff)
fg_inds = np.where((max_overlaps >= cfg.TRAIN.FG_THRESH) & (max_overlaps_angle_diff <= cfg.TRAIN.R_POSITIVE_ANGLE_FILTER))[0] # D
####################
# print 'anglediff',max_overlaps_angle_diff[fg_inds]
# print gt_boxes
# Guard against the case when an image has fewer than fg_rois_per_image
# foreground RoIs
fg_rois_per_this_image = int(min(fg_rois_per_image, fg_inds.size))
# Sample foreground regions without replacement
if fg_inds.size > 0:
# print(type(fg_inds))
fg_inds = npr.choice(fg_inds, size=fg_rois_per_this_image, replace=False)
# Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI)
####################
bg_inds = np.where(((max_overlaps < cfg.TRAIN.BG_THRESH_HI) &
(max_overlaps >= cfg.TRAIN.BG_THRESH_LO)) | ((max_overlaps>=cfg.TRAIN.FG_THRESH)&(max_overlaps_angle_diff>cfg.TRAIN.R_NEGATIVE_ANGLE_FILTER)))[0]
####################
# print 'proposal fg',len(fg_inds),'bg',len(bg_inds)
# print
# Compute number of background RoIs to take from this image (guarding
# against there being fewer than desired)
bg_rois_per_this_image = rois_per_image - fg_rois_per_this_image
bg_rois_per_this_image = int(min(bg_rois_per_this_image, bg_inds.size))
# Sample background regions without replacement
if bg_inds.size > 0:
bg_inds = npr.choice(bg_inds, size=bg_rois_per_this_image, replace=False)
# The indices that we're selecting (both fg and bg)
keep_inds = np.append(fg_inds, bg_inds)
# Select sampled values from various arrays:
labels = labels[keep_inds]
# Clamp labels for the background RoIs to 0
labels[fg_rois_per_this_image:] = 0
rois = all_rois[keep_inds]
bbox_target_data = _compute_targets(
rois[:, 1:_bbox_para_num + 1], gt_boxes[gt_assignment[keep_inds], :_bbox_para_num], labels) # D
bbox_targets, bbox_inside_weights = \
_get_bbox_regression_labels(bbox_target_data, num_classes)
return labels, rois, bbox_targets, bbox_inside_weights
fg_inds = np.where(max_overlaps >= cfg.TRAIN.FG_THRESH)[0]
# Guard against the case when an image has fewer than fg_rois_per_image
# foreground RoIs
'''
##################
# End no angle filter
##################
##################
# angle filter
##################
# overlaps: (rois x gt_boxes)
overlaps = rbbx_overlaps( # D
all_rois[:, 1: _bbox_para_num + 1],# D
gt_boxes[:, :_bbox_para_num] ,cfg.GPU_ID) # D
an_gt_diffs = angle_diff(all_rois[:, 1: _bbox_para_num + 1],gt_boxes[:, :_bbox_para_num]) # D
gt_assignment = overlaps.argmax(axis=1)
max_overlaps = overlaps.max(axis=1)
print "gt_assignment"
print gt_assignment
max_overlaps_angle_diff = an_gt_diffs[np.arange(len(gt_assignment)), gt_assignment] # D
labels = gt_boxes[gt_assignment, 5] # D: label is in the last column
# Select foreground RoIs as those with >= FG_THRESH overlap
black = np.ones((500, 500, 3), dtype=np.uint8) * 255
black = vis_image([i], black, color=(255, 0, 0))
cv2.imshow('black', black)
k = cv2.waitKey(0) & 0xff
if k == ord('q'):
cv2.destroyAllWindows()
break
if SHOW_ROI:
# label: 1 is positive, 0 is negative, -1 is dont care
labels = np.empty((len(inds_inside), ), dtype=np.float32)
labels.fill(-1)
#overlaps = rbbx_overlaps(np.ascontiguousarray(anchors, dtype=np.float32), np.ascontiguousarray(gt_boxes[:,0:5], dtype=np.float32))
overlaps = rbbx_overlaps(anchors.astype(dtype=np.float32),
gt_boxes[:, 0:5].astype(dtype=np.float32))
an_gt_diffs = angle_diff(anchors, gt_boxes)
argmax_overlaps = overlaps.argmax(
axis=1) # max overlaps of anchor compared with gts
max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps]
gt_argmax_overlaps = overlaps.argmax(
axis=0) # max overlaps of gt compared with anchors
gt_max_overlaps = overlaps[gt_argmax_overlaps,
np.arange(overlaps.shape[1])]
max_overlaps_angle_diff = an_gt_diffs[np.arange(len(inds_inside)),
argmax_overlaps]
gt_argmax_overlaps = np.where((overlaps == gt_max_overlaps) & (
an_gt_diffs <= cfg.TRAIN.R_POSITIVE_ANGLE_FILTER))[0]
