def iou_loss(self, index, label_dict, pred_dict):
pmask = label_dict[maps_dict.GT_PMASK][index]
pmask = tf.reduce_max(pmask, axis=-1)
gt_cls = label_dict[maps_dict.GT_CLS][index] # bs, pts_num
gt_cls = tf.cast(
tf.one_hot(gt_cls - 1,
depth=len(self.cls_list),
on_value=1,
off_value=0,
axis=-1), tf.float32) # [bs, pts_num, cls_num]
assigned_gt_boxes_3d = label_dict[maps_dict.GT_BOXES_ANCHORS_3D][index]
proposals = pred_dict[maps_dict.KEY_ANCHORS_3D][index]
# bs, proposal_num, cls_num
target_iou_bev, target_iou_3d = calc_iou_match_warper(
proposals, assigned_gt_boxes_3d)
# then normalize target_iou to [-1, 1]
target_iou_3d = target_iou_3d * 2. - 1.
target_iou_3d = target_iou_3d * gt_cls
pred_iou = pred_dict[maps_dict.PRED_IOU_3D_VALUE][index]
norm_param = tf.maximum(1., tf.reduce_sum(pmask))
iou_loss = model_util.huber_loss(pred_iou - target_iou_3d, delta=1.)
iou_loss = tf.reduce_mean(iou_loss, axis=-1) * pmask
iou_loss = tf.identity(
tf.reduce_sum(iou_loss) / norm_param, 'iou_loss%d' % index)
tf.summary.scalar('iou_loss%d' % index, iou_loss)
# tf.add_to_collection(tf.GraphKeys.LOSSES, iou_loss)
return iou_loss
def offset_loss_res(self, index, label_dict, pred_dict):
pmask = label_dict[maps_dict.GT_PMASK][index]
nmask = label_dict[maps_dict.GT_NMASK][index]
gt_offset = label_dict[maps_dict.GT_OFFSET][index]
pred_offset = pred_dict[maps_dict.PRED_OFFSET][index]
norm_param = tf.maximum(1., tf.reduce_sum(pmask))
offset_loss = model_util.huber_loss((pred_offset - gt_offset),
delta=1.)
offset_loss = tf.reduce_sum(offset_loss, axis=-1) * pmask
offset_loss = tf.identity(
tf.reduce_sum(offset_loss) / norm_param, 'offset_loss%d' % index)
tf.summary.scalar('offset_loss%d' % index, offset_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, offset_loss)
def corner_loss(self, index, label_dict, pred_dict):
pmask = label_dict[maps_dict.GT_PMASK][index]
nmask = label_dict[maps_dict.GT_NMASK][index]
gt_corners = label_dict[maps_dict.CORNER_LOSS_GT_BOXES_CORNERS][index]
pred_corners = pred_dict[
maps_dict.CORNER_LOSS_PRED_BOXES_CORNERS][index]
norm_param = tf.maximum(1., tf.reduce_sum(pmask))
corner_loss = model_util.huber_loss((pred_corners - gt_corners),
delta=1.)
corner_loss = tf.reduce_sum(corner_loss, axis=[-2, -1]) * pmask
corner_loss = tf.identity(
tf.reduce_sum(corner_loss) / norm_param, 'corner_loss%d' % index)
tf.summary.scalar('corner_loss%d' % index, corner_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, corner_loss)
def vote_loss(self, index, pred_dict, placeholders):
vote_offset = pred_dict[maps_dict.PRED_VOTE_OFFSET][index]
vote_base = pred_dict[maps_dict.PRED_VOTE_BASE][index]
bs, pts_num, _ = vote_offset.get_shape().as_list()
gt_boxes_3d = placeholders[maps_dict.PL_LABEL_BOXES_3D]
vote_mask, vote_target = tf.py_func(vote_targets_np,
[vote_base, gt_boxes_3d],
[tf.float32, tf.float32])
vote_mask = tf.reshape(vote_mask, [bs, pts_num])
vote_target = tf.reshape(vote_target, [bs, pts_num, 3])
vote_loss = tf.reduce_sum(model_util.huber_loss(
vote_target - vote_offset, delta=1.),
axis=-1) * vote_mask
vote_loss = tf.reduce_sum(vote_loss) / tf.maximum(
1., tf.reduce_sum(vote_mask))
vote_loss = tf.identity(vote_loss, 'vote_loss%d' % index)
tf.summary.scalar('vote_loss%d' % index, vote_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, vote_loss)
def velo_attr_loss(self, index, label_dict, pred_dict):
pmask = label_dict[maps_dict.GT_PMASK][index]
nmask = label_dict[maps_dict.GT_NMASK][index]
# bs, pts_num, cls_num
gt_attribute = label_dict[maps_dict.GT_ATTRIBUTE][index]
# bs,pts_num,cls_num,2
gt_velocity = label_dict[maps_dict.GT_VELOCITY][index]
pred_attribute = pred_dict[maps_dict.PRED_ATTRIBUTE][index]
pred_velocity = pred_dict[maps_dict.PRED_VELOCITY][index]
attr_mask = tf.cast(tf.greater_equal(gt_attribute, 0), tf.float32)
attr_mask = attr_mask * pmask
gt_attribute_onehot = tf.cast(
tf.one_hot(gt_attribute, depth=8, on_value=1, off_value=0,
axis=-1), tf.float32) # [bs, pts_num, cls_num, 8]
attr_loss = tf.nn.sigmoid_cross_entropy_with_logits(
labels=gt_attribute_onehot, logits=pred_attribute)
attr_loss = attr_loss * tf.expand_dims(attr_mask, axis=-1)
attr_loss = tf.reduce_sum(attr_loss) / (
tf.maximum(1., tf.reduce_sum(attr_mask)) * 8.)
attr_loss = tf.identity(attr_loss, 'attribute_loss_%d' % index)
tf.summary.scalar('attribute_loss_%d' % index, attr_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, attr_loss)
velo_mask = tf.cast(
tf.logical_not(tf.is_nan(tf.reduce_sum(gt_velocity, axis=-1))),
tf.float32)
velo_mask = velo_mask * pmask
zero_velocity = tf.zeros_like(gt_velocity)
gt_velocity = tf.where(tf.is_nan(gt_velocity), zero_velocity,
gt_velocity)
velo_loss = model_util.huber_loss(pred_velocity - gt_velocity,
delta=1.)
velo_loss = tf.reduce_sum(velo_loss, axis=-1) * velo_mask
velo_loss = tf.identity(
tf.reduce_sum(velo_loss) /
tf.maximum(1., tf.reduce_sum(velo_mask)),
'velocity_loss_%d' % index)
tf.summary.scalar('velocity_loss_%d' % index, velo_loss)
# tf.add_to_collection(tf.GraphKeys.LOSSES, velo_loss)
return velo_loss
def offset_loss_bin(self, index, label_dict, pred_dict):
pmask = label_dict[maps_dict.GT_PMASK][index]
nmask = label_dict[maps_dict.GT_NMASK][index]
# bs, points_num, cls_num, 8
# xbin/xres/zbin/zres/yres/size_res
gt_offset = label_dict[maps_dict.GT_OFFSET][index]
xbin, xres, zbin, zres = tf.unstack(gt_offset[:, :, :, :4], axis=-1)
gt_other_offset = gt_offset[:, :, :, 4:]
pred_offset = pred_dict[maps_dict.PRED_OFFSET][index]
pred_xbin = tf.slice(pred_offset, [0, 0, 0, self.reg_bin_cls_num * 0],
[-1, -1, -1, self.reg_bin_cls_num])
pred_xres = tf.slice(pred_offset, [0, 0, 0, self.reg_bin_cls_num * 1],
[-1, -1, -1, self.reg_bin_cls_num])
pred_zbin = tf.slice(pred_offset, [0, 0, 0, self.reg_bin_cls_num * 2],
[-1, -1, -1, self.reg_bin_cls_num])
pred_zres = tf.slice(pred_offset, [0, 0, 0, self.reg_bin_cls_num * 3],
[-1, -1, -1, self.reg_bin_cls_num])
pred_other_offset = tf.slice(pred_offset,
[0, 0, 0, self.reg_bin_cls_num * 4],
[-1, -1, -1, -1])
norm_param = tf.maximum(1., tf.reduce_sum(pmask))
self.bin_res_loss(pmask, norm_param, xbin, xres, pred_xbin, pred_xres,
self.reg_bin_cls_num, 'x_loss%d' % index)
self.bin_res_loss(pmask, norm_param, zbin, zres, pred_zbin, pred_zres,
self.reg_bin_cls_num, 'z_loss%d' % index)
other_offset_loss = model_util.huber_loss(
(pred_other_offset - gt_other_offset), delta=1.)
other_offset_loss = tf.reduce_sum(other_offset_loss, axis=-1) * pmask
other_offset_loss = tf.identity(
tf.reduce_sum(other_offset_loss) / norm_param,
'other_offset_loss%d' % index)
tf.summary.scalar('other_offset_loss%d' % index, other_offset_loss)
# tf.add_to_collection(tf.GraphKeys.LOSSES, other_offset_loss)
return other_offset_loss
def bin_res_loss(self, pmask, norm_param, gt_bin, gt_res, pred_bin,
pred_res, bin_class_num, scope):
gt_bin = tf.cast(gt_bin, tf.int32)
bin_loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
logits=pred_bin, labels=gt_bin) * pmask
bin_loss = tf.identity(
tf.reduce_sum(bin_loss) / norm_param, 'bin_%s' % scope)
tf.summary.scalar('bin_%s' % scope, bin_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, bin_loss)
gt_bin_onehot = tf.cast(
tf.one_hot(gt_bin,
depth=bin_class_num,
on_value=1,
off_value=0,
axis=-1), tf.float32)
pred_res = tf.reduce_sum(pred_res * gt_bin_onehot, axis=-1)
res_loss = model_util.huber_loss((pred_res - gt_res) * pmask, delta=1.)
res_loss = tf.identity(
tf.reduce_sum(res_loss) / norm_param, 'res_%s' % scope)
tf.summary.scalar('res_%s' % scope, res_loss)
tf.add_to_collection(tf.GraphKeys.LOSSES, res_loss)
