update soft/hard dice, iou/ u-net all-->80+

Author: zsdonghao

tensorlayer/cost.py

@@ -122,10 +122,10 @@ def normalized_mean_square_error(output, target):
 
 
 
-def dice_coe(output, target, loss_type='jaccard', axis=[1,2,3], epsilon=1e-5):
+def dice_coe(output, target, loss_type='jaccard', axis=[1,2,3], smooth=1e-5):
     """Soft dice (Sørensen or Jaccard) coefficient for comparing the similarity
-    of two distributions, usually be used for binary image segmentation
-    i.e. labels are binary. The coefficient in [0, 1], 1 means totally match.
+    of two batch of data, usually be used for binary image segmentation
+    i.e. labels are binary. The coefficient between 0 to 1, 1 means totally match.
 
     Parameters
     -----------
@@ -137,8 +137,12 @@ def dice_coe(output, target, loss_type='jaccard', axis=[1,2,3], epsilon=1e-5):
         ``jaccard`` or ``sorensen``, default is ``jaccard``.
     axis : list of integer
         All dimensions are reduced, default ``[1,2,3]``.
-    epsilon : float
-        An small value be added to the numerator and denominator.
+    smooth : float
+        This small value will be added to the numerator and denominator.
+        If both output and target are empty, it makes sure dice is 1.
+        If either output or target are empty (all pixels are background), dice = ```smooth/(small_value + smooth)``,
+        then if smooth is very small, dice close to 0 (even the image values lower than the threshold),
+        so in this case, higher smooth can have a higher dice.
 
     Examples
     ---------
@@ -149,25 +153,6 @@ def dice_coe(output, target, loss_type='jaccard', axis=[1,2,3], epsilon=1e-5):
     -----------
     - `Wiki-Dice <https://en.wikipedia.org/wiki/Sørensen–Dice_coefficient>`_
     """
-    # # inse = tf.reduce_sum( tf.mul(output, target) )
-    # # l = tf.reduce_sum( tf.mul(output, output) )
-    # # r = tf.reduce_sum( tf.mul(target, target) )
-    # inse = tf.reduce_sum( output * target )
-    # if loss_type == 'jaccard':
-    #     l = tf.reduce_sum( output * output )
-    #     r = tf.reduce_sum( target * target )
-    # elif loss_type == 'sorensen':
-    #     l = tf.reduce_sum( output )
-    #     r = tf.reduce_sum( target )
-    # else:
-    #     raise Exception("Unknow loss_type")
-    # dice = (2. * inse + epsilon) / (l + r + epsilon)  # if both output and target are empty, dice is 1
-    # return dice
-    # # dice = 2 * (inse) / (l + r)
-    # # if epsilon == 0:
-    # #     return dice
-    # # else:
-    # #     return tf.clip_by_value(dice, 0, 1.0-epsilon)
     inse = tf.reduce_sum(output * target, axis=axis)
     if loss_type == 'jaccard':
         l = tf.reduce_sum(output * output, axis=axis)
@@ -177,15 +162,21 @@ def dice_coe(output, target, loss_type='jaccard', axis=[1,2,3], epsilon=1e-5):
         r = tf.reduce_sum(target, axis=axis)
     else:
         raise Exception("Unknow loss_type")
-    dice = (2. * inse + epsilon) / (l + r + epsilon)  # if both output and target are empty, dice is 1
+    ## old axis=[0,1,2,3]
+    # dice = 2 * (inse) / (l + r)
+    # epsilon = 1e-5
+    # dice = tf.clip_by_value(dice, 0, 1.0-epsilon) # if all empty, dice = 1
+    ## new haodong
+    dice = (2. * inse + smooth) / (l + r + smooth)
+    ##
     dice = tf.reduce_mean(dice)
     return dice
 
 
-def dice_hard_coe(output, target, threshold=0.5, axis=[1,2,3], epsilon=1e-5):
-    """Non-differentiable Sørensen–Dice coefficient for comparing the similarity of two distributions,
-    usually be used for binary image segmentation i.e. labels are binary.
-    The coefficient = [0, 1], 1 if totally match.
+def dice_hard_coe(output, target, threshold=0.5, axis=[1,2,3], smooth=1e-5):
+    """Non-differentiable Sørensen–Dice coefficient for comparing the similarity
+    of two batch of data, usually be used for binary image segmentation i.e. labels are binary.
+    The coefficient between 0 to 1, 1 if totally match.
 
     Parameters
     -----------
@@ -197,42 +188,33 @@ def dice_hard_coe(output, target, threshold=0.5, axis=[1,2,3], epsilon=1e-5):
         The threshold value to be true.
     axis : list of integer
         All dimensions are reduced, default ``[1,2,3]``.
