def test_anchor_to_box_3d(self):
anchors = np.asarray([[-0.59, 1.90, 25.01, 3.2, 1.66, 1.61],
[-0.59, 1.90, 25.01, 1.61, 1.66, 3.2]],
dtype=np.float32)
exp_3d_box = np.asarray([[-0.59, 1.90, 25.01, 3.2, 1.61, 1.66, 0],
[-0.59, 1.90, 25.01, 3.2, 1.61, 1.66, -1.57]],
dtype=np.float32)
anchor_boxes_3d = box_3d_encoder.anchors_to_box_3d(anchors,
fix_lw=True)
np.testing.assert_almost_equal(anchor_boxes_3d,
exp_3d_box,
decimal=3,
err_msg='Wrong anchor to box3D format')
def get_rpn_proposals_and_scores(self, predictions):
"""Returns the proposals and scores stacked for saving to file.
Args:
predictions: A dictionary containing the model outputs.
Returns:
proposals_and_scores: A numpy array of shape (number_of_proposals,
8), containing the rpn proposal boxes and scores.
"""
top_anchors = predictions[RpnModel.PRED_TOP_ANCHORS]
top_proposals = box_3d_encoder.anchors_to_box_3d(top_anchors)
softmax_scores = predictions[RpnModel.PRED_TOP_OBJECTNESS_SOFTMAX]
proposals_and_scores = np.column_stack((top_proposals, softmax_scores))
return proposals_and_scores
def test_anchor_tensor_to_box_3d(self):
anchors = np.asarray([[-0.59, 1.90, 25.01, 3.2, 1.66, 1.61],
[-0.59, 1.90, 25.01, 1.61, 1.66, 3.2]],
dtype=np.float32)
exp_3d_box = np.asarray([[-0.59, 1.90, 25.01, 3.2, 1.61, 1.66, 0],
[-0.59, 1.90, 25.01, 3.2, 1.61, 1.66, -1.57]],
dtype=np.float32)
anchor_tensors = tf.convert_to_tensor(anchors, dtype=tf.float32)
boxes_3d = \
box_3d_encoder.anchors_to_box_3d(anchor_tensors,
fix_lw=True)
sess = tf.Session()
with sess.as_default():
boxes_3d_out = boxes_3d.eval()
np.testing.assert_almost_equal(
boxes_3d_out, exp_3d_box, decimal=3,
err_msg='Wrong tensor anchor to box3D format')
def test_box_3d_to_box_8co(self):
# Tests the numpy version of the anchors_to_box_3d
# function. This is the non-vectorized version.
# Sample ground-truth in box3D format
gt_box_3d = np.asarray(
[-0.69, 1.69, 25.01, 3.2, 1.66, 1.61, -1.59],
dtype=np.float32)
# Sample box in anchor format
anchors = np.asarray([[-0.59, 1.90, 25.01, 3.2, 1.61, 1.66]],
dtype=np.float32)
# Convert the anchor to box3D format
anchor_box_3d = box_3d_encoder.anchors_to_box_3d(anchors,
fix_lw=True)
exp_gt_box_8co = np.asarray(
[[-1.55, 0.10, 0.17, -1.49, -1.55, 0.11, 0.17, -1.49],
[1.69, 1.69, 1.69, 1.69, 0.08, 0.08, 0.08, 0.08],
[26.59, 26.62, 23.43, 23.39, 26.59, 26.62, 23.42, 23.39]])
exp_anchor_box_8co = np.asarray(
[[1.01, 1.01, -2.19, -2.19, 1.01, 1.01, -2.19, -2.19],
[1.89, 1.89, 1.89, 1.89, 0.24, 0.24, 0.24, 0.24],
[25.81, 24.21, 24.21, 25.82, 25.82, 24.21, 24.21, 25.82]])
# convert to 8 corners
gt_box_8co = box_8c_encoder.np_box_3d_to_box_8co(gt_box_3d)
# the numpy version takes a single box
anchor_box_8co = \
box_8c_encoder.np_box_3d_to_box_8co(anchor_box_3d[0])
np.testing.assert_almost_equal(exp_gt_box_8co,
gt_box_8co,
decimal=2,
err_msg='GT corner encoding mismatch')
np.testing.assert_almost_equal(
exp_anchor_box_8co, anchor_box_8co, decimal=1,
err_msg='Anchor corner encoding mismatch')
def test_box_3d_tensor_to_box_8co(self):
# Tests the tensor version of the anchors_to_box_3d
# function. This is the vectorized version.
anchors = np.asarray([
[-0.59, 1.90, 25.01, 3.2, 1.66, 1.61],
[-0.80, 1.50, 22.01, 1.2, 1.70, 1.50]
])
anchor_boxes_3d = box_3d_encoder.anchors_to_box_3d(anchors,
fix_lw=True)
# convert each box to corner using the numpy version
boxes_8c_1 = \
box_8c_encoder.np_box_3d_to_box_8co(anchor_boxes_3d[0])
boxes_8c_2 = \
box_8c_encoder.np_box_3d_to_box_8co(anchor_boxes_3d[1])
exp_anchor_box_8co = np.stack((boxes_8c_1,
boxes_8c_2),
axis=0)
anchors_box3d_tensor = tf.convert_to_tensor(anchor_boxes_3d,
dtype=tf.float32)
# convert to 8 corners
anchor_box_corner_tensor = \
box_8c_encoder.tf_box_3d_to_box_8co(anchors_box3d_tensor)
sess = tf.Session()
with sess.as_default():
anchor_box_corner_out = anchor_box_corner_tensor.eval()
np.testing.assert_almost_equal(
exp_anchor_box_8co[0], anchor_box_corner_out[0], decimal=2,
err_msg='Anchor tensor corner encoding mismatch')
np.testing.assert_almost_equal(
exp_anchor_box_8co[1], anchor_box_corner_out[1], decimal=2,
err_msg='Anchor tensor corner encoding mismatch')
def build(self):
rpn_model = self._rpn_model
# Share the same prediction dict as RPN
prediction_dict = rpn_model.build()
top_anchors = prediction_dict[RpnModel.PRED_TOP_ANCHORS]
ground_plane = rpn_model.placeholders[RpnModel.PL_GROUND_PLANE]
class_labels = rpn_model.placeholders[RpnModel.PL_LABEL_CLASSES]
with tf.variable_scope('avod_projection'):
if self._config.expand_proposals_xz > 0.0:
expand_length = self._config.expand_proposals_xz
# Expand anchors along x and z
with tf.variable_scope('expand_xz'):
expanded_dim_x = top_anchors[:, 3] + expand_length
expanded_dim_z = top_anchors[:, 5] + expand_length
expanded_anchors = tf.stack([
top_anchors[:, 0], top_anchors[:, 1], top_anchors[:,
2],
expanded_dim_x, top_anchors[:, 4], expanded_dim_z
],
axis=1)
avod_projection_in = expanded_anchors
else:
avod_projection_in = top_anchors
with tf.variable_scope('bev'):
# Project top anchors into bev and image spaces
bev_proposal_boxes, bev_proposal_boxes_norm = \
anchor_projector.project_to_bev(
avod_projection_in,
self.dataset.kitti_utils.bev_extents)
# Reorder projected boxes into [y1, x1, y2, x2]
bev_proposal_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_proposal_boxes)
bev_proposal_boxes_norm_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_proposal_boxes_norm)
with tf.variable_scope('img'):
image_shape = tf.cast(
tf.shape(
rpn_model.placeholders[RpnModel.PL_IMG_INPUT])[0:2],
tf.float32)
img_proposal_boxes, img_proposal_boxes_norm = \
anchor_projector.tf_project_to_image_space(
avod_projection_in,
rpn_model.placeholders[RpnModel.PL_CALIB_P2],
image_shape)
# Only reorder the normalized img
img_proposal_boxes_norm_tf_order = \
anchor_projector.reorder_projected_boxes(
img_proposal_boxes_norm)
with tf.variable_scope('img_r'):
image_r_shape = tf.cast(
tf.shape(
rpn_model.placeholders[RpnModel.PL_IMG_R_INPUT])[0:2],
tf.float32)
img_r_proposal_boxes, img_r_proposal_boxes_norm = \
anchor_projector.tf_project_to_image_space(
avod_projection_in,
rpn_model.placeholders[RpnModel.PL_CALIB_P3],
image_r_shape)
# Only reorder the normalized img
img_r_proposal_boxes_norm_tf_order = \
anchor_projector.reorder_projected_boxes(
img_r_proposal_boxes_norm)
#bev_feature_maps = rpn_model.bev_feature_maps
img_feature_maps = rpn_model.img_feature_maps
img_r_feature_maps = rpn_model.img_r_feature_maps
"""
if not (self._path_drop_probabilities[0] ==
self._path_drop_probabilities[1] == 1.0):
with tf.variable_scope('avod_path_drop'):
img_mask = rpn_model.img_path_drop_mask
#bev_mask = rpn_model.bev_path_drop_mask
img_r_mask = rpn_model.img_r_path_drop_mask
img_feature_maps = tf.multiply(img_feature_maps,
img_mask)
#bev_feature_maps = tf.multiply(bev_feature_maps,
# bev_mask)
img_r_feature_maps = tf.multiply(img_r_feature_maps,
img_r_mask)
else:
#bev_mask = tf.constant(1.0)
img_mask = tf.constant(1.0)
img_r_mask = tf.constant(1.0)
"""
img_mask = tf.constant(1.0)
img_r_mask = tf.constant(1.0)
# ROI Pooling
with tf.variable_scope('avod_roi_pooling'):
def get_box_indices(boxes):
proposals_shape = boxes.get_shape().as_list()
if any(dim is None for dim in proposals_shape):
proposals_shape = tf.shape(boxes)
ones_mat = tf.ones(proposals_shape[:2], dtype=tf.int32)
multiplier = tf.expand_dims(
tf.range(start=0, limit=proposals_shape[0]), 1)
return tf.reshape(ones_mat * multiplier, [-1])
"""
bev_boxes_norm_batches = tf.expand_dims(
bev_proposal_boxes_norm, axis=0)
# These should be all 0's since there is only 1 image
tf_box_indices = get_box_indices(bev_boxes_norm_batches)
# Do ROI Pooling on BEV
bev_rois = tf.image.crop_and_resize(
bev_feature_maps,
bev_proposal_boxes_norm_tf_order,
tf_box_indices,
self._proposal_roi_crop_size,
name='bev_rois')
"""
img_boxes_norm_batches = tf.expand_dims(img_proposal_boxes_norm,
axis=0)
# These should be all 0's since there is only 1 image
tf_box_indices = get_box_indices(img_boxes_norm_batches)
# Do ROI Pooling on image
img_rois = tf.image.crop_and_resize(
img_feature_maps,
img_proposal_boxes_norm_tf_order,
tf_box_indices, (32, 32),
name='img_rois')
img_r_rois = tf.image.crop_and_resize(
img_r_feature_maps,
img_r_proposal_boxes_norm_tf_order,
tf_box_indices, (32, 32),
name='img_r_rois')
img_rois = self._sub_mean(img_rois)
img_r_rois = self._sub_mean(img_r_rois)
cos_simi = tf.reduce_sum(img_rois * img_r_rois, \
axis=[1, 2], keep_dims=True)
cos_simi = cos_simi / (tf.norm(img_rois + 1e-5, axis=[1, 2], keep_dims=True) * \
tf.norm(img_r_rois + 1e-5, axis=[1, 2], keep_dims=True))
cos_simi = tf.nn.relu(cos_simi)
img_rois = tf.image.resize_bilinear(
img_rois, self._proposal_roi_crop_size) * cos_simi
img_r_rois = tf.image.resize_bilinear(
img_r_rois, self._proposal_roi_crop_size) * cos_simi
# Fully connected layers (Box Predictor)
avod_layers_config = self.model_config.layers_config.avod_config
fc_output_layers = \
avod_fc_layers_builder.build(
layers_config=avod_layers_config,
input_rois=[img_rois, img_r_rois],
input_weights=[img_mask, img_r_mask],
num_final_classes=self._num_final_classes,
box_rep=self._box_rep,
top_anchors=top_anchors,
ground_plane=ground_plane,
is_training=self._is_training)
all_cls_logits = \
fc_output_layers[avod_fc_layers_builder.KEY_CLS_LOGITS]
all_offsets = fc_output_layers[avod_fc_layers_builder.KEY_OFFSETS]
# This may be None
all_angle_vectors = \
fc_output_layers.get(avod_fc_layers_builder.KEY_ANGLE_VECTORS)
with tf.variable_scope('softmax'):
all_cls_softmax = tf.nn.softmax(all_cls_logits)
######################################################
# Subsample mini_batch for the loss function
######################################################
# Get the ground truth tensors
anchors_gt = rpn_model.placeholders[RpnModel.PL_LABEL_ANCHORS]
if self._box_rep in ['box_3d', 'box_4ca']:
boxes_3d_gt = rpn_model.placeholders[RpnModel.PL_LABEL_BOXES_3D]
orientations_gt = boxes_3d_gt[:, 6]
elif self._box_rep in ['box_8c', 'box_8co', 'box_4c']:
boxes_3d_gt = rpn_model.placeholders[RpnModel.PL_LABEL_BOXES_3D]
else:
raise NotImplementedError('Ground truth tensors not implemented')
# Project anchor_gts to 2D bev
with tf.variable_scope('avod_gt_projection'):
bev_anchor_boxes_gt, _ = anchor_projector.project_to_bev(
anchors_gt, self.dataset.kitti_utils.bev_extents)
bev_anchor_boxes_gt_tf_order = \
anchor_projector.reorder_projected_boxes(bev_anchor_boxes_gt)
with tf.variable_scope('avod_box_list'):
# Convert to box_list format
anchor_box_list_gt = box_list.BoxList(bev_anchor_boxes_gt_tf_order)
anchor_box_list = box_list.BoxList(bev_proposal_boxes_tf_order)
mb_mask, mb_class_label_indices, mb_gt_indices = \
self.sample_mini_batch(
anchor_box_list_gt=anchor_box_list_gt,
anchor_box_list=anchor_box_list,
class_labels=class_labels)
# Create classification one_hot vector
with tf.variable_scope('avod_one_hot_classes'):
mb_classification_gt = tf.one_hot(
mb_class_label_indices,
depth=self._num_final_classes,
on_value=1.0 - self._config.label_smoothing_epsilon,
off_value=(self._config.label_smoothing_epsilon /
self.dataset.num_classes))
# TODO: Don't create a mini batch in test mode
# Mask predictions
with tf.variable_scope('avod_apply_mb_mask'):
# Classification
mb_classifications_logits = tf.boolean_mask(
all_cls_logits, mb_mask)
mb_classifications_softmax = tf.boolean_mask(
all_cls_softmax, mb_mask)
# Offsets
mb_offsets = tf.boolean_mask(all_offsets, mb_mask)
# Angle Vectors
if all_angle_vectors is not None:
mb_angle_vectors = tf.boolean_mask(all_angle_vectors, mb_mask)
else:
mb_angle_vectors = None
# Encode anchor offsets
with tf.variable_scope('avod_encode_mb_anchors'):
mb_anchors = tf.boolean_mask(top_anchors, mb_mask)
if self._box_rep == 'box_3d':
# Gather corresponding ground truth anchors for each mb sample
mb_anchors_gt = tf.gather(anchors_gt, mb_gt_indices)
mb_offsets_gt = anchor_encoder.tf_anchor_to_offset(
mb_anchors, mb_anchors_gt)
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt, mb_gt_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
# Get boxes_3d ground truth mini-batch and convert to box_8c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
if self._box_rep == 'box_8c':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8c(mb_boxes_3d_gt)
elif self._box_rep == 'box_8co':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8co(mb_boxes_3d_gt)
# Convert proposals: anchors -> box_3d -> box8c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(top_anchors, fix_lw=True)
proposal_boxes_8c = \
box_8c_encoder.tf_box_3d_to_box_8c(proposal_boxes_3d)
# Get mini batch offsets
mb_boxes_8c = tf.boolean_mask(proposal_boxes_8c, mb_mask)
mb_offsets_gt = box_8c_encoder.tf_box_8c_to_offsets(
mb_boxes_8c, mb_boxes_8c_gt)
# Flatten the offsets to a (N x 24) vector
mb_offsets_gt = tf.reshape(mb_offsets_gt, [-1, 24])
elif self._box_rep in ['box_4c', 'box_4ca']:
# Get ground plane for box_4c conversion
ground_plane = self._rpn_model.placeholders[
self._rpn_model.PL_GROUND_PLANE]
# Convert gt boxes_3d -> box_4c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
mb_boxes_4c_gt = box_4c_encoder.tf_box_3d_to_box_4c(
mb_boxes_3d_gt, ground_plane)
# Convert proposals: anchors -> box_3d -> box_4c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(top_anchors, fix_lw=True)
proposal_boxes_4c = \
box_4c_encoder.tf_box_3d_to_box_4c(proposal_boxes_3d,
ground_plane)
# Get mini batch
mb_boxes_4c = tf.boolean_mask(proposal_boxes_4c, mb_mask)
mb_offsets_gt = box_4c_encoder.tf_box_4c_to_offsets(
mb_boxes_4c, mb_boxes_4c_gt)
if self._box_rep == 'box_4ca':
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt,
mb_gt_indices)
else:
raise NotImplementedError(
'Anchor encoding not implemented for', self._box_rep)
######################################################
# ROI summary images
######################################################
avod_mini_batch_size = \
self.dataset.kitti_utils.mini_batch_utils.avod_mini_batch_size
"""
with tf.variable_scope('bev_avod_rois'):
mb_bev_anchors_norm = tf.boolean_mask(
bev_proposal_boxes_norm_tf_order, mb_mask)
mb_bev_box_indices = tf.zeros_like(mb_gt_indices, dtype=tf.int32)
# Show the ROIs of the BEV input density map
# for the mini batch anchors
bev_input_rois = tf.image.crop_and_resize(
self._rpn_model._bev_preprocessed,
mb_bev_anchors_norm,
mb_bev_box_indices,
(32, 32))
bev_input_roi_summary_images = tf.split(
bev_input_rois, self._bev_depth, axis=3)
tf.summary.image('bev_avod_rois',
bev_input_roi_summary_images[-1],
max_outputs=avod_mini_batch_size)
"""
with tf.variable_scope('img_avod_rois'):
# ROIs on image input
mb_img_anchors_norm = tf.boolean_mask(
img_proposal_boxes_norm_tf_order, mb_mask)
mb_img_box_indices = tf.zeros_like(mb_gt_indices, dtype=tf.int32)
# Do test ROI pooling on mini batch
img_input_rois = tf.image.crop_and_resize(
self._rpn_model._img_preprocessed, mb_img_anchors_norm,
mb_img_box_indices, (32, 32))
tf.summary.image('img_avod_rois',
img_input_rois,
max_outputs=avod_mini_batch_size)
with tf.variable_scope('img_r_avod_rois'):
# ROIs on image input
mb_img_r_anchors_norm = tf.boolean_mask(
img_r_proposal_boxes_norm_tf_order, mb_mask)
mb_img_r_box_indices = tf.zeros_like(mb_gt_indices, dtype=tf.int32)
# Do test ROI pooling on mini batch
img_r_input_rois = tf.image.crop_and_resize(
self._rpn_model._img_r_preprocessed, mb_img_r_anchors_norm,
mb_img_r_box_indices, (32, 32))
tf.summary.image('img_r_avod_rois',
img_r_input_rois,
max_outputs=avod_mini_batch_size)
######################################################
# Final Predictions
######################################################
# Get orientations from angle vectors
if all_angle_vectors is not None:
with tf.variable_scope('avod_orientation'):
all_orientations = \
orientation_encoder.tf_angle_vector_to_orientation(
all_angle_vectors)
# Apply offsets to regress proposals
with tf.variable_scope('avod_regression'):
if self._box_rep == 'box_3d':
prediction_anchors = \
anchor_encoder.offset_to_anchor(top_anchors,
all_offsets)
elif self._box_rep in ['box_8c', 'box_8co']:
# Reshape the 24-dim regressed offsets to (N x 3 x 8)
reshaped_offsets = tf.reshape(all_offsets, [-1, 3, 8])
# Given the offsets, get the boxes_8c
prediction_boxes_8c = \
box_8c_encoder.tf_offsets_to_box_8c(proposal_boxes_8c,
reshaped_offsets)
# Convert corners back to box3D
prediction_boxes_3d = \
box_8c_encoder.box_8c_to_box_3d(prediction_boxes_8c)
# Convert the box_3d to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
elif self._box_rep in ['box_4c', 'box_4ca']:
# Convert predictions box_4c -> box_3d
prediction_boxes_4c = \
box_4c_encoder.tf_offsets_to_box_4c(proposal_boxes_4c,
all_offsets)
prediction_boxes_3d = \
box_4c_encoder.tf_box_4c_to_box_3d(prediction_boxes_4c,
ground_plane)
# Convert to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
else:
raise NotImplementedError('Regression not implemented for',
self._box_rep)
# Apply Non-oriented NMS in BEV
with tf.variable_scope('avod_nms'):
bev_extents = self.dataset.kitti_utils.bev_extents
with tf.variable_scope('bev_projection'):
# Project predictions into BEV
avod_bev_boxes, _ = anchor_projector.project_to_bev(
prediction_anchors, bev_extents)
avod_bev_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
avod_bev_boxes)
# Get top score from second column onward
all_top_scores = tf.reduce_max(all_cls_logits[:, 1:], axis=1)
# Apply NMS in BEV
nms_indices = tf.image.non_max_suppression(
avod_bev_boxes_tf_order,
all_top_scores,
max_output_size=self._nms_size,
iou_threshold=self._nms_iou_threshold)
# Gather predictions from NMS indices
top_classification_logits = tf.gather(all_cls_logits, nms_indices)
top_classification_softmax = tf.gather(all_cls_softmax,
nms_indices)
top_prediction_anchors = tf.gather(prediction_anchors, nms_indices)
if self._box_rep == 'box_3d':
top_orientations = tf.gather(all_orientations, nms_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_8c = tf.gather(prediction_boxes_8c,
nms_indices)
elif self._box_rep == 'box_4c':
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_4c = tf.gather(prediction_boxes_4c,
nms_indices)
elif self._box_rep == 'box_4ca':
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_4c = tf.gather(prediction_boxes_4c,
nms_indices)
top_orientations = tf.gather(all_orientations, nms_indices)
else:
raise NotImplementedError('NMS gather not implemented for',
self._box_rep)
if self._train_val_test in ['train', 'val']:
# Additional entries are added to the shared prediction_dict
# Mini batch predictions
prediction_dict[self.PRED_MB_CLASSIFICATION_LOGITS] = \
mb_classifications_logits
prediction_dict[self.PRED_MB_CLASSIFICATION_SOFTMAX] = \
mb_classifications_softmax
prediction_dict[self.PRED_MB_OFFSETS] = mb_offsets
# Mini batch ground truth
prediction_dict[self.PRED_MB_CLASSIFICATIONS_GT] = \
mb_classification_gt
prediction_dict[self.PRED_MB_OFFSETS_GT] = mb_offsets_gt
# Top NMS predictions
prediction_dict[self.PRED_TOP_CLASSIFICATION_LOGITS] = \
top_classification_logits
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
# Mini batch predictions (for debugging)
prediction_dict[self.PRED_MB_MASK] = mb_mask
# prediction_dict[self.PRED_MB_POS_MASK] = mb_pos_mask
prediction_dict[self.PRED_MB_CLASS_INDICES_GT] = \
mb_class_label_indices
# All predictions (for debugging)
prediction_dict[self.PRED_ALL_CLASSIFICATIONS] = \
all_cls_logits
prediction_dict[self.PRED_ALL_OFFSETS] = all_offsets
# Path drop masks (for debugging)
#prediction_dict['bev_mask'] = bev_mask
prediction_dict['img_mask'] = img_mask
prediction_dict['img_r_mask'] = img_r_mask
else:
# self._train_val_test == 'test'
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
if self._box_rep == 'box_3d':
prediction_dict[self.PRED_MB_ANCHORS_GT] = mb_anchors_gt
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
# For debugging
prediction_dict[self.PRED_ALL_ANGLE_VECTORS] = all_angle_vectors
elif self._box_rep in ['box_8c', 'box_8co']:
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
# Store the corners before converting for visualization purposes
prediction_dict[self.PRED_TOP_BOXES_8C] = top_prediction_boxes_8c
elif self._box_rep == 'box_4c':
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
elif self._box_rep == 'box_4ca':
if self._train_val_test in ['train', 'val']:
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = \
mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
else:
raise NotImplementedError('Prediction dict not implemented for',
self._box_rep)
# prediction_dict[self.PRED_MAX_IOUS] = max_ious
# prediction_dict[self.PRED_ALL_IOUS] = all_ious
return prediction_dict
def get_avod_predicted_boxes_3d_and_scores(self, predictions, box_rep):
"""Returns the predictions and scores stacked for saving to file.
Args:
predictions: A dictionary containing the model outputs.
box_rep: A string indicating the format of the 3D bounding
boxes i.e. 'box_3d', 'box_8c' etc.
Returns:
predictions_and_scores: A numpy array of shape
(number_of_predicted_boxes, 9), containing the final prediction
boxes, orientations, scores, and types.
"""
if box_rep == 'box_3d':
# Convert anchors + orientation to box_3d
final_pred_anchors = predictions[
AvodModel.PRED_TOP_PREDICTION_ANCHORS]
final_pred_orientations = predictions[
AvodModel.PRED_TOP_ORIENTATIONS]
final_pred_boxes_3d = box_3d_encoder.anchors_to_box_3d(
final_pred_anchors, fix_lw=True)
final_pred_boxes_3d[:, 6] = final_pred_orientations
elif box_rep in ['box_8c', 'box_8co', 'box_4c']:
# Predictions are in box_3d format already
final_pred_boxes_3d = predictions[
AvodModel.PRED_TOP_PREDICTION_BOXES_3D]
elif box_rep == 'box_4ca':
# boxes_3d from boxes_4c
final_pred_boxes_3d = predictions[
AvodModel.PRED_TOP_PREDICTION_BOXES_3D]
# Predicted orientation from layers
final_pred_orientations = predictions[
AvodModel.PRED_TOP_ORIENTATIONS]
# Calculate difference between box_3d and predicted angle
ang_diff = final_pred_boxes_3d[:, 6] - final_pred_orientations
# Wrap differences between -pi and pi
two_pi = 2 * np.pi
ang_diff[ang_diff < -np.pi] += two_pi
ang_diff[ang_diff > np.pi] -= two_pi
def swap_boxes_3d_lw(boxes_3d):
boxes_3d_lengths = np.copy(boxes_3d[:, 3])
boxes_3d[:, 3] = boxes_3d[:, 4]
boxes_3d[:, 4] = boxes_3d_lengths
return boxes_3d
pi_0_25 = 0.25 * np.pi
pi_0_50 = 0.50 * np.pi
pi_0_75 = 0.75 * np.pi
# Rotate 90 degrees if difference between pi/4 and 3/4 pi
rot_pos_90_indices = np.logical_and(pi_0_25 < ang_diff,
ang_diff < pi_0_75)
final_pred_boxes_3d[rot_pos_90_indices] = \
swap_boxes_3d_lw(final_pred_boxes_3d[rot_pos_90_indices])
final_pred_boxes_3d[rot_pos_90_indices, 6] += pi_0_50
# Rotate -90 degrees if difference between -pi/4 and -3/4 pi
rot_neg_90_indices = np.logical_and(-pi_0_25 > ang_diff,
ang_diff > -pi_0_75)
final_pred_boxes_3d[rot_neg_90_indices] = \
swap_boxes_3d_lw(final_pred_boxes_3d[rot_neg_90_indices])
final_pred_boxes_3d[rot_neg_90_indices, 6] -= pi_0_50
# Flip angles if abs difference if greater than or equal to 135
# degrees
swap_indices = np.abs(ang_diff) >= pi_0_75
final_pred_boxes_3d[swap_indices, 6] += np.pi
# Wrap to -pi, pi
above_pi_indices = final_pred_boxes_3d[:, 6] > np.pi
final_pred_boxes_3d[above_pi_indices, 6] -= two_pi
else:
raise NotImplementedError('Parse predictions not implemented for',
box_rep)
# Append score and class index (object type)
final_pred_softmax = predictions[
AvodModel.PRED_TOP_CLASSIFICATION_SOFTMAX]
# Find max class score index
not_bkg_scores = final_pred_softmax[:, 1:]
final_pred_types = np.argmax(not_bkg_scores, axis=1)
# Take max class score (ignoring background)
final_pred_scores = np.array([])
for pred_idx in range(len(final_pred_boxes_3d)):
all_class_scores = not_bkg_scores[pred_idx]
max_class_score = all_class_scores[final_pred_types[pred_idx]]
final_pred_scores = np.append(final_pred_scores, max_class_score)
# Stack into prediction format
predictions_and_scores = np.column_stack(
[final_pred_boxes_3d, final_pred_scores, final_pred_types])
return predictions_and_scores
def build(self):
rpn_model = self._rpn_model
# Share the same prediction dict as RPN
prediction_dict = rpn_model.build()
top_anchors = prediction_dict[RpnModel.PRED_TOP_ANCHORS]
ground_plane = rpn_model.placeholders[RpnModel.PL_GROUND_PLANE]
class_labels = rpn_model.placeholders[RpnModel.PL_LABEL_CLASSES]
with tf.variable_scope('avod_projection'):
if self._config.expand_proposals_xz > 0.0:
expand_length = self._config.expand_proposals_xz
# Expand anchors along x and z
with tf.variable_scope('expand_xz'):
expanded_dim_x = top_anchors[:, 3] + expand_length
expanded_dim_z = top_anchors[:, 5] + expand_length
expanded_anchors = tf.stack([
top_anchors[:, 0], top_anchors[:, 1], top_anchors[:,
2],
expanded_dim_x, top_anchors[:, 4], expanded_dim_z
],
axis=1)
avod_projection_in = expanded_anchors
else:
avod_projection_in = top_anchors
with tf.variable_scope('bev'):
# Project top anchors into bev and image spaces
# bev_proposal_boxes are boxes' x and z coordinate relative to bev_extents
# bev_proposal_boxes_norm are normalized boxes in bev_extents' range
bev_proposal_boxes, bev_proposal_boxes_norm = \
anchor_projector.project_to_bev(
avod_projection_in,
self.dataset.kitti_utils.bev_extents)
# Reorder projected boxes into [y1, x1, y2, x2]
bev_proposal_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_proposal_boxes)
bev_proposal_boxes_norm_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_proposal_boxes_norm)
with tf.variable_scope('img'):
image_shape = tf.cast(
tf.shape(
rpn_model.placeholders[RpnModel.PL_IMG_INPUT])[0:2],
tf.float32)
img_proposal_boxes, img_proposal_boxes_norm = \
anchor_projector.tf_project_to_image_space(
avod_projection_in,
rpn_model.placeholders[RpnModel.PL_CALIB_P2],
image_shape)
# Only reorder the normalized img
img_proposal_boxes_norm_tf_order = \
anchor_projector.reorder_projected_boxes(
img_proposal_boxes_norm)
bev_feature_maps = rpn_model.bev_feature_maps
img_feature_maps = rpn_model.img_feature_maps
if not (self._path_drop_probabilities[0] ==
self._path_drop_probabilities[1] == 1.0):
with tf.variable_scope('avod_path_drop'):
img_mask = rpn_model.img_path_drop_mask
bev_mask = rpn_model.bev_path_drop_mask
img_feature_maps = tf.multiply(img_feature_maps, img_mask)
bev_feature_maps = tf.multiply(bev_feature_maps, bev_mask)
else:
bev_mask = tf.constant(1.0)
img_mask = tf.constant(1.0)
# ROI Pooling
with tf.variable_scope('avod_roi_pooling'):
def get_box_indices(boxes):
proposals_shape = boxes.get_shape().as_list()
if any(dim is None for dim in proposals_shape):
proposals_shape = tf.shape(boxes)
ones_mat = tf.ones(proposals_shape[:2], dtype=tf.int32)
multiplier = tf.expand_dims(
tf.range(start=0, limit=proposals_shape[0]), 1)
return tf.reshape(ones_mat * multiplier, [-1])
bev_boxes_norm_batches = tf.expand_dims(bev_proposal_boxes_norm,
axis=0)
# These should be all 0's since there is only 1 image
tf_box_indices = get_box_indices(bev_boxes_norm_batches)
# Do ROI Pooling on BEV
# tf_box_indices contains 1D tensor with size [num_boxes], each element specifies
# batch index to whom this box belongs. Because the batch size here is 1, so it
# doesn't matter
# bev_rois is a 4-D tensor of shape [num_boxes, crop_height, crop_width, depth]
####################################################################################
# TODO PROJECT: set bev_feature_maps or img_feature_maps to zeros for testing
# bev_feature_maps = tf.zeros_like(bev_feature_maps)
# self.bev_feature_maps = tf.zeros_like(bev_feature_maps)
# bev_feature_maps = self.bev_feature_maps
####################################################################################
bev_rois = tf.image.crop_and_resize(
bev_feature_maps,
bev_proposal_boxes_norm_tf_order,
tf_box_indices,
self._proposal_roi_crop_size,
name='bev_rois')
# Do ROI Pooling on image
img_rois = tf.image.crop_and_resize(
img_feature_maps,
img_proposal_boxes_norm_tf_order,
tf_box_indices,
self._proposal_roi_crop_size,
name='img_rois')
####################################################################################
# TODO PROJECT: create member variables for accessing
# bev_rois4moe = tf.image.crop_and_resize(
# bev_feature_maps,
# bev_proposal_boxes_norm_tf_order,
# tf_box_indices,
# [28,28],
# name='bev_rois4moe')
# # Do ROI Pooling on image
# img_rois4moe = tf.image.crop_and_resize(
# img_feature_maps,
# img_proposal_boxes_norm_tf_order,
# tf_box_indices,
# [28,28],
# name='img_rois4moe')
####################################################################################
####################################################################################
# TODO PROJECT: create member variables for accessing
# self.bev_rois = bev_rois
# self.img_rois = img_rois
self.bev_boxes = bev_proposal_boxes_tf_order
self.bev_boxes_norm = bev_proposal_boxes_norm
self.img_boxes = img_proposal_boxes
self.img_boxes_norm = img_proposal_boxes_norm
# self.bev_mask = rpn_model.bev_path_drop_mask
# self.img_mask = rpn_model.img_path_drop_mask
####################################################################################
####################################################################################
# TODO PROJECT: scale the features to features with larger maximum values
# self.max_img_feature_val = tf.reduce_max(img_rois, axis=None)
# self.max_bev_feature_val = tf.reduce_max(bev_rois, axis=None)
#
# bev_rois_moe = tf.cond(tf.greater(self.max_img_feature_val, self.max_bev_feature_val),
# lambda: self.scale_bev(bev_rois, img_rois),
# lambda: bev_rois)
# img_rois_moe = tf.cond(tf.greater(self.max_bev_feature_val, self.max_img_feature_val),
# lambda: self.scale_img(bev_rois, img_rois),
# lambda: img_rois)
####################################################################################
####################################################################################
# TODO PROJECT: insert code here to add mixture of experts
# self._moe_model = MoeModel(img_rois, bev_rois, img_proposal_boxes, bev_proposal_boxes)
# self._moe_model = MoeModel(img_feature_maps, bev_feature_maps, img_proposal_boxes, bev_proposal_boxes)
# self._moe_model._set_up_input_pls()
# self.moe_prediction = self._moe_model.build()
####################################################################################
####################################################################################
# TODO PROJECT: weight the feature before average img and bev
# img_weights = tf.reshape(self.moe_prediction['img_weight'],[-1,1,1,1])
# bev_weights = tf.reshape(self.moe_prediction['bev_weight'],[-1,1,1,1])
# img_weights = 0.5 * tf.ones([1024,1,1,1], tf.float32)
# bev_weights = 0.5 * tf.ones([1024,1,1,1], tf.float32)
# weighted_img_rois = tf.multiply(img_weights,img_rois)
# weighted_bev_rois = tf.multiply(bev_weights,bev_rois)
####################################################################################
####################################################################################
# TODO PROJECT: create fused bev
_, bev_mar_boxes_norm = cf.add_margin_to_regions(
bev_proposal_boxes, self.dataset.kitti_utils.bev_extents)
bev_pixels_loc = cf.bev_pixel_eq_1_loc(
self._rpn_model._bev_preprocessed)
max_height = self.dataset.config.kitti_utils_config.bev_generator.slices.height_hi
min_height = self.dataset.config.kitti_utils_config.bev_generator.slices.height_lo
num_slices = self.dataset.config.kitti_utils_config.bev_generator.slices.num_slices
height_list = [
min_height + (2 * x + 1) * (max_height - min_height) /
(2.0 * num_slices) for x in range(num_slices)
]
print("bev_preprocess shape: ",
(self._rpn_model._bev_preprocessed).shape)
velo_pc = cf.bev_pixel_loc_to_3d_velo(
bev_pixels_loc,
tf.shape(self._rpn_model._bev_preprocessed)[1:3], height_list,
self.dataset.kitti_utils.bev_extents)
print("PL_CALIB_P2 shape: ",
self._rpn_model.placeholders[RpnModel.PL_CALIB_P2].shape)
p_2d = anchor_projector.project_to_image_tensor(
tf.transpose(tf.cast(velo_pc, tf.float32)),
self._rpn_model.placeholders[RpnModel.PL_CALIB_P2])
print("image feature maps [0] shape: ", img_feature_maps[0].shape)
features_at_p_2d = tf.gather_nd(
img_feature_maps[0], tf.cast(tf.round(tf.transpose(p_2d)),
tf.int32))
print("features_at_p_2d shape: ", features_at_p_2d.shape)
new_bev = cf.create_fused_bev(
tf.shape(self._rpn_model._bev_preprocessed), bev_pixels_loc,
features_at_p_2d)
# raise Exception("finish fused_bev generation!")
self._new_bev_feature_extractor = feature_extractor_builder.get_extractor(
self.model_config.layers_config.bev_feature_extractor)
self.new_bev_feature_maps, self.new_bev_end_points = \
self._new_bev_feature_extractor.build(
new_bev,
self._bev_pixel_size,
self._is_training,
scope='new_bev_vgg'
)
new_bev_rois = tf.image.crop_and_resize(
self.new_bev_feature_maps,
bev_proposal_boxes_norm_tf_order,
tf_box_indices,
self._proposal_roi_crop_size,
name='new_bev_rois')
####################################################################################
# Fully connected layers (Box Predictor)
avod_layers_config = self.model_config.layers_config.avod_config
# fc_output_layers = \
# avod_fc_layers_builder.build(
# layers_config=avod_layers_config,
# input_rois=[bev_rois, img_rois],
# input_weights=[bev_mask, img_mask],
# num_final_classes=self._num_final_classes,
# box_rep=self._box_rep,
# top_anchors=top_anchors,
# ground_plane=ground_plane,
# is_training=self._is_training)
####################################################################################
# TODO PROJECT: average img and bev features first and then concat with new bev
rois_sum = tf.reduce_sum([bev_rois, img_rois], axis=0)
rois_mean = tf.divide(rois_sum, tf.reduce_sum([bev_mask, img_mask]))
fc_output_layers = \
avod_fc_layers_builder.build(
layers_config=avod_layers_config,
input_rois=[rois_mean, new_bev_rois],
input_weights=[1, img_mask],
num_final_classes=self._num_final_classes,
box_rep=self._box_rep,
top_anchors=top_anchors,
ground_plane=ground_plane,
is_training=self._is_training)
####################################################################################
####################################################################################
# TODO PROJECT: input weighted bev_rois and img_rois to output layer
# fc_output_layers = \
# avod_fc_layers_builder.build(
# layers_config=avod_layers_config,
# input_rois=[weighted_bev_rois, weighted_img_rois],
# input_weights=[bev_mask * bev_weights, img_mask * img_weights],
# num_final_classes=self._num_final_classes,
# box_rep=self._box_rep,
# top_anchors=top_anchors,
# ground_plane=ground_plane,
# is_training=self._is_training)
####################################################################################
all_cls_logits = \
fc_output_layers[avod_fc_layers_builder.KEY_CLS_LOGITS]
all_offsets = fc_output_layers[avod_fc_layers_builder.KEY_OFFSETS]
# This may be None
all_angle_vectors = \
fc_output_layers.get(avod_fc_layers_builder.KEY_ANGLE_VECTORS)
with tf.variable_scope('softmax'):
all_cls_softmax = tf.nn.softmax(all_cls_logits)
######################################################
# Subsample mini_batch for the loss function
######################################################
# Get the ground truth tensors
anchors_gt = rpn_model.placeholders[RpnModel.PL_LABEL_ANCHORS]
if self._box_rep in ['box_3d', 'box_4ca']:
boxes_3d_gt = rpn_model.placeholders[RpnModel.PL_LABEL_BOXES_3D]
orientations_gt = boxes_3d_gt[:, 6]
elif self._box_rep in ['box_8c', 'box_8co', 'box_4c']:
boxes_3d_gt = rpn_model.placeholders[RpnModel.PL_LABEL_BOXES_3D]
else:
raise NotImplementedError('Ground truth tensors not implemented')
# Project anchor_gts to 2D bev
with tf.variable_scope('avod_gt_projection'):
bev_anchor_boxes_gt, _ = anchor_projector.project_to_bev(
anchors_gt, self.dataset.kitti_utils.bev_extents)
bev_anchor_boxes_gt_tf_order = \
anchor_projector.reorder_projected_boxes(bev_anchor_boxes_gt)
with tf.variable_scope('avod_box_list'):
# Convert to box_list format
anchor_box_list_gt = box_list.BoxList(bev_anchor_boxes_gt_tf_order)
anchor_box_list = box_list.BoxList(bev_proposal_boxes_tf_order)
mb_mask, mb_class_label_indices, mb_gt_indices = \
self.sample_mini_batch(
anchor_box_list_gt=anchor_box_list_gt,
anchor_box_list=anchor_box_list,
class_labels=class_labels)
# Create classification one_hot vector
with tf.variable_scope('avod_one_hot_classes'):
mb_classification_gt = tf.one_hot(
mb_class_label_indices,
depth=self._num_final_classes,
on_value=1.0 - self._config.label_smoothing_epsilon,
off_value=(self._config.label_smoothing_epsilon /
self.dataset.num_classes))
# TODO: Don't create a mini batch in test mode
# Mask predictions
with tf.variable_scope('avod_apply_mb_mask'):
# Classification
mb_classifications_logits = tf.boolean_mask(
all_cls_logits, mb_mask)
mb_classifications_softmax = tf.boolean_mask(
all_cls_softmax, mb_mask)
# Offsets
mb_offsets = tf.boolean_mask(all_offsets, mb_mask)
# Angle Vectors
if all_angle_vectors is not None:
mb_angle_vectors = tf.boolean_mask(all_angle_vectors, mb_mask)
else:
mb_angle_vectors = None
# Encode anchor offsets
with tf.variable_scope('avod_encode_mb_anchors'):
mb_anchors = tf.boolean_mask(top_anchors, mb_mask)
if self._box_rep == 'box_3d':
# Gather corresponding ground truth anchors for each mb sample
mb_anchors_gt = tf.gather(anchors_gt, mb_gt_indices)
mb_offsets_gt = anchor_encoder.tf_anchor_to_offset(
mb_anchors, mb_anchors_gt)
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt, mb_gt_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
# Get boxes_3d ground truth mini-batch and convert to box_8c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
if self._box_rep == 'box_8c':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8c(mb_boxes_3d_gt)
elif self._box_rep == 'box_8co':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8co(mb_boxes_3d_gt)
# Convert proposals: anchors -> box_3d -> box8c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(top_anchors, fix_lw=True)
proposal_boxes_8c = \
box_8c_encoder.tf_box_3d_to_box_8c(proposal_boxes_3d)
# Get mini batch offsets
mb_boxes_8c = tf.boolean_mask(proposal_boxes_8c, mb_mask)
mb_offsets_gt = box_8c_encoder.tf_box_8c_to_offsets(
mb_boxes_8c, mb_boxes_8c_gt)
# Flatten the offsets to a (N x 24) vector
mb_offsets_gt = tf.reshape(mb_offsets_gt, [-1, 24])
elif self._box_rep in ['box_4c', 'box_4ca']:
# Get ground plane for box_4c conversion
ground_plane = self._rpn_model.placeholders[
self._rpn_model.PL_GROUND_PLANE]
# Convert gt boxes_3d -> box_4c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
mb_boxes_4c_gt = box_4c_encoder.tf_box_3d_to_box_4c(
mb_boxes_3d_gt, ground_plane)
# Convert proposals: anchors -> box_3d -> box_4c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(top_anchors, fix_lw=True)
proposal_boxes_4c = \
box_4c_encoder.tf_box_3d_to_box_4c(proposal_boxes_3d,
ground_plane)
# Get mini batch
mb_boxes_4c = tf.boolean_mask(proposal_boxes_4c, mb_mask)
mb_offsets_gt = box_4c_encoder.tf_box_4c_to_offsets(
mb_boxes_4c, mb_boxes_4c_gt)
if self._box_rep == 'box_4ca':
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt,
mb_gt_indices)
else:
raise NotImplementedError(
'Anchor encoding not implemented for', self._box_rep)
######################################################
# ROI summary images
######################################################
avod_mini_batch_size = \
self.dataset.kitti_utils.mini_batch_utils.avod_mini_batch_size
with tf.variable_scope('bev_avod_rois'):
mb_bev_anchors_norm = tf.boolean_mask(
bev_proposal_boxes_norm_tf_order, mb_mask)
mb_bev_box_indices = tf.zeros_like(mb_gt_indices, dtype=tf.int32)
# Show the ROIs of the BEV input density map
# for the mini batch anchors
bev_input_rois = tf.image.crop_and_resize(
self._rpn_model._bev_preprocessed, mb_bev_anchors_norm,
mb_bev_box_indices, (32, 32))
bev_input_roi_summary_images = tf.split(bev_input_rois,
self._bev_depth,
axis=3)
tf.summary.image('bev_avod_rois',
bev_input_roi_summary_images[-1],
max_outputs=avod_mini_batch_size)
with tf.variable_scope('img_avod_rois'):
# ROIs on image input
mb_img_anchors_norm = tf.boolean_mask(
img_proposal_boxes_norm_tf_order, mb_mask)
mb_img_box_indices = tf.zeros_like(mb_gt_indices, dtype=tf.int32)
# Do test ROI pooling on mini batch
img_input_rois = tf.image.crop_and_resize(
self._rpn_model._img_preprocessed, mb_img_anchors_norm,
mb_img_box_indices, (32, 32))
tf.summary.image('img_avod_rois',
img_input_rois,
max_outputs=avod_mini_batch_size)
######################################################
# Final Predictions
######################################################
# Get orientations from angle vectors
if all_angle_vectors is not None:
with tf.variable_scope('avod_orientation'):
all_orientations = \
orientation_encoder.tf_angle_vector_to_orientation(
all_angle_vectors)
# Apply offsets to regress proposals
with tf.variable_scope('avod_regression'):
if self._box_rep == 'box_3d':
prediction_anchors = \
anchor_encoder.offset_to_anchor(top_anchors,
all_offsets)
elif self._box_rep in ['box_8c', 'box_8co']:
# Reshape the 24-dim regressed offsets to (N x 3 x 8)
reshaped_offsets = tf.reshape(all_offsets, [-1, 3, 8])
# Given the offsets, get the boxes_8c
prediction_boxes_8c = \
box_8c_encoder.tf_offsets_to_box_8c(proposal_boxes_8c,
reshaped_offsets)
# Convert corners back to box3D
prediction_boxes_3d = \
box_8c_encoder.box_8c_to_box_3d(prediction_boxes_8c)
# Convert the box_3d to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
elif self._box_rep in ['box_4c', 'box_4ca']:
# Convert predictions box_4c -> box_3d
prediction_boxes_4c = \
box_4c_encoder.tf_offsets_to_box_4c(proposal_boxes_4c,
all_offsets)
prediction_boxes_3d = \
box_4c_encoder.tf_box_4c_to_box_3d(prediction_boxes_4c,
ground_plane)
# Convert to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
else:
raise NotImplementedError('Regression not implemented for',
self._box_rep)
# Apply Non-oriented NMS in BEV
with tf.variable_scope('avod_nms'):
bev_extents = self.dataset.kitti_utils.bev_extents
with tf.variable_scope('bev_projection'):
# Project predictions into BEV
avod_bev_boxes, _ = anchor_projector.project_to_bev(
prediction_anchors, bev_extents)
avod_bev_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
avod_bev_boxes)
# Get top score from second column onward
all_top_scores = tf.reduce_max(all_cls_logits[:, 1:], axis=1)
# Apply NMS in BEV
nms_indices = tf.image.non_max_suppression(
avod_bev_boxes_tf_order,
all_top_scores,
max_output_size=self._nms_size,
iou_threshold=self._nms_iou_threshold)
# Gather predictions from NMS indices
top_classification_logits = tf.gather(all_cls_logits, nms_indices)
top_classification_softmax = tf.gather(all_cls_softmax,
nms_indices)
top_prediction_anchors = tf.gather(prediction_anchors, nms_indices)
if self._box_rep == 'box_3d':
top_orientations = tf.gather(all_orientations, nms_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_8c = tf.gather(prediction_boxes_8c,
nms_indices)
elif self._box_rep == 'box_4c':
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_4c = tf.gather(prediction_boxes_4c,
nms_indices)
elif self._box_rep == 'box_4ca':
top_prediction_boxes_3d = tf.gather(prediction_boxes_3d,
nms_indices)
top_prediction_boxes_4c = tf.gather(prediction_boxes_4c,
nms_indices)
top_orientations = tf.gather(all_orientations, nms_indices)
else:
raise NotImplementedError('NMS gather not implemented for',
self._box_rep)
if self._train_val_test in ['train', 'val']:
# Additional entries are added to the shared prediction_dict
# Mini batch predictions
prediction_dict[self.PRED_MB_CLASSIFICATION_LOGITS] = \
mb_classifications_logits
prediction_dict[self.PRED_MB_CLASSIFICATION_SOFTMAX] = \
mb_classifications_softmax
prediction_dict[self.PRED_MB_OFFSETS] = mb_offsets
# Mini batch ground truth
prediction_dict[self.PRED_MB_CLASSIFICATIONS_GT] = \
mb_classification_gt
prediction_dict[self.PRED_MB_OFFSETS_GT] = mb_offsets_gt
# Top NMS predictions
prediction_dict[self.PRED_TOP_CLASSIFICATION_LOGITS] = \
top_classification_logits
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
# Mini batch predictions (for debugging)
prediction_dict[self.PRED_MB_MASK] = mb_mask
# prediction_dict[self.PRED_MB_POS_MASK] = mb_pos_mask
prediction_dict[self.PRED_MB_CLASS_INDICES_GT] = \
mb_class_label_indices
# All predictions (for debugging)
prediction_dict[self.PRED_ALL_CLASSIFICATIONS] = \
all_cls_logits
prediction_dict[self.PRED_ALL_OFFSETS] = all_offsets
# Path drop masks (for debugging)
prediction_dict['bev_mask'] = bev_mask
prediction_dict['img_mask'] = img_mask
else:
# self._train_val_test == 'test'
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
if self._box_rep == 'box_3d':
prediction_dict[self.PRED_MB_ANCHORS_GT] = mb_anchors_gt
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
# For debugging
prediction_dict[self.PRED_ALL_ANGLE_VECTORS] = all_angle_vectors
# 8c means 8 corners
elif self._box_rep in ['box_8c', 'box_8co']:
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
# Store the corners before converting for visualization purposes
prediction_dict[self.PRED_TOP_BOXES_8C] = top_prediction_boxes_8c
# 4c means 4 corners
elif self._box_rep == 'box_4c':
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
elif self._box_rep == 'box_4ca':
if self._train_val_test in ['train', 'val']:
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = \
mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
else:
raise NotImplementedError('Prediction dict not implemented for',
self._box_rep)
# prediction_dict[self.PRED_MAX_IOUS] = max_ious
# prediction_dict[self.PRED_ALL_IOUS] = all_ious
return prediction_dict
def build(self):
# Setup input placeholders
self._set_up_input_pls()
# Setup feature extractors
self._set_up_feature_extractors()
bev_proposal_input = self.bev_feature_maps
img_proposal_input = self.img_feature_maps
fusion_mean_div_factor = 2.0
# If both img and bev probabilites are set to 1.0, don't do
# path drop.
if not (self._path_drop_probabilities[0] ==
self._path_drop_probabilities[1] == 1.0):
with tf.variable_scope('rpn_path_drop'):
random_values = tf.random_uniform(shape=[3],
minval=0.0,
maxval=1.0)
img_mask, bev_mask = self.create_path_drop_masks(
self._path_drop_probabilities[0],
self._path_drop_probabilities[1],
random_values)
img_proposal_input = tf.multiply(img_proposal_input,
img_mask)
bev_proposal_input = tf.multiply(bev_proposal_input,
bev_mask)
self.img_path_drop_mask = img_mask
self.bev_path_drop_mask = bev_mask
# Overwrite the division factor
fusion_mean_div_factor = img_mask + bev_mask
with tf.variable_scope('proposal_roi_pooling'):
with tf.variable_scope('box_indices'):
def get_box_indices(boxes):
proposals_shape = boxes.get_shape().as_list()
if any(dim is None for dim in proposals_shape):
proposals_shape = tf.shape(boxes)
ones_mat = tf.ones(proposals_shape[:2], dtype=tf.int32)
multiplier = tf.expand_dims(
tf.range(start=0, limit=proposals_shape[0]), 1)
return tf.reshape(ones_mat * multiplier, [-1])
bev_boxes_norm_batches = tf.expand_dims(
self._bev_anchors_norm_pl, axis=0)
# These should be all 0's since there is only 1 image
tf_box_indices = get_box_indices(bev_boxes_norm_batches)
# Do ROI Pooling on BEV
bev_proposal_rois = tf.image.crop_and_resize(
bev_proposal_input,
self._bev_anchors_norm_pl,
tf_box_indices,
self._proposal_roi_crop_size)
# Do ROI Pooling on image
img_proposal_rois = tf.image.crop_and_resize(
img_proposal_input,
self._img_anchors_norm_pl,
tf_box_indices,
self._proposal_roi_crop_size)
# Fully connected layers (Box Predictor)
avod_layers_config = self.model_config.layers_config.avod_config
with tf.variable_scope('proposal_roi_fusion'):
feat_fusion_out = None
fc_layers_type = avod_layers_config.WhichOneof('fc_layers')
if fc_layers_type == 'basic_fc_layers':
fusion_method = \
avod_layers_config.basic_fc_layers.fusion_method
elif fc_layers_type == 'fusion_fc_layers':
fusion_method = \
avod_layers_config.fusion_fc_layers.fusion_method
if fusion_method == 'mean':
tf_features_sum = tf.add(bev_proposal_rois, img_proposal_rois)
feat_fusion_out = tf.divide(tf_features_sum,
fusion_mean_div_factor)
elif fusion_method == 'concat':
feat_fusion_out = tf.concat(
[bev_proposal_rois, img_proposal_rois], axis=3)
else:
raise ValueError('Invalid fusion method', self._fusion_method)
all_anchors = self.placeholders[self.PL_ANCHORS]
ground_plane = self.placeholders[self.PL_GROUND_PLANE]
fc_output_layers = \
avod_fc_layers_builder.build(
layers_config=avod_layers_config,
input_rois=[feat_fusion_out],
input_weights=[1.0],
num_final_classes=self._num_final_classes,
box_rep=self._box_rep,
top_anchors=all_anchors,
ground_plane=ground_plane,
is_training=self._is_training)
all_cls_logits = \
fc_output_layers[avod_fc_layers_builder.KEY_CLS_LOGITS]
all_offsets = fc_output_layers[avod_fc_layers_builder.KEY_OFFSETS]
# This may be None
all_angle_vectors = \
fc_output_layers.get(avod_fc_layers_builder.KEY_ANGLE_VECTORS)
with tf.variable_scope('softmax'):
all_cls_softmax = tf.nn.softmax(
all_cls_logits)
######################################################
# Subsample mini_batch for the loss function
######################################################
# Get the ground truth tensors
anchors_gt = self.placeholders[self.PL_LABEL_ANCHORS]
if self._box_rep in ['box_3d', 'box_4ca']:
boxes_3d_gt = self.placeholders[self.PL_LABEL_BOXES_3D]
orientations_gt = boxes_3d_gt[:, 6]
elif self._box_rep in ['box_8c', 'box_8co', 'box_4c']:
boxes_3d_gt = self.placeholders[self.PL_LABEL_BOXES_3D]
else:
raise NotImplementedError('Ground truth tensors not implemented')
if self._train_val_test in ['train', 'val']:
with tf.variable_scope('bev'):
# Project all anchors into bev and image spaces
bev_proposal_boxes, bev_proposal_boxes_norm = \
anchor_projector.project_to_bev(
all_anchors,
self.dataset.kitti_utils.bev_extents)
# Reorder projected boxes into [y1, x1, y2, x2]
bev_proposal_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_proposal_boxes)
with tf.variable_scope('img'):
image_shape = tf.cast(tf.shape(
self.placeholders[self.PL_IMG_INPUT])[0:2],
tf.float32)
img_proposal_boxes, img_proposal_boxes_norm = \
anchor_projector.tf_project_to_image_space(
all_anchors,
self.placeholders[self.PL_CALIB_P2],
image_shape)
# Project anchor_gts to 2D bev
with tf.variable_scope('avod_gt_projection'):
bev_anchor_boxes_gt, _ = anchor_projector.project_to_bev(
anchors_gt, self.dataset.kitti_utils.bev_extents)
bev_anchor_boxes_gt_tf_order = \
anchor_projector.reorder_projected_boxes(
bev_anchor_boxes_gt)
with tf.variable_scope('avod_box_list'):
# Convert to box_list format
anchor_box_list_gt = \
box_list.BoxList(bev_anchor_boxes_gt_tf_order)
anchor_box_list = \
box_list.BoxList(bev_proposal_boxes_tf_order)
class_labels = self.placeholders[self.PL_LABEL_CLASSES]
mb_mask, mb_class_label_indices, mb_gt_indices = \
self.sample_mini_batch(
anchor_box_list_gt=anchor_box_list_gt,
anchor_box_list=anchor_box_list,
class_labels=class_labels)
# Create classification one_hot vector
with tf.variable_scope('avod_one_hot_classes'):
mb_classification_gt = tf.one_hot(
mb_class_label_indices,
depth=self._num_final_classes,
on_value=1.0 - self._config.label_smoothing_epsilon,
off_value=(self._config.label_smoothing_epsilon /
self.dataset.num_classes))
# Mask predictions
with tf.variable_scope('avod_apply_mb_mask'):
# Classification
mb_classifications_logits = tf.boolean_mask(
all_cls_logits, mb_mask)
mb_classifications_softmax = tf.boolean_mask(
all_cls_softmax, mb_mask)
# Offsets
mb_offsets = tf.boolean_mask(all_offsets, mb_mask)
# Angle Vectors
if all_angle_vectors is not None:
mb_angle_vectors = tf.boolean_mask(
all_angle_vectors, mb_mask)
else:
mb_angle_vectors = None
# Encode anchor offsets
with tf.variable_scope('avod_encode_mb_anchors'):
mb_anchors = tf.boolean_mask(all_anchors, mb_mask)
if self._box_rep == 'box_3d':
# Gather corresponding ground truth anchors for each mb
# sample
mb_anchors_gt = tf.gather(anchors_gt, mb_gt_indices)
mb_offsets_gt = anchor_encoder.tf_anchor_to_offset(
mb_anchors, mb_anchors_gt)
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt,
mb_gt_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
# Get boxes_3d ground truth mini-batch and convert to box_8c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
if self._box_rep == 'box_8c':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8c(mb_boxes_3d_gt)
elif self._box_rep == 'box_8co':
mb_boxes_8c_gt = \
box_8c_encoder.tf_box_3d_to_box_8co(mb_boxes_3d_gt)
# Convert proposals: anchors -> box_3d -> box8c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(all_anchors,
fix_lw=True)
proposal_boxes_8c = \
box_8c_encoder.tf_box_3d_to_box_8c(proposal_boxes_3d)
# Get mini batch offsets
mb_boxes_8c = tf.boolean_mask(proposal_boxes_8c, mb_mask)
mb_offsets_gt = box_8c_encoder.tf_box_8c_to_offsets(
mb_boxes_8c, mb_boxes_8c_gt)
# Flatten the offsets to a (N x 24) vector
mb_offsets_gt = tf.reshape(mb_offsets_gt, [-1, 24])
elif self._box_rep in ['box_4c', 'box_4ca']:
# Get ground plane for box_4c conversion
ground_plane = self.placeholders[
self.PL_GROUND_PLANE]
# Convert gt boxes_3d -> box_4c
mb_boxes_3d_gt = tf.gather(boxes_3d_gt, mb_gt_indices)
mb_boxes_4c_gt = box_4c_encoder.tf_box_3d_to_box_4c(
mb_boxes_3d_gt, ground_plane)
# Convert proposals: anchors -> box_3d -> box_4c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(all_anchors,
fix_lw=True)
proposal_boxes_4c = \
box_4c_encoder.tf_box_3d_to_box_4c(proposal_boxes_3d,
ground_plane)
# Get mini batch
mb_boxes_4c = tf.boolean_mask(proposal_boxes_4c, mb_mask)
mb_offsets_gt = box_4c_encoder.tf_box_4c_to_offsets(
mb_boxes_4c, mb_boxes_4c_gt)
if self._box_rep == 'box_4ca':
# Gather corresponding ground truth orientation for each
# mb sample
mb_orientations_gt = tf.gather(orientations_gt,
mb_gt_indices)
else:
raise NotImplementedError(
'Anchor encoding not implemented for', self._box_rep)
elif self._train_val_test in ['test']:
# In test-mode, skip mini-batch processing and just calculate
# box conversions.
if self._box_rep in ['box_4c', 'box_4ca']:
# Convert proposals: anchors -> box_3d -> box_4c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(all_anchors, fix_lw=True)
proposal_boxes_4c = \
box_4c_encoder.tf_box_3d_to_box_4c(proposal_boxes_3d,
ground_plane)
elif self._box_rep in ['box_8c', 'box_8co']:
# Convert proposals: anchors -> box_3d -> box8c
proposal_boxes_3d = \
box_3d_encoder.anchors_to_box_3d(all_anchors, fix_lw=True)
proposal_boxes_8c = \
box_8c_encoder.tf_box_3d_to_box_8c(proposal_boxes_3d)
######################################################
# Final Predictions
######################################################
# Get orientations from angle vectors
if all_angle_vectors is not None:
with tf.variable_scope('avod_orientation'):
all_orientations = \
orientation_encoder.tf_angle_vector_to_orientation(
all_angle_vectors)
# Apply offsets to regress proposals
with tf.variable_scope('avod_regression'):
if self._box_rep == 'box_3d':
prediction_anchors = \
anchor_encoder.offset_to_anchor(all_anchors,
all_offsets)
elif self._box_rep in ['box_8c', 'box_8co']:
# Reshape the 24-dim regressed offsets to (N x 3 x 8)
reshaped_offsets = tf.reshape(all_offsets,
[-1, 3, 8])
# Given the offsets, get the boxes_8c
prediction_boxes_8c = \
box_8c_encoder.tf_offsets_to_box_8c(proposal_boxes_8c,
reshaped_offsets)
# Convert corners back to box3D
prediction_boxes_3d = \
box_8c_encoder.box_8c_to_box_3d(prediction_boxes_8c)
# Convert the box_3d to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
elif self._box_rep in ['box_4c', 'box_4ca']:
# Convert predictions box_4c -> box_3d
prediction_boxes_4c = \
box_4c_encoder.tf_offsets_to_box_4c(proposal_boxes_4c,
all_offsets)
prediction_boxes_3d = \
box_4c_encoder.tf_box_4c_to_box_3d(prediction_boxes_4c,
ground_plane)
# Convert to anchor format for nms
prediction_anchors = \
box_3d_encoder.tf_box_3d_to_anchor(prediction_boxes_3d)
else:
raise NotImplementedError('Regression not implemented for',
self._box_rep)
# Apply Non-oriented NMS in BEV
with tf.variable_scope('avod_nms'):
bev_extents = self.dataset.kitti_utils.bev_extents
with tf.variable_scope('bev_projection'):
# Project predictions into BEV
avod_bev_boxes, _ = anchor_projector.project_to_bev(
prediction_anchors, bev_extents)
avod_bev_boxes_tf_order = \
anchor_projector.reorder_projected_boxes(
avod_bev_boxes)
# Get top score from second column onward
all_top_scores = tf.reduce_max(all_cls_logits[:, 1:], axis=1)
# Apply NMS in BEV
nms_indices = tf.image.non_max_suppression(
avod_bev_boxes_tf_order,
all_top_scores,
max_output_size=self._nms_size,
iou_threshold=self._nms_iou_threshold)
# Gather predictions from NMS indices
top_classification_logits = tf.gather(all_cls_logits,
nms_indices)
top_classification_softmax = tf.gather(all_cls_softmax,
nms_indices)
top_prediction_anchors = tf.gather(prediction_anchors,
nms_indices)
if self._box_rep == 'box_3d':
top_orientations = tf.gather(
all_orientations, nms_indices)
elif self._box_rep in ['box_8c', 'box_8co']:
top_prediction_boxes_3d = tf.gather(
prediction_boxes_3d, nms_indices)
top_prediction_boxes_8c = tf.gather(
prediction_boxes_8c, nms_indices)
elif self._box_rep == 'box_4c':
top_prediction_boxes_3d = tf.gather(
prediction_boxes_3d, nms_indices)
top_prediction_boxes_4c = tf.gather(
prediction_boxes_4c, nms_indices)
elif self._box_rep == 'box_4ca':
top_prediction_boxes_3d = tf.gather(
prediction_boxes_3d, nms_indices)
top_prediction_boxes_4c = tf.gather(
prediction_boxes_4c, nms_indices)
top_orientations = tf.gather(
all_orientations, nms_indices)
else:
raise NotImplementedError('NMS gather not implemented for',
self._box_rep)
prediction_dict = dict()
if self._train_val_test in ['train', 'val']:
# Additional entries are added to the shared prediction_dict
# Mini batch predictions
prediction_dict[self.PRED_MB_CLASSIFICATION_LOGITS] = \
mb_classifications_logits
prediction_dict[self.PRED_MB_CLASSIFICATION_SOFTMAX] = \
mb_classifications_softmax
prediction_dict[self.PRED_MB_OFFSETS] = mb_offsets
# Mini batch ground truth
prediction_dict[self.PRED_MB_CLASSIFICATIONS_GT] = \
mb_classification_gt
prediction_dict[self.PRED_MB_OFFSETS_GT] = mb_offsets_gt
# Top NMS predictions
prediction_dict[self.PRED_TOP_CLASSIFICATION_LOGITS] = \
top_classification_logits
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
else:
# self._train_val_test == 'test'
prediction_dict[self.PRED_TOP_CLASSIFICATION_SOFTMAX] = \
top_classification_softmax
prediction_dict[self.PRED_TOP_PREDICTION_ANCHORS] = \
top_prediction_anchors
if self._box_rep == 'box_3d':
if self._train_val_test in ['train', 'val']:
prediction_dict[self.PRED_MB_ANCHORS_GT] = mb_anchors_gt
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = \
mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
# For debugging
prediction_dict[self.PRED_ALL_ANGLE_VECTORS] = all_angle_vectors
elif self._box_rep in ['box_8c', 'box_8co']:
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
# Store the corners before converting for visualization purposes
prediction_dict[self.PRED_TOP_BOXES_8C] = top_prediction_boxes_8c
elif self._box_rep == 'box_4c':
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
elif self._box_rep == 'box_4ca':
if self._train_val_test in ['train', 'val']:
prediction_dict[self.PRED_MB_ORIENTATIONS_GT] = \
mb_orientations_gt
prediction_dict[self.PRED_MB_ANGLE_VECTORS] = mb_angle_vectors
prediction_dict[self.PRED_TOP_PREDICTION_BOXES_3D] = \
top_prediction_boxes_3d
prediction_dict[self.PRED_TOP_BOXES_4C] = top_prediction_boxes_4c
prediction_dict[self.PRED_TOP_ORIENTATIONS] = top_orientations
else:
raise NotImplementedError('Prediction dict not implemented for',
self._box_rep)
return prediction_dict
def inference(rpn_model_path, detect_model_path, avod_config_path):
model_config, _, eval_config, dataset_config = \
config_builder.get_configs_from_pipeline_file(
avod_config_path, is_training=False)
# Setup the model
model_name = model_config.model_name
# Overwrite repeated field
model_config = config_builder.proto_to_obj(model_config)
# Switch path drop off during evaluation
model_config.path_drop_probabilities = [1.0, 1.0]
dataset = get_dataset(dataset_config, 'val')
# run avod proposal network
rpn_endpoints, sess1, rpn_model = get_proposal_network(model_config, dataset, rpn_model_path)
end_points, sess2 = get_detection_network(detect_model_path)
all_prediction = []
all_id_list = None
all_2d_boxes = []
for idx in range(3769):
feed_dict1 = rpn_model.create_feed_dict()
kitti_samples = dataset.load_samples([idx])
sample = kitti_samples[0]
'''
if sample[constants.KEY_SAMPLE_NAME] < '001100':
continue
if sample[constants.KEY_SAMPLE_NAME] > '001200':
break
'''
start_time = time.time()
rpn_predictions = sess1.run(rpn_endpoints, feed_dict=feed_dict1)
top_anchors = rpn_predictions[RpnModel.PRED_TOP_ANCHORS]
top_proposals = box_3d_encoder.anchors_to_box_3d(top_anchors)
softmax_scores = rpn_predictions[RpnModel.PRED_TOP_OBJECTNESS_SOFTMAX]
proposals_and_scores = np.column_stack((top_proposals,
softmax_scores))
top_img_roi = rpn_predictions[RpnModel.PRED_TOP_IMG_ROI]
top_bev_roi = rpn_predictions[RpnModel.PRED_TOP_BEV_ROI]
roi_num = len(top_img_roi)
top_img_roi = np.reshape(top_img_roi, (roi_num, -1))
top_bev_roi = np.reshape(top_bev_roi, (roi_num, -1))
roi_features = np.column_stack((top_img_roi, top_bev_roi))
'''
# save proposal
if os.path.exists(os.path.join('/data/ssd/public/jlliu/Kitti/object/training/proposal', '%s.txt'%(sample[constants.KEY_SAMPLE_NAME]))):
continue
np.savetxt(os.path.join('./proposals_and_scores/', '%s.txt'%sample[constants.KEY_SAMPLE_NAME]), proposals_and_scores, fmt='%.3f')
np.savetxt(os.path.join('./roi_features/', '%s_roi.txt'%sample[constants.KEY_SAMPLE_NAME]), roi_features, fmt='%.5f')
print('save ' + sample[constants.KEY_SAMPLE_NAME])
'''
# run frustum_pointnets_v2
point_clouds, feature_vec, rot_angle_list, prop_cls_labels = get_pointnet_input(sample, proposals_and_scores, roi_features)
try:
prediction = detect_batch(sess2, end_points, point_clouds, feature_vec, rot_angle_list, prop_cls_labels)
except:
traceback.print_exc()
continue
elapsed_time = time.time() - start_time
print(sample[constants.KEY_SAMPLE_NAME], elapsed_time)
# concat all predictions for kitti eval
id_list = np.ones((len(prediction),)) * int(sample[constants.KEY_SAMPLE_NAME])
if all_id_list is None:
all_id_list = id_list
else:
all_id_list = np.concatenate((all_id_list, id_list), axis=0)
for pred in prediction:
obj = box_3d_encoder.box_3d_to_object_label(np.array(pred[0:7]), obj_type=type_whitelist[pred[8]])
corners = compute_box_3d(obj)
projected = calib_utils.project_to_image(corners.T, sample[constants.KEY_STEREO_CALIB_P2])
x1 = np.amin(projected[0])
y1 = np.amin(projected[1])
x2 = np.amax(projected[0])
y2 = np.amax(projected[1])
all_2d_boxes.append([x1, y1, x2, y2])
all_prediction += prediction
# save result
pickle.dump({'proposals_and_scores': proposals_and_scores, 'roi_features': roi_features}, open("rpn_out/%s"%sample[constants.KEY_SAMPLE_NAME], "wb"))
pickle.dump(prediction, open('final_out/%s' % sample[constants.KEY_SAMPLE_NAME], 'wb'))
visualize(dataset, sample, prediction)
# for kitti eval
write_detection_results('./detection_results', all_prediction, all_id_list, all_2d_boxes)
