def _build_cls_off_ang_loss(model, prediction_dict): """Builds classification, offset, and angle vector losses. Args: model: network model prediction_dict: prediction dictionary Returns: losses_output: losses dictionary """ # Minibatch Predictions mb_cls_logits = prediction_dict[model.PRED_MB_CLASSIFICATION_LOGITS] mb_cls_softmax = prediction_dict[model.PRED_MB_CLASSIFICATION_SOFTMAX] mb_offsets = prediction_dict[model.PRED_MB_OFFSETS] mb_angle_vectors = prediction_dict[model.PRED_MB_ANGLE_VECTORS] # Ground Truth mb_cls_gt = prediction_dict[model.PRED_MB_CLASSIFICATIONS_GT] mb_offsets_gt = prediction_dict[model.PRED_MB_OFFSETS_GT] mb_orientations_gt = prediction_dict[model.PRED_MB_ORIENTATIONS_GT] mb_pos_gt = tf.cast(tf.greater(tf.argmax(mb_cls_gt, axis=1), 0), tf.float32) mb_neg_gt = tf.cast(tf.equal(tf.argmax(mb_cls_gt, axis=1), 0), tf.float32) # Decode ground truth orientations with tf.variable_scope('avod_gt_angle_vectors'): mb_angle_vectors_gt = \ orientation_encoder.tf_orientation_to_angle_vector( mb_orientations_gt) # Losses with tf.variable_scope('avod_losses'): with tf.variable_scope('classification'): cls_loss, acc_all, acc_pos = _get_cls_loss(model, mb_cls_logits, mb_cls_gt, mb_pos_gt, mb_neg_gt) with tf.variable_scope('regression'): final_reg_loss, offset_loss_norm, ang_loss_norm = _get_off_ang_loss( model, mb_offsets, mb_offsets_gt, mb_angle_vectors, mb_angle_vectors_gt, mb_cls_softmax, mb_cls_gt) with tf.variable_scope('avod_loss'): avod_loss = cls_loss + final_reg_loss tf.summary.scalar('avod_loss', avod_loss) # Loss dictionary losses_output = dict() losses_output[KEY_CLASSIFICATION_LOSS] = cls_loss losses_output[KEY_REGRESSION_LOSS] = final_reg_loss losses_output[KEY_AVOD_LOSS] = avod_loss # Separate losses for plotting losses_output[KEY_OFFSET_LOSS_NORM] = offset_loss_norm losses_output[KEY_ANG_LOSS_NORM] = ang_loss_norm return losses_output, acc_all, acc_pos
def test_two_way_conversion(self): # Test conversion for angles between [-pi, pi] with 0.5 degree steps np_orientations = np.arange(np.pi, np.pi, np.pi / 360.0) tf_angle_vectors = orientation_encoder.tf_orientation_to_angle_vector( np_orientations) tf_orientations = orientation_encoder.tf_angle_vector_to_orientation( tf_angle_vectors) # Check that conversion from orientation -> angle vector -> # orientation results in the same values with self.test_session() as sess: orientations_out = sess.run(tf_orientations) np.testing.assert_allclose(orientations_out, np_orientations)
def test_tf_orientation_to_angle_vector(self): # Test conversion for angles between [-pi, pi] with 0.5 degree steps np_orientations = np.arange(-np.pi, np.pi, np.pi / 360.0) expected_angle_vectors = np.stack( [np.cos(np_orientations), np.sin(np_orientations)], axis=1) # Convert to tensors and convert to angle unit vectors tf_orientations = tf.convert_to_tensor(np_orientations) tf_angle_vectors = orientation_encoder.tf_orientation_to_angle_vector( tf_orientations) with self.test_session() as sess: angle_vectors_out = sess.run(tf_angle_vectors) np.testing.assert_allclose(angle_vectors_out, expected_angle_vectors)
def loss(self, prediction_dict): # Fetch the ground truth values location_gt = prediction_dict[self.PRED_LOCATION_GT] orientation_gt = prediction_dict[self.PRED_ORIENT_GT] orientation_vec_gt = orientation_encoder.tf_orientation_to_angle_vector( orientation_gt) size_gt = prediction_dict[self.PRED_SIZE_GT] # Fetch the prediction values with tf.variable_scope('epbrm_prediction_batch'): location_pred = prediction_dict[self.PRED_LOCATION] orientation_vec_pred = prediction_dict[self.PRED_ORIENT] size_pred = prediction_dict[self.PRED_SIZE] # Calculate the losses with tf.variable_scope('epbrm_losses'): # Location loss with tf.variable_scope('location'): # Fetch the loss function reg_loss = losses.WeightedSmoothL1Loss() location_loss = reg_loss(location_pred, location_gt, weight=5.0) # Size loss with tf.variable_scope('size'): # Fetch the loss function reg_loss = losses.WeightedSmoothL1Loss() size_loss = reg_loss(size_pred, size_gt, weight=5.0) # Orientation loss with tf.variable_scope('orientation'): # Fetch the loss function reg_loss = losses.WeightedSmoothL1Loss() orientation_loss = reg_loss(orientation_vec_pred, orientation_vec_gt, weight=1.0) with tf.variable_scope('epBRM_loss'): total_loss = tf.reduce_sum(location_loss) + tf.reduce_sum( size_loss) + tf.reduce_sum(orientation_loss) return total_loss