loss.py
ultralytics\models\utils\loss.py
目录
loss.py
1.所需的库和模块
2.class DETRLoss(nn.Module):
3.class RTDETRDetectionLoss(DETRLoss):
1.所需的库和模块
# Ultralytics YOLO 🚀, AGPL-3.0 licenseimport torch
import torch.nn as nn
import torch.nn.functional as Ffrom ultralytics.utils.loss import FocalLoss, VarifocalLoss
from ultralytics.utils.metrics import bbox_iou
from .ops import HungarianMatcher2.class DETRLoss(nn.Module):
# 这段代码定义了一个名为 DETRLoss 的类，继承自 nn.Module ，用于计算DETR（Detection Transformer）模型的损失函数。
# 定义了 DETRLoss 类，继承自PyTorch的 nn.Module 基类。
class DETRLoss(nn.Module):# DETR (DEtection TRansformer) 损失类。此类计算并返回 DETR 对象检测模型的不同损失组件。它计算分类损失、边界框损失、GIoU 损失以及可选的辅助损失。"""DETR (DEtection TRansformer) Loss class. This class calculates and returns the different loss components for theDETR object detection model. It computes classification loss, bounding box loss, GIoU loss, and optionally auxiliarylosses.Attributes:nc (int): The number of classes.loss_gain (dict): Coefficients for different loss components.aux_loss (bool): Whether to compute auxiliary losses.use_fl (bool): Use FocalLoss or not.use_vfl (bool): Use VarifocalLoss or not.use_uni_match (bool): Whether to use a fixed layer to assign labels for the auxiliary branch.uni_match_ind (int): The fixed indices of a layer to use if `use_uni_match` is True.matcher (HungarianMatcher): Object to compute matching cost and indices.fl (FocalLoss or None): Focal Loss object if `use_fl` is True, otherwise None.vfl (VarifocalLoss or None): Varifocal Loss object if `use_vfl` is True, otherwise None.device (torch.device): Device on which tensors are stored."""# 这段代码是 DETRLoss 类的初始化方法 __init__ ，用于设置损失函数的相关参数和初始化一些组件。# 定义了 DETRLoss 类的初始化方法，接受以下参数 ：# 1.nc ：类别数，默认为80。# 2.loss_gain ：损失权重字典，默认为None。# 3.aux_loss ：是否使用辅助损失，默认为True。# 4.use_fl ：是否使用Focal Loss，默认为True。# 5.use_vfl ：是否使用Varifocal Loss，默认为False。# 6.use_uni_match ：是否使用统一匹配，默认为False。# 7.uni_match_ind ：统一匹配的索引，默认为0。def __init__(self, nc=80, loss_gain=None, aux_loss=True, use_fl=True, use_vfl=False, use_uni_match=False, uni_match_ind=0):# DETR 损失函数。"""DETR loss function.Args:nc (int): The number of classes.loss_gain (dict): The coefficient of loss.aux_loss (bool): If 'aux_loss = True', loss at each decoder layer are to be used.use_vfl (bool): Use VarifocalLoss or not.use_uni_match (bool): Whether to use a fixed layer to assign labels for auxiliary branch.uni_match_ind (int): The fixed indices of a layer."""# 调用基类 nn.Module 的初始化方法，这是PyTorch中模块初始化的标准做法，确保基类的初始化逻辑得以执行。super().__init__()# 如果 loss_gain 参数为None，则使用 默认的损失权重字典 。这个字典定义了 不同损失项的权重 ，例如分类损失权重为1，边界框损失权重为5等。if loss_gain is None:loss_gain = {"class": 1, "bbox": 5, "giou": 2, "no_object": 0.1, "mask": 1, "dice": 1}# 将传入的 类别数 nc 赋值给实例变量 self.nc ，这个变量在后续计算中用于处理类别相关的信息。self.nc = nc# 初始化一个 HungarianMatcher 实例，用于计算预测和目标之间的最优匹配。 cost_gain 字典定义了匹配成本的权重，这里类别、边界框和GIoU的权重分别为2、5、2。# class HungarianMatcher(nn.Module):# -> 用于实现基于匈牙利算法的目标检测中的匹配过程。# -> def __init__(self, cost_gain=None, use_fl=True, with_mask=False, num_sample_points=12544, alpha=0.25, gamma=2.0):self.matcher = HungarianMatcher(cost_gain={"class": 2, "bbox": 5, "giou": 2})# 将传入的 损失权重字典 loss_gain 赋值给实例变量 self.loss_gain ，这个变量在计算损失时用于调整不同损失项的权重。self.loss_gain = loss_gain# 将 是否使用辅助损失的标志 aux_loss 赋值给实例变量 self.aux_loss 。辅助损失通常用于在训练过程中提供额外的监督信号，帮助模型更好地学习。self.aux_loss = aux_loss# 根据 use_fl 的值决定是否初始化一个 FocalLoss 实例。Focal Loss是一种改进的交叉熵损失，用于解决类别不平衡问题。如果 use_fl 为True，则初始化 FocalLoss ，否则为None。self.fl = FocalLoss() if use_fl else None# 根据 use_vfl 的值决定是否初始化一个 VarifocalLoss 实例。Varifocal Loss是另一种用于目标检测的损失函数，如果 use_vfl 为True，则初始化 VarifocalLoss ，否则为None。self.vfl = VarifocalLoss() if use_vfl else None# 将 是否使用统一匹配的标志 use_uni_match 赋值给实例变量 self.use_uni_match 。统一匹配是一种特殊的匹配策略，可能在某些情况下用于优化匹配过程。self.use_uni_match = use_uni_match# 将 统一匹配的索引 uni_match_ind 赋值给实例变量 self.uni_match_ind 。这个索引用于在统一匹配过程中选择特定的预测或目标。self.uni_match_ind = uni_match_ind# 初始化设备变量 self.device 为None。这个变量在后续的计算中用于确保张量操作在正确的设备（CPU或GPU）上执行。self.device = None# 这段初始化方法的主要作用是设置 DETRLoss 类的各个参数和初始化一些关键组件，如匹配器和损失函数。这些设置和初始化操作为后续的损失计算提供了必要的基础。通过传入不同的参数，用户可以灵活地配置损失函数的行为，以适应不同的训练需求和数据特性。# 这段代码是 DETRLoss 类中的一个私有方法 _get_loss_class ，用于计算分类损失。# 定义了 _get_loss_class 方法，接受以下参数 :# 1.pred_scores ：预测的分数，形状为[b, query, num_classes]。# 2.targets ：目标类别，形状为[b, query]。# 3.gt_scores ：目标分数，形状为[b, query]。# 4.num_gts ：目标数量。# 5.postfix ：后缀，用于在损失名称中添加额外的标识。def _get_loss_class(self, pred_scores, targets, gt_scores, num_gts, postfix=""):# 根据预测、目标值和基本事实分数计算分类损失。"""Computes the classification loss based on predictions, target values, and ground truth scores."""# Logits: [b, query, num_classes], gt_class: list[[n, 1]]# 定义了分类损失的名称，包含后缀。name_class = f"loss_class{postfix}"# 获取 批量大小 bs 和 查询数量 nq 。bs, nq = pred_scores.shape[:2]# one_hot = F.one_hot(targets, self.nc + 1)[..., :-1] # (bs, num_queries, num_classes)# 这段代码的主要目的是将目标类别标签转换为one-hot编码，并将目标分数与one-hot编码相乘，以便后续计算分类损失。# 创建一个形状为 (bs, nq, self.nc + 1) 的零张量 one_hot ，数据类型为 torch.int64 ，设备与 targets 相同。这里 self.nc + 1 是为了包括背景类（通常背景类的索引为 self.nc ）。one_hot = torch.zeros((bs, nq, self.nc + 1), dtype=torch.int64, device=targets.device)# scatter_(self, dim, index, src, reduce='unsorted')# scatter_() 是 PyTorch 中的一个就地（in-place）操作函数，它用于将一个源张量（ src ）的值根据索引张量（ index ）指定的位置，沿着指定的维度（ dim ）“散布”（scatter）到目标张量（ self ）中。如果目标位置已经有值，会根据 reduce 参数的设置进行聚合操作。# 参数 ：# self ：目标张量，将要被修改的张量。# dim ：整数，指定沿着哪个维度进行散布操作。# index ：索引张量，包含要散布到的目标位置的索引。# src ：源张量，包含要散布的值。# reduce ：字符串，指定如何处理重叠索引的聚合操作。可选值为 'unsorted' , 'add' , 'sub' , 'mul' , 'div' , 'mean' 。默认为 'unsorted' ，表示不进行聚合，如果索引有重叠，结果将是不确定的。# 功能 ：# scatter_() 函数将 src 张量中的值根据 index 张量提供的索引，沿着 dim 维度“散布”到 self 张量中。# 如果 index 中有重复的索引，且 reduce 参数未设置为 'unsorted' ，则会根据 reduce 参数的值进行相应的聚合操作。例如，如果 reduce='add' ，则会将 src 中对应索引的值相加。# 返回值 ：函数没有返回值，因为它直接在 self 张量上进行修改。# scatter_() 函数是一个就地操作，意味着它直接修改输入的张量 self ，而不是返回一个新的张量。这个函数在处理图数据或者需要将稀疏数据聚合到密集张量的场景中非常有用。# 使用 scatter_ 方法将 targets 中的每个目标类别索引对应的位置设置为1，从而生成one-hot编码。# targets.unsqueeze(-1) ：将 targets 的形状从 (bs, nq) 变为 (bs, nq, 1) ，以便在 scatter_ 方法中使用。# one_hot.scatter_(2, targets.unsqueeze(-1), 1) ：在 one_hot 的第三个维度（类别维度）上，将 targets 中的每个索引对应的位置设置为1。例如，如果 targets 中的某个值为3，则 one_hot 中对应位置的第3个元素将被设置为1。one_hot.scatter_(2, targets.unsqueeze(-1), 1)# 去掉最后一个维度，即背景类，得到形状为 (bs, nq, self.nc) 的one-hot编码。这是因为背景类通常不需要参与分类损失的计算。one_hot = one_hot[..., :-1]# 将目标分数 gt_scores 与one-hot编码 one_hot 相乘，得到 每个类别的目标分数 。# gt_scores.view(bs, nq, 1) ：将 gt_scores 的形状从 (bs, nq) 变为 (bs, nq, 1) ，以便与 one_hot 相乘。# gt_scores.view(bs, nq, 1) * one_hot ：将 gt_scores 中的每个分数与 one_hot 中的对应位置相乘，得到每个类别的目标分数。这样，只有目标类别的分数会被保留，其他类别的分数为0。gt_scores = gt_scores.view(bs, nq, 1) * one_hot# 这段代码通过以下步骤将目标类别标签转换为one-hot编码，并将目标分数与one-hot编码相乘。创建一个形状为 (bs, nq, self.nc + 1) 的零张量 one_hot 。使用 scatter_ 方法将目标类别索引对应的位置设置为1，生成one-hot编码。去掉最后一个维度（背景类），得到形状为 (bs, nq, self.nc) 的one-hot编码。将目标分数与one-hot编码相乘，得到每个类别的目标分数。这样处理后的 gt_scores 可以用于后续的分类损失计算，确保只有目标类别的分数参与损失计算。# 假设有一个简单的例子，其中批量大小 bs 为2，查询数量 nq 为3，类别数 self.nc 为4（不包括背景类）。将逐步演示如何将目标类别标签转换为one-hot编码，并将目标分数与one-hot编码相乘。# 输入数据 ：# 假设目标类别 targets 和目标分数 gt_scores 如下：# targets = torch.tensor([[1, 3, 2], [0, 2, 4]]) # 形状为 (2, 3)# gt_scores = torch.tensor([[0.9, 0.8, 0.7], [0.6, 0.5, 0.4]]) # 形状为 (2, 3)# 代码执行过程 ：# 创建零张量 one_hot ：# bs, nq = 2, 3# self.nc = 4# one_hot = torch.zeros((bs, nq, self.nc + 1), dtype=torch.int64, device=targets.device)# one_hot 的初始值为 ：# [[[0, 0, 0, 0, 0],# [0, 0, 0, 0, 0],# [0, 0, 0, 0, 0]],# # [[0, 0, 0, 0, 0],# [0, 0, 0, 0, 0],# [0, 0, 0, 0, 0]]]# 使用 scatter_ 方法生成one-hot编码 ：# one_hot.scatter_(2, targets.unsqueeze(-1), 1)# targets.unsqueeze(-1) 的值为 ：# [[[1],# [3],# [2]],# # [[0],# [2],# [4]]]# one_hot 的值变为 ：# [[[0, 1, 0, 0, 0],# [0, 0, 0, 1, 0],# [0, 0, 1, 0, 0]],# # [[1, 0, 0, 0, 0],# [0, 0, 1, 0, 0],# [0, 0, 0, 0, 1]]]# 去掉最后一个维度（背景类） ：# one_hot = one_hot[..., :-1]# one_hot 的值变为 ：# [[[0, 1, 0, 0],# [0, 0, 0, 1],# [0, 0, 1, 0]],# # [[1, 0, 0, 0],# [0, 0, 1, 0],# [0, 0, 0, 0]]]# 将目标分数与one-hot编码相乘 ：# gt_scores = gt_scores.view(bs, nq, 1) * one_hot# gt_scores.view(bs, nq, 1) 的值为 ：# [[[0.9],# [0.8],# [0.7]],# # [[0.6],# [0.5],# [0.4]]]# gt_scores 与 one_hot 相乘后的值为 ：# [[[0.0, 0.9, 0.0, 0.0],# [0.0, 0.0, 0.0, 0.8],# [0.0, 0.0, 0.7, 0.0]],# # [[0.6, 0.0, 0.0, 0.0],# [0.0, 0.0, 0.5, 0.0],# [0.0, 0.0, 0.0, 0.0]]]# 检查是否使用Focal Loss。如果 self.fl 不为None，则表示使用Focal Loss。if self.fl:# 如果目标数量 num_gts 大于0且使用Varifocal Loss（ self.vfl 不为None），则进入这个分支。if num_gts and self.vfl:# 调用 VarifocalLoss 实例 self.vfl ，传入预测分数 pred_scores 、目标分数 gt_scores 和one-hot编码 one_hot ，计算 分类损失 。loss_cls = self.vfl(pred_scores, gt_scores, one_hot)# 如果目标数量 num_gts 为0或不使用Varifocal Loss，则进入这个分支。else:# 调用 FocalLoss 实例 self.fl ，传入预测分数 pred_scores 和one-hot编码 one_hot （转换为浮点数），计算 分类损失 。loss_cls = self.fl(pred_scores, one_hot.float())# 将计算得到的分类损失除以 max(num_gts, 1) / nq ，以得到平均损失。这样可以确保即使目标数量为0时，也不会导致除以0的错误。loss_cls /= max(num_gts, 1) / nq# 如果 self.fl 为None，即不使用Focal Loss，则进入这个分支。else:# 使用PyTorch的 BCEWithLogitsLoss 计算二元交叉熵损失。 reduction="none" 表示不进行任何缩减，返回每个元素的损失。然后对每个查询的损失求平均（ mean(1) ），再对所有查询的损失求和（ sum() ），得到总损失。这是YOLO分类损失的计算方法。loss_cls = nn.BCEWithLogitsLoss(reduction="none")(pred_scores, gt_scores).mean(1).sum() # YOLO CLS loss# 返回 分类损失 ，乘以相应的权重 self.loss_gain["class"] ，并去除多余的维度。return {name_class: loss_cls.squeeze() * self.loss_gain["class"]}# 这个方法 _get_loss_class 用于计算分类损失，支持Focal Loss和Varifocal Loss。根据配置，它将目标类别转换为one-hot编码，然后计算预测分数和目标分数之间的损失。最后，它将损失乘以相应的权重，并返回损失字典。这个方法是 DETRLoss 类中计算总损失的一部分。# 这段代码是 DETRLoss 类中的一个私有方法 _get_loss_bbox ，用于计算边界框损失和GIoU损失。# 定义了 _get_loss_bbox 方法，接受以下参数 ：# 1.pred_bboxes ：预测的边界框，形状为[b, query, 4]。# 2.gt_bboxes ：目标边界框，形状为[n, 4]。# 3.postfix ：后缀，用于在损失名称中添加额外的标识。def _get_loss_bbox(self, pred_bboxes, gt_bboxes, postfix=""):# 计算并返回预测和真实边界框的边界框损失和 GIoU 损失。"""Calculates and returns the bounding box loss and GIoU loss for the predicted and ground truth boundingboxes."""# Boxes: [b, query, 4], gt_bbox: list[[n, 4]]# 定义了 边界框损失 和 GIoU损失 的名称，包含后缀。name_bbox = f"loss_bbox{postfix}"name_giou = f"loss_giou{postfix}"# 初始化一个空字典 loss ，用于存储计算得到的损失。loss = {}# 如果 目标边界框 的数量为0，则直接返回0损失。这是为了处理没有目标的情况，避免在计算损失时出现错误。if len(gt_bboxes) == 0:loss[name_bbox] = torch.tensor(0.0, device=self.device)loss[name_giou] = torch.tensor(0.0, device=self.device)return loss# 计算 L1损失 ，并乘以相应的权重 self.loss_gain["bbox"] 。 F.l1_loss 计算 预测边界框 和 目标边界框 之间的 L1距离 ， reduction="sum" 表示对所有元素求和，然后除以目标边界框的数量，得到 平均L1损失 。loss[name_bbox] = self.loss_gain["bbox"] * F.l1_loss(pred_bboxes, gt_bboxes, reduction="sum") / len(gt_bboxes)# 计算 GIoU损失 。 bbox_iou 函数计算预测边界框和目标边界框之间的GIoU， xywh=True 表示边界框的格式为(x, y, w, h)， GIoU=True 表示计算GIoU而不是IoU。GIoU损失为1减去GIoU值。loss[name_giou] = 1.0 - bbox_iou(pred_bboxes, gt_bboxes, xywh=True, GIoU=True)# 对计算得到的GIoU损失求和，然后除以目标边界框的数量，得到 平均GIoU损失 。loss[name_giou] = loss[name_giou].sum() / len(gt_bboxes)# 将平均GIoU损失乘以相应的权重 self.loss_gain["giou"] 。loss[name_giou] = self.loss_gain["giou"] * loss[name_giou]# 返回损失字典，去除多余的维度。 squeeze 方法用于去除张量中大小为1的维度，确保返回的损失值是标量。return {k: v.squeeze() for k, v in loss.items()}# 这个方法 _get_loss_bbox 用于计算边界框损失和GIoU损失。定义损失名称，包含后缀。初始化一个空字典 loss ，用于存储计算得到的损失。如果目标边界框的数量为0，直接返回0损失。计算L1损失，并乘以相应的权重，得到平均L1损失。计算GIoU损失，对计算得到的GIoU损失求和，然后除以目标边界框的数量，得到平均GIoU损失。将平均GIoU损失乘以相应的权重。返回损失字典，去除多余的维度。这样处理后的损失字典可以用于后续的总损失计算，确保边界框损失和GIoU损失的计算方法灵活且适应不同的训练需求。# This function is for future RT-DETR Segment models 此功能适用于未来的 RT-DETR 细分模型。# def _get_loss_mask(self, masks, gt_mask, match_indices, postfix=''):# # masks: [b, query, h, w], gt_mask: list[[n, H, W]]# name_mask = f'loss_mask{postfix}'# name_dice = f'loss_dice{postfix}'## loss = {}# if sum(len(a) for a in gt_mask) == 0:# loss[name_mask] = torch.tensor(0., device=self.device)# loss[name_dice] = torch.tensor(0., device=self.device)# return loss## num_gts = len(gt_mask)# src_masks, target_masks = self._get_assigned_bboxes(masks, gt_mask, match_indices)# src_masks = F.interpolate(src_masks.unsqueeze(0), size=target_masks.shape[-2:], mode='bilinear')[0]# # TODO: torch does not have `sigmoid_focal_loss`, but it's not urgent since we don't use mask branch for now.# loss[name_mask] = self.loss_gain['mask'] * F.sigmoid_focal_loss(src_masks, target_masks,# torch.tensor([num_gts], dtype=torch.float32))# loss[name_dice] = self.loss_gain['dice'] * self._dice_loss(src_masks, target_masks, num_gts)# return loss# This function is for future RT-DETR Segment models 此功能适用于未来的 RT-DETR 细分模型。# @staticmethod# def _dice_loss(inputs, targets, num_gts):# inputs = F.sigmoid(inputs).flatten(1)# targets = targets.flatten(1)# numerator = 2 * (inputs * targets).sum(1)# denominator = inputs.sum(-1) + targets.sum(-1)# loss = 1 - (numerator + 1) / (denominator + 1)# return loss.sum() / num_gts# 这段代码是 DETRLoss 类中的一个私有方法 _get_loss_aux ，用于计算辅助损失。辅助损失通常用于在训练过程中提供额外的监督信号，帮助模型更好地学习。# 定义了 _get_loss_aux 方法，接受以下参数 ：# 1.pred_bboxes ：预测的边界框，形状为[List[Tensor]]，每个Tensor的形状为[b, query, 4]。# 2.pred_scores ：预测的分数，形状为[List[Tensor]]，每个Tensor的形状为[b, query, num_classes]。# 3.gt_bboxes ：目标边界框，形状为[n, 4]。# 4.gt_cls ：目标类别，形状为[n]。# 5.gt_groups ：目标组，形状为[n]。# 6.match_indices ：匹配索引，形状为[List[Tuple[Tensor, Tensor]]]。# 7.postfix ：后缀，用于在损失名称中添加额外的标识。# 8.masks ：预测的掩码，形状为[List[Tensor]]，每个Tensor的形状为[b, query, H, W]。# 9.gt_mask ：目标掩码，形状为[n, H, W]。def _get_loss_aux(self,pred_bboxes,pred_scores,gt_bboxes,gt_cls,gt_groups,match_indices=None,postfix="",masks=None,gt_mask=None,):# 获取辅助损失。"""Get auxiliary losses."""# NOTE: loss class, bbox, giou, mask, dice# 初始化一个零张量 loss ，用于存储 分类损失 、 边界框损失 和 GIoU损失 。如果提供了掩码，则还包括 掩码损失 和 Dice损失 。loss = torch.zeros(5 if masks is not None else 3, device=pred_bboxes.device)# 如果匹配索引 match_indices 为空且使用统一匹配（ self.use_uni_match 为True） 。if match_indices is None and self.use_uni_match:# 则调用匹配器 self.matcher 计算匹配索引。匹配器使用指定索引 self.uni_match_ind 的预测边界框和分数进行匹配。match_indices = self.matcher(pred_bboxes[self.uni_match_ind],pred_scores[self.uni_match_ind],gt_bboxes,gt_cls,gt_groups,masks=masks[self.uni_match_ind] if masks is not None else None,gt_mask=gt_mask,)# 这段代码是 _get_loss_aux 方法的核心部分，用于计算辅助损失。# 遍历每个 辅助预测的边界框 aux_bboxes 和 分数 aux_scores 。 pred_bboxes 和 pred_scores 是列表，每个元素是一个Tensor，分别表示 预测的边界框 和 分数 。for i, (aux_bboxes, aux_scores) in enumerate(zip(pred_bboxes, pred_scores)):# 如果提供了掩码 masks ，则获取 当前辅助预测的掩码 aux_masks 。如果 masks 为None，则 aux_masks 也为None。aux_masks = masks[i] if masks is not None else None# 调用 self._get_loss 方法，传入当前辅助预测的边界框 aux_bboxes 、分数 aux_scores 、目标边界框 gt_bboxes 、目标类别 gt_cls 、目标组 gt_groups 、当前辅助预测的掩码 aux_masks 、目标掩码 gt_mask 、后缀 postfix 和匹配索引 match_indices 。# 计算 分类损失 、 边界框损失 和 GIoU损失 。返回的 loss_ 是一个字典，包含这些损失。loss_ = self._get_loss(aux_bboxes,aux_scores,gt_bboxes,gt_cls,gt_groups,masks=aux_masks,gt_mask=gt_mask,postfix=postfix,match_indices=match_indices,)# 将计算得到的 分类损失 、 边界框损失 和 GIoU损失 累加到 loss 张量中。 loss 张量的第0个元素存储分类损失，第1个元素存储边界框损失，第2个元素存储GIoU损失。loss[0] += loss_[f"loss_class{postfix}"]loss[1] += loss_[f"loss_bbox{postfix}"]loss[2] += loss_[f"loss_giou{postfix}"]# if masks is not None and gt_mask is not None:# loss_ = self._get_loss_mask(aux_masks, gt_mask, match_indices, postfix)# loss[3] += loss_[f'loss_mask{postfix}']# loss[4] += loss_[f'loss_dice{postfix}']# 将累加的损失封装为字典，键名包含后缀 postfix 。这样可以方便地在后续的总损失计算中使用这些辅助损失。loss = {f"loss_class_aux{postfix}": loss[0],f"loss_bbox_aux{postfix}": loss[1],f"loss_giou_aux{postfix}": loss[2],}# 这段代码通过以下步骤计算辅助损失。遍历每个辅助预测的边界框和分数。获取当前辅助预测的掩码（如果提供）。调用 self._get_loss 方法计算分类损失、边界框损失和GIoU损失。将这些损失累加到 loss 张量中。将累加的损失封装为字典，键名包含后缀 postfix 。这样处理后的辅助损失字典可以用于后续的总损失计算，确保辅助损失的计算方法灵活且适应不同的训练需求。# if masks is not None and gt_mask is not None:# loss[f'loss_mask_aux{postfix}'] = loss[3]# loss[f'loss_dice_aux{postfix}'] = loss[4]# 返回 辅助损失字典 。return loss# 这个方法 _get_loss_aux 用于计算辅助损失。初始化一个零张量 loss ，用于存储分类损失、边界框损失和GIoU损失。如果匹配索引为空且使用统一匹配，则调用匹配器计算匹配索引。遍历每个辅助预测的边界框和分数，调用 self._get_loss 方法计算分类损失、边界框损失和GIoU损失，并将这些损失累加到 loss 张量中。将累加的损失封装为字典，键名包含后缀 postfix 。返回辅助损失字典。这样处理后的辅助损失字典可以用于后续的总损失计算，确保辅助损失的计算方法灵活且适应不同的训练需求。# 这段代码定义了一个静态方法 _get_index ，用于从匹配索引 match_indices 中提取批次索引、源索引和目标索引。这些索引用于后续的张量操作，例如提取匹配的预测和目标。@staticmethod# 定义了一个静态方法 _get_index ，接受一个参数。# match_indices ：是一个列表，每个元素是一个元组，包含两个Tensor ： 源索引 src 和 目标索引 dst 。def _get_index(match_indices):# 从提供的匹配索引返回批量索引、源索引和目标索引。"""Returns batch indices, source indices, and destination indices from provided match indices."""# 创建一个 批次索引 batch_idx ，用于 标识每个匹配项所属的批次 。# enumerate(match_indices) ：遍历 match_indices ，获取 每个匹配项的索引 i 和 内容 (src, _) 。# torch.full_like(src, i) ：创建一个与 src 形状相同的Tensor，填充值为 i ，表示当前匹配项所属的批次。# torch.cat([...]) ：将所有批次索引Tensor连接成一个Tensor。batch_idx = torch.cat([torch.full_like(src, i) for i, (src, _) in enumerate(match_indices)])# 创建一个 源索引 src_idx ，用于 标识匹配的预测索引 。# [(src, _) in match_indices] ：遍历 match_indices ，提取每个匹配项的源索引 src 。# torch.cat([...]) ：将所有源索引Tensor连接成一个Tensor。src_idx = torch.cat([src for (src, _) in match_indices])# 创建一个 目标索引 dst_idx ，用于 标识匹配的目标索引 。# [(_, dst) in match_indices] ：遍历 match_indices ，提取每个匹配项的目标索引 dst 。# torch.cat([...]) ：将所有目标索引Tensor连接成一个Tensor。dst_idx = torch.cat([dst for (_, dst) in match_indices])# 返回一个元组，包含两个元素 ： (batch_idx, src_idx) 批次索引和源索引。 dst_idx 目标索引。return (batch_idx, src_idx), dst_idx# 这个静态方法 _get_index 用于从匹配索引 match_indices 中提取批次索引、源索引和目标索引。创建一个批次索引 batch_idx ，用于标识每个匹配项所属的批次。创建一个源索引 src_idx ，用于标识匹配的预测索引。创建一个目标索引 dst_idx ，用于标识匹配的目标索引。返回一个元组，包含批次索引和源索引，以及目标索引。这样处理后的索引可以用于后续的张量操作，例如提取匹配的预测和目标，确保这些操作在正确的批次和索引上进行。# 这段代码定义了一个方法 _get_assigned_bboxes ，用于从预测的边界框和目标边界框中提取匹配的边界框。这个方法在目标检测任务中非常有用，特别是在计算损失函数时，需要将预测的边界框和目标边界框进行匹配。# 定义了 _get_assigned_bboxes 方法，接受以下参数 ：# 1.pred_bboxes ：预测的边界框，形状为 [b, query, 4] 。# 2.gt_bboxes ：目标边界框，形状为 [n, 4] 。# 3.match_indices ：匹配索引，形状为 [List[Tuple[Tensor, Tensor]]]，每个元组包含两个Tensor ： 源索引 src 和 目标索引 dst 。def _get_assigned_bboxes(self, pred_bboxes, gt_bboxes, match_indices):# 根据匹配索引将预测边界框分配给地面真实边界框。"""Assigns predicted bounding boxes to ground truth bounding boxes based on the match indices."""# 从 预测的边界框 中提取 匹配的边界框 。# torch.cat([...]) ：将所有提取的边界框连接成一个Tensor。pred_assigned = torch.cat([# t[i] ：根据 匹配索引 i 提取 预测的边界框 。如果 i 为空（即没有匹配项），则创建一个形状为 [0, t.shape[-1]] 的零张量。t[i] if len(i) > 0 else torch.zeros(0, t.shape[-1], device=self.device)# zip(pred_bboxes, match_indices) ：遍历 预测的边界框 和 匹配索引 。for t, (i, _) in zip(pred_bboxes, match_indices)])# 从 目标边界框 中提取 匹配的边界框 。# torch.cat([...]) ：将所有提取的边界框连接成一个Tensor。gt_assigned = torch.cat([# t[j] ：根据 匹配索引 j 提取 目标的边界框 。如果 j 为空（即没有匹配项），则创建一个形状为 [0, t.shape[-1]] 的零张量。t[j] if len(j) > 0 else torch.zeros(0, t.shape[-1], device=self.device)# zip(gt_bboxes, match_indices) ：遍历 目标边界框 和 匹配索引 。for t, (_, j) in zip(gt_bboxes, match_indices)])# 返回提取的 预测边界框 pred_assigned 和 目标边界框 gt_assigned 。return pred_assigned, gt_assigned# 这个方法 _get_assigned_bboxes 用于从预测的边界框和目标边界框中提取匹配的边界框。从预测的边界框中提取匹配的边界框，如果匹配索引为空，则创建一个零张量。从目标边界框中提取匹配的边界框，如果匹配索引为空，则创建一个零张量。将提取的边界框连接成一个Tensor。返回提取的预测边界框和目标边界框。这样处理后的边界框可以用于后续的损失计算，确保只有匹配的预测和目标参与损失计算。这对于目标检测任务中的损失函数计算非常重要，因为它可以确保模型在训练过程中关注正确的预测和目标。# 这段代码定义了 _get_loss 方法，用于计算预测的边界框、分数和目标之间的总损失。这个方法综合了分类损失、边界框损失和（可选的）掩码损失。# 定义了 _get_loss 方法，接受以下参数 ：# 1.pred_bboxes ：预测的边界框，形状为 [b, query, 4] 。# 2.pred_scores ：预测的分数，形状为 [b, query, num_classes] 。# 3.gt_bboxes ：目标边界框，形状为 [n, 4] 。# 4.gt_cls ：目标类别，形状为 [n] 。# 5.gt_groups ：目标组，形状为 [n] 。# 6.masks ：预测的掩码，形状为 [b, query, H, W] 。# 7.gt_mask ：目标掩码，形状为 [n, H, W] 。# 8.postfix ：后缀，用于在损失名称中添加额外的标识。# 9.match_indices ：匹配索引，形状为 [List[Tuple[Tensor, Tensor]]]，每个元组包含两个Tensor ： 源索引 src 和 目标索引 dst 。def _get_loss(self,pred_bboxes,pred_scores,gt_bboxes,gt_cls,gt_groups,masks=None,gt_mask=None,postfix="",match_indices=None,):# 计算损失。"""Get losses."""# 如果 match_indices 为空，则调用匹配器 self.matcher 计算匹配索引。匹配器根据预测的边界框、分数、目标边界框、类别、组和掩码进行匹配。if match_indices is None:match_indices = self.matcher(pred_bboxes, pred_scores, gt_bboxes, gt_cls, gt_groups, masks=masks, gt_mask=gt_mask)# 调用 _get_index 方法从 匹配索引 中提取 批次索引 idx 和 目标索引 gt_idx 。idx, gt_idx = self._get_index(match_indices)# 根据提取的索引，从 预测的边界框 和 目标边界框 中提取 匹配的边界框 。pred_bboxes, gt_bboxes = pred_bboxes[idx], gt_bboxes[gt_idx]# 这段代码是 _get_loss 方法的核心部分，用于计算分类损失和边界框损失。# 获取 批量大小 bs 和 查询数量 nq ，这两个值从预测分数 pred_scores 的形状中提取。 pred_scores 的形状为 [b, query, num_classes]。bs, nq = pred_scores.shape[:2]# 创建一个形状为 [bs, nq] 的Tensor targets ，初始值为 背景类别的索引 self.nc 。这个Tensor用于 存储目标类别 ，初始时假设所有预测都是背景类别。 device 和 dtype 分别与 pred_scores 和 gt_cls 保持一致。targets = torch.full((bs, nq), self.nc, device=pred_scores.device, dtype=gt_cls.dtype)# 根据 匹配索引 idx 和 gt_idx ，将 目标类别 gt_cls 赋值给 targets 中对应的位置。这样， targets 中存储了 每个预测的匹配目标类别 。targets[idx] = gt_cls[gt_idx]# 创建一个形状为 [bs, nq] 的零张量 gt_scores ，用于存储 目标分数 。初始时，所有分数为0。gt_scores = torch.zeros([bs, nq], device=pred_scores.device)# 如果 目标边界框 gt_bboxes 不为空。if len(gt_bboxes):# 则计算 预测边界框 pred_bboxes 和 目标边界框 gt_bboxes 之间的IoU，并将IoU值赋值给 gt_scores 中对应的位置。 pred_bboxes.detach() 用于避免梯度回传， bbox_iou 函数计算IoU， xywh=True 表示边界框的格式为 (x, y, w, h)， squeeze(-1) 用于去除多余的维度。gt_scores[idx] = bbox_iou(pred_bboxes.detach(), gt_bboxes, xywh=True).squeeze(-1)# 初始化一个空字典 loss ，用于存储计算得到的损失。loss = {}# 调用 _get_loss_class 方法计算 分类损失 ，并将结果更新到 loss 字典中。 _get_loss_class 方法接受预测分数 pred_scores 、目标类别 targets 、目标分数 gt_scores 、目标数量 len(gt_bboxes) 和后缀 postfix 。loss.update(self._get_loss_class(pred_scores, targets, gt_scores, len(gt_bboxes), postfix))# 调用 _get_loss_bbox 方法计算 边界框损失 ，并将结果更新到 loss 字典中。 _get_loss_bbox 方法接受预测边界框 pred_bboxes 、目标边界框 gt_bboxes 和后缀 postfix 。loss.update(self._get_loss_bbox(pred_bboxes, gt_bboxes, postfix))# 这段代码通过以下步骤计算分类损失和边界框损失。获取批量大小 bs 和查询数量 nq 。创建一个初始值为背景类别的目标张量 targets 。根据匹配索引将目标类别赋值给 targets 中对应的位置。创建一个零张量 gt_scores ，用于存储目标分数。如果目标边界框不为空，计算预测边界框和目标边界框之间的IoU，并将IoU值赋值给 gt_scores 中对应的位置。初始化一个空字典 loss ，用于存储计算得到的损失。调用 _get_loss_class 方法计算分类损失，并将结果更新到 loss 字典中。调用 _get_loss_bbox 方法计算边界框损失，并将结果更新到 loss 字典中。这样处理后的 loss 字典包含分类损失和边界框损失，可以用于后续的总损失计算，确保损失函数的计算方法灵活且适应不同的训练需求。# if masks is not None and gt_mask is not None:# loss.update(self._get_loss_mask(masks, gt_mask, match_indices, postfix))# 返回包含所有损失的字典 loss 。return loss# 这个方法 _get_loss 用于计算预测的边界框、分数和目标之间的总损失。如果匹配索引为空，则调用匹配器计算匹配索引。从匹配索引中提取批次索引和目标索引。根据提取的索引，从预测的边界框和目标边界框中提取匹配的边界框。创建一个全为背景类别的目标张量，并根据匹配索引将目标类别赋值给对应的位置。创建一个零张量，用于存储目标分数，并计算预测边界框和目标边界框之间的IoU。初始化一个空字典，用于存储计算得到的损失。调用 _get_loss_class 方法计算分类损失，调用 _get_loss_bbox 方法计算边界框损失，并将这些损失更新到字典中。如果提供了预测掩码和目标掩码，则调用 _get_loss_mask 方法计算掩码损失，并将损失更新到字典中。返回包含所有损失的字典。这样处理后的损失字典可以用于后续的总损失计算，确保损失函数的计算方法灵活且适应不同的训练需求。# 这段代码定义了 DETRLoss 类的 forward 方法，这是 PyTorch 模块中用于前向传播的主要方法。 forward 方法计算并返回总损失，包括主损失和辅助损失（如果启用）。# 定义了 forward 方法，接受以下参数 ：# 1.pred_bboxes ：预测的边界框，形状为 [List[Tensor]]，每个Tensor的形状为 [b, query, 4] 。# 2.pred_scores ：预测的分数，形状为 [List[Tensor]]，每个Tensor的形状为 [b, query, num_classes] 。# 3.batch ：一个字典，包含目标类别 cls 、目标边界框 bboxes 和目标组 gt_groups 。# 4.postfix ：后缀，用于在损失名称中添加额外的标识。# 5.**kwargs ：额外的关键字参数，用于传递其他可能需要的参数。def forward(self, pred_bboxes, pred_scores, batch, postfix="", **kwargs):# Args:# pred_bboxes (torch.Tensor): [l, b, query, 4]# pred_scores (torch.Tensor): [l, b, query, num_classes]# batch (dict): 一个字典，包括：# gt_cls (torch.Tensor)，形状为 [num_gts, ],# gt_bboxes (torch.Tensor): [num_gts, 4],# gt_groups (List(int)): 一个批次大小长度的列表，包括每个图像的 gts 数量。# postfix (str): 损失名称的后缀。"""Args:pred_bboxes (torch.Tensor): [l, b, query, 4]pred_scores (torch.Tensor): [l, b, query, num_classes]batch (dict): A dict includes:gt_cls (torch.Tensor) with shape [num_gts, ],gt_bboxes (torch.Tensor): [num_gts, 4],gt_groups (List(int)): a list of batch size length includes the number of gts of each image.postfix (str): postfix of loss name."""# 将预测边界框的设备赋值给 self.device ，确保后续操作在正确的设备上进行。self.device = pred_bboxes.device# 从 kwargs 中获取 匹配索引 match_indices ，如果不存在则默认为 None 。match_indices = kwargs.get("match_indices", None)# 从 batch 字典中提取 目标类别 gt_cls 、 目标边界框 gt_bboxes 和 目标组 gt_groups 。gt_cls, gt_bboxes, gt_groups = batch["cls"], batch["bboxes"], batch["gt_groups"]# 调用 _get_loss 方法计算 主损失 。使用 最后一个预测的边界框 和 分数 （通常是最优的预测），传入目标边界框、类别、组、后缀和匹配索引，计算 分类损失 和 边界框损失 。返回的 total_loss 是一个字典，包含这些损失。total_loss = self._get_loss(pred_bboxes[-1], pred_scores[-1], gt_bboxes, gt_cls, gt_groups, postfix=postfix, match_indices=match_indices)# 如果启用了辅助损失（ self.aux_loss 为 True ），则调用 _get_loss_aux 方法计算辅助损失。使用 除最后一个之外的所有 预测的边界框 和 分数 ，传入目标边界框、类别、组、匹配索引和后缀，计算辅助损失。将这些辅助损失更新到 total_loss 字典中。if self.aux_loss:total_loss.update(self._get_loss_aux(pred_bboxes[:-1], pred_scores[:-1], gt_bboxes, gt_cls, gt_groups, match_indices, postfix))# 返回包含所有损失的字典 total_loss 。return total_loss# 这个 forward 方法通过以下步骤计算总损失。获取预测边界框的设备。从 kwargs 中获取匹配索引。从 batch 字典中提取目标类别、边界框和组。调用 _get_loss 方法计算主损失，使用最后一个预测的边界框和分数。如果启用了辅助损失，则调用 _get_loss_aux 方法计算辅助损失，使用除最后一个之外的所有预测的边界框和分数。将辅助损失更新到主损失字典中。返回包含所有损失的字典。这样处理后的 total_loss 字典可以用于后续的反向传播和优化，确保模型在训练过程中同时考虑主损失和辅助损失，提高模型的性能和稳定性。
# DETRLoss 类是一个用于计算 DETR（Detection Transformer）模型损失的 PyTorch 模块。它综合了分类损失、边界框损失和（可选的）掩码损失，通过匹配预测和目标来计算总损失。该类支持主损失和辅助损失的计算，提供了灵活的配置选项，如使用 Focal Loss 和 Varifocal Loss，以及统一匹配策略。 forward 方法在前向传播中计算并返回总损失，确保模型在训练过程中能够同时优化多个损失项，提高检测性能和稳定性。3.class RTDETRDetectionLoss(DETRLoss):
# RTDETRDetectionLoss 类继承自 DETRLoss 类，用于计算 RT-DETR 模型的检测损失。这个类在 DETRLoss 的基础上增加了对去噪（denoising）训练的支持。
# 定义了 RTDETRDetectionLoss 类，继承自 DETRLoss 类。
class RTDETRDetectionLoss(DETRLoss):# 实时 DeepTracker (RT-DETR) 检测损失类，扩展了 DETRLoss。# 此类计算 RT-DETR 模型的检测损失，其中包括标准检测损失以及提供去噪元数据时的额外去噪训练损失。"""Real-Time DeepTracker (RT-DETR) Detection Loss class that extends the DETRLoss.This class computes the detection loss for the RT-DETR model, which includes the standard detection loss as well asan additional denoising training loss when provided with denoising metadata."""# 这段代码是 RTDETRDetectionLoss 类的 forward 方法，用于计算 RT-DETR 模型的检测损失，包括主损失和去噪（denoising）损失。# 定义了 forward 方法，接受以下参数 ：# 1.preds ：一个元组，包含预测的边界框 pred_bboxes 和预测的分数 pred_scores 。# 2.batch ：一个字典，包含目标类别 cls 、目标边界框 bboxes 和目标组 gt_groups 。# 3.dn_bboxes ：去噪预测的边界框。# 4.dn_scores ：去噪预测的分数。# 5.dn_meta ：去噪元数据，包含去噪位置索引 dn_pos_idx 和去噪组数 dn_num_group 。def forward(self, preds, batch, dn_bboxes=None, dn_scores=None, dn_meta=None):# 前向传递以计算检测损失。"""Forward pass to compute the detection loss.Args:preds (tuple): Predicted bounding boxes and scores.batch (dict): Batch data containing ground truth information.dn_bboxes (torch.Tensor, optional): Denoising bounding boxes. Default is None.dn_scores (torch.Tensor, optional): Denoising scores. Default is None.dn_meta (dict, optional): Metadata for denoising. Default is None.Returns:(dict): Dictionary containing the total loss and, if applicable, the denoising loss."""# 从 preds 中提取 预测的边界框 pred_bboxes 和 预测的分数 pred_scores 。pred_bboxes, pred_scores = preds# 然后调用父类 DETRLoss 的 forward 方法计算主损失。 total_loss 是一个字典，包含分类损失和边界框损失。total_loss = super().forward(pred_bboxes, pred_scores, batch)# Check for denoising metadata to compute denoising training loss# 如果提供了 去噪元数据 dn_meta ，则进行以下操作。if dn_meta is not None:# 从 dn_meta 中提取 去噪位置索引 dn_pos_idx 和 去噪组数 dn_num_group 。dn_pos_idx, dn_num_group = dn_meta["dn_pos_idx"], dn_meta["dn_num_group"]# 并确保 目标组的数量 与 去噪位置索引的数量 一致。assert len(batch["gt_groups"]) == len(dn_pos_idx)# Get the match indices for denoising# 调用 get_dn_match_indices 方法计算 去噪匹配索引 。这个方法返回一个列表 match_indices ，每个元素是一个元组 (src_idx, dst_idx) ，表示 预测和目标之间的匹配关系 。match_indices = self.get_dn_match_indices(dn_pos_idx, dn_num_group, batch["gt_groups"])# Compute the denoising training loss# 调用父类 DETRLoss 的 forward 方法计算去噪损失，传入去噪预测的边界框 dn_bboxes 、去噪预测的分数 dn_scores 、批次数据 batch 、后缀 _dn 和匹配索引 match_indices 。计算得到的去噪损失 dn_loss 是一个字典，包含 去噪分类损失 和 去噪边界框损失 。dn_loss = super().forward(dn_bboxes, dn_scores, batch, postfix="_dn", match_indices=match_indices)# 将这些损失更新到 total_loss 字典中。# update 方法 ： update 方法用于将 dn_loss 字典中的所有键值对添加到 total_loss 字典中。如果 total_loss 中已经存在与 dn_loss 中相同的键，则 update 方法会覆盖这些键的值。total_loss.update(dn_loss)# 如果未提供去噪元数据，则将去噪损失设置为0。具体做法是遍历 total_loss 字典中的每个键 k ，创建一个新的键 f"{k}_dn" ，并将其值设置为0，然后更新到 total_loss 字典中。else:# If no denoising metadata is provided, set denoising loss to zerototal_loss.update({f"{k}_dn": torch.tensor(0.0, device=self.device) for k in total_loss.keys()})# 返回包含 主损失 和 去噪损失 的字典 total_loss 。return total_loss# 这个 forward 方法通过以下步骤计算 RT-DETR 模型的总损失。从 preds 中提取预测的边界框和分数，调用父类 DETRLoss 的 forward 方法计算主损失。如果提供了去噪元数据，则：提取去噪位置索引和去噪组数。调用 get_dn_match_indices 方法计算去噪匹配索引。调用父类 DETRLoss 的 forward 方法计算去噪损失，并将去噪损失更新到总损失中。如果未提供去噪元数据，则将去噪损失设置为0。返回包含主损失和去噪损失的字典 total_loss 。这样处理后的 total_loss 字典可以用于后续的反向传播和优化，确保模型在训练过程中同时考虑主损失和去噪损失，提高模型的性能和稳定性。# 这段代码定义了一个静态方法 get_dn_match_indices ，用于计算去噪（denoising）训练中的匹配索引。这个方法在去噪训练中非常关键，因为它帮助确定哪些预测与哪些目标匹配。@staticmethod# 定义了一个静态方法 get_dn_match_indices ，接受以下参数 ：# 1.dn_pos_idx ：去噪位置索引，形状为 [List[Tensor]]，每个Tensor的形状为 [num_dn] 。# 2.dn_num_group ：去噪组数，一个整数。# 3.gt_groups ：目标组，形状为 [List[int]]，每个元素表示每个批次中的目标数量。def get_dn_match_indices(dn_pos_idx, dn_num_group, gt_groups):# 获取用于去噪的匹配索引。"""Get the match indices for denoising.Args:dn_pos_idx (List[torch.Tensor]): List of tensors containing positive indices for denoising.dn_num_group (int): Number of denoising groups.gt_groups (List[int]): List of integers representing the number of ground truths for each image.Returns:(List[tuple]): List of tuples containing matched indices for denoising."""# 初始化一个空列表 dn_match_indices ，用于 存储每个批次的匹配索引 。dn_match_indices = []# 计算 目标组的累积和 idx_groups ，用于确定每个目标组的起始索引。 [0, *gt_groups[:-1]] 创建一个列表，包含0和除了最后一个元素外的所有目标组数量，然后使用 cumsum_(0) 计算累积和。idx_groups = torch.as_tensor([0, *gt_groups[:-1]]).cumsum_(0)# 遍历每个目标组， i 是索引， num_gt 是当前目标组的目标数量。for i, num_gt in enumerate(gt_groups):# 如果当前目标组的目标数量大于0，则进行以下操作。if num_gt > 0:# 生成 当前目标组的目标索引 gt_idx ，从0到 num_gt ，然后加上当前组的起始索引 idx_groups[i] 。gt_idx = torch.arange(end=num_gt, dtype=torch.long) + idx_groups[i]# 将 目标索引 gt_idx 重复 dn_num_group 次，以 匹配去噪预测的数量 。gt_idx = gt_idx.repeat(dn_num_group)# 断言 dn_pos_idx[i] 和 gt_idx 的长度相同，确保匹配索引的长度一致。assert len(dn_pos_idx[i]) == len(gt_idx), "Expected the same length, " # 预期长度相同，但分别得到了 {len(dn_pos_idx[i])} 和 {len(gt_idx)}。f"but got {len(dn_pos_idx[i])} and {len(gt_idx)} respectively."# 将匹配索引 (dn_pos_idx[i], gt_idx) 添加到 dn_match_indices 列表中。dn_match_indices.append((dn_pos_idx[i], gt_idx))# 如果当前目标组的目标数量为0，则添加两个空的Tensor到 dn_match_indices 列表中。else:dn_match_indices.append((torch.zeros([0], dtype=torch.long), torch.zeros([0], dtype=torch.long)))# 返回包含所有匹配索引的列表 dn_match_indices 。return dn_match_indices# 这个静态方法 get_dn_match_indices 用于计算去噪训练中的匹配索引。初始化一个空列表 dn_match_indices ，用于存储匹配索引。计算目标组的累积和 idx_groups ，用于确定每个目标组的起始索引。遍历每个目标组，如果目标数量大于0，则：生成当前目标组的目标索引 gt_idx 。将目标索引 gt_idx 重复 dn_num_group 次。确保 dn_pos_idx[i] 和 gt_idx 的长度相同。将匹配索引 (dn_pos_idx[i], gt_idx) 添加到 dn_match_indices 列表中。如果目标数量为0，则添加两个空的Tensor到 dn_match_indices 列表中。返回包含所有匹配索引的列表 dn_match_indices 。这样处理后的 dn_match_indices 可以用于后续的去噪损失计算，确保去噪训练的正确性和有效性。
# RTDETRDetectionLoss 类在 DETRLoss 的基础上增加了对去噪训练的支持。计算主损失，包括分类损失和边界框损失。如果提供了去噪元数据，则计算去噪损失，并将去噪损失更新到总损失中。提供了一个静态方法 get_dn_match_indices ，用于计算去噪匹配索引。这样处理后的 total_loss 字典包含主损失和去噪损失，可以用于后续的反向传播和优化，确保模型在训练过程中同时考虑主损失和去噪损失，提高模型的性能和稳定性。
