code: 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 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
      -----------
      output : Tensor
          A distribution with shape: [batch_size, ....], (any dimensions).
      target : Tensor
          The target distribution, format the same with `output`.
      loss_type : str
          ``jaccard`` or ``sorensen``, default is ``jaccard``.
      axis : tuple of int
          All dimensions are reduced, default ``[1,2,3]``.
      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
      ---------
      >>> import tensorlayer as tl
      >>> outputs = tl.act.pixel_wise_softmax(outputs)
      >>> dice_loss = 1 - tl.cost.dice_coe(outputs, y_)
  
      References
      -----------
      - `Wiki-Dice <https://en.wikipedia.org/wiki/Sørensen–Dice_coefficient>`__
  
      """
      inse = tf.reduce_sum(output * target, axis=axis)
      if loss_type == "jaccard":
          l = tf.reduce_sum(output * output, axis=axis)
          r = tf.reduce_sum(target * target, axis=axis)
      elif loss_type == "sorensen":
          l = tf.reduce_sum(output, axis=axis)
          r = tf.reduce_sum(target, axis=axis)
      else:
          raise Exception("Unknow loss_type")
      # 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.0 * inse + smooth) / (l + r + smooth)
      ##
      dice = tf.reduce_mean(dice, name="dice_coe")
      return dice
  
imports: import numbers
  import tensorflow
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import array_ops, math_ops, nn_ops, standard_ops
  from tensorlayer import logging
label_desc: Use image node_id 7 for calling a global function with example usage: dice_coe(output, target, loss_type, axis, smooth) and returns: dice