class_docstr: This class computes an assignment between the targets and the predictions of the network
  
  For efficiency reasons, the targets don't include the no_object. Because of this, in general,
  there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
  while the others are un-matched (and thus treated as non-objects).
class_docstr_tok: ["This","class","computes","an","assignment","between","the","targets","and","the","predictions","of","the","network","For","efficiency","reasons",",","the","targets","do","n't","include","the","no_object",".","Because","of","this",",","in","general",",","there","are","more","predictions","than","targets",".","In","this","case",",","we","do","a","1-to-1","matching","of","the","best","predictions",",","while","the","others","are","un-matched","(","and","thus","treated","as","non-objects",")","."]
docstr: Performs the matching More memory-friendly.
  
  Params:
      outputs: This is a dict that contains at least these entries:
           "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
           "pred_masks": Tensor of dim [batch_size, num_queries, H_pred, W_pred] with the predicted masks
  
      targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
           "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
                     objects in the target) containing the class labels
           "masks": Tensor of dim [num_target_boxes, H_gt, W_gt] containing the target masks
  
  Returns:
      A list of size batch_size, containing tuples of (index_i, index_j) where:
          - index_i is the indices of the selected predictions (in order)
          - index_j is the indices of the corresponding selected targets (in order)
      For each batch element, it holds:
          len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
docstr_tok: ["Performs","the","matching","More","memory-friendly",".","Params",":","outputs",":","This","is","a","dict","that","contains","at","least","these","entries",":","``","pred_logits","''",":","Tensor","of","dim","[","batch_size",",","num_queries",",","num_classes","]","with","the","classification","logits","``","pred_masks","''",":","Tensor","of","dim","[","batch_size",",","num_queries",",","H_pred",",","W_pred","]","with","the","predicted","masks","targets",":","This","is","a","list","of","targets","(","len","(","targets",")","=","batch_size",")",",","where","each","target","is","a","dict","containing",":","``","labels","''",":","Tensor","of","dim","[","num_target_boxes","]","(","where","num_target_boxes","is","the","number","of","ground-truth","objects","in","the","target",")","containing","the","class","labels","``","masks","''",":","Tensor","of","dim","[","num_target_boxes",",","H_gt",",","W_gt","]","containing","the","target","masks","Returns",":","A","list","of","size","batch_size",",","containing","tuples","of","(","index_i",",","index_j",")","where",":","-","index_i","is","the","indices","of","the","selected","predictions","(","in","order",")","-","index_j","is","the","indices","of","the","corresponding","selected","targets","(","in","order",")","For","each","batch","element",",","it","holds",":","len","(","index_i",")","=","len","(","index_j",")","=","min","(","num_queries",",","num_target_boxes",")"]
code: def forward(self, outputs, targets):
      """Performs the matching More memory-friendly.
  
      Params:
          outputs: This is a dict that contains at least these entries:
               "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
               "pred_masks": Tensor of dim [batch_size, num_queries, H_pred, W_pred] with the predicted masks
  
          targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
               "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
                         objects in the target) containing the class labels
               "masks": Tensor of dim [num_target_boxes, H_gt, W_gt] containing the target masks
  
      Returns:
          A list of size batch_size, containing tuples of (index_i, index_j) where:
              - index_i is the indices of the selected predictions (in order)
              - index_j is the indices of the corresponding selected targets (in order)
          For each batch element, it holds:
              len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
      """
      bs, num_queries = outputs["pred_logits"].shape[:2]
  
      indices = []
  
      # Iterate through batch size
      for b in range(bs):
          out_prob = F.softmax(
              outputs["pred_logits"][b], axis=-1
          )  # [num_queries, num_classes]
          out_mask = outputs["pred_masks"][
              b
          ]  # [num_queries, H_pred, W_pred]
  
          tgt_ids = targets[b]["labels"]
          # gt masks are already padded when preparing target
          if targets[b]["labels"].shape[0] == 0:
              indices.append(
                  (
                      np.array([], dtype="int64"),
                      np.array([], dtype="int64"),
                  )
              )
              continue
          tgt_mask = paddle.cast(targets[b]["masks"], out_mask.dtype)
          # Compute the classification cost. Contrary to the loss, we don't use the NLL,
          # but approximate it in 1 - proba[target class].
          # The 1 is a constant that doesn't change the matching, it can be ommitted.
          cost_class = -paddle.gather(out_prob, index=tgt_ids, axis=1)
  
          # Downsample gt masks to save memory
          tgt_mask = F.interpolate(
              tgt_mask[:, None],
              size=out_mask.shape[-2:],
              mode="nearest",
          )
  
          # Flatten spatial dimension
          out_mask = out_mask.flatten(
              1
          )  # [batch_size * num_queries, H*W]
          tgt_mask = tgt_mask[:, 0].flatten(
              1
          )  # [num_total_targets, H*W]
  
          # Compute the focal loss between masks
          cost_mask = batch_sigmoid_focal_loss(out_mask, tgt_mask)
  
          # Compute the dice loss betwen masks
          cost_dice = batch_dice_loss(out_mask, tgt_mask)
  
          # Final cost matrix
          C = (
              self.cost_mask * cost_mask
              + self.cost_class * cost_class
              + self.cost_dice * cost_dice
          )
          C = C.reshape([num_queries, -1])
  
          indices.append(linear_sum_assignment(C))
  
      return [
          (
              paddle.to_tensor(i, dtype="int64"),
              paddle.to_tensor(j, dtype="int64"),
          )
          for i, j in indices
      ]
  
imports: import copy
  import numpy
  from scipy.optimize import linear_sum_assignment
  import paddle
  import paddle.nn
  import paddle.distributed
  import paddle.nn.functional
  from paddleseg.cvlibs import manager
label_desc: Use image node_id 2 for calling the HungarianMatcher obj's underlying member method code with example usage: obj.forward(outputs, targets) and returns: unknown