def anchor_target_layer(self, gt_boxes_h_batch, gt_boxes_r_batch, anchor_batch, gpu_id=0): all_labels, all_target_delta, all_anchor_states, all_target_boxes, all_target_encode_label = [], [], [], [], [] for i in range(self.cfgs.BATCH_SIZE): anchors = np.array(anchor_batch[i], np.float32) gt_boxes_h = gt_boxes_h_batch[i, :, :] gt_boxes_r = gt_boxes_r_batch[i, :, :] anchor_states = np.zeros((anchors.shape[0],)) labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM)) if gt_boxes_r.shape[0]: # [N, M] if self.cfgs.METHOD == 'H': overlaps = bbox_overlaps(np.ascontiguousarray(anchors, dtype=np.float), np.ascontiguousarray(gt_boxes_h, dtype=np.float)) else: overlaps = rbbx_overlaps(np.ascontiguousarray(anchors, dtype=np.float32), np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32), gpu_id) argmax_overlaps_inds = np.argmax(overlaps, axis=1) max_overlaps = overlaps[np.arange(overlaps.shape[0]), argmax_overlaps_inds] # compute box regression targets target_boxes = gt_boxes_r[argmax_overlaps_inds] positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD) & ~positive_indices anchor_states[ignore_indices] = -1 anchor_states[positive_indices] = 1 # compute target class labels labels[positive_indices, target_boxes[positive_indices, -1].astype(int) - 1] = 1 else: # no annotations? then everything is background target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1])) if self.cfgs.METHOD == 'H': x_c = (anchors[:, 2] + anchors[:, 0]) / 2 y_c = (anchors[:, 3] + anchors[:, 1]) / 2 h = anchors[:, 2] - anchors[:, 0] + 1 w = anchors[:, 3] - anchors[:, 1] + 1 theta = -90 * np.ones_like(x_c) anchors = np.vstack([x_c, y_c, w, h, theta]).transpose() if self.cfgs.ANGLE_RANGE == 180: anchors = coordinate_present_convert(anchors, mode=-1) target_boxes = coordinate_present_convert(target_boxes, mode=-1) target_delta = bbox_transform.rbbox_transform(ex_rois=anchors, gt_rois=target_boxes) all_labels.append(labels) all_target_delta.append(target_delta) all_anchor_states.append(anchor_states) all_target_boxes.append(target_boxes) return np.array(all_labels, np.float32), np.array(all_target_delta, np.float32), \ np.array(all_anchor_states, np.float32), np.array(all_target_boxes, np.float32), \
def anchor_target_layer(self, gt_boxes_h, gt_boxes_r, anchors, gpu_id=0): anchor_states = np.zeros((anchors.shape[0], )) labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM)) if gt_boxes_r.shape[0]: # [N, M] if self.cfgs.METHOD == 'H': overlaps = bbox_overlaps( np.ascontiguousarray(anchors, dtype=np.float), np.ascontiguousarray(gt_boxes_h, dtype=np.float)) else: overlaps = rbbx_overlaps( np.ascontiguousarray(anchors, dtype=np.float32), np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32), gpu_id) argmax_overlaps_inds = np.argmax(overlaps, axis=1) max_overlaps = overlaps[np.arange(overlaps.shape[0]), argmax_overlaps_inds] # compute box regression targets target_boxes = gt_boxes_r[argmax_overlaps_inds] positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD ) & ~positive_indices anchor_states[ignore_indices] = -1 anchor_states[positive_indices] = 1 # compute target class labels labels[positive_indices, target_boxes[positive_indices, -1].astype(int) - 1] = 1 else: # no annotations? then everything is background target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1])) # if self.cfgs.METHOD == 'H': # w = anchors[:, 2] - anchors[:, 0] + 1 # h = anchors[:, 3] - anchors[:, 1] + 1 # x1 = anchors[:, 0] # y1 = anchors[:, 1] # x2 = anchors[:, 2] # y2 = anchors[:, 1] # x3 = anchors[:, 2] # y3 = anchors[:, 3] # x4 = anchors[:, 0] # y4 = anchors[:, 3] # anchors = np.stack([x1, y1, x2, y2, x3, y3, x4, y4, w, h]).transpose() # # target_delta = bbox_transform.qbbox_transform(ex_rois=anchors, gt_rois=target_boxes) return np.array(labels, np.float32), np.array( anchor_states, np.float32), np.array(target_boxes, np.float32)
def anchor_target_layer(self, gt_boxes_h, gt_boxes_r, anchors, gpu_id=0): anchor_states = np.zeros((anchors.shape[0], )) labels = np.zeros((anchors.shape[0], self.cfgs.CLASS_NUM)) if gt_boxes_r.shape[0]: # [N, M] if self.cfgs.METHOD == 'H': overlaps = bbox_overlaps( np.ascontiguousarray(anchors, dtype=np.float), np.ascontiguousarray(gt_boxes_h, dtype=np.float)) else: overlaps = rbbx_overlaps( np.ascontiguousarray(anchors, dtype=np.float32), np.ascontiguousarray(gt_boxes_r[:, :-1], dtype=np.float32), gpu_id) argmax_overlaps_inds = np.argmax(overlaps, axis=1) max_overlaps = overlaps[np.arange(overlaps.shape[0]), argmax_overlaps_inds] # compute box regression targets target_boxes = gt_boxes_r[argmax_overlaps_inds] positive_indices = max_overlaps >= self.cfgs.IOU_POSITIVE_THRESHOLD ignore_indices = (max_overlaps > self.cfgs.IOU_NEGATIVE_THRESHOLD ) & ~positive_indices anchor_states[ignore_indices] = -1 anchor_states[positive_indices] = 1 # compute target class labels labels[positive_indices, target_boxes[positive_indices, -1].astype(int) - 1] = 1 else: # no annotations? then everything is background target_boxes = np.zeros((anchors.shape[0], gt_boxes_r.shape[1])) if self.cfgs.METHOD == 'H': x_c = (anchors[:, 2] + anchors[:, 0]) / 2 y_c = (anchors[:, 3] + anchors[:, 1]) / 2 h = anchors[:, 2] - anchors[:, 0] + 1 w = anchors[:, 3] - anchors[:, 1] + 1 theta = -90 * np.ones_like(x_c) anchors = np.vstack([x_c, y_c, w, h, theta]).transpose() target_delta = bbox_transform.rbbox_transform(ex_rois=anchors, gt_rois=target_boxes) return np.array(labels, np.float32), np.array(target_delta, np.float32), \ np.array(anchor_states, np.float32), np.array(target_boxes, np.float32)
def _sample_rois(self, all_rois, gt_boxes_h, gt_boxes_r, fg_rois_per_image, rois_per_image, num_classes): """Generate a random sample of RoIs comprising foreground and background examples. all_rois shape is [-1, 4] gt_boxes shape is [-1, 5]. that is [x1, y1, x2, y2, label] """ # overlaps: (rois x gt_boxes) overlaps = bbox_overlaps( np.ascontiguousarray(all_rois, dtype=np.float), np.ascontiguousarray(gt_boxes_h[:, :-1], dtype=np.float)) gt_assignment = overlaps.argmax(axis=1) max_overlaps = overlaps.max(axis=1) labels = gt_boxes_h[gt_assignment, -1] # Select foreground RoIs as those with >= FG_THRESH overlap fg_inds = np.where(max_overlaps >= self.cfgs.FAST_RCNN_IOU_POSITIVE_THRESHOLD)[0] # Guard against the case when an image has fewer than fg_rois_per_image # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI) bg_inds = np.where((max_overlaps < self.cfgs.FAST_RCNN_IOU_POSITIVE_THRESHOLD) & (max_overlaps >= self.cfgs.FAST_RCNN_IOU_NEGATIVE_THRESHOLD))[0] # print("first fileter, fg_size: {} || bg_size: {}".format(fg_inds.shape, bg_inds.shape)) # Guard against the case when an image has fewer than fg_rois_per_image # foreground RoIs fg_rois_per_this_image = min(fg_rois_per_image, fg_inds.size) # Sample foreground regions without replacement if fg_inds.size > 0: fg_inds = npr.choice(fg_inds, size=int(fg_rois_per_this_image), replace=False) # 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 = 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=int(bg_rois_per_this_image), replace=False) # print("second fileter, fg_size: {} || bg_size: {}".format(fg_inds.shape, bg_inds.shape)) # 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[int(fg_rois_per_this_image):] = 0 rois = all_rois[keep_inds] target_gt_h = gt_boxes_h[gt_assignment[keep_inds], :-1] bbox_target_data_h = self._compute_targets_h( rois, target_gt_h, labels) target_gt_r = gt_boxes_r[gt_assignment[keep_inds], :-1] bbox_target_data_r = self._compute_targets_r( rois, target_gt_r, labels) bbox_targets_h = \ self._get_bbox_regression_labels(bbox_target_data_h, num_classes) bbox_targets_r = \ self._get_bbox_regression_labels_r(bbox_target_data_r, num_classes) return labels, rois, bbox_targets_h, bbox_targets_r, target_gt_h, target_gt_r
def anchor_target_layer(self, gt_boxes, img_shape, all_anchors, is_restrict_bg=False): """Same as the anchor target layer in original Fast/er RCNN """ total_anchors = all_anchors.shape[0] img_h, img_w = img_shape[1], img_shape[2] gt_boxes = gt_boxes[:, :-1] # remove class label # allow boxes to sit over the edge by a small amount _allowed_border = 0 # only keep anchors inside the image if self.cfgs.IS_FILTER_OUTSIDE_BOXES: inds_inside = np.where( (all_anchors[:, 0] >= -_allowed_border) & (all_anchors[:, 1] >= -_allowed_border) & (all_anchors[:, 2] < img_w + _allowed_border) & # width (all_anchors[:, 3] < img_h + _allowed_border) # height )[0] else: inds_inside = range(all_anchors.shape[0]) anchors = all_anchors[inds_inside, :] # 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 = bbox_overlaps( np.ascontiguousarray(anchors, dtype=np.float), np.ascontiguousarray(gt_boxes, dtype=np.float)) argmax_overlaps = overlaps.argmax(axis=1) max_overlaps = overlaps[np.arange(len(inds_inside)), argmax_overlaps] gt_argmax_overlaps = overlaps.argmax(axis=0) gt_max_overlaps = overlaps[gt_argmax_overlaps, np.arange(overlaps.shape[1])] gt_argmax_overlaps = np.where(overlaps == gt_max_overlaps)[0] if not self.cfgs.TRAIN_RPN_CLOOBER_POSITIVES: labels[max_overlaps < self.cfgs.RPN_IOU_NEGATIVE_THRESHOLD] = 0 labels[gt_argmax_overlaps] = 1 labels[max_overlaps >= self.cfgs.RPN_IOU_POSITIVE_THRESHOLD] = 1 if self.cfgs.TRAIN_RPN_CLOOBER_POSITIVES: labels[max_overlaps < self.cfgs.RPN_IOU_NEGATIVE_THRESHOLD] = 0 num_fg = int(self.cfgs.RPN_MINIBATCH_SIZE * self.cfgs.RPN_POSITIVE_RATE) 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 num_bg = self.cfgs.RPN_MINIBATCH_SIZE - np.sum(labels == 1) if is_restrict_bg: num_bg = max(num_bg, num_fg * 1.5) 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 bbox_targets = self._compute_targets(anchors, gt_boxes[argmax_overlaps, :]) # map up to original set of anchors labels = self._unmap(labels, total_anchors, inds_inside, fill=-1) bbox_targets = self._unmap(bbox_targets, total_anchors, inds_inside, fill=0) # labels = labels.reshape((1, height, width, A)) rpn_labels = labels.reshape((-1, 1)) # bbox_targets bbox_targets = bbox_targets.reshape((-1, 4)) rpn_bbox_targets = bbox_targets return rpn_labels, rpn_bbox_targets