def parse_det_offset(Y, C, score=0.1, down=4):
seman = Y[0][0, :, :, 0]
height = Y[1][0, :, :, 0]
offset_y = Y[2][0, :, :, 0]
offset_x = Y[2][0, :, :, 1]
y_c, x_c = np.where(seman > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * down
w = 0.41 * h
o_y = offset_y[y_c[i], x_c[i]]
o_x = offset_x[y_c[i], x_c[i]]
s = seman[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + o_x + 0.5) * down - w / 2), max(
0, (y_c[i] + o_y + 0.5) * down - h / 2)
boxs.append([
x1, y1,
min(x1 + w, C.size_test[1]),
min(y1 + h, C.size_test[0]), s
])
boxs = np.asarray(boxs, dtype=np.float32)
keep = nms(boxs, 0.5, usegpu=False, gpu_id=0)
boxs = boxs[keep, :]
return boxs
def parse_det(Y, C, score=0.1, down=4, scale='h'):
seman = Y[0][0, :, :, 0]
if scale == 'h':
height = np.exp(Y[1][0, :, :, 0]) * down
width = 0.41 * height
elif scale == 'w':
width = np.exp(Y[1][0, :, :, 0]) * down
height = width / 0.41
elif scale == 'hw':
height = np.exp(Y[1][0, :, :, 0]) * down
width = np.exp(Y[1][0, :, :, 1]) * down
y_c, x_c = np.where(seman > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = height[y_c[i], x_c[i]]
w = width[y_c[i], x_c[i]]
s = seman[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + 0.5) * down - w / 2), max(
0, (y_c[i] + 0.5) * down - h / 2)
boxs.append([
x1, y1,
min(x1 + w, C.size_test[1]),
min(y1 + h, C.size_test[0]), s
])
boxs = np.asarray(boxs, dtype=np.float32)
keep = nms(boxs, 0.5, usegpu=False, gpu_id=0)
boxs = boxs[keep, :]
return boxs
def demo(net, image_name):
"""Detect object classes in an image using pre-computed object proposals."""
# Load the demo image
# im_file = os.path.join('/home/shelly/superstar/star/SuperNova/static/upload',image_name)
# change filepath
im_file = os.path.join(
'/home/shelly/flask/star/star/SuperNova/static/upload', image_name)
im = cv2.imread(im_file)
# Detect all object classes and regress object bounds
timer = Timer()
timer.tic()
scores, boxes = im_detect(net, im)
timer.toc()
print('Detection took {:.3f}s for '
'{:d} object proposals').format(timer.total_time, boxes.shape[0])
# Visualize detections for each class
CONF_THRESH = 0.1
NMS_THRESH = 0.3
for cls_ind, cls in enumerate(CLASSES[1:]):
cls_ind += 1 # because we skipped background
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(dets, NMS_THRESH)
dets = dets[keep, :]
vis_detections(im, cls, dets, image_name, thresh=CONF_THRESH)
def slpn_pred(ROIs, P_cls, P_regr, C, bbox_thresh=0.1, nms_thresh=0.3,roi_stride=8): # classifier output the box of x y w h and downscaled scores = np.squeeze(P_cls[:,:,0], axis=0) regr = np.squeeze(P_regr, axis=0) rois = np.squeeze(ROIs, axis=0) keep = np.where(scores>=bbox_thresh)[0] if len(keep)==0: return [], [] rois[:, 2] += rois[:, 0] rois[:, 3] += rois[:, 1] rois = rois[keep]*roi_stride scores = scores[keep] regr = regr[keep]*np.array(C.classifier_regr_std).astype(dtype=np.float32) # regr = regr[keep] pred_boxes = bbox_transform_inv(rois, regr) pred_boxes = clip_boxes(pred_boxes, [C.random_crop[0],C.random_crop[1]]) keep = np.where((pred_boxes[:,2]-pred_boxes[:,0]>=3)& (pred_boxes[:,3]-pred_boxes[:,1]>=3))[0] pred_boxes = pred_boxes[keep] scores = scores[keep].reshape((-1,1)) keep = nms(np.hstack((pred_boxes, scores)), nms_thresh, usegpu=False, gpu_id=0) pred_boxes = pred_boxes[keep] scores = scores[keep] return pred_boxes, scores
def parse_det_offset_batch(Y, C, score=0.1, down=4):
batch_size = Y[0].shape[0]
boxes = []
for bnum in range(batch_size):
seman = Y[0][bnum, :, :, 0]
height = Y[1][bnum, :, :, 0]
offset_y = Y[2][bnum, :, :, 0]
offset_x = Y[2][bnum, :, :, 1]
y_c, x_c = np.where(seman > score)
boxs_img = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * down
w = 0.41 * h
o_y = offset_y[y_c[i], x_c[i]]
o_x = offset_x[y_c[i], x_c[i]]
s = seman[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + o_x + 0.5) * down - w / 2), max(
0, (y_c[i] + o_y + 0.5) * down - h / 2)
x1 = x1
y1 = y1
boxs_img.append([
x1, y1,
min(x1 + w, C.size_test[1]),
min(y1 + h, C.size_test[0]), s
])
boxs_img = np.asarray(boxs_img, dtype=np.float32)
keep = nms(boxs_img, 0.5, usegpu=False, gpu_id=0)
boxs_img = boxs_img[keep, :]
boxes.append(boxs_img)
return boxes
def detect(self, image):
scores, boxes = self.im_detect(image)
all_regions = {}
# process all classes except the background
for cls_ind in range(1, self._num_classes):
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
detections = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = nms(detections, self._nms_thresh)
detections = detections[keep, :]
regions = []
#import pdb; pdb.set_trace()
for detection in detections:
overlap, idx = helpers.iou(np.asarray(regions), detection)
if overlap < self._iou_thresh and detection[
4] > self._conf_thresh:
region = (int(detection[0]), int(detection[1]),
int(math.ceil(detection[2])),
int(math.ceil(detection[3])), detection[4])
regions.append(region)
object_class = cls_ind
if object_class < len(self._classes):
object_class = self._classes[object_class]
all_regions[object_class] = regions
return all_regions
def apply_nms(all_boxes, thresh):
"""Apply non-maximum suppression to all predicted boxes output by the
test_net method.
"""
num_classes = len(all_boxes)
num_images = len(all_boxes[0])
nms_boxes = [[[] for _ in range(num_images)] for _ in range(num_classes)]
for cls_ind in range(num_classes):
for im_ind in range(num_images):
dets = all_boxes[cls_ind][im_ind]
if dets == []:
continue
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
inds = np.where((x2 > x1) & (y2 > y1))[0]
dets = dets[inds,:]
if dets == []:
continue
keep = nms(dets, thresh)
if len(keep) == 0:
continue
nms_boxes[cls_ind][im_ind] = dets[keep, :].copy()
return nms_boxes
def pred_det(anchors, cls_pred, regr_pred, C, step=1):
if step == 1:
scores = cls_pred[0, :, :]
elif step == 2:
scores = anchors[:, -1:] * cls_pred[0, :, :]
elif step == 3:
scores = anchors[:, -2:-1] * anchors[:, -1:] * cls_pred[0, :, :]
A = np.copy(anchors[:, :4])
bbox_deltas = regr_pred.reshape((-1, 4))
bbox_deltas = bbox_deltas * np.array(
C.classifier_regr_std).astype(dtype=np.float32)
proposals = bbox_transform_inv(A, bbox_deltas)
proposals = clip_boxes(proposals, [C.random_crop[0], C.random_crop[1]])
keep = filter_boxes(proposals, C.roi_stride)
proposals = proposals[keep, :]
scores = scores[keep]
order = scores.ravel().argsort()[::-1]
order = order[:C.pre_nms_topN]
proposals = proposals[order, :]
scores = scores[order]
keep = np.where(scores > C.scorethre)[0]
proposals = proposals[keep, :]
scores = scores[keep]
keep = nms(np.hstack((proposals, scores)),
C.overlap_thresh,
usegpu=False,
gpu_id=0)
keep = keep[:C.post_nms_topN]
proposals = proposals[keep, :]
scores = scores[keep]
return proposals, scores
def parse_det_offset(pos,
height,
offset,
size,
score=0.1,
down=4,
nms_thresh=0.3):
pos = np.squeeze(pos)
height = np.squeeze(height)
offset_y = offset[0, 0, :, :]
offset_x = offset[0, 1, :, :]
y_c, x_c = np.where(pos > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * down
w = 0.41 * h
o_y = offset_y[y_c[i], x_c[i]]
o_x = offset_x[y_c[i], x_c[i]]
s = pos[y_c[i], x_c[i]]
x1, y1 = max(0, (x_c[i] + o_x + 0.5) * down - w / 2), max(
0, (y_c[i] + o_y + 0.5) * down - h / 2)
boxs.append(
[x1, y1, min(x1 + w, size[1]),
min(y1 + h, size[0]), s])
boxs = np.asarray(boxs, dtype=np.float32)
keep = nms(boxs, nms_thresh, usegpu=False, gpu_id=0)
boxs = boxs[keep, :]
return boxs
def inference(model_file, device, records, result_queue):
def val_func():
pred_boxes = net(net.inputs)
return pred_boxes
mge.set_default_device('xpu{}'.format(device))
net = network.Network()
net = load_model(net, model_file)
net.eval()
for record in records:
np.set_printoptions(precision=2, suppress=True)
image, gt_boxes, im_info, ID = get_data(record, device)
net.inputs["image"].set_value(image.astype(np.float32))
net.inputs["im_info"].set_value(im_info)
del record, image
pred_boxes = val_func().numpy()
pred_bbox = pred_boxes[:, 1]
scale = im_info[0, 2]
cls_dets = pred_bbox[:, :4] / scale
if config.test_nms_version == 'set_nms':
n = cls_dets.shape[0] // 2
idents = np.tile(np.linspace(0, n-1, n).reshape(-1, 1),(1, 2)).reshape(-1, 1)
pred_boxes = np.hstack([cls_dets, pred_bbox[:,4:5], idents])
flag = pred_boxes[:, 4] >= config.test_cls_threshold
cls_dets = pred_boxes[flag]
keep = emd_cpu_nms(cls_dets, config.test_nms)
cls_dets = cls_dets[keep, :5].astype(np.float64)
elif config.test_nms_version == 'normal_nms':
pred_boxes = np.hstack([cls_dets, pred_bbox[:, 4:5]])
flag = pred_boxes[:, 4] >= config.test_cls_threshold
cls_dets = pred_boxes[flag]
keep = nms(cls_dets.astype(np.float32), config.test_nms)
cls_dets = cls_dets[keep, :5].astype(np.float64)
else:
raise NotImplementedError('the results should be post processed.')
pred_tags = np.ones([cls_dets.shape[0],]).astype(np.float64)
gt_boxes = gt_boxes.astype(np.float64)
dtboxes = boxes_dump(cls_dets[:, :5], pred_tags, False)
gtboxes = boxes_dump(gt_boxes, None, True)
# im_info = im_info.astype(np.int32)
# height, width = im_info[0, 3], im_info[0, 4]
height, width = int(im_info[0, 3]), int(im_info[0, 4])
result_dict = dict(ID=ID, height=height, width=width,
dtboxes = dtboxes, gtboxes = gtboxes)
result_queue.put_nowait(result_dict)
def eval_batch(scene_list, opts):
""" evaluate a batch of bbox files """
mAP = 0
n_obj = 0
if opts.scene_name != '': # eval one scene
scene_list = [opts.scene_name]
for obj in opts.labels: # iter thru each obj
if obj == 'background': # skip background class
continue
opts.test_cls = obj
dets_all = np.empty((0, 6))
scene_id = 0
for scene in scene_list: # iter thru each scene
# read bbox file
dets = np.genfromtxt('./data/out/' + opts.eval_dir + '/' +
opts.eval_prefix + '_' + scene + '_' +
opts.test_cls + '.txt')
# remove the trash
trash_idx = np.nonzero(dets < 0)[0][::2]
dets = np.delete(dets, trash_idx, axis=0)
# append scene_id to dets
if dets.ndim > 1:
dets = np.hstack(
[dets, scene_id * np.ones((dets.shape[0], 1))])
else:
dets = np.hstack([dets, scene_id])
# use nms to prune dets
if opts.nms_thresh > 0.0:
# keep = selective_nms(dets, opts)
keep = nms(dets.astype(np.float32), opts.nms_thresh, opts) # pylint: disable=E1101
nms_dets = dets[keep, :]
dets_all = np.vstack([dets_all, nms_dets]) # adding dets
else:
dets_all = np.vstack([dets_all, dets]) # adding dets
scene_id += 1 # increment scene_id
# filter low likelihood bbox
if opts.low_thresh > 0.0:
low_idx = np.nonzero(dets_all[:, 4] < opts.low_thresh)
dets_all = np.delete(dets_all, low_idx, axis=0)
prec, rec = calc_pr_batch(dets_all, scene_list, opts)
ap = calc_ap(rec, prec)
print('Eval: {}, AP: {}'.format(obj, ap))
if ap > 0:
mAP += ap
n_obj += 1
if opts.viz_pr:
plot_pr(prec, rec, ap, opts.test_cls)
mAP = mAP / n_obj
print('mAP: {}'.format(mAP))
if opts.viz_pr:
plt.show()
return mAP
def main():
data = read_csv(filename="../../ImageSets/gen_box.csv", sep=',')
assert (data.shape[1] % 5 == 0)
for i in range(data.shape[0]):
dets = data[i].reshape(-1, 5)
init_time = time.time()
for j in range(50):
nms(dets, 0.5, force_cpu=True)
cpu_time = (time.time() - init_time)
print("number of picture is: {}, the cpu_time is: {} \n".format(
dets.shape[0], cpu_time))
np.random.shuffle(dets)
init_time = time.time()
for j in range(50):
nms(dets, 0.5, force_cpu=True)
cpu_time = (time.time() - init_time)
print("After shuffle, the cpu_time is: {} \n".format(cpu_time))
def proposal_layer(rpn_cls_prob, rpn_bbox_pred, im_info, cfg_key, _feat_stride,
anchors, num_anchors):
"""A simplified version compared to fast/er RCNN
For details please see the technical report
"""
if type(cfg_key) == bytes:
cfg_key = cfg_key.decode('utf-8')
pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N # RPN_PRE_NMS_TOP_N = 6000
post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N
# __C.TEST.RPN_POST_NMS_TOP_N = 300 非极大值抑制输出的 最大个数
nms_thresh = cfg[cfg_key].RPN_NMS_THRESH
# __C.TEST.RPN_NMS_THRESH = 0.7
# Get the scores and bounding boxes
scores = rpn_cls_prob[:, :, :, num_anchors:]
rpn_bbox_pred = rpn_bbox_pred.reshape((-1, 4))
scores = scores.reshape((-1, 1))
proposals = bbox_transform_inv(anchors, rpn_bbox_pred)
# shape = (length, 4)
# proposals 就是真实预测的边框的四个坐标值
# 特征图映射到原图的所有的框anchors 与特征图的值rpn_bbox_pred 组合 进行回归预测
proposals = clip_boxes(proposals, im_info[:2])
# 限制预测坐标在原始图像上 限制这预测 的坐标的 值 在一定的范围内
# Pick the top region proposals
order = scores.ravel().argsort()[::-1]
if pre_nms_topN > 0:
order = order[:pre_nms_topN]
proposals = proposals[order, :]
scores = scores[order]
# Non-maximal suppression
keep = nms(np.hstack((proposals, scores)), nms_thresh)
# Pick th top region proposals after NMS
if post_nms_topN > 0:
keep = keep[:post_nms_topN]
proposals = proposals[keep, :]
scores = scores[keep]
# Only support single image as input
batch_inds = np.zeros((proposals.shape[0], 1), dtype=np.float32)
blob = np.hstack((batch_inds, proposals.astype(np.float32, copy=False)))
return blob, scores
def get_proposal(all_anchors, cls_layer, regr_layer, C, overlap_thresh=0.7,pre_nms_topN=1000,post_nms_topN=300, roi_stride=8): A = np.copy(all_anchors[:,:4]) scores = cls_layer.reshape((-1,1)) bbox_deltas = regr_layer.reshape((-1,4)) proposals = bbox_transform_inv(A, bbox_deltas) proposals = clip_boxes(proposals, [C.random_crop[0],C.random_crop[1]]) keep = filter_boxes(proposals, roi_stride) proposals = proposals[keep,:] scores = scores[keep] order = scores.ravel().argsort()[::-1] order = order[:pre_nms_topN] proposals = proposals[order,:] scores = scores[order] keep = nms(np.hstack((proposals, scores)), overlap_thresh, usegpu=False, gpu_id=0) keep = keep[:post_nms_topN] proposals = proposals[keep,:] return proposals
def parse_det_bottom(Y, C, score=0.1):
seman = Y[0][0, :, :, 0]
height = Y[1][0, :, :, 0]
y_c, x_c = np.where(seman > score)
boxs = []
if len(y_c) > 0:
for i in range(len(y_c)):
h = np.exp(height[y_c[i], x_c[i]]) * 4
w = 0.41 * h
s = seman[y_c[i], x_c[i]]
x1, y1 = max(0, x_c[i] * 4 + 2 - w / 2), max(0, y_c[i] * 4 + 2 - h)
boxs.append([
x1, y1,
min(x1 + w, C.size_test[1]),
min(y1 + h, C.size_test[0]), s
])
boxs = np.asarray(boxs, dtype=np.float32)
keep = nms(boxs, 0.5, usegpu=False, gpu_id=0)
boxs = boxs[keep, :]
return boxs
def apply_nms(all_boxes, thresh):
"""Apply non-maximum suppression to all predicted boxes output by the
test_net method.
"""
num_classes = len(all_boxes)
num_images = len(all_boxes[0])
nms_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(num_classes)]
for cls_ind in xrange(num_classes):
for im_ind in xrange(num_images):
dets = all_boxes[cls_ind][im_ind]
if dets == []:
continue
# CPU NMS is much faster than GPU NMS when the number of boxes
# is relative small (e.g., < 10k)
# TODO(rbg): autotune NMS dispatch
keep = nms(dets, thresh, force_cpu=True)
if len(keep) == 0:
continue
nms_boxes[cls_ind][im_ind] = dets[keep, :].copy()
return nms_boxes
def proposal_layer(rpn_cls_prob, rpn_bbox_pred, im_info, _feat_stride, anchors, num_anchors, mode='train'):
"""A simplified version compared to fast/er RCNN
For details please see the technical report
"""
pre_nms_topN = 12000
post_nms_topN = 2000
nms_thresh = 0.7
if mode == 'test':
pre_nms_topN = 3000
post_nms_topN = 300
# Get the scores and bounding boxes
scores = rpn_cls_prob[:, :, :, num_anchors:]
rpn_bbox_pred = rpn_bbox_pred.reshape((-1, 4))
scores = scores.reshape((-1, 1))
proposals = bbox_transform_inv(anchors, rpn_bbox_pred)
proposals = clip_boxes(proposals, im_info[:2])
# Pick the top region proposals
order = scores.ravel().argsort()[::-1]
if pre_nms_topN > 0:
order = order[:pre_nms_topN]
proposals = proposals[order, :]
scores = scores[order]
# Non-maximal suppression
keep = nms(np.hstack((proposals, scores)), nms_thresh)
# Pick th top region proposals after NMS
if post_nms_topN > 0:
keep = keep[:post_nms_topN]
proposals = proposals[keep, :]
scores = scores[keep]
# Only support single image as input
batch_inds = np.zeros((proposals.shape[0], 1), dtype=np.float32)
blob = np.hstack((batch_inds, proposals.astype(np.float32, copy=False)))
return blob, scores
def _proposal_layer_py(rpn_bbox_cls_prob, rpn_bbox_pred, im_dims, cfg_key,
_feat_stride, anchor_scales):
'''
# Algorithm:
#
# for each (H, W) location i
# generate A anchor boxes centered on cell i
# apply predicted bbox deltas at cell i to each of the A anchors
# clip predicted boxes to image
# remove predicted boxes with either height or width < threshold
# sort all (proposal, score) pairs by score from highest to lowest
# take top pre_nms_topN proposals before NMS
# apply NMS with threshold 0.7 to remaining proposals
# take after_nms_topN proposals after NMS
# return the top proposals (-> RoIs top, scores top)
# rpn_bbox_cls_prob shape : 1 , h , w , 2*9
# rpn_bbox_pred shape : 1 , h , w , 4*9
'''
_anchors = generate_anchor.generate_anchors(
scales=np.array(anchor_scales)) # #_anchors ( 9, 4 )
_num_anchors = _anchors.shape[0] #9
rpn_bbox_cls_prob = np.transpose(
rpn_bbox_cls_prob, [0, 3, 1, 2]) # rpn bbox _cls prob # 1, 18 , h , w
rpn_bbox_pred = np.transpose(rpn_bbox_pred, [0, 3, 1, 2]) # 1, 36 , h , w
# Only minibatch of 1 supported
assert rpn_bbox_cls_prob.shape[0] == 1, \
'Only single item batches are supported'
if cfg_key == 'TRAIN':
pre_nms_topN = cfg.TRAIN.RPN_PRE_NMS_TOP_N #12000
post_nms_topN = cfg.TRAIN.RPN_POST_NMS_TOP_N # 2000
nms_thresh = cfg.TRAIN.RPN_NMS_THRESH #0.7
min_size = cfg.TRAIN.RPN_MIN_SIZE # 16
else: # cfg_key == 'TEST':
pre_nms_topN = cfg.TEST.RPN_PRE_NMS_TOP_N
post_nms_topN = cfg.TEST.RPN_POST_NMS_TOP_N
nms_thresh = cfg.TEST.RPN_NMS_THRESH
min_size = cfg.TEST.RPN_MIN_SIZE
# the first set of _num_anchors channels are bg probs
# the second set are the fg probs
scores = rpn_bbox_cls_prob[:,
_num_anchors:, :, :] # 1, 18 , H, W --> 1, 9, H, W
# 1. Generate proposals from bbox deltas and shifted anchors
height, width = scores.shape[-2:]
# Enumerate all shifts
shift_x = np.arange(0, width) * _feat_stride
shift_y = np.arange(0, height) * _feat_stride
shift_x, shift_y = np.meshgrid(shift_x, shift_y)
shifts = np.vstack((shift_x.ravel(), shift_y.ravel(), shift_x.ravel(),
shift_y.ravel())).transpose()
# Enumerate all shifted anchors:
# add A anchors (1, A, 4) to
# cell K shifts (K, 1, 4) to get
# shift anchors (K, A, 4)
# reshape to (K*A, 4) shifted anchors
A = _num_anchors
K = shifts.shape[0]
#anchors = _anchors.reshape((1, A, 4)) + shifts.reshape((1, K, 4)).transpose((1, 0, 2))
anchors = np.array([])
for i in range(len(_anchors)):
if i == 0:
anchors = np.add(shifts, _anchors[i])
else:
anchors = np.concatenate((anchors, np.add(shifts, _anchors[i])),
axis=0)
anchors = anchors.reshape((K * A, 4))
## BBOX TRANSPOSE (1,4*A,H,W --> A*H*W,4)
shape = rpn_bbox_pred.shape # 1,4*A , H, W
rpn_bbox_pred = rpn_bbox_pred.reshape(
[1, 4, (shape[1] // 4) * shape[2], shape[3]])
rpn_bbox_pred = rpn_bbox_pred.transpose([0, 2, 3, 1])
rpn_bbox_pred = rpn_bbox_pred.reshape([-1, 4])
bbox_deltas = rpn_bbox_pred
## CLS TRANSPOSE
scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1)) # (h * w * A , 1)
scores_ori = scores
## BBOX TRANSPOSE Using Anchor
proposals = bbox_transform_inv(anchors, bbox_deltas)
proposals_ori = proposals
proposals = clip_boxes(
proposals, im_dims) # image size 보다 큰 proposals 들이 줄어 들수 있도록 한다.
keep = _filter_boxes(proposals,
min_size) # min size = 16 # min보다 큰 놈들만 살아남았다
proposals = proposals[keep, :]
scores = scores[keep]
# 4. sort all (proposal, score) pairs by score from highest to lowest
# 5. take top pre_nms_topN (e.g. 6000)
#print 'scores : ',np.shape(scores) #421 ,13 <--여기 13이 자꾸 바귄다..
order = scores.ravel().argsort()[::-1] # 크기 순서를 뒤집는다 가장 큰 값이 먼저 오게 한다
if pre_nms_topN > 0: #120000
order = order[:pre_nms_topN]
#print np.sum([scores>0.7])
scores = scores[order]
# 6. apply nms (e.g. threshold = 0.7)
# 7. take after_nms_topN (e.g. 300)
# 8. return the top proposals (-> RoIs top)
#print np.shape(np.hstack ((proposals , scores))) # --> [x_start , y_start ,x_end, y_end , score ] 이런 형태로 만든다
keep = nms(np.hstack((proposals, scores)),
nms_thresh) # nms_thresh = 0.7 | hstack --> axis =1
if post_nms_topN > 0:
keep = keep[:post_nms_topN]
proposals = proposals[keep, :]
scores = scores[keep]
# Output rois blob
# Our RPN implementation only supports a single input image, so all
# batch inds are 0
batch_inds = np.zeros((proposals.shape[0], 1), dtype=np.float32)
blob = np.hstack((batch_inds, proposals.astype(np.float32,
copy=False))) # N , 5
#blob=np.hstack((blob , scores))
return blob, scores, proposals_ori, scores_ori
def test_net(sess, net, imdb, weights_filename, max_per_image=100, thresh=0.):
np.random.seed(cfg.RNG_SEED) # 3
"""Test a Fast R-CNN network on an image database."""
num_images = len(imdb.image_index)
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in range(num_images)]
for _ in range(imdb.num_classes)]
output_dir = get_output_dir(imdb, weights_filename)
# timers
_t = {'im_detect': Timer(), 'misc': Timer()}
for i in range(num_images):
im = cv2.imread(imdb.image_path_at(i))
_t['im_detect'].tic()
#得到的就是 是前景的概率scores 与 预测到的boxes边框
scores, boxes = im_detect(sess, net, im)
# scores 是rpn scores = self._predictions['cls_prob'] = 每个类别的概率cls_score 讲过soft_max得到
# pred_boxes
# pred_boxes = bbox_transform_inv(boxes, box_deltas)
# 做回归预测 两条路劲rpn得到的的 box_deltas 作为 dx dy dw dh 与 筛选出来的框做回归预测
# pred_boxes anchors回归预测后的值
#return scores, pred_boxes
_t['im_detect'].toc()
_t['misc'].tic()
# skip j = 0, because it's the background class
for j in range(1, imdb.num_classes):
inds = np.where(scores[:, j] > thresh)[0]
cls_scores = scores[inds, j]
cls_boxes = boxes[inds, j * 4:(j + 1) * 4]
cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \
.astype(np.float32, copy=False)
keep = nms(cls_dets, cfg.TEST.NMS)
cls_dets = cls_dets[keep, :]
all_boxes[j][i] = cls_dets
# Limit to max_per_image detections *over all classes*
if max_per_image > 0:
image_scores = np.hstack(
[all_boxes[j][i][:, -1] for j in range(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in range(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
_t['misc'].toc()
print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \
.format(i + 1, num_images, _t['im_detect'].average_time,
_t['misc'].average_time))
det_file = os.path.join(output_dir, 'detections.pkl')
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
imdb.evaluate_detections(all_boxes, output_dir)
import sys
sys.path.insert(0,'/home/yfji/Workspace/PyTorch/DLMOT-FRCNN/nms')
from nms_wrapper import nms
import numpy as numpy
import torch
import numpy as np
bboxes=np.array([[0,0,50,50],
[1,1,51,51],
[2,2,52,52],
[25,25,75,75],
[26,26,76,76],
[100,100,150,150],
[101,101,151,151]])
scores=np.array([0.9,0.8,0.7,0.9,0.5,0.2,0.6])
bboxes_with_score=np.hstack((bboxes, scores.reshape(-1,1)))
bboxes_with_score[:,0]+=20
bboxes_pth=torch.from_numpy(bboxes_with_score).float().cuda()
keep=nms(bboxes_pth, 0.7)
print(keep)
r_box = np.array([x0,y0,x1,y1,x2,y2,x3,y3])
return r_box
if __name__ == '__main__':
boxes = np.array([[110, 110, 210, 210, 0, 0.88],
[100, 100, 200, 200, 0, 0.99], # res1
[100, 100, 200, 200, 10, 0.66],
[250, 250, 350, 350, 0., 0.77]], # res2
dtype=np.float32)
dets_th=torch.from_numpy(boxes).cuda()
iou_thr = 0.1
print(dets_th.shape)
inds = nms(dets_th, iou_thr)
print(inds)
img = np.zeros((1000,1000,3), np.uint8)
img.fill(255)
boxes = boxes[:, :-1]
cbox = (255,0,0) # format GBR!!
ctar = (0,0,255) # red is target!!
boxes = [get_rotated_coors(i).reshape(-1,2).astype(np.int32) for i in boxes]
for idx, box in enumerate(boxes):
color = ctar if idx in inds else cbox
img = cv2.polylines(img,[box],True,color,1)
cv2.imshow('anchor_show', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def nms_detections(boxes_pred, scores, nms_thresh, force_cpu=False):
dets = np.hstack((boxes_pred, scores[:, np.newaxis])).astype(np.float32)
return nms(dets, nms_thresh, force_cpu)
def demo(sess, net, image_name):
"""Detect object classes in an image using pre-computed object proposals."""
# im_names = ['000456.jpg', '000542.jpg', '001150.jpg',
# '001763.jpg', '004545.jpg']
#一张张图片输入
# net = vgg16()
# demo(sess, net, im_name)
im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name)
im = cv2.imread(im_file)
# Detect all object classes and regress object bounds
timer = Timer()
timer.tic()
#输入 net = vgg16() im一张图片
scores, boxes = im_detect(sess, net, im)
# post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N#__C.TEST.RPN_POST_NMS_TOP_N = 300 非极大值抑制输出的 最大个数
# nms_thresh = cfg[cfg_key].RPN_NMS_THRESH#__C.TEST.RPN_NMS_THRESH = 0.7
# scores 是rpn scores = self._predictions['cls_prob'] = 每个类别的概率cls_score 讲过soft_max得到
# pred_boxes
# pred_boxes = bbox_transform_inv(boxes, box_deltas)
# 做回归预测 两条路劲rpn得到的的 box_deltas 作为 dx dy dw dh 与 筛选出来的框做回归预测
# pred_boxes anchors回归预测后的值
# return scores, pred_boxes
timer.toc()
print('Detection took {:.3f}s for {:d} object proposals'.format(timer.total_time, boxes.shape[0]))
# Visualize detections for each class
CONF_THRESH = 0.8
NMS_THRESH = 0.3
for cls_ind, cls in enumerate(CLASSES[1:]):#CLASSES就是英文标签
cls_ind += 1 # because we skipped background
cls_boxes = boxes[:, 4*cls_ind:4*(cls_ind + 1)]
#得到抽取出来的 一个框 一个 boxes shape (?, 21*4) 得到 [?*21,4]
cls_scores = scores[:, cls_ind]#scores shape (？，21) # 得到[?*21]
dets = np.hstack((cls_boxes,# [?*21,4]
cls_scores[:, np.newaxis])).astype(np.float32)#[?*21,1]
#得到的是[?*21,x,y,w,h,scores] 0.3
#所有的框预测 21个类别 输入的是 所有的框预测一个类别的框与得分值
# 是一个一个类别输入NMS 假如类别1 则输入 [?,x,y,w,h,scores]
keep = nms(dets, NMS_THRESH)#为什么要用 (cpu)gpu_nms.pys
#nms 纯python语言实现：简介方便、速度慢
#Cython是一个快速生成Python扩展模块的工具，从语法层面上来讲是Python语法和C语言语法的混血，
# 当Python性能遇到瓶颈时，Cython直接将C的原生速度植入Python程序，这样使Python程序无需使用C重写
# ，能快速整合原有的Python程序，这样使得开发效率和执行效率都有很大的提高，而这些中间的部分，
# 都是Cython帮我们做了。
#https://www.cnblogs.com/king-lps/p/9031568.html 解释
# 之前的 非极大值抑制 作用实在rpn路径上的 rpn路径就是为了做推荐而已 推荐 VGG16特征出来的框，但是太多 所以需要筛选
#这里 是筛选出来之后 再做 nms
#CONF_THRESH = 0.8
#NMS_THRESH = 0.3
dets = dets[keep, :]
#im输入的图像经过限制在600，1000
#cls 是实际的英文标签
# dets是 [?*21,x,y,w,h,scores] 经过nms 得到 的 0.3
#for cls_ind, cls in enumerate(CLASSES[1:]):#CLASSES就是英文标签
#所有的框预测 21个类别 输入的是 所有的框预测一个类别的框与得分值
# 进行NMS后 得到的框就是需要输出的框 他对应的英文标签是 cls #CONF_THRESH = 0.8
vis_detections(im, cls, dets, thresh=CONF_THRESH)
def test_net(net, imdb, max_per_image=100, thresh=0.01, vis=False):
"""Test a Fast R-CNN network on an image database."""
num_images = len(imdb.image_index)
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
output_dir = get_output_dir(imdb, net)
# timers
_t = {
'im_preproc': Timer(),
'im_net': Timer(),
'im_postproc': Timer(),
'misc': Timer()
}
if not cfg.TEST.HAS_RPN:
roidb = imdb.roidb
for i in xrange(num_images):
# filter out any ground truth boxes
if cfg.TEST.HAS_RPN:
box_proposals = None
else:
# The roidb may contain ground-truth rois (for example, if the roidb
# comes from the training or val split). We only want to evaluate
# detection on the *non*-ground-truth rois. We select those the rois
# that have the gt_classes field set to 0, which means there's no
# ground truth.
box_proposals = roidb[i]['boxes'][roidb[i]['gt_classes'] == 0]
im = cv2.imread(imdb.image_path_at(i))
scores, boxes = im_detect(net, im, _t, box_proposals)
_t['misc'].tic()
# skip j = 0, because it's the background class
for j in xrange(1, imdb.num_classes):
inds = np.where(scores[:, j] > thresh)[0]
cls_scores = scores[inds, j]
cls_boxes = boxes[inds, j * 4:(j + 1) * 4]
#cls_boxes = boxes[inds, 4:8] # 0.6971 vs 0.74
cls_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \
.astype(np.float32, copy=False)
keep = nms(cls_dets, cfg.TEST.NMS)
#SOFT_NMS=1
#keep = soft_nms(cls_dets, method=SOFT_NMS)
dets_NMSed = cls_dets[keep, :]
if cfg.TEST.BBOX_VOTE:
cls_dets = bbox_vote(dets_NMSed, cls_dets)
else:
cls_dets = dets_NMSed
if vis:
vis_detections(im, imdb.classes[j], cls_dets)
all_boxes[j][i] = cls_dets
# Limit to max_per_image detections *over all classes*
if max_per_image > 0:
image_scores = np.hstack(
[all_boxes[j][i][:, -1] for j in xrange(1, imdb.num_classes)])
if len(image_scores) > max_per_image:
image_thresh = np.sort(image_scores)[-max_per_image]
for j in xrange(1, imdb.num_classes):
keep = np.where(all_boxes[j][i][:, -1] >= image_thresh)[0]
all_boxes[j][i] = all_boxes[j][i][keep, :]
_t['misc'].toc()
print 'im_detect: {:d}/{:d} net {:.3f}s preproc {:.3f}s postproc {:.3f}s misc {:.3f}s' \
.format(i + 1, num_images, _t['im_net'].average_time,
_t['im_preproc'].average_time, _t['im_postproc'].average_time,
_t['misc'].average_time)
det_file = os.path.join(output_dir, 'detections.pkl')
with open(det_file, 'wb') as f:
cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL)
print 'Evaluating detections'
imdb.evaluate_detections(all_boxes, output_dir)