new version

Author: engineer1109

data/demo/000013.jpg

@@ -0,0 +1,3 @@
+GPU_ID=0
+CUDA_VISIBLE_DEVICES=${GPU_ID} python3 ./tools/demo.py --dataset pascal_voc --language en
+

data/demo/000456.jpg

@@ -0,0 +1 @@
+tensorboard --logdir=tensorboard/res101/voc_2007_trainval/ --port=7003

data/demo/000542.jpg

@@ -0,0 +1,9 @@
+import tensorflow as tf
+import numpy as np
+from layer_utils import snippets
+
+
+if __name__ == '__main__':
+    anchors, length = snippets.generate_anchors_pre(40, 60, 16)
+    print(anchors[:32, :])
+    print(length)

data/demo/004545.jpg

@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
+from tensorflow.python import pywrap_tensorflow
+
+
+if __name__ == '__main__':
+    # ckpt_path = '/home/aurora/workspaces/PycharmProjects/tensorflow/tf_rfcn/output/res101/voc_2007_trainval+voc_2012_' \
+    #             'trainval/default/res101_faster_rcnn_iter_10.ckpt'
+    # ckpt_path = '/home/aurora/workspaces/PycharmProjects/tensorflow/tf_rfcn/output/res101/voc_2007_trainval+voc_2012_' \
+    #             'trainval/default/res101_faster_rcnn_iter_400000.ckpt'
+    ckpt_path = '/home/aurora/pretrained_models/tensorflow_backbone_network/resnet_v1_50.ckpt'
+    ckpt_path = '/home/aurora/workspaces/PycharmProjects/tensorflow/tf_rfcn/output/res101_global_local' \
+                '/voc_2007_trainval+voc_2012_trainval/local_global_7721/res101_rfcn_local_global_iter_110000.ckpt'
+    try:
+        reader = pywrap_tensorflow.NewCheckpointReader(ckpt_path)
+        var_to_shape_map = reader.get_variable_to_shape_map()
+        count = 0
+        for key in var_to_shape_map:
+            # if 'rfcn_network/resnet_v1_101' in key and 'rfcn_network/resnet_v1_101/block' not in key:
+            # if 'rpn_network/resnet_v1_101/block2/unit_1' in key:
+            # if 'resnet_v1_101/conv1' in key:
+                print(key)
+                count += 1
+        print(count)
+    except Exception as e:
+        print(str(e))

run.sh

