class_docstr: Computes one-to-one matching between predictions and ground truth.
  
  This class computes an assignment between the targets and the predictions
  based on the costs. The costs are weighted sum of three components:
  classification cost, regression L1 cost and regression oks cost. The
  targets don't include the no_object, so generally there are more
  predictions than targets. After the one-to-one matching, the un-matched
  are treated as backgrounds. Thus each query prediction will be assigned
  with `0` or a positive integer indicating the ground truth index:
  
  - 0: negative sample, no assigned gt.
  - positive integer: positive sample, index (1-based) of assigned gt.
  
  Args:
      cls_weight (int | float, optional): The scale factor for classification
          cost. Default 1.0.
      kpt_weight (int | float, optional): The scale factor for regression
          L1 cost. Default 1.0.
      oks_weight (int | float, optional): The scale factor for regression
          oks cost. Default 1.0.
class_docstr_tok: ["Computes","one-to-one","matching","between","predictions","and","ground","truth",".","This","class","computes","an","assignment","between","the","targets","and","the","predictions","based","on","the","costs",".","The","costs","are","weighted","sum","of","three","components",":","classification","cost",",","regression","L1","cost","and","regression","oks","cost",".","The","targets","do","n't","include","the","no_object",",","so","generally","there","are","more","predictions","than","targets",".","After","the","one-to-one","matching",",","the","un-matched","are","treated","as","backgrounds",".","Thus","each","query","prediction","will","be","assigned","with","`","0","`","or","a","positive","integer","indicating","the","ground","truth","index",":","-","0",":","negative","sample",",","no","assigned","gt",".","-","positive","integer",":","positive","sample",",","index","(","1-based",")","of","assigned","gt",".","Args",":","cls_weight","(","int","|","float",",","optional",")",":","The","scale","factor","for","classification","cost",".","Default","1.0.","kpt_weight","(","int","|","float",",","optional",")",":","The","scale","factor","for","regression","L1","cost",".","Default","1.0.","oks_weight","(","int","|","float",",","optional",")",":","The","scale","factor","for","regression","oks","cost",".","Default","1.0","."]
docstr: Computes one-to-one matching based on the weighted costs.
  
  This method assign each query prediction to a ground truth or
  background. The `assigned_gt_inds` with -1 means don't care,
  0 means negative sample, and positive number is the index (1-based)
  of assigned gt.
  The assignment is done in the following steps, the order matters.
  
  1. assign every prediction to -1
  2. compute the weighted costs
  3. do Hungarian matching on CPU based on the costs
  4. assign all to 0 (background) first, then for each matched pair
     between predictions and gts, treat this prediction as foreground
     and assign the corresponding gt index (plus 1) to it.
  
  Args:
      cls_pred (Tensor): Predicted classification logits, shape
          [num_query, num_class].
      kpt_pred (Tensor): Predicted keypoints with normalized coordinates
          (x_{i}, y_{i}), which are all in range [0, 1]. Shape
          [num_query, K*2].
      gt_labels (Tensor): Label of `gt_keypoints`, shape (num_gt,).
      gt_keypoints (Tensor): Ground truth keypoints with unnormalized
          coordinates [p^{1}_x, p^{1}_y, p^{1}_v, ...,                     p^{K}_x, p^{K}_y, p^{K}_v]. Shape [num_gt, K*3].
      gt_areas (Tensor): Ground truth mask areas, shape (num_gt,).
      img_meta (dict): Meta information for current image.
      eps (int | float, optional): A value added to the denominator for
          numerical stability. Default 1e-7.
  
  Returns:
      :obj:`AssignResult`: The assigned result.
