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
