code: def binary_cross_entropy(
      pred,
      label,
      weight=None,
      reduction="mean",
      avg_factor=None,
      class_weight=None,
      ignore_index=-100,
      avg_non_ignore=False,
      **kwargs,
  ):
      """Calculate the binary CrossEntropy loss.
  
      Args:
          pred (torch.Tensor): The prediction with shape (N, 1).
          label (torch.Tensor): The learning label of the prediction.
              Note: In bce loss, label < 0 is invalid.
          weight (torch.Tensor, optional): Sample-wise loss weight.
          reduction (str, optional): The method used to reduce the loss.
              Options are "none", "mean" and "sum".
          avg_factor (int, optional): Average factor that is used to average
              the loss. Defaults to None.
          class_weight (list[float], optional): The weight for each class.
          ignore_index (int): The label index to be ignored. Default: -100.
          avg_non_ignore (bool): The flag decides to whether the loss is
              only averaged over non-ignored targets. Default: False.
              `New in version 0.23.0.`
  
      Returns:
          torch.Tensor: The calculated loss
      """
      if pred.size(1) == 1:
          # For binary class segmentation, the shape of pred is
          # [N, 1, H, W] and that of label is [N, H, W].
          assert label.max() <= 1, (
              "For pred with shape [N, 1, H, W], its label must have at "
              "most 2 classes"
          )
          pred = pred.squeeze()
      if pred.dim() != label.dim():
          assert (pred.dim() == 2 and label.dim() == 1) or (
              pred.dim() == 4 and label.dim() == 3
          ), (
              "Only pred shape [N, C], label shape [N] or pred shape [N, C, "
              "H, W], label shape [N, H, W] are supported"
          )
          # `weight` returned from `_expand_onehot_labels`
          # has been treated for valid (non-ignore) pixels
          label, weight, valid_mask = _expand_onehot_labels(
              label, weight, pred.shape, ignore_index
          )
      else:
          # should mask out the ignored elements
          valid_mask = ((label >= 0) & (label != ignore_index)).float()
          if weight is not None:
              weight = weight * valid_mask
          else:
              weight = valid_mask
      # average loss over non-ignored and valid elements
      if reduction == "mean" and avg_factor is None and avg_non_ignore:
          avg_factor = valid_mask.sum().item()
  
      loss = F.binary_cross_entropy_with_logits(
          pred, label.float(), pos_weight=class_weight, reduction="none"
      )
      # do the reduction for the weighted loss
      loss = weight_reduce_loss(
          loss, weight, reduction=reduction, avg_factor=avg_factor
      )
  
      return loss
  
file_path: dinov2/dinov2/eval/segmentation_m2f/models/losses/cross_entropy_loss.py
imports: import warnings
  import torch
  import torch.nn
  import torch.nn.functional
  from mmseg.models.builder import LOSSES
  from mmseg.models.losses.utils import get_class_weight, weight_reduce_loss
label_desc: Use image node_id 3 for calling a global function with example usage: binary_cross_entropy(pred, label, weight, reduction, avg_factor, class_weight, ignore_index, avg_non_ignore) and returns: loss