def get_rand_boxes(self, base_box, num_gen, im_height, im_width): assert list(base_box.size()) == [4] base_box = to_center_form(base_box.unsqueeze(0)).squeeze() selected_indices = torch.LongTensor( np.random.choice(self._seed_pool_size, num_gen * 100, replace=False)) dx = self._delta[:, 0][selected_indices] dy = self._delta[:, 1][selected_indices] dw = self._delta[:, 2][selected_indices] dh = self._delta[:, 3][selected_indices] ret = torch.zeros(num_gen * 100, 5) ret[:, 1] = base_box[0] + dx * base_box[2] ret[:, 2] = base_box[1] + dy * base_box[3] ret[:, 3] = base_box[2] * torch.exp(dw) ret[:, 4] = base_box[3] * torch.exp(dh) ret[:, 1:] = to_point_form(ret[:, 1:]) mask = ret[:, 1].ge(0) * ret[:, 2].ge(0) * ret[:, 3].le( im_width - 1) * ret[:, 4].le(im_height - 1) ratio = dw / dh ratio_mask = ratio.ge(0.333) * ratio.le(3.0) mask *= ratio_mask if mask.sum() == 0: return None ret = ret[mask.unsqueeze(1).expand(ret.size(0), 5)].view(-1, 5) ret = ret[:min(num_gen, ret.size(0)), :] return ret
def __init__(self, iou_begin=10, iou_end=100, seed_pool_size_per_bag=10000): print('Initialize UniformIouBoxGenerator...') self._seed_pool_size_per_bag = seed_pool_size_per_bag self._delta = torch.zeros((100, seed_pool_size_per_bag, 4)) self.iou_begin = iou_begin self.iou_end = iou_end for idx in range(iou_begin, iou_end): cnt = 0 iou_th = idx / 100 while cnt < seed_pool_size_per_bag: pos_th = min((1 / (2 * iou_th)) - 0.5, 0.5) scale_th = max(0.7, iou_th) dx = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size_per_bag * 100)) dy = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size_per_bag * 100)) dw = torch.FloatTensor( np.random.uniform(np.log(iou_th), -np.log(scale_th), seed_pool_size_per_bag * 100)) dh = torch.FloatTensor( np.random.uniform(np.log(iou_th), -np.log(scale_th), seed_pool_size_per_bag * 100)) boxes = torch.stack([dx, dy, torch.exp(dw), torch.exp(dh)], 1) iou = jaccard(torch.FloatTensor([[-0.5, -0.5, 0.5, 0.5]]), to_point_form(boxes)).squeeze() mask = iou.gt(iou_th) * iou.le(iou_th + 0.01) dx = dx[mask] dy = dy[mask] dw = dw[mask] dh = dh[mask] new_cnt = min(seed_pool_size_per_bag - cnt, mask.sum()) self._delta[idx, cnt:cnt + new_cnt, 0] = dx[:new_cnt] self._delta[idx, cnt:cnt + new_cnt, 1] = dy[:new_cnt] self._delta[idx, cnt:cnt + new_cnt, 2] = dw[:new_cnt] self._delta[idx, cnt:cnt + new_cnt, 3] = dh[:new_cnt] cnt += new_cnt print('Complete')
def __init__(self, iou_th, seed_pool_size=100000, pos_th=0.35, scale_min=0.5, scale_max=1.5): self._seed_pool_size = seed_pool_size self._delta = torch.zeros((seed_pool_size, 4)) self._iou_th = iou_th cnt = 0 while cnt < seed_pool_size: scale_th_min = np.log(scale_min) scale_th_max = np.log(scale_max) dx = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size * 10)) dy = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size * 10)) dw = torch.FloatTensor( np.exp( np.random.uniform(scale_th_min, scale_th_max, seed_pool_size * 10))) dh = torch.FloatTensor( np.exp( np.random.uniform(scale_th_min, scale_th_max, seed_pool_size * 10))) boxes = torch.stack([dx, dy, dw, dh], 1) iou = jaccard(torch.FloatTensor([[-0.5, -0.5, 0.5, 0.5]]), to_point_form(boxes)).squeeze() mask = iou.ge(iou_th) dx = dx[mask] dy = dy[mask] dw = dw[mask] dh = dh[mask] new_cnt = min(seed_pool_size - cnt, mask.sum()) self._delta[cnt:cnt + new_cnt, 0] = dx[:new_cnt] self._delta[cnt:cnt + new_cnt, 1] = dy[:new_cnt] self._delta[cnt:cnt + new_cnt, 2] = dw[:new_cnt] self._delta[cnt:cnt + new_cnt, 3] = dh[:new_cnt] cnt += new_cnt print('init NaturalBoxGenerator')
def get_rand_boxes(self, base_box, num_gen, im_height, im_width): assert list(base_box.size()) == [4] base_box = to_center_form(base_box.unsqueeze(0)).squeeze() ret = torch.zeros(self.iou_end - self.iou_begin, 5) cnt = 0 for idx in range(self.iou_begin, self.iou_end): selected_indices = torch.LongTensor( np.random.choice(self._seed_pool_size_per_bag, 100, replace=False)) dx = self._delta[idx, :, 0][selected_indices] dy = self._delta[idx, :, 1][selected_indices] dw = self._delta[idx, :, 2][selected_indices] dh = self._delta[idx, :, 3][selected_indices] gen_boxes = torch.zeros(100, 4) gen_boxes[:, 0] = base_box[0] + dx * base_box[2] gen_boxes[:, 1] = base_box[1] + dy * base_box[3] gen_boxes[:, 2] = base_box[2] * torch.exp(dw) gen_boxes[:, 3] = base_box[3] * torch.exp(dh) gen_boxes = to_point_form(gen_boxes) mask = gen_boxes[:, 0].ge(0) * gen_boxes[:, 1].ge( 0) * gen_boxes[:, 2].le(im_width - 1) * gen_boxes[:, 3].le(im_height - 1) ratio = dw / dh ratio_mask = ratio.ge(0.333) * ratio.le(3.0) mask *= ratio_mask if mask.sum() == 0: continue gen_boxes = gen_boxes[mask.unsqueeze(1).expand( gen_boxes.size(0), 4)].view(-1, 4) ret[cnt, 1:] = gen_boxes[0, :] cnt += 1 selected_indices = torch.LongTensor( np.random.choice(cnt, min(cnt, num_gen), replace=False)) ret = ret[selected_indices] return ret
def __init__(self, iou_th, seed_pool_size=100000): self._seed_pool_size = seed_pool_size self._delta = torch.zeros((seed_pool_size, 4)) self._iou_th = iou_th cnt = 0 while cnt < seed_pool_size: pos_th = min((1 / (2 * iou_th)) - 0.5, 0.5) scale_th = max(0.7, iou_th) dx = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size * 10)) dy = torch.FloatTensor( np.random.uniform(-pos_th, pos_th, seed_pool_size * 10)) dw = torch.FloatTensor( np.random.uniform(np.log(iou_th), -np.log(scale_th), seed_pool_size * 10)) dh = torch.FloatTensor( np.random.uniform(np.log(iou_th), -np.log(scale_th), seed_pool_size * 10)) boxes = torch.stack([dx, dy, torch.exp(dw), torch.exp(dh)], 1) iou = jaccard(torch.FloatTensor([[-0.5, -0.5, 0.5, 0.5]]), to_point_form(boxes)).squeeze() mask = iou.ge(iou_th) dx = dx[mask] dy = dy[mask] dw = dw[mask] dh = dh[mask] new_cnt = min(seed_pool_size - cnt, mask.sum()) self._delta[cnt:cnt + new_cnt, 0] = dx[:new_cnt] self._delta[cnt:cnt + new_cnt, 1] = dy[:new_cnt] self._delta[cnt:cnt + new_cnt, 2] = dw[:new_cnt] self._delta[cnt:cnt + new_cnt, 3] = dh[:new_cnt] cnt += new_cnt print('init UniformBoxGenerator')
def __getitem__(self, index): here = self._image_set[index] im = imread(here['img_full_path']) if len(im.shape) == 2: im = im[:, :, np.newaxis] im = np.concatenate((im, im, im), axis=2) raw_img = im.copy() # rgb -> bgr im = im[:, :, ::-1] gt_boxes = here['object_set'].copy() # random flip if self.training and np.random.rand() > 0.5: im = im[:, ::-1, :] raw_img = raw_img[:, ::-1, :].copy() flipped_gt_boxes = gt_boxes.copy() flipped_gt_boxes[:, 0] = im.shape[1] - gt_boxes[:, 2] flipped_gt_boxes[:, 2] = im.shape[1] - gt_boxes[:, 0] gt_boxes = flipped_gt_boxes if self.rotation: gt_boxes = to_center_form(gt_boxes) rotated_gt_boxes = gt_boxes.copy() h, w = im.shape[0], im.shape[1] angle = np.random.choice([0, 90, 180, 270]) #im = rotate(im, angle) #raw_img = rotate(raw_img, angle) if angle == 90: im = im.transpose([1, 0, 2])[::-1, :, :].copy() raw_img = raw_img.transpose([1, 0, 2])[::-1, :, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = gt_boxes[:, 1], w - gt_boxes[:, 0] rotated_gt_boxes[:, 2], rotated_gt_boxes[:, 3] = gt_boxes[:, 3], gt_boxes[:, 2] elif angle == 180: im = im[::-1, ::-1, :].copy() raw_img = raw_img[::-1, ::-1, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = w - gt_boxes[:, 0], h - gt_boxes[:, 1] elif angle == 270: im = im.transpose([1, 0, 2])[:, ::-1, :].copy() raw_img = raw_img.transpose([1, 0, 2])[:, ::-1, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = h - gt_boxes[:, 1], gt_boxes[:, 0] rotated_gt_boxes[:, 2], rotated_gt_boxes[:, 3] = gt_boxes[:, 3], gt_boxes[:, 2] gt_boxes = to_point_form(rotated_gt_boxes) im = im.astype(np.float32, copy=False) if self.pd is not None: im = self.pd(im) im -= np.array([[[102.9801, 115.9465, 122.7717]]]) im_shape = im.shape im_size_min = np.min(im_shape[0:2]) if self.multi_scale: im_scale = np.random.choice([416, 500, 600, 720, 864 ]) / float(im_size_min) else: im_scale = 600 / float(im_size_min) im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) data = torch.from_numpy(im) data_height, data_width = data.size(0), data.size(1) data = data.permute(2, 0, 1).contiguous() if self.training: np.random.shuffle(gt_boxes) box_categories = gt_boxes[:, 4].astype(np.long) for i in range(len(box_categories)): box_categories[i] = self._id_to_index[box_categories[i]] gt_boxes = gt_boxes[:, :4] gt_boxes *= im_scale gt_boxes = torch.from_numpy(gt_boxes) box_categories = torch.from_numpy(box_categories) #print(data, gt_boxes, data_height, data_width, im_scale, raw_img) return data, gt_boxes, box_categories, data_height, data_width, im_scale, raw_img, here[ 'id']
def __getitem__(self, index): im, gt_boxes, gt_categories, proposals, prop_scores, id, loader_index = self.get_raw_data( index) raw_img = im.copy() proposals, prop_scores = self.select_proposals(proposals, prop_scores) if self.warping and np.random.rand() > 0.8: src, dst = make_transform(im, gt_boxes) tform = PiecewiseAffineTransform() tform.estimate(src, dst) im = warp(im, tform, output_shape=(im.shape[0], im.shape[1])) raw_img = im.copy() # rgb -> bgr im = im[:, :, ::-1] # random flip # if self.training and np.random.rand() > 0.5: # im = im[:, ::-1, :] # raw_img = raw_img[:, ::-1, :].copy() # # flipped_gt_boxes = gt_boxes.copy() # flipped_gt_boxes[:, 0] = im.shape[1] - gt_boxes[:, 2] # flipped_gt_boxes[:, 2] = im.shape[1] - gt_boxes[:, 0] # gt_boxes = flipped_gt_boxes # # flipped_xmin = im.shape[1] - proposals[:, 2] # flipped_xmax = im.shape[1] - proposals[:, 0] # proposals[:, 0] = flipped_xmin # proposals[:, 2] = flipped_xmax if self.training and self.rotation: gt_boxes = to_center_form(gt_boxes) rotated_gt_boxes = gt_boxes.copy() h, w = im.shape[0], im.shape[1] angle = np.random.choice([0, 90, 180, 270]) #im = rotate(im, angle) #raw_img = rotate(raw_img, angle) if angle == 90: im = im.transpose([1, 0, 2])[::-1, :, :].copy() raw_img = raw_img.transpose([1, 0, 2])[::-1, :, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = gt_boxes[:, 1], w - gt_boxes[:, 0] rotated_gt_boxes[:, 2], rotated_gt_boxes[:, 3] = gt_boxes[:, 3], gt_boxes[:, 2] elif angle == 180: im = im[::-1, ::-1, :].copy() raw_img = raw_img[::-1, ::-1, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = w - gt_boxes[:, 0], h - gt_boxes[:, 1] elif angle == 270: im = im.transpose([1, 0, 2])[:, ::-1, :].copy() raw_img = raw_img.transpose([1, 0, 2])[:, ::-1, :].copy() rotated_gt_boxes[:, 0], rotated_gt_boxes[:, 1] = h - gt_boxes[:, 1], gt_boxes[:, 0] rotated_gt_boxes[:, 2], rotated_gt_boxes[:, 3] = gt_boxes[:, 3], gt_boxes[:, 2] gt_boxes = to_point_form(rotated_gt_boxes) # cast to float type and mean subtraction im = im.astype(np.float32, copy=False) if self.pd is not None: im = self.pd(im) raw_img = self.pd(raw_img.astype(np.float32, copy=False)).astype(np.uint8) im -= np.array([[[102.9801, 115.9465, 122.7717]]]) # image rescale im_shape = im.shape im_size_min = np.min(im_shape[0:2]) im_size_max = np.max(im_shape[0:2]) if self.multi_scale: im_scale = np.random.choice([416, 500, 600, 720, 864 ]) / float(im_size_min) if im_size_max * im_scale > 1200: im_scale = 1200 / im_size_max else: im_scale = 600 / float(im_size_min) im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) gt_boxes = gt_boxes * im_scale proposals = proposals * im_scale # to tensor data = torch.from_numpy(im) data = data.permute(2, 0, 1).contiguous() gt_boxes = torch.from_numpy(gt_boxes) proposals = torch.from_numpy(proposals) prop_scores = torch.from_numpy(prop_scores) gt_categories = torch.from_numpy(gt_categories) image_level_label = torch.zeros(80) for label in gt_categories: image_level_label[label] = 1.0 return data, gt_boxes, gt_categories, proposals, prop_scores, image_level_label, im_scale, raw_img, id, loader_index