@@ -0,0 +1,105 @@
+import tensorflow as tf
+from tensorflow.python.ops import array_ops
+
+slim = tf.contrib.slim
+
+def focal_loss(onehot_labels, cls_preds,
+                            alpha=0.25, gamma=2.0, name=None, scope=None):
+    """Compute softmax focal loss between logits and onehot labels
+    logits and onehot_labels must have same shape [batchsize, num_classes] and
+    the same data type (float16, 32, 64)
+    Args:
+      onehot_labels: Each row labels[i] must be a valid probability distribution
+      cls_preds: Unscaled log probabilities
+      alpha: The hyperparameter for adjusting biased samples, default is 0.25
+      gamma: The hyperparameter for penalizing the easy labeled samples
+      name: A name for the operation (optional)
+    Returns:
+      A 1-D tensor of length batch_size of same type as logits with softmax focal loss
+    """
+    with tf.name_scope(scope, 'focal_loss', [cls_preds, onehot_labels]) as sc:
+        logits = tf.convert_to_tensor(cls_preds)
+        onehot_labels = tf.convert_to_tensor(onehot_labels)
+
+        precise_logits = tf.cast(logits, tf.float32) if (
+                        logits.dtype == tf.float16) else logits
+        onehot_labels = tf.cast(onehot_labels, precise_logits.dtype)
+        predictions = tf.nn.sigmoid(logits)
+        predictions_pt = tf.where(tf.equal(onehot_labels, 1), predictions, 1.-predictions)
+        # add small value to avoid 0
+        epsilon = 1e-8
+        alpha_t = tf.scalar_mul(alpha, tf.ones_like(onehot_labels, dtype=tf.float32))
+        alpha_t = tf.where(tf.equal(onehot_labels, 1.0), alpha_t, 1-alpha_t)
+        losses = tf.reduce_sum(-alpha_t * tf.pow(1. - predictions_pt, gamma) * onehot_labels * tf.log(predictions_pt+epsilon),
+                                     name=name, axis=1)
+        return losses
+
+
+def focal_loss2(prediction_tensor, target_tensor, weights=None, alpha=0.25, gamma=2):
+    r"""Compute focal loss for predictions.
+        Multi-labels Focal loss formula:
+            FL = -alpha * (z-p)^gamma * log(p) -(1-alpha) * p^gamma * log(1-p)
+                 ,which alpha = 0.25, gamma = 2, p = sigmoid(x), z = target_tensor.
+    Args:
+     prediction_tensor: A float tensor of shape [batch_size, num_anchors,
+        num_classes] representing the predicted logits for each class
+     target_tensor: A float tensor of shape [batch_size, num_anchors,
+        num_classes] representing one-hot encoded classification targets
+     weights: A float tensor of shape [batch_size, num_anchors]
+     alpha: A scalar tensor for focal loss alpha hyper-parameter
+     gamma: A scalar tensor for focal loss gamma hyper-parameter
+    Returns:
+        loss: A (scalar) tensor representing the value of the loss function
+    """
+    sigmoid_p = tf.nn.sigmoid(prediction_tensor)
+    zeros = array_ops.zeros_like(sigmoid_p, dtype=sigmoid_p.dtype)
+    pos_p_sub = array_ops.where(target_tensor >= sigmoid_p, target_tensor - sigmoid_p, zeros)
+    neg_p_sub = array_ops.where(target_tensor > zeros, zeros, sigmoid_p)
+    per_entry_cross_ent = - alpha * (pos_p_sub ** gamma) * tf.log(tf.clip_by_value(sigmoid_p, 1e-8, 1.0)) \
+                          - (1 - alpha) * (neg_p_sub ** gamma) * tf.log(tf.clip_by_value(1.0 - sigmoid_p, 1e-8, 1.0))
+    return tf.reduce_mean(per_entry_cross_ent, axis=1)
+
+
+def focal_loss3(cls_score, label, num_classes):
+    alpha_scale = 0.25
+    gamma = 2
+    epsilon = 1e-8
+    label = tf.one_hot(label, depth=num_classes)
+    cls_pred = tf.nn.sigmoid(cls_score)
+    predictions_pt = tf.where(tf.equal(label, 1), cls_pred, 1 - cls_pred)
+    alpha_t = tf.ones_like(label, dtype=tf.float32)
+    alpha_t = tf.scalar_mul(alpha_scale, alpha_t)
+    alpha_t = tf.where(tf.equal(label, 1.0), alpha_t, 1. - alpha_t)
+    losses = tf.reduce_mean(-alpha_t * tf.pow(1 - predictions_pt, gamma) * tf.log(predictions_pt + epsilon), axis=1)
+    return losses
+
+
+def regression_loss(pred_boxes, gt_boxes, weights):
+    """
+    Regression loss (Smooth L1 loss: also known as huber loss)
+    Args:
+        pred_boxes: [# anchors, 4]
+        gt_boxes: [# anchors, 4]
+        weights: Tensor of weights multiplied by loss with shape [# anchors]
+    """
+    loss = tf.losses.huber_loss(predictions=pred_boxes, labels=gt_boxes,
+                                weights=weights, scope='box_loss')
+    return loss
+
+
+def test():
+    logits = tf.convert_to_tensor([[0.2, 0.3, 0.4, 0.5], [0.5, 0.4, 0.3, 0.2]])
+    logits_sigmoid = tf.nn.sigmoid(logits)
+    labels = slim.one_hot_encoding([1, 2], 4)
+    labels_vector = tf.constant([1, 2])
+    bbox = tf.ones_like(logits)
+    with tf.Session() as sess:
+        print(sess.run(logits))
+        print(sess.run(logits_sigmoid))
+        print(sess.run(focal_loss(onehot_labels=labels, cls_preds=logits)))
+        print(sess.run(focal_loss2(target_tensor=labels, prediction_tensor=logits)))
+        print(sess.run(focal_loss3(cls_score=logits, label=labels_vector, num_classes=4)))
+        print(sess.run(regression_loss(logits, bbox, tf.expand_dims(1./tf.convert_to_tensor([2, 3], dtype=tf.float32), 1))))
+    sess.close()
+
+test()

tensorboard.sh

@@ -0,0 +1,18 @@
+import tensorflow as tf
+import numpy as np
+
+if __name__ == '__main__':
+    boxes_np = [[0, 0, 1, 1], [0, 0.1, 1, 1.1], [0, -0.1, 1, 0.9],
+                [0, 10, 1, 11], [0, 10.1, 1, 11.1], [0, 100, 1, 101]]
+    scores_np = [0.9, 0.75, 0.6, 0.95, 0.5, 0.3]
+    max_output_size_np = 2
+    iou_threshold_np = 0.5
+
+    boxes = tf.constant(boxes_np)
+    scores = tf.constant(scores_np)
+    max_output_size = tf.constant(max_output_size_np)
+    # iou_threshold = tf.constant(iou_threshold_np, dtype=tf.float32)
+    keep_index = tf.image.non_max_suppression(boxes, scores, max_output_size, iou_threshold_np)
+
+    sess = tf.Session()
+    print(sess.run(keep_index))