code: def mean_iou(
      pred: torch.Tensor,
      target: torch.Tensor,
      num_classes: int,
      eps: float = 1e-6,
  ) -> torch.Tensor:
      r"""Calculate mean Intersection-Over-Union (mIOU).
  
      The function internally computes the confusion matrix.
  
      Args:
          pred : tensor with estimated targets returned by a
            classifier. The shape can be :math:`(B, *)` and must contain integer
            values between 0 and K-1.
          target: tensor with ground truth (correct) target
            values. The shape can be :math:`(B, *)` and must contain integer
            values between 0 and K-1, where targets are assumed to be provided as
            one-hot vectors.
          num_classes: total possible number of classes in target.
  
      Returns:
          a tensor representing the mean intersection-over union
          with shape :math:`(B, K)` where K is the number of classes.
  
      Example:
          >>> logits = torch.tensor([[0, 1, 0]])
          >>> target = torch.tensor([[0, 1, 0]])
          >>> mean_iou(logits, target, num_classes=3)
          tensor([[1., 1., 1.]])
      """
      if not torch.is_tensor(pred) and pred.dtype is not torch.int64:
          raise TypeError(
              f"Input pred type is not a torch.Tensor with torch.int64 dtype. Got {type(pred)}"
          )
  
      if (
          not torch.is_tensor(target)
          and target.dtype is not torch.int64
      ):
          raise TypeError(
              f"Input target type is not a torch.Tensor with torch.int64 dtype. Got {type(target)}"
          )
      if not pred.shape == target.shape:
          raise ValueError(
              f"Inputs pred and target must have the same shape. Got: {pred.shape} and {target.shape}"
          )
      if not pred.device == target.device:
          raise ValueError(
              f"Inputs must be in the same device. Got: {pred.device} - {target.device}"
          )
  
      if not isinstance(num_classes, int) or num_classes < 2:
          raise ValueError(
              f"The number of classes must be an integer bigger than two. Got: {num_classes}"
          )
  
      # we first compute the confusion matrix
      conf_mat: torch.Tensor = confusion_matrix(
          pred, target, num_classes
      )
  
      # compute the actual intersection over union
      sum_over_row = torch.sum(conf_mat, dim=1)
      sum_over_col = torch.sum(conf_mat, dim=2)
      conf_mat_diag = torch.diagonal(conf_mat, dim1=-2, dim2=-1)
      denominator = sum_over_row + sum_over_col - conf_mat_diag
  
      # NOTE: we add epsilon so that samples that are neither in the
      # prediction or ground truth are taken into account.
      ious = (conf_mat_diag + eps) / (denominator + eps)
      return ious
  
label_desc: Use image node_id 1 for calling a global function with example usage: mean_iou(pred, target, num_classes, eps) and returns: ious