def test_net(name, net, imdb, max_per_image=300, thresh=1 / 7.0, vis=False, iters="0000", ext=[]): """Test a Fast R-CNN network on an image database.""" vis_www = True 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, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} det_file = os.path.join(output_dir, 'detections.pkl') images = [] print("in test process, plz wait, total %d items", num_images) for i in tqdm(range(num_images)): im = cv2.imread(imdb.image_path_at(i)) _t['im_detect'].tic() scores, boxes = im_detect(net, im) detect_time = _t['im_detect'].toc(average=False) _t['misc'].tic() if vis: # im2show = np.copy(im[:, :, (2, 1, 0)]) im2show = np.copy(im) if vis_www: im2show = np.copy(im) images.append(np.copy(im)) # 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, :] if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets, thresh) if vis_www: im2show = vis_detections(im2show, imdb.classes[j], cls_dets, thresh) 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, :] nms_time = _t['misc'].toc(average=False) # print 'im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \ # .format(i + 1, num_images, detect_time, nms_time) if vis: cv2.imshow('test', im2show) cv2.waitKey(1) if vis_www: images.append(np.copy(im2show)) with open(det_file, 'wb') as f: cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL) vis_dir = os.path.join(output_dir, "..", "..", "..", "www", "_".join(ext)) print(vis_dir) if not os.path.exists(vis_dir): os.makedirs(vis_dir) visImg.writeImgHTML(images, iters, "test", 2, vis_dir) print 'Evaluating detections' imdb.evaluate_detections(all_boxes, output_dir)
def test_net(net, imdb, max_per_image=300, thresh=0.05, 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, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} # det_file = os.path.join(output_dir, 'detections.pkl') for i in range(num_images): im = cv2.imread(imdb.image_path_at(i)) _t['im_detect'].tic() scores, boxes = im_detect(net, im) detect_time = _t['im_detect'].toc(average=False) _t['misc'].tic() if vis or sav: # im2show = np.copy(im[:, :, (2, 1, 0)]) im2show = np.copy(im) # 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_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, :] if vis: im2show = vis_detections(im2show, 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, :] nms_time = _t['misc'].toc(average=False) print 'im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \ .format(i + 1, num_images, detect_time, nms_time) # if vis: # cv2.imshow('test', im2show) # cv2.waitKey(1) if sav: cv2.imwrite(output_dir_detections + str(i) + '.png', im2show) 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)
def test_net(name, net, imdb, max_per_image=300, thresh=0.05, vis=False, vis_gt=False, vis_proposals=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 range(num_images)] for _ in range(imdb.num_classes)] output_dir = get_output_dir(imdb, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} det_file = os.path.join(output_dir, 'detections.pkl') for i in range(num_images): im = cv2.imread(imdb.image_path_at(i)) _t['im_detect'].tic() scores, boxes = im_detect(net, im) detect_time = _t['im_detect'].toc(average=False) if vis: # im2show = np.copy(im[:, :, (2, 1, 0)]) im2show = np.copy(im) if vis and vis_proposals: for j in range(scores.shape[0]): bbox_1 = tuple(x_1 for x_1 in boxes[j, :4]) cv2.rectangle(im2show, bbox_1[0:2], bbox_1[2:4], (0, j / 300 * 255, j / 300 * 255), 1) _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, :] if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets, thresh) 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, :] nms_time = _t['misc'].toc(average=False) print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \ .format(i + 1, num_images, detect_time, nms_time)) if vis_gt and vis: annopath_1 = os.path.join(imdb._devkit_path, 'VOC' + imdb._year, 'Annotations', '{:s}.xml') recs_1 = parse_rec(annopath_1.format(imdb._image_index[i])) bbox_2 = np.array([x['bbox'] for x in recs_1]) for d in range(len(recs_1)): bbox_1 = tuple(x_1 for x_1 in bbox_2[d, :4]) cv2.rectangle(im2show, bbox_1[0:2], bbox_1[2:4], (0, 0, 255), 1) if vis: cv2.imshow('test', im2show) cv2.waitKey(0) 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)
def proposal_layer(rpn_cls_prob_reshape, rpn_bbox_pred, im_info, cfg_key, _feat_stride, anchor_scales, anchor_ratios, is_region=False): # 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) # layer_params = yaml.load(self.param_str_) _anchors = generate_anchors(scales=anchor_scales, ratios=anchor_ratios) _num_anchors = _anchors.shape[0] # don't need transpose for pytorch # rpn_cls_prob_reshape = np.transpose(rpn_cls_prob_reshape, [0, 3, 1, 2]) # rpn_bbox_pred = np.transpose(rpn_bbox_pred, [0, 3, 1, 2]) # rpn_cls_prob_reshape = np.transpose(np.reshape(rpn_cls_prob_reshape,[1,rpn_cls_prob_reshape.shape[0],rpn_cls_prob_reshape.shape[1],rpn_cls_prob_reshape.shape[2]]),[0,3,2,1]) # rpn_bbox_pred = np.transpose(rpn_bbox_pred,[0,3,2,1]) im_info = im_info[0] assert rpn_cls_prob_reshape.shape[0] == 1, \ 'Only single item batches are supported' # cfg_key = str(self.phase) # either 'TRAIN' or 'TEST' # cfg_key = 'TEST' if is_region: pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N_REGION post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N_REGION nms_thresh = cfg[cfg_key].RPN_NMS_THRESH_REGION min_size = cfg[cfg_key].RPN_MIN_SIZE_REGION else: pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N nms_thresh = cfg[cfg_key].RPN_NMS_THRESH min_size = cfg[cfg_key].RPN_MIN_SIZE # the first set of _num_anchors channels are bg probs # the second set are the fg probs, which we want scores = rpn_cls_prob_reshape[:, _num_anchors:, :, :] bbox_deltas = rpn_bbox_pred # im_info = bottom[2].data[0, :] if DEBUG: print 'im_size: ({}, {})'.format(im_info[0], im_info[1]) print 'scale: {}'.format(im_info[2]) # 1. Generate proposals from bbox deltas and shifted anchors height, width = scores.shape[-2:] if DEBUG: print 'score map size: {}'.format(scores.shape) # 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 = anchors.reshape((K * A, 4)) # Transpose and reshape predicted bbox transformations to get them # into the same order as the anchors: # # bbox deltas will be (1, 4 * A, H, W) format # transpose to (1, H, W, 4 * A) # reshape to (1 * H * W * A, 4) where rows are ordered by (h, w, a) # in slowest to fastest order bbox_deltas = bbox_deltas.transpose((0, 2, 3, 1)).reshape((-1, 4)) # Same story for the scores: # # scores are (1, A, H, W) format # transpose to (1, H, W, A) # reshape to (1 * H * W * A, 1) where rows are ordered by (h, w, a) scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1)) # Convert anchors into proposals via bbox transformations proposals = bbox_transform_inv(anchors, bbox_deltas) # 2. clip predicted boxes to image if cfg.TEST.RPN_DROPOUT_BOXES_RUNOFF_IMAGE: _allowed_border = 16 inds_inside = np.where( (proposals[:, 0] >= -_allowed_border) & (proposals[:, 1] >= -_allowed_border) & (proposals[:, 2] < im_info[1] + _allowed_border) & # width (proposals[:, 3] < im_info[0] + _allowed_border) # height )[0] proposals = proposals[inds_inside, :] proposals = clip_boxes(proposals, im_info[:2]) # 3. remove predicted boxes with either height or width < threshold # (NOTE: convert min_size to input image scale stored in im_info[2]) keep = _filter_boxes(proposals, min_size * im_info[2]) 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) order = scores.ravel().argsort()[::-1] if pre_nms_topN > 0: order = order[:pre_nms_topN] proposals = proposals[order, :] 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 'proposals', proposals # print 'scores', scores keep = nms(np.hstack((proposals, scores)).astype(np.float32), nms_thresh) 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))) # print(blob.shape) return blob
def proposal_layer(rpn_cls_prob_reshape, rpn_bbox_pred, im_info, cfg_key, _feat_stride=[16, ], anchor_scales=[4, 8, 16, 32]): """ Parameters ---------- rpn_cls_prob_reshape: (1 , H , W , Ax2) outputs of RPN, prob of bg or fg NOTICE: the old version is ordered by (1, H, W, 2, A) !!!! rpn_bbox_pred: (1 , H , W , Ax4), rgs boxes output of RPN im_info: a list of [image_height, image_width, scale_ratios] cfg_key: 'TRAIN' or 'TEST' _feat_stride: the downsampling ratio of feature map to the original input image anchor_scales: the scales to the basic_anchor (basic anchor is [16, 16]) ---------- Returns ---------- rpn_rois : (1 x H x W x A, 5) e.g. [0, x1, y1, x2, y2] # 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) #layer_params = yaml.load(self.param_str_) """ _anchors = generate_anchors(scales=np.array(anchor_scales)) _num_anchors = _anchors.shape[0] # rpn_cls_prob_reshape = np.transpose(rpn_cls_prob_reshape,[0,3,1,2]) #-> (1 , 2xA, H , W) # rpn_bbox_pred = np.transpose(rpn_bbox_pred,[0,3,1,2]) # -> (1 , Ax4, H , W) # rpn_cls_prob_reshape = np.transpose(np.reshape(rpn_cls_prob_reshape,[1,rpn_cls_prob_reshape.shape[0],rpn_cls_prob_reshape.shape[1],rpn_cls_prob_reshape.shape[2]]),[0,3,2,1]) # rpn_bbox_pred = np.transpose(rpn_bbox_pred,[0,3,2,1]) im_info = im_info[0] assert rpn_cls_prob_reshape.shape[0] == 1, \ 'Only single item batches are supported' # cfg_key = str(self.phase) # either 'TRAIN' or 'TEST' # cfg_key = 'TEST' pre_nms_topN = cfg[cfg_key].RPN_PRE_NMS_TOP_N post_nms_topN = cfg[cfg_key].RPN_POST_NMS_TOP_N nms_thresh = cfg[cfg_key].RPN_NMS_THRESH min_size = cfg[cfg_key].RPN_MIN_SIZE # the first set of _num_anchors channels are bg probs # the second set are the fg probs, which we want scores = rpn_cls_prob_reshape[:, _num_anchors:, :, :] bbox_deltas = rpn_bbox_pred # im_info = bottom[2].data[0, :] if DEBUG: print(('im_size: ({}, {})'.format(im_info[0], im_info[1]))) print(('scale: {}'.format(im_info[2]))) # 1. Generate proposals from bbox deltas and shifted anchors height, width = scores.shape[-2:] if DEBUG: print(('score map size: {}'.format(scores.shape))) # 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 = anchors.reshape((K * A, 4)) # Transpose and reshape predicted bbox transformations to get them # into the same order as the anchors: # # bbox deltas will be (1, 4 * A, H, W) format # transpose to (1, H, W, 4 * A) # reshape to (1 * H * W * A, 4) where rows are ordered by (h, w, a) # in slowest to fastest order bbox_deltas = bbox_deltas.transpose((0, 2, 3, 1)).reshape((-1, 4)) # Same story for the scores: # # scores are (1, A, H, W) format # transpose to (1, H, W, A) # reshape to (1 * H * W * A, 1) where rows are ordered by (h, w, a) scores = scores.transpose((0, 2, 3, 1)).reshape((-1, 1)) # Convert anchors into proposals via bbox transformations proposals = bbox_transform_inv(anchors, bbox_deltas) # 2. clip predicted boxes to image proposals = clip_boxes(proposals, im_info[:2]) # 3. remove predicted boxes with either height or width < threshold # (NOTE: convert min_size to input image scale stored in im_info[2]) keep = _filter_boxes(proposals, min_size * im_info[2]) proposals = proposals[keep, :] scores = scores[keep] # # remove irregular boxes, too fat too tall # keep = _filter_irregular_boxes(proposals) # 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) order = scores.ravel().argsort()[::-1] if pre_nms_topN > 0: order = order[:pre_nms_topN] proposals = proposals[order, :] 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) keep = nms(np.hstack((proposals, scores)), nms_thresh) 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))) return blob
def test_net(name, net, imdb, max_per_image=300, thresh=0.05, test_bbox_reg=True, 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 range(num_images)] for _ in range(imdb.num_classes)] output_dir = get_output_dir(imdb, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} det_file = os.path.join(output_dir, 'detections.pkl') cmap = get_cmap(imdb.num_classes) for i in range(num_images): im = imdb.im_getter(i) _t['im_detect'].tic() scores, boxes = im_detect(net, im, test_bbox_reg) detect_time = _t['im_detect'].toc(average=False) _t['misc'].tic() if vis: # im2show = np.copy(im[:, :, (2, 1, 0)]) im2show = np.copy(im, 'C') im2show_gt = np.copy(im, 'C') # 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, :] if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets, thresh=thresh, color=cmap(j)) gt_boxes = imdb.all_boxes[ imdb.im_to_first_box[i]:imdb.im_to_last_box[i] + 1, :] gt_classes = imdb.labels[imdb.im_to_first_box[i]:imdb. im_to_last_box[i] + 1] gt_dets = np.hstack(( gt_boxes, np.ones((gt_boxes.shape[0], 1)), ))[gt_classes == j] im2show_gt = vis_detections(im2show_gt, imdb.classes[j], gt_dets, thresh=thresh, color=cmap(j)) 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, :] nms_time = _t['misc'].toc(average=False) print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \ .format(i + 1, num_images, detect_time, nms_time)) if vis: path = os.path.join(output_dir, 'viz') if not os.path.exists(path): os.mkdir(path) cv2.imwrite(os.path.join(path, '{}.jpg'.format(i)), im2show) cv2.imwrite(os.path.join(path, '{}_gt.jpg'.format(i)), im2show_gt) 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)
def get_preds(name, net, imdb, max_per_image=300, thresh=0.05, test_bbox_reg=True, vis=False): """Extract predictions and visual features (of the GT boxes).""" num_images = len(imdb.image_index) output_dir = get_output_dir(imdb, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} det_file = os.path.join(output_dir, 'saved_feats.pkl') dets = [] for i in range(num_images): all_boxes = [[] for j in range(imdb.num_classes)] gt_boxes = imdb.all_boxes[ imdb.im_to_first_box[i]:imdb.im_to_last_box[i] + 1, :] gt_classes = imdb.labels[imdb. im_to_first_box[i]:imdb.im_to_last_box[i] + 1] im = imdb.im_getter(i) _t['im_detect'].tic() scores, boxes = im_detect(net, im) detect_time = _t['im_detect'].toc(average=False) _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] = cls_dets # Limit to max_per_image detections *over all classes* if max_per_image > 0: image_scores = np.hstack( [all_boxes[j][:, -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][:, -1] >= image_thresh)[0] all_boxes[j] = all_boxes[j][keep, :] nms_time = _t['misc'].toc(average=False) dets.append(make_results_tuple(all_boxes, gt_classes, gt_boxes)) if i % 100 == 0: print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s'.format( i + 1, num_images, detect_time, nms_time), flush=True) with open(det_file, 'wb') as f: pickle.dump(dets, f, pickle.HIGHEST_PROTOCOL)
def test_net(net, imdb, max_per_image=300, thresh=0.05, vis=False): """Test a Fast R-CNN network on an image database.""" num_images = len(imdb.image_index) print 'num_images',num_images # 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, name) # timers _t = {'im_detect': Timer(), 'misc': Timer()} # det_file = os.path.join(output_dir, 'detections.pkl') old_dets=None for i in range(num_images): im = cv2.imread(imdb.image_path_at(i)) _t['im_detect'].tic() scores, boxes = im_detect(net, im) detect_time = _t['im_detect'].toc(average=False) _t['misc'].tic() if vis or sav: # im2show = np.copy(im[:, :, (2, 1, 0)]) im2show = np.copy(im) # 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_dets = np.hstack((cls_boxes, cls_scores[:, np.newaxis])) \ .astype(np.float32, copy=False) cls_dets = filterThresh(cls_dets,im,10) cls_dets = filterShape(cls_dets) keep = nms(cls_dets, cfg.TEST.NMS) cls_dets = cls_dets[keep, :] #check if new dets were there before, # if not then : the former detection was a misdetection if vis: im2show = vis_detections(im2show, imdb.classes[j], cls_dets,thresh) all_boxes[j][i] = cls_dets if i>0: if len(all_boxes[j][i-1])>0: # print all_boxes[j][i-1] old_cls_dets=all_boxes[j][i-1] keep=np.zeros((old_cls_dets.shape[0])) for l in range(old_cls_dets.shape[0]): #compute IoU old_x1 = old_cls_dets[l, 0] old_y1 = old_cls_dets[l, 1] old_x2 = old_cls_dets[l, 2] old_y2 = old_cls_dets[l, 3] area = (old_x2 - old_x1 + 1.) * (old_y2 - old_y1 + 1.) if len(all_boxes[j][i])>0: for k in range(cls_dets.shape[0]): new_x1 = cls_dets[k,0] new_y1 = cls_dets[k,1] new_x2 = cls_dets[k,2] new_y2 = cls_dets[k,3] w = max(0.,min(old_x2, new_x2) - max(old_x1, new_x1) + 1.) h = max(0.,min(old_y2, new_y2) - max(old_y1, new_y1) + 1.) inter = w * h iou=inter/area if iou>0.5: keep[l]=1 for l in range(old_cls_dets.shape[0]): if not keep[l]: print "image[",i-1,"]", "false detection[",l,"]" # 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, :] nms_time = _t['misc'].toc(average=False) print 'im_detect: {:d}/{:d} {:.3f}s {:.3f}s' \ .format(i + 1, num_images, detect_time, nms_time) # if vis: # cv2.imshow('test', im2show) # cv2.waitKey(1) if sav: cv2.imwrite(output_dir_detections+str(i)+'.png', im2show) 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)
def nms_detections(pred_boxes, scores, nms_thresh, inds=None): dets = np.hstack((pred_boxes, scores[:, np.newaxis])).astype(np.float32) keep = nms(dets, nms_thresh) if inds is None: return pred_boxes[keep], scores[keep] return pred_boxes[keep], scores[keep], inds[keep]