docstr_tok: ["Computes","one-to-one","matching","based","on","the","weighted","costs",".","This","method","assign","each","query","prediction","to","a","ground","truth","or","background",".","The","`","assigned_gt_inds","`","with","-1","means","do","n't","care",",","0","means","negative","sample",",","and","positive","number","is","the","index","(","1-based",")","of","assigned","gt",".","The","assignment","is","done","in","the","following","steps",",","the","order","matters",".","1.","assign","every","prediction","to","-1","2.","compute","the","weighted","costs","3.","do","Hungarian","matching","on","CPU","based","on","the","costs","4.","assign","all","to","0","(","background",")","first",",","then","for","each","matched","pair","between","predictions","and","gts",",","treat","this","prediction","as","foreground","and","assign","the","corresponding","gt","index","(","plus","1",")","to","it",".","Args",":","cls_pred","(","Tensor",")",":","Predicted","classification","logits",",","shape","[","num_query",",","num_class","]",".","kpt_pred","(","Tensor",")",":","Predicted","keypoints","with","normalized","coordinates","(","x_","{","i","}",",","y_","{","i","}",")",",","which","are","all","in","range","[","0",",","1","]",".","Shape","[","num_query",",","K","*","2","]",".","gt_labels","(","Tensor",")",":","Label","of","`","gt_keypoints","`",",","shape","(","num_gt",",",")",".","gt_keypoints","(","Tensor",")",":","Ground","truth","keypoints","with","unnormalized","coordinates","[","p^","{","1","}","_x",",","p^","{","1","}","_y",",","p^","{","1","}","_v",",","...",",","p^","{","K","}","_x",",","p^","{","K","}","_y",",","p^","{","K","}","_v","]",".","Shape","[","num_gt",",","K","*","3","]",".","gt_areas","(","Tensor",")",":","Ground","truth","mask","areas",",","shape","(","num_gt",",",")",".","img_meta","(","dict",")",":","Meta","information","for","current","image",".","eps","(","int","|","float",",","optional",")",":","A","value","added","to","the","denominator","for","numerical","stability",".","Default","1e-7",".","Returns",":",":","obj",":","`","AssignResult","`",":","The","assigned","result","."]
code: def assign(
      self,
      cls_pred,
      kpt_pred,
      gt_labels,
      gt_keypoints,
      gt_areas,
      img_meta,
      eps=1e-7,
  ):
      """Computes one-to-one matching based on the weighted costs.
  
          This method assign each query prediction to a ground truth or
          background. The `assigned_gt_inds` with -1 means don't care,
          0 means negative sample, and positive number is the index (1-based)
          of assigned gt.
          The assignment is done in the following steps, the order matters.
  
          1. assign every prediction to -1
          2. compute the weighted costs
          3. do Hungarian matching on CPU based on the costs
          4. assign all to 0 (background) first, then for each matched pair
             between predictions and gts, treat this prediction as foreground
             and assign the corresponding gt index (plus 1) to it.
  
          Args:
              cls_pred (Tensor): Predicted classification logits, shape
                  [num_query, num_class].
              kpt_pred (Tensor): Predicted keypoints with normalized coordinates
                  (x_{i}, y_{i}), which are all in range [0, 1]. Shape
                  [num_query, K*2].
              gt_labels (Tensor): Label of `gt_keypoints`, shape (num_gt,).
              gt_keypoints (Tensor): Ground truth keypoints with unnormalized
                  coordinates [p^{1}_x, p^{1}_y, p^{1}_v, ..., \
                      p^{K}_x, p^{K}_y, p^{K}_v]. Shape [num_gt, K*3].
              gt_areas (Tensor): Ground truth mask areas, shape (num_gt,).
              img_meta (dict): Meta information for current image.
              eps (int | float, optional): A value added to the denominator for
                  numerical stability. Default 1e-7.
  
          Returns:
              :obj:`AssignResult`: The assigned result.
          """
      num_gts, num_kpts = gt_keypoints.shape[0], kpt_pred.shape[0]
      if not gt_keypoints.astype("bool").any():
          num_gts = 0
  
      # 1. assign -1 by default
      assigned_gt_inds = paddle.full((num_kpts,), -1, dtype="int64")
      assigned_labels = paddle.full((num_kpts,), -1, dtype="int64")
      if num_gts == 0 or num_kpts == 0:
          # No ground truth or keypoints, return empty assignment
          if num_gts == 0:
              # No ground truth, assign all to background
              assigned_gt_inds[:] = 0
          return AssignResult(
              num_gts, assigned_gt_inds, None, labels=assigned_labels
          )
      img_h, img_w, _ = img_meta["img_shape"]
      factor = paddle.to_tensor(
          [img_w, img_h, img_w, img_h], dtype=gt_keypoints.dtype
      ).reshape((1, -1))
  
      # 2. compute the weighted costs
      # classification cost
      cls_cost = self.cls_cost(cls_pred, gt_labels)
  
      # keypoint regression L1 cost
      gt_keypoints_reshape = gt_keypoints.reshape(
          (gt_keypoints.shape[0], -1, 3)
      )
      valid_kpt_flag = gt_keypoints_reshape[..., -1]
      kpt_pred_tmp = (
          kpt_pred.clone().detach().reshape((kpt_pred.shape[0], -1, 2))
      )
      normalize_gt_keypoints = gt_keypoints_reshape[..., :2] / factor[
          :, :2
      ].unsqueeze(0)
      kpt_cost = self.kpt_cost(
          kpt_pred_tmp, normalize_gt_keypoints, valid_kpt_flag
      )
      # keypoint OKS cost
      kpt_pred_tmp = (
          kpt_pred.clone().detach().reshape((kpt_pred.shape[0], -1, 2))
      )
      kpt_pred_tmp = kpt_pred_tmp * factor[:, :2].unsqueeze(0)
      oks_cost = self.oks_cost(
          kpt_pred_tmp,
          gt_keypoints_reshape[..., :2],
          valid_kpt_flag,
          gt_areas,
      )
      # weighted sum of above three costs
      cost = cls_cost + kpt_cost + oks_cost
  
      # 3. do Hungarian matching on CPU using linear_sum_assignment
      cost = cost.detach().cpu()
      if linear_sum_assignment is None:
          raise ImportError(
              'Please run "pip install scipy" '
              "to install scipy first."
          )
      matched_row_inds, matched_col_inds = linear_sum_assignment(cost)
      matched_row_inds = paddle.to_tensor(matched_row_inds)
      matched_col_inds = paddle.to_tensor(matched_col_inds)
  
      # 4. assign backgrounds and foregrounds
      # assign all indices to backgrounds first
      assigned_gt_inds[:] = 0
      # assign foregrounds based on matching results
      assigned_gt_inds[matched_row_inds] = matched_col_inds + 1
      assigned_labels[matched_row_inds] = gt_labels[matched_col_inds][
          ..., 0
      ].astype("int64")
      return AssignResult(
          num_gts, assigned_gt_inds, None, labels=assigned_labels
      )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import paddle
  from ppdet.core.workspace import register
label_desc: Use image node_id 2 for calling the PoseHungarianAssigner obj's underlying member method code with example usage: obj.assign(cls_pred, kpt_pred, gt_labels, gt_keypoints, gt_areas, img_meta, eps) and returns: AssignResult, AssignResult