code: def batch_bbox_overlaps(
      bboxes1, bboxes2, mode="iou", is_aligned=False, eps=1e-6
  ):
      """Calculate overlap between two set of bboxes.
      If ``is_aligned `` is ``False``, then calculate the overlaps between each
      bbox of bboxes1 and bboxes2, otherwise the overlaps between each aligned
      pair of bboxes1 and bboxes2.
      Args:
          bboxes1 (Tensor): shape (B, m, 4) in <x1, y1, x2, y2> format or empty.
          bboxes2 (Tensor): shape (B, n, 4) in <x1, y1, x2, y2> format or empty.
              B indicates the batch dim, in shape (B1, B2, ..., Bn).
              If ``is_aligned `` is ``True``, then m and n must be equal.
          mode (str): "iou" (intersection over union) or "iof" (intersection over
              foreground).
          is_aligned (bool, optional): If True, then m and n must be equal.
              Default False.
          eps (float, optional): A value added to the denominator for numerical
              stability. Default 1e-6.
      Returns:
          Tensor: shape (m, n) if ``is_aligned `` is False else shape (m,)
      """
      assert mode in [
          "iou",
          "iof",
          "giou",
      ], "Unsupported mode {}".format(mode)
      # Either the boxes are empty or the length of boxes's last dimenstion is 4
      assert bboxes1.shape[-1] == 4 or bboxes1.shape[0] == 0
      assert bboxes2.shape[-1] == 4 or bboxes2.shape[0] == 0
  
      # Batch dim must be the same
      # Batch dim: (B1, B2, ... Bn)
      assert bboxes1.shape[:-2] == bboxes2.shape[:-2]
      batch_shape = bboxes1.shape[:-2]
  
      rows = bboxes1.shape[-2] if bboxes1.shape[0] > 0 else 0
      cols = bboxes2.shape[-2] if bboxes2.shape[0] > 0 else 0
      if is_aligned:
          assert rows == cols
  
      if rows * cols == 0:
          if is_aligned:
              return paddle.full(batch_shape + (rows,), 1)
          else:
              return paddle.full(batch_shape + (rows, cols), 1)
  
      area1 = (bboxes1[:, 2] - bboxes1[:, 0]) * (
          bboxes1[:, 3] - bboxes1[:, 1]
      )
      area2 = (bboxes2[:, 2] - bboxes2[:, 0]) * (
          bboxes2[:, 3] - bboxes2[:, 1]
      )
  
      if is_aligned:
          lt = paddle.maximum(
              bboxes1[:, :2], bboxes2[:, :2]
          )  # [B, rows, 2]
          rb = paddle.minimum(
              bboxes1[:, 2:], bboxes2[:, 2:]
          )  # [B, rows, 2]
  
          wh = (rb - lt).clip(min=0)  # [B, rows, 2]
          overlap = wh[:, 0] * wh[:, 1]
  
          if mode in ["iou", "giou"]:
              union = area1 + area2 - overlap
          else:
              union = area1
          if mode == "giou":
              enclosed_lt = paddle.minimum(
                  bboxes1[:, :2], bboxes2[:, :2]
              )
              enclosed_rb = paddle.maximum(
                  bboxes1[:, 2:], bboxes2[:, 2:]
              )
      else:
          lt = paddle.maximum(
              bboxes1[:, :2].reshape([rows, 1, 2]), bboxes2[:, :2]
          )  # [B, rows, cols, 2]
          rb = paddle.minimum(
              bboxes1[:, 2:].reshape([rows, 1, 2]), bboxes2[:, 2:]
          )  # [B, rows, cols, 2]
  
          wh = (rb - lt).clip(min=0)  # [B, rows, cols, 2]
          overlap = wh[:, :, 0] * wh[:, :, 1]
  
          if mode in ["iou", "giou"]:
              union = (
                  area1.reshape([rows, 1])
                  + area2.reshape([1, cols])
                  - overlap
              )
          else:
              union = area1[:, None]
          if mode == "giou":
              enclosed_lt = paddle.minimum(
                  bboxes1[:, :2].reshape([rows, 1, 2]), bboxes2[:, :2]
              )
              enclosed_rb = paddle.maximum(
                  bboxes1[:, 2:].reshape([rows, 1, 2]), bboxes2[:, 2:]
              )
  
      eps = paddle.to_tensor([eps])
      union = paddle.maximum(union, eps)
      ious = overlap / union
      if mode in ["iou", "iof"]:
          return ious
      # calculate gious
      enclose_wh = (enclosed_rb - enclosed_lt).clip(min=0)
      enclose_area = enclose_wh[:, :, 0] * enclose_wh[:, :, 1]
      enclose_area = paddle.maximum(enclose_area, eps)
      gious = ious - (enclose_area - union) / enclose_area
      return 1 - gious
  
imports: import math
  import paddle
  import numpy
label_desc: Use image node_id 10 for calling a global function with example usage: batch_bbox_overlaps(bboxes1, bboxes2, mode, is_aligned, eps) and returns: unknown, ious, paddle, paddle