class_docstr: see https://arxiv.org/pdf/2205.12740.pdf 
  Args:
      loss_weight (float): siou loss weight, default as 1
      eps (float): epsilon to avoid divide by zero, default as 1e-10
      theta (float): default as 4
      reduction (str): Options are "none", "mean" and "sum". default as none
code: def __call__(self, pbox, gbox):
      x1, y1, x2, y2 = paddle.split(pbox, num_or_sections=4, axis=-1)
      x1g, y1g, x2g, y2g = paddle.split(
          gbox, num_or_sections=4, axis=-1
      )
  
      box1 = [x1, y1, x2, y2]
      box2 = [x1g, y1g, x2g, y2g]
      iou = bbox_iou(box1, box2)
  
      cx = (x1 + x2) / 2
      cy = (y1 + y2) / 2
      w = x2 - x1 + self.eps
      h = y2 - y1 + self.eps
  
      cxg = (x1g + x2g) / 2
      cyg = (y1g + y2g) / 2
      wg = x2g - x1g + self.eps
      hg = y2g - y1g + self.eps
  
      x2 = paddle.maximum(x1, x2)
      y2 = paddle.maximum(y1, y2)
  
      # A or B
      xc1 = paddle.minimum(x1, x1g)
      yc1 = paddle.minimum(y1, y1g)
      xc2 = paddle.maximum(x2, x2g)
      yc2 = paddle.maximum(y2, y2g)
  
      cw_out = xc2 - xc1
      ch_out = yc2 - yc1
  
      ch = paddle.maximum(cy, cyg) - paddle.minimum(cy, cyg)
      cw = paddle.maximum(cx, cxg) - paddle.minimum(cx, cxg)
  
      # angle cost
      dist_intersection = paddle.sqrt((cx - cxg) ** 2 + (cy - cyg) ** 2)
      sin_angle_alpha = ch / dist_intersection
      sin_angle_beta = cw / dist_intersection
      thred = paddle.pow(paddle.to_tensor(2), 0.5) / 2
      thred.stop_gradient = True
      sin_alpha = paddle.where(
          sin_angle_alpha > thred, sin_angle_beta, sin_angle_alpha
      )
      angle_cost = paddle.cos(paddle.asin(sin_alpha) * 2 - math.pi / 2)
  
      # distance cost
      gamma = 2 - angle_cost
      # gamma.stop_gradient = True
      beta_x = ((cxg - cx) / cw_out) ** 2
      beta_y = ((cyg - cy) / ch_out) ** 2
      dist_cost = (
          1
          - paddle.exp(-gamma * beta_x)
          + 1
          - paddle.exp(-gamma * beta_y)
      )
  
      # shape cost
      omega_w = paddle.abs(w - wg) / paddle.maximum(w, wg)
      omega_h = paddle.abs(hg - h) / paddle.maximum(h, hg)
      omega = (1 - paddle.exp(-omega_w)) ** self.theta + (
          1 - paddle.exp(-omega_h)
      ) ** self.theta
      siou_loss = 1 - iou + (omega + dist_cost) / 2
  
      if self.reduction == "mean":
          siou_loss = paddle.mean(siou_loss)
      elif self.reduction == "sum":
          siou_loss = paddle.sum(siou_loss)
  
      return siou_loss * self.loss_weight
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import numpy
  import math
  import paddle
  from ppdet.core.workspace import register, serializable
  from ..bbox_utils import bbox_iou
label_desc: Use image node_id 2 for calling the SIoULoss obj's underlying member method code with example usage: obj.__call__(pbox, gbox) and returns: unknown