def inference_to_loss(image_batch, label_batch, is_training=True): with arg_scope( resnet_arg_scope_gn(weight_decay=FLAGS.weight_decay, group_norm_num=32)): ########################### Define Network Structure ############################ net, end_points = resnet_v1_50(image_batch, num_classes=FLAGS.num_classes, is_training=is_training, global_pool=True, rates=(1, 1, 1, 1), scope='resnet_v1_50_gn') logits = tf.squeeze(net, axis=[1, 2]) loss = softmax_with_logits(logits, label_batch, ignore_labels=[], loss_collections=tf.GraphKeys.LOSSES, reduce_method='nonzero_mean') # add accuracy predictions = tf.argmax(logits, axis=-1, output_type=label_batch.dtype) label_batch = tf.squeeze(label_batch, axis=-1) accuracy = tf.reduce_mean( tf.cast(tf.equal(predictions, label_batch), tf.float32)) metrics_loss, _ = tf.metrics.mean( loss, updates_collections=LOCAL_VARIABLE_UPDATE_OPS) metrics_acc, _ = tf.metrics.mean( accuracy, updates_collections=LOCAL_VARIABLE_UPDATE_OPS) with tf.name_scope('summary_input_output'): tf.summary.scalar('classfication_loss', metrics_loss) tf.summary.scalar('classfication_acc', metrics_acc) return loss, accuracy
def inference_to_loss(gpu_id): image_batch = image[gpu_id*FLAGS.batch_size:(gpu_id+1)*FLAGS.batch_size, ...] label_batch = label[gpu_id*FLAGS.batch_size:(gpu_id+1)*FLAGS.batch_size, ...] with arg_scope(xception_arg_scope_gn(weight_decay=FLAGS.weight_decay)): net, end_points = xception_65(image_batch, global_pool=True, num_classes=FLAGS.num_classes, is_training=True, output_stride=32, keep_prob=0.5) logits = tf.squeeze(net, axis=[1, 2]) loss = softmax_with_logits(logits, label_batch, ignore_labels=[], loss_collections=tf.GraphKeys.LOSSES, reduce_method='nonzero_mean') # add accuracy predictions = tf.argmax(logits, axis=-1, output_type=label_batch.dtype) label_batch = tf.squeeze(label_batch, axis=-1) accuracy = tf.reduce_mean(tf.cast(tf.equal(predictions, label_batch), tf.float32)) metrics_loss, _ = tf.metrics.mean(loss, updates_collections=LOCAL_VARIABLE_UPDATE_OPS) metrics_acc, _ = tf.metrics.mean(accuracy, updates_collections=LOCAL_VARIABLE_UPDATE_OPS) # add summaries with tf.name_scope('summary_input_output'): # tf.summary.image('image_batch', image_batch, max_outputs=3) # tf.summary.histogram('label_batch', label_batch) tf.summary.scalar('classfication_loss', metrics_loss) tf.summary.scalar('classfication_acc', metrics_acc) return loss, accuracy
def _layer_loss(locations, scores, encode_locations, encode_labels, encode_ious, pos_th, neg_th, neg_ratio, background_label=0): """ Calculate loss for one layer, encode_labels corresponds to the GT box with highest iou, but this iou can be less than neg_th! so need to process and create new labels ! :param locations: predicted locations [1, H, W, K, 4 ] :param scores: predicted scores [1, H, W, K, 21] :param encode_locations: [H, W, K, 4] :param encode_labels: [H, W, K] :param encode_ious: [H, W, K] :return: """ positive_mask = encode_ious > pos_th positive_num = tf.reduce_sum(tf.cast(positive_mask, tf.int32)) # need to redefine the labels, those assgined to some class with iou < neg_th, should be assgined to background negative_mask = tf.logical_and(encode_ious < neg_th, tf.logical_not(positive_mask)) negative_labels = tf.where( negative_mask, background_label * tf.cast(negative_mask, tf.int32), encode_labels) # calculate background scores neg_scores = tf.nn.softmax(scores, axis=-1)[:, :, :, background_label] neg_scores = tf.where( negative_mask, neg_scores, # set positive ones's negative score to be 1, so that it won't be count in top_k 1.0 - tf.cast(negative_mask, tf.float32)) # solve # negative, add one so that neg_values has more than one value max_negative_num = 1 + tf.reduce_sum(tf.cast(negative_mask, tf.int32)) negative_num = tf.maximum(neg_ratio * positive_num, tf.shape(encode_locations)[0] * 4) negative_num = tf.minimum(negative_num, max_negative_num) # Hard Negative Mining : # find those with lower background scores, but are indeed background! neg_values, _ = tf.nn.top_k(tf.reshape(-1.0 * neg_scores, [-1]), k=negative_num) negative_mask = tf.logical_and(negative_mask, neg_scores < -neg_values[-1]) positive_mask = tf.cast(positive_mask, tf.float32) negative_mask = tf.cast(negative_mask, tf.float32) with tf.name_scope('cross_entropy_loss'): with tf.name_scope('positive'): pos_loss = softmax_with_logits(predictions=scores, labels=encode_labels, ignore_labels=[], weights=tf.reshape( positive_mask, [-1]), loss_collections=LOSS_COLLECTIONS) with tf.name_scope('negative'): neg_loss = softmax_with_logits(predictions=scores, labels=negative_labels, ignore_labels=[], weights=tf.reshape( negative_mask, [-1]), loss_collections=LOSS_COLLECTIONS) with tf.name_scope('bbox_regression_loss'): bbox_loss = smooth_l1(locations - encode_locations) bbox_loss = tf.reduce_sum(bbox_loss, axis=-1) # [H*W*K] bbox_loss = tf.reduce_mean(bbox_loss * positive_mask, name='bbox_regression_loss') tf.add_to_collection(LOSS_COLLECTIONS, bbox_loss) return pos_loss, neg_loss, bbox_loss