-    epsilon : float
-        An small value be added to the numerator and denominator.
+    smooth : float
+        This small value will be added to the numerator and denominator, see ``dice_coe``.
 
     References
     -----------
     - `Wiki-Dice <https://en.wikipedia.org/wiki/Sørensen–Dice_coefficient>`_
     """
-    # output = tf.cast(output > threshold, dtype=tf.float32)
-    # target = tf.cast(target > threshold, dtype=tf.float32)
-    # inse = tf.reduce_sum( output * target )
-    # l = tf.reduce_sum( output )
-    # r = tf.reduce_sum( target )
-    # # l = tf.reduce_sum( output * output )
-    # # r = tf.reduce_sum( target * target )
-    # dice = (2. * inse + epsilon) / (l + r + epsilon)  # if both output and target are empty, it is 1
-    # return dice
-    # # dice = 2 * (inse) / (l + r)
-    # # if epsilon == 0:
-    # #     return dice
-    # # else:
-    # #     return tf.clip_by_value(dice, 0, 1.0-epsilon)
     output = tf.cast(output > threshold, dtype=tf.float32)
     target = tf.cast(target > threshold, dtype=tf.float32)
-    inse = tf.reduce_sum( output * target, axis=axis)
+    inse = tf.reduce_sum(tf.multiply(output, target), axis=axis)
     l = tf.reduce_sum(output, axis=axis)
     r = tf.reduce_sum(target, axis=axis)
-    # hard_dice = (2. * inse ) / (l + r + epsilon)
-    hard_dice = (2. * inse + epsilon) / (l + r + epsilon)
+    ## old axis=[0,1,2,3]
+    # hard_dice = 2 * (inse) / (l + r)
+    # epsilon = 1e-5
+    # hard_dice = tf.clip_by_value(hard_dice, 0, 1.0-epsilon)
+    ## new haodong
+    hard_dice = (2. * inse + smooth) / (l + r + smooth)
+    ##
     hard_dice = tf.reduce_mean(hard_dice)
     return hard_dice
 
 
-def iou_coe(output, target, threshold=0.5, axis=[1,2,3], epsilon=1e-5):
-    """Non-differentiable Intersection over Union, usually be used for
-    evaluating binary image segmentation.
-    The coefficient = [0, 1], 1 means totally match.
+def iou_coe(output, target, threshold=0.5, axis=[1,2,3], smooth=1e-5):
+    """Non-differentiable Intersection over Union (IoU) for comparing the
+    similarity of two batch of data, usually be used for evaluating binary image segmentation.
+    The coefficient between 0 to 1, 1 means totally match.
 
     Parameters
     -----------
@@ -244,25 +226,58 @@ def iou_coe(output, target, threshold=0.5, axis=[1,2,3], epsilon=1e-5):
         The threshold value to be true.
     axis : list of integer
         All dimensions are reduced, default ``[1,2,3]``.
-    epsilon : float
-        An small value be added to the numerator and denominator.
+    smooth : float
+        This small value will be added to the numerator and denominator, see ``dice_coe``.
 
     Notes
     ------
-    - IOU cannot be used as training loss, people usually use dice coefficient for training, and IOU for evaluating.
+    - IoU cannot be used as training loss, people usually use dice coefficient for training, IoU and hard-dice for evaluating.
     """
     pre = tf.cast(output > threshold, dtype=tf.float32)
     truth = tf.cast(target > threshold, dtype=tf.float32)
     inse = tf.reduce_sum(tf.multiply(pre, truth), axis=axis) # AND
-    union = tf.reduce_sum(tf.cast(tf.add(pre,truth)>= 1, dtype=tf.float32), axis=axis) # OR
-        # iou = (tf.reduce_sum(inse) + epsilon) / (tf.reduce_sum(union) + epsilon)
-        #   it is incorrect as. if one empty, not inse==0 and union==0, it cannt be 1
-        # iou = tf.reduce_sum(inse) / (tf.reduce_sum(union) + epsilon)
-        # iou = inse / (union + epsilon)    # bug: if one empty, iou=0 (correct), but if all empty, iou=0 (incorrect, it should be 1)
-    batch_iou = (inse + epsilon) / (union + epsilon)
+    union = tf.reduce_sum(tf.cast(tf.add(pre, truth)>= 1, dtype=tf.float32), axis=axis) # OR
+    ## old axis=[0,1,2,3]
+    # epsilon = 1e-5
+    # batch_iou = inse / (union + epsilon)
+    ## new haodong
+    batch_iou = (inse + smooth) / (union + smooth)
     iou = tf.reduce_mean(batch_iou)
     return iou#, pre, truth, inse, union
 
+# ## test soft/hard dice and iou
+# import numpy as np
+# y = np.zeros((1,10,10,1))
+# # y[0,0:5,0:5]=1.0
+# o = np.zeros((1,10,10,1))
+# # o[:,:,:,:] = 0            # what we want: dice=0   iou=0  OK
+# # o[0,0:2,0:2]=0.3          # what we want: dice larger iou=0  OK
+# # o[0,0:2,0:2]=0.6          # what we want: dice larger  iou small  OK
+# # o[0,0:3,0:3]=0.6          # what we want: dice larger iou larger OK
+# # o[0,0:3,0:3]=1            # what we want: dice larger iou same OK
+# # o[0,0:5,0:5]=1            # what we want: dice=1 iou=1  OK
+# # o[0,0:5,0:5]=0.3          # what we want: dice smaller  iou=0  OK
+# # o[0,0:5,0:5]=1e-2           # what we want: dice≈0 iou=0  OK
+# # o[0,8:10,8:10]=1.0        # what we want: dice=0 iou=0  OK
+# # o[0,8:10,8:10]=1e-10        # what we want: dice=0 iou=0  OK
+# # y[:,:,:,:] = o[:,:,:,:] = 0 # what we want: dice=1 iou=1  OK
+# ## why in u-net, dice=1 hard-dice=1 iou=1 exist?? print bug?
+#
+# d = dice_coe(o, y, 'jaccard', smooth=1.)
+# hd = dice_hard_coe(o, y, smooth=1e-5)
+# i = iou_coe(o, y, smooth=1e-5)
+# sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
+# # sess.run(tf.local_variables_initializer())
+# print(sess.run([d,hd,i]))
+# # p, t, i, u = sess.run([pre, truth, inse, union])
+# # import pprint
+# # pprint.pprint(((y>0.5)*(o>0.5)).astype(int).tolist())
+# # pprint.pprint(p.tolist())
+# # pprint.pprint(t.tolist())
+# # pprint.pprint(i)
+# # pprint.pprint(u)
+# exit()
+
 
 def cross_entropy_seq(logits, target_seqs, batch_size=None):#, batch_size=1, num_steps=None):
     """Returns the expression of cross-entropy of two sequences, implement