## class HungarianMatcher(nn.Module)的forward函数
@torch.no_grad()
    def forward(self, outputs, targets):
    
        bs, num_queries = outputs["pred_logits"].shape[:2]  # outputs包含两个keys:pred_logits和pred_boxes
                                                            # 尺寸分别为(bs, num_queries, num_classes) ; (bs, num_queries, 4) 
        # We flatten to compute the cost matrices in a batch
        out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1)  # [batch_size * num_queries, num_classes]
        out_bbox = outputs["pred_boxes"].flatten(0, 1)  # [batch_size * num_queries, 4]

        # Also concat the target labels and boxes
        tgt_ids = torch.cat([v["labels"] for v in targets]) # target是个列表,有bs个值，值为字典(key为之前设计的annotation),取boxes和labels
        tgt_bbox = torch.cat([v["boxes"] for v in targets]) # 注意如果一张image里有2个object，那么boxes和labels也就有2个值，分别表示这两个objects
                                                            # cat在一起,假如一共有6个objects，那么ids长度为[6]，bbox长度为[6,4]
        # 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 = -out_prob[:, tgt_ids]  # 假设该batch有共有6个objects,下面同，cost_class尺寸为[bs * num_queries, 6]

        # Compute the L1 cost between boxes
        cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)    # 计算L1距离，返回尺寸为[bs * num_queries , 6]

        # Compute the giou cost betwen boxes
        cost_giou = -generalized_box_iou(box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox))

        # Final cost matrix
        C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou  # [200,6]
        C = C.view(bs, num_queries, -1).cpu()   # [bs,num_queries,6]

        sizes = [len(v["boxes"]) for v in targets]  # sizes尺寸为[bs]，表示每一张图有多少个objects，此处为[2,4]
        indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C.split(sizes, -1))]   # 将C沿最后一维，拆分成[bs,num_queries,2], [bs,num_queries,4]
        # 返回的indices为[(array([22, 70], dtype=int64), array([0, 1], dtype=int64)), (array([ 7, 33, 34, 69], dtype=int64), array([0, 1, 2, 3], dtype=int64))]
        # 可以用理解为第22个object query对应第一个图像的第0个object
        return [(torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices]

import torch
from torchvision.ops.boxes import box_area


def box_cxcywh_to_xyxy(x):
    x_c, y_c, w, h = x.unbind(-1)   #x为[200,4]，最后一维unbind，得到4个[200]
    b = [(x_c - 0.5 * w), (y_c - 0.5 * h),
         (x_c + 0.5 * w), (y_c + 0.5 * h)]  # 四个角坐标计算(左上角和右下角)
    return torch.stack(b, dim=-1)   #stack回去


# modified from torchvision to also return the union
def box_iou(boxes1, boxes2):
    area1 = box_area(boxes1)    #[200]
    area2 = box_area(boxes2)    #[6]

    lt = torch.max(boxes1[:, None, :2], boxes2[:, :2])  # [bs*num_queries, 6, 2]
    rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  # 比较bs*num_queries个预测框和 6个GT框的最多值,比如[1,6,2]指的是第一个预测框和所有GT框的左上角最大值/右下角最小值

    wh = (rb - lt).clamp(min=0)  # 交集区域内部的w和h
    inter = wh[:, :, 0] * wh[:, :, 1]  # [bs*num_queries, 6]，表示交集面积

    union = area1[:, None] + area2 - inter # [bs*num_queries, 6], 并集区域面积,

    iou = inter / union # iou = 交集面积/并集面积
    return iou, union


def generalized_box_iou(boxes1, boxes2):
    """
    Generalized IoU from https://giou.stanford.edu/

    The boxes should be in [x0, y0, x1, y1] format

    Returns a [N, M] pairwise matrix, where N = len(boxes1)
    and M = len(boxes2)
    """
    # degenerate boxes gives inf / nan results
    # so do an early check
    assert (boxes1[:, 2:] >= boxes1[:, :2]).all()   # 现在的boxes是左上角坐标（较小）和右下角坐标（较大）
    assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
    iou, union = box_iou(boxes1, boxes2)

    lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])
    rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:])

    wh = (rb - lt).clamp(min=0)  # [N,M,2]
    area = wh[:, :, 0] * wh[:, :, 1]

    return iou - (area - union) / area  # giou = iou - (并集-交集)/并集

        num_boxes = sum(len(t["labels"]) for t in targets)  # [num_objects]，此处为[6]
        num_boxes = torch.as_tensor([num_boxes], dtype=torch.float, device=next(iter(outputs.values())).device)
        if is_dist_avail_and_initialized():
            torch.distributed.all_reduce(num_boxes)
        num_boxes = torch.clamp(num_boxes / get_world_size(), min=1).item() # 检查每个gpu上的boxes是否小于1

        # Compute all the requested losses
        losses = {}
        for loss in self.losses:
            losses.update(self.get_loss(loss, outputs, targets, indices, num_boxes))

    def loss_labels(self, outputs, targets, indices, num_boxes, log=True):
        """Classification loss (NLL)
        targets dicts must contain the key "labels" containing a tensor of dim [nb_target_boxes]
        """
        assert 'pred_logits' in outputs
        src_logits = outputs['pred_logits'] #[bs, num_queries, num_classes]

        idx = self._get_src_permutation_idx(indices)    # 返回tuple,第一个值为图像索引，既哪个obj query对应哪张图像；第二个值为obj query索引
        target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)])   # J为该图像对应的object索引,得到每个object对应的target labels
        target_classes = torch.full(src_logits.shape[:2], self.num_classes,
                                    dtype=torch.int64, device=src_logits.device)    # [bs,num_queries]填满值为num_classes(此处为91)
        target_classes[idx] = target_classes_o  #此处表示在第i个image的第j个query填充对应的target_classes_o，此步骤为填充"no obj"

        loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight)  # [bs,num_query,num_classes] -> [bs,num_classes,num_query]
        losses = {'loss_ce': loss_ce}

        if log:
            # TODO this should probably be a separate loss, not hacked in this one here
            losses['class_error'] = 100 - accuracy(src_logits[idx], target_classes_o)[0]    #错误个数
         return losses
    
    def _get_src_permutation_idx(self, indices):
        # permute predictions following indices
        batch_idx = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(indices)]) # i为第i个图像,src为第i个图像对应的query的索引,_为第i个图像对应的object索引
                                                                                    # batch_idx得到[num_object],比如[0,0,1,1,1,1]，可知哪个object对应哪个图像
        src_idx = torch.cat([src for (src, _) in indices])  # 如tensor([22, 70,  7, 33, 34, 69])，既对应的object query索引
        return batch_idx, src_idx   

    def loss_boxes(self, outputs, targets, indices, num_boxes):
        """Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss
           targets dicts must contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4]
           The target boxes are expected in format (center_x, center_y, w, h), normalized by the image size.
        """
        assert 'pred_boxes' in outputs
        idx = self._get_src_permutation_idx(indices)
        src_boxes = outputs['pred_boxes'][idx]  # [num_object,4]
        target_boxes = torch.cat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0) #[num_object,4]

        loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none')

        losses = {}
        losses['loss_bbox'] = loss_bbox.sum() / num_boxes

        loss_giou = 1 - torch.diag(box_ops.generalized_box_iou(
            box_ops.box_cxcywh_to_xyxy(src_boxes),
            box_ops.box_cxcywh_to_xyxy(target_boxes)))
        losses['loss_giou'] = loss_giou.sum() / num_boxes
        return losses