docstr: body_feats (list[Tensor]): Feature maps from backbone
  rois (Tensor): RoIs generated from RPN module
  rois_num (Tensor): The number of RoIs in each image
  inputs (dict{Tensor}): The ground-truth of image
docstr_tok: ["body_feats","(","list","[","Tensor","]",")",":","Feature","maps","from","backbone","rois","(","Tensor",")",":","RoIs","generated","from","RPN","module","rois_num","(","Tensor",")",":","The","number","of","RoIs","in","each","image","inputs","(","dict","{","Tensor","}",")",":","The","ground-truth","of","image"]
code: def forward(
      self, body_feats=None, rois=None, rois_num=None, inputs=None
  ):
      """
      body_feats (list[Tensor]): Feature maps from backbone
      rois (Tensor): RoIs generated from RPN module
      rois_num (Tensor): The number of RoIs in each image
      inputs (dict{Tensor}): The ground-truth of image
      """
      targets = []
      if self.training:
          rois, rois_num, targets = self.bbox_assigner(
              rois,
              rois_num,
              inputs,
              add_gt_as_proposals=self.add_gt_as_proposals[0],
          )
          targets_list = [targets]
          self.assigned_rois = (rois, rois_num)
          self.assigned_targets = targets
  
      pred_bbox = None
      head_out_list = []
      for i in range(self.num_cascade_stages):
          if i > 0:
              rois, rois_num = self._get_rois_from_boxes(
                  pred_bbox, inputs["im_shape"]
              )
              if self.training:
                  rois, rois_num, targets = self.bbox_assigner(
                      rois,
                      rois_num,
                      inputs,
                      i,
                      is_cascade=True,
                      add_gt_as_proposals=self.add_gt_as_proposals[i],
                  )
                  targets_list.append(targets)
  
          rois_feat = self.roi_extractor(body_feats, rois, rois_num)
          bbox_feat = self.head(rois_feat, i)
          scores = self.bbox_score_list[i](bbox_feat)
          deltas = self.bbox_delta_list[i](bbox_feat)
  
          # TODO (lyuwenyu) Is it correct for only one class ?
          if (
              not self.reg_class_agnostic
              and i < self.num_cascade_stages - 1
          ):
              deltas = deltas.reshape(
                  [deltas.shape[0], self.num_classes, 4]
              )
              labels = scores[:, :-1].argmax(axis=-1)
  
              if self.training:
                  deltas = deltas[
                      paddle.arange(deltas.shape[0]), labels
                  ]
              else:
                  deltas = deltas[
                      (
                          (deltas + 10000)
                          * F.one_hot(
                              labels, num_classes=self.num_classes
                          ).unsqueeze(-1)
                          != 0
                      ).nonzero(as_tuple=True)
                  ].reshape([deltas.shape[0], 4])
  
          head_out_list.append([scores, deltas, rois])
          pred_bbox = self._get_pred_bbox(
              deltas, rois, self.bbox_weight[i]
          )
  
      if self.training:
          loss = {}
          for stage, value in enumerate(
              zip(head_out_list, targets_list)
          ):
              (scores, deltas, rois), targets = value
              loss_stage = self.get_loss(
                  scores,
                  deltas,
                  targets,
                  rois,
                  self.bbox_weight[stage],
                  loss_normalize_pos=self.loss_normalize_pos,
              )
              for k, v in loss_stage.items():
                  loss[k + "_stage{}".format(stage)] = (
                      v * self.stage_loss_weights[stage]
                  )
  
          return loss, bbox_feat
      else:
          scores, deltas, self.refined_rois = self.get_prediction(
              head_out_list
          )
          return (deltas, scores), self.head
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from paddle.nn.initializer import Normal
  from ppdet.core.workspace import register
  from .bbox_head import BBoxHead, TwoFCHead, XConvNormHead
  from .roi_extractor import RoIAlign
  from ..shape_spec import ShapeSpec
  from ..bbox_utils import delta2bbox, clip_bbox, nonempty_bbox
  from ..cls_utils import _get_class_default_kwargs
label_desc: Use image node_id 2 for calling the CascadeHead obj's underlying member method code with example usage: obj.forward(body_feats, rois, rois_num, inputs) and returns: loss,  bbox_feat, deltas,  scores,  self