code: def dice_loss(
      pred,
      target,
      weight=None,
      eps=1e-3,
      reduction="mean",
      naive_dice=False,
      avg_factor=None,
  ):
      """Calculate dice loss, there are two forms of dice loss is supported:
  
          - the one proposed in `V-Net: Fully Convolutional Neural
              Networks for Volumetric Medical Image Segmentation
              <https://arxiv.org/abs/1606.04797>`_.
          - the dice loss in which the power of the number in the
              denominator is the first power instead of the second
              power.
  
      Args:
          pred (torch.Tensor): The prediction, has a shape (n, *)
          target (torch.Tensor): The learning label of the prediction,
              shape (n, *), same shape of pred.
          weight (torch.Tensor, optional): The weight of loss for each
              prediction, has a shape (n,). Defaults to None.
          eps (float): Avoid dividing by zero. Default: 1e-3.
          reduction (str, optional): The method used to reduce the loss into
              a scalar. Defaults to 'mean'.
              Options are "none", "mean" and "sum".
          naive_dice (bool, optional): If false, use the dice
                  loss defined in the V-Net paper, otherwise, use the
                  naive dice loss in which the power of the number in the
                  denominator is the first power instead of the second
                  power.Defaults to False.
          avg_factor (int, optional): Average factor that is used to average
              the loss. Defaults to None.
      """
  
      input = pred.flatten(1)
      target = target.flatten(1).float()
  
      a = torch.sum(input * target, 1)
      if naive_dice:
          b = torch.sum(input, 1)
          c = torch.sum(target, 1)
          d = (2 * a + eps) / (b + c + eps)
      else:
          b = torch.sum(input * input, 1) + eps
          c = torch.sum(target * target, 1) + eps
          d = (2 * a) / (b + c)
  
      loss = 1 - d
      if weight is not None:
          assert weight.ndim == loss.ndim
          assert len(weight) == len(pred)
      loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
      return loss
  
file_path: mmdetection/mmdet/models/losses/dice_loss.py
imports: import torch
  import torch.nn
  from mmdet.registry import MODELS
  from .utils import weight_reduce_loss
label_desc: Use image node_id 1 for calling a global function with example usage: dice_loss(pred, target, weight, eps, reduction, naive_dice, avg_factor) and returns: loss