def infer_shape(self, max_data_shape=None, max_label_shape=None):
""" Return maximum data and label shape for single gpu """
if max_data_shape is None:
max_data_shape = []
if max_label_shape is None:
max_label_shape = []
max_shapes = dict(max_data_shape + max_label_shape)
input_batch_size = max_shapes['data'][0]
dummy_boxes = np.zeros((0, 5))
dummy_info = [ [max_shapes['data'][2], max_shapes['data'][3], 1.0] ]
dummy_label = {'gt_boxes' : dummy_boxes}
# infer shape
feat_shape_list = []
for i in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[i].infer_shape(**max_shapes)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label_dict = {}
if config.HEAD_BOX:
head_label_dict = assign_anchor_fpn(feat_shape_list, dummy_label, dummy_info, False, prefix='head')
label_dict.update(head_label_dict)
if config.FACE_LANDMARK:
dummy_landmarks = np.zeros( (0,11) )
dummy_label['gt_landmarks'] = dummy_landmarks
face_label_dict = assign_anchor_fpn(feat_shape_list, dummy_label, dummy_info, config.FACE_LANDMARK, prefix='face')
label_dict.update(face_label_dict)
label_list = []
for k in self.label_name:
label_list.append(label_dict[k])
label_shape = [(k, tuple([input_batch_size] + list(v.shape[1:]))) for k, v in zip(self.label_name, label_list)]
return max_data_shape, label_shape
def get_batch(self):
deq = self.q_out.get()
print('q_out got')
data_list, label_list = deq
for data, label in zip(data_list, label_list):
data_shape = {k: v.shape for k, v in data.items()}
del data_shape['im_info']
feat_shape_list = []
for s in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[s].infer_shape(**data_shape)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
#for k in self.label_name:
# label[k] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
im_info = data['im_info']
gt_boxes = label['gt_boxes']
gt_label = {'gt_boxes': gt_boxes}
label_dict = {}
head_label_dict = assign_anchor_fpn(feat_shape_list,
gt_label,
im_info,
False,
prefix='head')
label_dict.update(head_label_dict)
if config.FACE_LANDMARK:
gt_landmarks = label['gt_landmarks']
gt_label['gt_landmarks'] = gt_landmarks
face_label_dict = assign_anchor_fpn(feat_shape_list,
gt_label,
im_info,
config.FACE_LANDMARK,
prefix='face')
label_dict.update(face_label_dict)
#print('im_info', im_info.shape)
#print(gt_boxes.shape)
for k in self.label_name:
label[k] = label_dict[k]
all_data = dict()
for key in self.data_name:
all_data[key] = tensor_vstack([batch[key] for batch in data_list])
all_label = dict()
for key in self.label_name:
pad = 0 if key.startswith('bbox_') else -1
#print('label vstack', key, pad, len(label_list), file=sys.stderr)
all_label[key] = tensor_vstack(
[batch[key] for batch in label_list], pad=pad)
self.data = [mx.nd.array(all_data[key]) for key in self.data_name]
self.label = [mx.nd.array(all_label[key]) for key in self.label_name]
def infer_shape(self, max_data_shape=None, max_label_shape=None):
""" Return maximum data and label shape for single gpu """
if max_data_shape is None:
max_data_shape = []
if max_label_shape is None:
max_label_shape = []
max_shapes = dict(max_data_shape + max_label_shape)
input_batch_size = max_shapes['data'][0]
dummy_boxes = np.zeros((0, 5))
dummy_info = [max_shapes['data'][2], max_shapes['data'][3], 1.0]
# infer shape
feat_shape_list = []
for i in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[i].infer_shape(**max_shapes)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label_dict = assign_anchor_fpn(feat_shape_list, dummy_boxes,
dummy_info, self.feat_stride,
self.anchor_scales, self.anchor_ratios,
self.allowed_border)
label_list = [
label_dict['label'], label_dict['bbox_target'],
label_dict['bbox_weight']
]
label_shape = [(k, tuple([input_batch_size] + list(v.shape[1:])))
for k, v in zip(self.label_name, label_list)]
return max_data_shape, label_shape
def infer_shape(self, max_data_shape=None, max_label_shape=None):
""" Return maximum data and label shape for single gpu """
if max_data_shape is None:
max_data_shape = []
if max_label_shape is None:
max_label_shape = []
max_shapes = dict(max_data_shape + max_label_shape)
input_batch_size = max_shapes['data'][0]
dummy_boxes = np.zeros((0, 5))
dummy_points = np.zeros((0, 11))
dummy_info = [ [max_shapes['data'][2], max_shapes['data'][3], 1.0] ]
# infer shape
feat_shape_list = []
for i in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[i].infer_shape(**max_shapes)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label_dict = assign_anchor_fpn(feat_shape_list, dummy_boxes, dummy_points, dummy_info)
label_list = []
for k in self.label_name:
label_list.append(label_dict[k])
label_shape = [(k, tuple([input_batch_size] + list(v.shape[1:]))) for k, v in zip(self.label_name, label_list)]
return max_data_shape, label_shape
def infer_shape(self, max_data_shape=None, max_label_shape=None):
""" Return maximum data and label shape for single gpu """
if max_data_shape is None:
max_data_shape = []
if max_label_shape is None:
max_label_shape = []
max_shapes = dict(max_data_shape + max_label_shape)
input_batch_size = max_shapes['data'][0]
dummy_boxes = np.zeros((0, 5))
dummy_info = [max_shapes['data'][2], max_shapes['data'][3], 1.0]
# infer shape
feat_shape_list = []
for i in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[i].infer_shape(**max_shapes)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label_dict = assign_anchor_fpn(feat_shape_list, dummy_boxes, dummy_info, self.feat_stride,
self.anchor_scales, self.anchor_ratios, self.allowed_border)
label_list = [label_dict['label'], label_dict['bbox_target'], label_dict['bbox_weight']]
label_shape = [(k, tuple([input_batch_size] + list(v.shape[1:]))) for k, v in zip(self.label_name, label_list)]
return max_data_shape, label_shape
def get_batch(self):
# slice roidb
cur_from = self.cur
cur_to = min(cur_from + self.batch_size, self.size)
roidb = [self.roidb[self.index[i]] for i in range(cur_from, cur_to)]
# decide multi device slice
work_load_list = self.work_load_list
ctx = self.ctx
if work_load_list is None:
work_load_list = [1] * len(ctx)
assert isinstance(work_load_list, list) and len(work_load_list) == len(ctx), \
"Invalid settings for work load. "
slices = _split_input_slice(self.batch_size, work_load_list)
# get testing data for multigpu
data_list = []
label_list = []
for islice in slices:
iroidb = [roidb[i] for i in range(islice.start, islice.stop)]
data, label = get_rpn_batch(iroidb)
data_list.append(data)
label_list.append(label)
# pad data first and then assign anchor (read label)
data_tensor = tensor_vstack([batch['data'] for batch in data_list])
for i_card in range(len(data_list)):
data_list[i_card]['data'] = data_tensor[
i_card * config.TRAIN.BATCH_IMAGES:(1 + i_card) * config.TRAIN.BATCH_IMAGES]
for data, label in zip(data_list, label_list):
data_shape = {k: v.shape for k, v in data.items()}
del data_shape['im_info']
feat_shape_list = []
for s in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[s].infer_shape(**data_shape)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label['label'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
label['bbox_target'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
label['bbox_weight'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
for im_i in range(config.TRAIN.BATCH_IMAGES):
im_info = data['im_info'][im_i]
gt_boxes = label['gt_boxes'][im_i][0]
label_dict = \
assign_anchor_fpn(feat_shape_list, gt_boxes, im_info,
self.feat_stride,
self.anchor_scales,
self.anchor_ratios,
self.allowed_border)
label['label'][im_i] = label_dict['label']
label['bbox_target'][im_i] = label_dict['bbox_target']
label['bbox_weight'][im_i] = label_dict['bbox_weight']
label['label'] = np.vstack(label['label'])
label['bbox_target'] = np.vstack(label['bbox_target'])
label['bbox_weight'] = np.vstack(label['bbox_weight'])
all_data = dict()
for key in self.data_name:
all_data[key] = tensor_vstack([batch[key] for batch in data_list])
all_label = dict()
for key in self.label_name:
pad = 0 if key == 'weight' else -1
all_label[key] = tensor_vstack([batch[key] for batch in label_list], pad=pad)
self.data = [mx.nd.array(all_data[key]) for key in self.data_name]
self.label = [mx.nd.array(all_label[key]) for key in self.label_name]
def get_batch(self):
# slice roidb
cur_from = self.cur
cur_to = min(cur_from + self.batch_size, self.size)
roidb = [self.roidb[self.index[i]] for i in range(cur_from, cur_to)]
# decide multi device slice
work_load_list = self.work_load_list
ctx = self.ctx
if work_load_list is None:
work_load_list = [1] * len(ctx)
assert isinstance(work_load_list, list) and len(work_load_list) == len(ctx), \
"Invalid settings for work load. "
slices = _split_input_slice(self.batch_size, work_load_list)
# get testing data for multigpu
data_list = []
label_list = []
for islice in slices:
iroidb = [roidb[i] for i in range(islice.start, islice.stop)]
data, label = get_rpn_batch(iroidb)
data_list.append(data)
label_list.append(label)
# pad data first and then assign anchor (read label)
data_tensor = tensor_vstack([batch['data'] for batch in data_list])
for i_card in range(len(data_list)):
data_list[i_card]['data'] = data_tensor[
i_card * config.TRAIN.BATCH_IMAGES:(1 + i_card) * config.TRAIN.BATCH_IMAGES]
for data, label in zip(data_list, label_list):
data_shape = {k: v.shape for k, v in data.items()}
del data_shape['im_info']
feat_shape_list = []
for s in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[s].infer_shape(**data_shape)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
label['label'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
label['bbox_target'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
label['bbox_weight'] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
for im_i in range(config.TRAIN.BATCH_IMAGES):
im_info = data['im_info'][im_i]
gt_boxes = label['gt_boxes'][im_i][0]
label_dict = \
assign_anchor_fpn(feat_shape_list, gt_boxes, im_info,
self.feat_stride,
self.anchor_scales,
self.anchor_ratios,
self.allowed_border)
label['label'][im_i] = label_dict['label']
label['bbox_target'][im_i] = label_dict['bbox_target']
label['bbox_weight'][im_i] = label_dict['bbox_weight']
label['label'] = np.vstack(label['label'])
label['bbox_target'] = np.vstack(label['bbox_target'])
label['bbox_weight'] = np.vstack(label['bbox_weight'])
all_data = dict()
for key in self.data_name:
all_data[key] = tensor_vstack([batch[key] for batch in data_list])
all_label = dict()
for key in self.label_name:
pad = 0 if key == 'weight' else -1
all_label[key] = tensor_vstack([batch[key] for batch in label_list], pad=pad)
self.data = [mx.nd.array(all_data[key]) for key in self.data_name]
self.label = [mx.nd.array(all_label[key]) for key in self.label_name]
def get_batch(self):
# slice roidb
cur_from = self.cur
cur_to = min(cur_from + self.batch_size, self.size)
assert cur_to==cur_from+self.batch_size
roidb = [self.roidb[self.index[i]] for i in range(cur_from, cur_to)]
# decide multi device slice
work_load_list = self.work_load_list
ctx = self.ctx
if work_load_list is None:
work_load_list = [1] * len(ctx)
assert isinstance(work_load_list, list) and len(work_load_list) == len(ctx), \
"Invalid settings for work load. "
slices = _split_input_slice(self.batch_size, work_load_list)
# get testing data for multigpu
data_list = []
label_list = []
for islice in slices:
iroidb = [roidb[i] for i in range(islice.start, islice.stop)]
data, label = get_crop_batch(iroidb)
data_list += data
label_list += label
#data_list.append(data)
#label_list.append(label)
# pad data first and then assign anchor (read label)
#data_tensor = tensor_vstack([batch['data'] for batch in data_list])
#for i_card in range(len(data_list)):
# data_list[i_card]['data'] = data_tensor[
# i_card * config.TRAIN.BATCH_IMAGES:(1 + i_card) * config.TRAIN.BATCH_IMAGES]
for data, label in zip(data_list, label_list):
data_shape = {k: v.shape for k, v in data.items()}
del data_shape['im_info']
feat_shape_list = []
for s in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[s].infer_shape(**data_shape)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
#for k in self.label_name:
# label[k] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
im_info = data['im_info']
gt_boxes = label['gt_boxes']
gt_points = label['gt_points']
#print('im_info', im_info.shape)
#print(gt_boxes.shape)
label_dict = assign_anchor_fpn(feat_shape_list, gt_boxes, gt_points, im_info)
for k in self.label_name:
label[k] = label_dict[k]
all_data = dict()
for key in self.data_name:
all_data[key] = tensor_vstack([batch[key] for batch in data_list])
all_label = dict()
for key in self.label_name:
pad = 0 if key.startswith('bbox_') or key.startswith('kpoint_') else -1
#print('label vstack', key, pad, len(label_list), file=sys.stderr)
all_label[key] = tensor_vstack([batch[key] for batch in label_list], pad=pad)
self.data = [mx.nd.array(all_data[key]) for key in self.data_name]
self.label = [mx.nd.array(all_label[key]) for key in self.label_name]
def get_batch(self):
# slice roidb
cur_from = self.cur
cur_to = min(cur_from + self.batch_size, self.size)
roidb = [self.roidb[self.index[i]] for i in range(cur_from, cur_to)]
# decide multi device slice
work_load_list = self.work_load_list
ctx = self.ctx
if work_load_list is None:
work_load_list = [1] * len(ctx)
assert isinstance(work_load_list, list) and len(work_load_list) == len(ctx), \
"Invalid settings for work load. "
slices = _split_input_slice(self.batch_size, work_load_list)
# get testing data for multigpu
data_list = []
label_list = []
for islice in slices:
iroidb = [roidb[i] for i in range(islice.start, islice.stop)]
data, label = get_rpn_batch(iroidb)
data_list.append(data)
label_list.append(label)
# pad data first and then assign anchor (read label)
data_tensor = tensor_vstack([batch['data'] for batch in data_list])
for i_card in range(len(data_list)):
data_list[i_card]['data'] = data_tensor[
i_card * config.TRAIN.BATCH_IMAGES:(1 + i_card) * config.TRAIN.BATCH_IMAGES]
for data, label in zip(data_list, label_list):
data_shape = {k: v.shape for k, v in data.items()}
del data_shape['im_info']
feat_shape_list = []
for s in range(len(self.feat_stride)):
_, feat_shape, _ = self.feat_sym[s].infer_shape(**data_shape)
feat_shape = [int(i) for i in feat_shape[0]]
feat_shape_list.append(feat_shape)
for k in self.label_name:
label[k] = [0 for i in range(config.TRAIN.BATCH_IMAGES)]
for im_i in range(config.TRAIN.BATCH_IMAGES):
#im_info = data['im_info'][im_i]
#gt_boxes = label['gt_boxes'][im_i][0]
im_info = data['im_info']
gt_boxes = label['gt_boxes']
#print('im_info', im_info.shape)
#print(gt_boxes.shape)
vis=True if self.visid>=0 else False
label_dict = assign_anchor_fpn(feat_shape_list, gt_boxes, im_info, vis)
#do visualize for debug here
if self.visid>=0 and self.visid<10:
for _roi in roidb:
print('image', _roi['image'], file=sys.stderr)
self.visid+=1
anchors = label_dict['anchors'].copy()
_im = data['data'].copy()
#print(label_dict['olabel'].shape)
_label = label_dict['olabel'].copy()
_gt_boxes = gt_boxes.copy().astype(np.int)
filename = './vis/A%d.png'%self.visid
_im = _im[0].transpose( (1,2,0) )
_im = _im[...,::-1] #bgr
for c in range(3):
_im[:,:,c] += config.PIXEL_MEANS[c]
_im = _im.astype(np.uint8).copy()
fg_inds = np.where(_label == 1)[0]
print(_im.shape, _label.shape, anchors.shape, len(fg_inds), _gt_boxes.shape, file=sys.stderr)
#draw FG anchors
_bc = 0
for a in range(anchors.shape[0]):
anchor = anchors[a].astype(np.int)
l = _label[a]
if l!=1:
continue
#print('drawing', _im.shape, anchor)
cv2.rectangle(_im, (anchor[0], anchor[1]), (anchor[2], anchor[3]), (255, 0, 0), 1)
_bc+=1
for a in range(_gt_boxes.shape[0]):
_box = _gt_boxes[a]
cv2.rectangle(_im, (_box[0], _box[1]), (_box[2], _box[3]), (0, 0, 255), 1)
print('draw to', filename, _bc, file=sys.stderr)
cv2.imwrite(filename, _im)
for k in self.label_name:
#print('0in_loader', k, label_dict[k].shape, file=sys.stderr)
label[k][im_i] = label_dict[k]
for k in self.label_name:
label[k] = np.vstack(label[k])
#print('in_loader', k, label[k].shape, file=sys.stderr)
all_data = dict()
for key in self.data_name:
all_data[key] = tensor_vstack([batch[key] for batch in data_list])
all_label = dict()
for key in self.label_name:
pad = 0 if key.startswith('bbox_') else -1
#print('label vstack', key, pad, len(label_list), file=sys.stderr)
all_label[key] = tensor_vstack([batch[key] for batch in label_list], pad=pad)
self.data = [mx.nd.array(all_data[key]) for key in self.data_name]
self.label = [mx.nd.array(all_label[key]) for key in self.label_name]
