text: Title: Question about the implementation of the 'Jaccard' Dice coefficient
  Body: ### New Issue Checklist
  
  - [x] I have read the [Contribution Guidelines](https://github.com/tensorlayer/tensorlayer/blob/master/CONTRIBUTING.md)
  - [x] I searched for [existing GitHub issues](https://github.com/tensorlayer/tensorlayer/issues)
  
  ### Issue Description
  
  I am wondering about the implementation of the 'Jaccard' Dice coefficient in the `tensorlayer.cost` module.
  
  Does the `loss_type` `jaccard` refer here to the Jaccard index. Because the Jaccard index should be calculated as (X∩Y)/(X∪Y). In the code below it uses the same numerator of the Sorensen Dice, but it squares both the output and the target in the denominator:
  
  ```python
  l = tf.reduce_sum(output * output, axis=axis)
  r = tf.reduce_sum(target * target, axis=axis)
  ```
  
  Shouldn't the denomiator for the Jaccard Index be:
  
  ` tf.reduce_sum(output, axis=axis) + tf.reduce_sum(target, axis=axis) - tf.reduce_sum(output * target, axis=axis)` or |X|+|Y|-X∩Y.
  
  And the nominator should not have the factor 2.
  
  I am confused what metric the option `jaccard` is actually computing here. It gives me a different output from the regular Jaccard Index. Is there another name this metric is known by?
  
  ### Reproducible Code
  
  - python 3.7, tensorflow 1.15, tensorlayer 2.2.4
  
  ```python
  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. * inse + smooth) / (l + r + smooth)
      ##
      dice = tf.reduce_mean(dice, name='dice_coe')
  ```
  
  
  
  