目标检测-20200526：DETR (DEtection TRansformer) 详细分析
·
DETR (DEtection TRansformer) 详细分析
基于论文 End-to-End Object Detection with Transformers 和项目代码的深入解析
目录
1. 模型概述
1.1 什么是DETR?
DETR (DEtection TRansformer) 是Facebook AI Research在2020年提出的一种端到端的目标检测模型。它革命性地将目标检测问题转化为集合预测问题,摆脱了传统方法中需要的锚框(anchor)、非极大值抑制(NMS)等手工设计的组件。
1.2 核心创新点
| 传统方法 | DETR方法 |
|---|---|
| 需要锚框(Anchor Boxes) | 无需锚框 |
| 需要NMS后处理 | 无需NMS |
| 间接预测 | 直接集合预测 |
| 复杂的后处理流程 | 端到端训练 |
2. 模型架构详解
DETR的整体架构可以分为三个主要部分:
输入图像 → CNN骨干网络 → Transformer编码器-解码器 → 预测头 → 输出
2.1 CNN骨干网络 (Backbone)
作用: 提取图像特征
实现 (来自 models/backbone.py):
# 使用ResNet作为骨干网络
backbone = ResNet50/ResNet101
# 输入: 图像 [batch_size, 3, H, W]
# 输出: 特征图 [batch_size, C, H/32, W/32]
# 其中 C=2048 (对于ResNet50/101)
通俗理解:
想象你在看一张照片,CNN骨干网络就像是你的眼睛,它把照片中的信息(颜色、形状、纹理等)提取出来,变成计算机能理解的"特征"。
2.2 位置编码 (Position Encoding)
为什么需要位置编码?
Transformer本身不知道图像中每个位置的空间关系,位置编码就是告诉模型"这个特征在图像的哪个位置"。
数学公式 (来自 models/position_encoding.py):
对于图像中位置 ( x , y ) (x, y) (x,y),位置编码计算如下:
PE ( x , y , 2 i ) = sin ( x 1000 0 2 i / d ) \text{PE}(x, y, 2i) = \sin\left(\frac{x}{10000^{2i/d}}\right) PE(x,y,2i)=sin(100002i/dx)
PE ( x , y , 2 i + 1 ) = cos ( x 1000 0 2 i / d ) \text{PE}(x, y, 2i+1) = \cos\left(\frac{x}{10000^{2i/d}}\right) PE(x,y,2i+1)=cos(100002i/dx)
其中:
- x , y x, y x,y 是像素的坐标位置
- i i i 是特征维度的索引 ( i = 0 , 1 , 2 , . . . , d / 2 − 1 i = 0, 1, 2, ..., d/2-1 i=0,1,2,...,d/2−1)
- d d d 是特征维度 (默认256)
高中生理解:
这就像给每个位置一个"身份证号码"。使用正弦和余弦函数是因为它们有周期性,可以让模型学习到相对位置关系。
2.3 Transformer编码器 (Encoder)
作用: 让图像的不同部分"互相交流",理解全局上下文
结构 (来自 models/transformer.py):
输入特征 → [自注意力层 → 前馈网络] × 6层 → 编码后的特征
自注意力机制 (Self-Attention) 数学公式:
Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V Attention(Q,K,V)=softmax(dkQKT)V
其中:
- Q Q Q (Query): 查询矩阵,表示"我想找什么"
- K K K (Key): 键矩阵,表示"我是什么"
- V V V (Value): 值矩阵,表示"我的内容是什么"
- d k d_k dk: 键的维度,用于缩放(防止数值过大)
详细推导过程:
-
计算相似度: Score = Q K T \text{Score} = QK^T Score=QKT
- 这一步计算每个位置与其他位置的相关性
- 结果是一个矩阵,大小为 [ H W , H W ] [HW, HW] [HW,HW] (H×W是特征图的高和宽)
-
缩放: Scaled Score = Q K T d k \text{Scaled Score} = \frac{QK^T}{\sqrt{d_k}} Scaled Score=dkQKT
- 除以 d k \sqrt{d_k} dk 是为了防止点积结果过大
- 如果不缩放,softmax会变得很"尖锐",梯度会很小
-
归一化: Attention Weights = softmax ( Scaled Score ) \text{Attention Weights} = \text{softmax}(\text{Scaled Score}) Attention Weights=softmax(Scaled Score)
- softmax函数: softmax ( x i ) = e x i ∑ j e x j \text{softmax}(x_i) = \frac{e^{x_i}}{\sum_j e^{x_j}} softmax(xi)=∑jexjexi
- 将分数转换为概率分布(所有权重和为1)
-
加权求和: Output = Attention Weights × V \text{Output} = \text{Attention Weights} \times V Output=Attention Weights×V
- 根据注意力权重对值进行加权平均
高中生理解:
想象你在教室里,你想找一个同学借笔(Query)。你会看看每个同学(Key),判断谁最可能有笔。然后你会更关注那些可能有笔的同学(Attention Weights),最后从他们那里得到笔(Value)。
2.4 Transformer解码器 (Decoder)
作用: 根据图像特征,生成目标检测结果
关键概念 - Object Queries (对象查询):
DETR使用100个可学习的对象查询(Object Queries),每个查询负责检测图像中的一个目标。
# 来自 models/detr.py
self.query_embed = nn.Embedding(num_queries, hidden_dim) # 100个查询,每个256维
解码器结构:
Object Queries → [自注意力 → 交叉注意力 → 前馈网络] × 6层 → 输出特征
↑ ↑
| |
查询之间 查询与图像特征
交叉注意力 (Cross-Attention) 公式:
CrossAttention ( Q query , K encoder , V encoder ) = softmax ( Q query K encoder T d k ) V encoder \text{CrossAttention}(Q_{\text{query}}, K_{\text{encoder}}, V_{\text{encoder}}) = \text{softmax}\left(\frac{Q_{\text{query}}K_{\text{encoder}}^T}{\sqrt{d_k}}\right)V_{\text{encoder}} CrossAttention(Qquery,Kencoder,Vencoder)=softmax(dkQqueryKencoderT)Vencoder
这里:
- Q query Q_{\text{query}} Qquery: 来自对象查询
- K encoder , V encoder K_{\text{encoder}}, V_{\text{encoder}} Kencoder,Vencoder: 来自编码器的图像特征
高中生理解:
100个对象查询就像100个"侦探",每个侦探负责在图像中找一个目标。交叉注意力让侦探去"询问"图像的每个部分:“这里有我要找的目标吗?”
2.5 预测头 (Prediction Heads)
解码器输出后,通过两个预测头得到最终结果:
1. 分类头 (来自 models/detr.py):
self.class_embed = nn.Linear(hidden_dim, num_classes + 1) # +1 是"无目标"类
输出: 每个查询预测的类别概率 [ 100 , 91 ] [100, 91] [100,91] (COCO数据集有90类+1个"无目标"类)
2. 边界框头:
self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3) # 输出4个值: (中心x, 中心y, 宽, 高)
详细解释 MLP(hidden_dim, hidden_dim, 4, 3) 的含义:
这是一个多层感知机 (Multi-Layer Perceptron),用于将Transformer的输出特征转换为边界框坐标。
参数解析:
- 第1个参数
hidden_dim(256): 输入维度 - 来自Transformer解码器的特征维度 - 第2个参数
hidden_dim(256): 隐藏层维度 - 中间层的神经元数量 - 第3个参数
4: 输出维度 - 边界框的4个坐标值 ( c x , c y , w , h ) (c_x, c_y, w, h) (cx,cy,w,h) - 第4个参数
3: 网络层数 - 总共3层全连接层
MLP的网络结构 (来自 models/detr.py):
class MLP(nn.Module):
"""多层感知机 (也叫前馈神经网络 FFN)"""
def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
super().__init__()
self.num_layers = num_layers
h = [hidden_dim] * (num_layers - 1)
# 构建层序列: [input_dim → hidden_dim → hidden_dim → output_dim]
self.layers = nn.ModuleList(
nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])
)
def forward(self, x):
for i, layer in enumerate(self.layers):
# 前面的层使用ReLU激活,最后一层不使用激活函数
x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
return x
具体到 MLP(256, 256, 4, 3) 的结构:
输入特征 [B, 100, 256]
↓
第1层: Linear(256 → 256) + ReLU
↓
中间特征 [B, 100, 256]
↓
第2层: Linear(256 → 256) + ReLU
↓
中间特征 [B, 100, 256]
↓
第3层: Linear(256 → 4) (无激活函数)
↓
输出坐标 [B, 100, 4]
数学表达式:
h 1 = ReLU ( W 1 x + b 1 ) h 2 = ReLU ( W 2 h 1 + b 2 ) bbox = W 3 h 2 + b 3 \begin{align} h_1 &= \text{ReLU}(W_1 x + b_1) \\ h_2 &= \text{ReLU}(W_2 h_1 + b_2) \\ \text{bbox} &= W_3 h_2 + b_3 \end{align} h1h2bbox=ReLU(W1x+b1)=ReLU(W2h1+b2)=W3h2+b3
其中:
- x ∈ R 256 x \in \mathbb{R}^{256} x∈R256: 输入特征向量
- h 1 , h 2 ∈ R 256 h_1, h_2 \in \mathbb{R}^{256} h1,h2∈R256: 隐藏层特征
- bbox ∈ R 4 \text{bbox} \in \mathbb{R}^{4} bbox∈R4: 输出的边界框坐标
- W 1 , W 2 ∈ R 256 × 256 W_1, W_2 \in \mathbb{R}^{256 \times 256} W1,W2∈R256×256: 前两层的权重矩阵
- W 3 ∈ R 4 × 256 W_3 \in \mathbb{R}^{4 \times 256} W3∈R4×256: 最后一层的权重矩阵
- b 1 , b 2 ∈ R 256 b_1, b_2 \in \mathbb{R}^{256} b1,b2∈R256, b 3 ∈ R 4 b_3 \in \mathbb{R}^{4} b3∈R4: 偏置向量
为什么使用3层而不是1层?
- 非线性表达能力: 多层网络可以学习更复杂的映射关系
- 特征变换: 逐步将抽象的语义特征转换为具体的坐标值
- 经验选择: 3层是一个平衡性能和计算量的经验值
为什么最后一层不用激活函数?
因为边界框坐标可以是任意实数值,不需要限制在特定范围内(后续会用sigmoid归一化到[0,1])。
完整的边界框预测流程:
# 1. MLP输出原始坐标
bbox_raw = self.bbox_embed(hs) # [B, 100, 4]
# 2. Sigmoid归一化到 [0, 1]
bbox_normalized = bbox_raw.sigmoid() # [B, 100, 4]
# 3. 输出格式: (中心x, 中心y, 宽度, 高度)
# 所有值都是相对于图像尺寸的比例
输出: 每个查询预测的边界框坐标 [ 100 , 4 ] [100, 4] [100,4]
边界框格式: ( c x , c y , w , h ) (c_x, c_y, w, h) (cx,cy,w,h),所有值归一化到 [ 0 , 1 ] [0, 1] [0,1]
高中生理解:
想象你要在一张纸上画一个矩形框:
- c x c_x cx: 框中心的横坐标(0表示最左边,1表示最右边)
- c y c_y cy: 框中心的纵坐标(0表示最上边,1表示最下边)
- w w w: 框的宽度占图像宽度的比例
- h h h: 框的高度占图像高度的比例
例如: ( 0.5 , 0.5 , 0.3 , 0.4 ) (0.5, 0.5, 0.3, 0.4) (0.5,0.5,0.3,0.4) 表示一个位于图像中心,宽度为图像宽度30%,高度为图像高度40%的框。
3. 数学公式推导
3.1 多头注意力 (Multi-Head Attention)
为了让模型从不同角度理解图像,DETR使用多头注意力:
MultiHead ( Q , K , V ) = Concat ( head 1 , . . . , head h ) W O \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, ..., \text{head}_h)W^O MultiHead(Q,K,V)=Concat(head1,...,headh)WO
其中每个头:
head i = Attention ( Q W i Q , K W i K , V W i V ) \text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V) headi=Attention(QWiQ,KWiK,VWiV)
参数:
- h = 8 h = 8 h=8: 注意力头的数量
- W i Q , W i K , W i V W_i^Q, W_i^K, W_i^V WiQ,WiK,WiV: 每个头的投影矩阵
- W O W^O WO: 输出投影矩阵
为什么需要多头?
想象你在看一幅画:
- 第1个头可能关注颜色
- 第2个头可能关注形状
- 第3个头可能关注纹理
- …
多个头让模型能从多个角度理解图像。
3.2 前馈网络 (Feed-Forward Network)
在每个Transformer层中,注意力机制后面跟着一个前馈网络:
FFN ( x ) = ReLU ( x W 1 + b 1 ) W 2 + b 2 \text{FFN}(x) = \text{ReLU}(xW_1 + b_1)W_2 + b_2 FFN(x)=ReLU(xW1+b1)W2+b2
其中:
- W 1 W_1 W1: 将维度从256扩展到2048
- W 2 W_2 W2: 将维度从2048压缩回256
- ReLU激活函数: ReLU ( x ) = max ( 0 , x ) \text{ReLU}(x) = \max(0, x) ReLU(x)=max(0,x)
作用: 对每个位置的特征进行非线性变换,增强模型的表达能力。
FFN与MLP的关系:
FFN (Feed-Forward Network) 和 MLP (Multi-Layer Perceptron) 本质上是同一种结构,都是多层全连接神经网络:
| 使用场景 | 结构 | 说明 |
|---|---|---|
| Transformer中的FFN | 256 → 2048 → 256 (2层) | 用于特征变换,先扩展后压缩 |
| 边界框预测的MLP | 256 → 256 → 256 → 4 (3层) | 用于回归任务,逐步降维到目标维度 |
为什么FFN要先扩展再压缩?
这种"瓶颈"结构(bottleneck)有特殊作用:
- 扩展阶段 (256→2048): 在高维空间中进行非线性变换,增加表达能力
- 压缩阶段 (2048→256): 提取最重要的信息,降低维度
高中生理解:
想象你在做笔记:
- 扩展阶段: 把一句话展开成详细的解释(增加信息量)
- 压缩阶段: 把详细解释总结成精炼的要点(提取核心)
这个过程让模型能够学习更复杂的特征变换。
4. 损失函数详解
DETR的损失函数是其核心创新之一,包含两个关键步骤:
4.1 匈牙利匹配 (Hungarian Matching)
问题: 模型预测了100个目标,但图像中可能只有3个真实目标,如何匹配?
解决方案: 使用匈牙利算法找到最优的一对一匹配。
匹配代价 (Matching Cost) (来自 models/matcher.py):
对于每个预测 y ^ i = ( c ^ i , b ^ i ) \hat{y}_i = (\hat{c}_i, \hat{b}_i) y^i=(c^i,b^i) 和真实目标 y j = ( c j , b j ) y_j = (c_j, b_j) yj=(cj,bj),计算代价:
C match ( i , j ) = − 1 { c j ≠ ∅ } p ^ c j ( i ) + 1 { c j ≠ ∅ } L box ( b ^ i , b j ) \mathcal{C}_{\text{match}}(i, j) = -\mathbb{1}_{\{c_j \neq \emptyset\}} \hat{p}_{c_j}(i) + \mathbb{1}_{\{c_j \neq \emptyset\}} \mathcal{L}_{\text{box}}(\hat{b}_i, b_j) Cmatch(i,j)=−1{cj=∅}p^cj(i)+1{cj=∅}Lbox(b^i,bj)
分解为三部分:
1. 分类代价 (Classification Cost):
C class = − p ^ c j ( i ) \mathcal{C}_{\text{class}} = -\hat{p}_{c_j}(i) Cclass=−p^cj(i)
其中 p ^ c j ( i ) \hat{p}_{c_j}(i) p^cj(i) 是预测 i i i 对类别 c j c_j cj 的概率(通过softmax得到)。
高中生理解: 如果预测说"这是一只猫"的概率很高,而真实标签确实是猫,那么代价就很小(负的概率,概率越大,代价越小)。
2. L1边界框代价 (L1 Box Cost):
C bbox = ∥ b j − b ^ i ∥ 1 \mathcal{C}_{\text{bbox}} = \|b_j - \hat{b}_i\|_1 Cbbox=∥bj−b^i∥1
L1距离(曼哈顿距离):
∥ b j − b ^ i ∥ 1 = ∣ c x j − c ^ x i ∣ + ∣ c y j − c ^ y i ∣ + ∣ w j − w ^ i ∣ + ∣ h j − h ^ i ∣ \|b_j - \hat{b}_i\|_1 = |c_x^j - \hat{c}_x^i| + |c_y^j - \hat{c}_y^i| + |w^j - \hat{w}^i| + |h^j - \hat{h}^i| ∥bj−b^i∥1=∣cxj−c^xi∣+∣cyj−c^yi∣+∣wj−w^i∣+∣hj−h^i∣
高中生理解: 计算预测框和真实框的坐标差异,差异越小代价越小。
3. GIoU代价 (Generalized IoU Cost):
首先理解IoU (Intersection over Union,交并比):
IoU ( A , B ) = ∣ A ∩ B ∣ ∣ A ∪ B ∣ = 交集面积 并集面积 \text{IoU}(A, B) = \frac{|A \cap B|}{|A \cup B|} = \frac{\text{交集面积}}{\text{并集面积}} IoU(A,B)=∣A∪B∣∣A∩B∣=并集面积交集面积
图示:
真实框: ┌─────┐
│ A │
└─────┘
预测框: ┌─────┐
│ B │
└─────┘
交集: A ∩ B (重叠部分)
并集: A ∪ B (两个框覆盖的总面积)
GIoU (Generalized IoU) 改进了IoU,考虑了不重叠的情况:
GIoU ( A , B ) = IoU ( A , B ) − ∣ C ∖ ( A ∪ B ) ∣ ∣ C ∣ \text{GIoU}(A, B) = \text{IoU}(A, B) - \frac{|C \setminus (A \cup B)|}{|C|} GIoU(A,B)=IoU(A,B)−∣C∣∣C∖(A∪B)∣
其中:
- C C C 是包含 A A A 和 B B B 的最小包围矩形 (smallest enclosing box)
- ∣ C ∖ ( A ∪ B ) ∣ |C \setminus (A \cup B)| ∣C∖(A∪B)∣ 是包围矩形中不被A和B覆盖的区域面积
- ∣ C ∣ |C| ∣C∣ 是包围矩形的总面积
C giou = − GIoU ( b ^ i , b j ) \mathcal{C}_{\text{giou}} = -\text{GIoU}(\hat{b}_i, b_j) Cgiou=−GIoU(b^i,bj)
GIoU公式详细拆解:
让我们逐步理解GIoU如何考虑相对位置:
步骤1: 计算IoU (衡量重叠度)
IoU ( A , B ) = ∣ A ∩ B ∣ ∣ A ∪ B ∣ \text{IoU}(A, B) = \frac{|A \cap B|}{|A \cup B|} IoU(A,B)=∣A∪B∣∣A∩B∣
步骤2: 计算惩罚项 (衡量相对位置)
Penalty = ∣ C ∖ ( A ∪ B ) ∣ ∣ C ∣ = ∣ C ∣ − ∣ A ∪ B ∣ ∣ C ∣ \text{Penalty} = \frac{|C \setminus (A \cup B)|}{|C|} = \frac{|C| - |A \cup B|}{|C|} Penalty=∣C∣∣C∖(A∪B)∣=∣C∣∣C∣−∣A∪B∣
这个惩罚项的含义:
- 分子 ∣ C ∣ − ∣ A ∪ B ∣ |C| - |A \cup B| ∣C∣−∣A∪B∣: 包围矩形中的"空白区域"
- 分母 ∣ C ∣ |C| ∣C∣: 包围矩形的总面积
- 关键: 空白区域越大,说明两个框距离越远,惩罚越大
步骤3: 组合得到GIoU
GIoU = IoU − Penalty = ∣ A ∩ B ∣ ∣ A ∪ B ∣ − ∣ C ∣ − ∣ A ∪ B ∣ ∣ C ∣ \text{GIoU} = \text{IoU} - \text{Penalty} = \frac{|A \cap B|}{|A \cup B|} - \frac{|C| - |A \cup B|}{|C|} GIoU=IoU−Penalty=∣A∪B∣∣A∩B∣−∣C∣∣C∣−∣A∪B∣
GIoU如何考虑相对位置? - 详细图解
让我们通过4个具体例子来理解:
情况1: 完全重叠
真实框A和预测框B完全一致:
┌─────────────┐
│ A = B │
│ │
└─────────────┘
分析:
- 交集 = A = B
- 并集 = A = B
- 包围矩形C = A = B
- 空白区域 = C - (A∪B) = 0
- IoU = 1.0
- GIoU = 1.0 - 0/C = 1.0 ✓ (最优)
情况2: 部分重叠 - 近距离
真实框A: ┌──────────┐
│ A │
└──────────┘
┌──────────┐
预测框B: │ B │
└──────────┘
包围矩形C: ┌──────────────┐
│ C │
└──────────────┘
分析:
- 交集(重叠部分): 中间的小矩形
- 并集: A和B覆盖的总区域
- 空白区域: C的左右两端(较小)
- IoU = 0.3 (假设30%重叠)
- 空白区域占C的10%
- GIoU = 0.3 - 0.1 = 0.2
情况3: 部分重叠 - 远距离
真实框A: ┌─────┐
│ A │
└─────┘
┌─────┐
预测框B: │ B │
└─────┘
包围矩形C: ┌─────────────────────────┐
│ C │
└─────────────────────────┘
分析:
- 交集: 假设仍有30%重叠(但两框整体很分散)
- 并集: A和B覆盖的总区域
- 空白区域: C中间的大片空白(很大)
- IoU = 0.3 (同样30%重叠)
- 空白区域占C的50%
- GIoU = 0.3 - 0.5 = -0.2 (更差!)
关键: 相同IoU,但GIoU能区分位置关系!
情况4: 完全不重叠 - IoU的致命缺陷
场景A: 两框相邻
真实框A: ┌──────┐
│ A │
└──────┘
┌──────┐
预测框B: │ B │
└──────┘
包围矩形C: ┌─────────────┐
│ C │
└─────────────┘
分析:
- 交集 = 0 (不重叠)
- 并集 = A + B
- 空白区域: C中间的小缝隙
- IoU = 0
- 空白区域占C的20%
- GIoU = 0 - 0.2 = -0.2
场景B: 两框很远
真实框A: ┌────┐
│ A │
└────┘
┌────┐
预测框B: │ B │
└────┘
包围矩形C: ┌────────────────────────────────────┐
│ C │
└────────────────────────────────────┘
分析:
- 交集 = 0 (不重叠)
- 并集 = A + B
- 空白区域: C中间的巨大空白
- IoU = 0 (与场景A相同!)
- 空白区域占C的80%
- GIoU = 0 - 0.8 = -0.8 (更差!)
关键: IoU无法区分远近,GIoU能明确指出距离差异!
关键洞察: GIoU如何体现相对位置
| 指标 | IoU | GIoU |
|---|---|---|
| 重叠时 | 只看重叠比例 | 重叠比例 - 空白区域比例 |
| 不重叠时 | 都是0,无法区分远近 | 通过空白区域区分距离 |
| 值域 | [0, 1] | [-1, 1] |
| 梯度 | 不重叠时无梯度 | 始终有梯度 |
数学证明GIoU考虑了相对位置:
对于两个不重叠的框 ( IoU = 0 \text{IoU} = 0 IoU=0):
GIoU = 0 − ∣ C ∣ − ∣ A ∣ − ∣ B ∣ ∣ C ∣ = − ∣ C ∣ − ∣ A ∣ − ∣ B ∣ ∣ C ∣ \text{GIoU} = 0 - \frac{|C| - |A| - |B|}{|C|} = -\frac{|C| - |A| - |B|}{|C|} GIoU=0−∣C∣∣C∣−∣A∣−∣B∣=−∣C∣∣C∣−∣A∣−∣B∣
- 当两框距离近时: ∣ C ∣ |C| ∣C∣ 接近 ∣ A ∣ + ∣ B ∣ |A| + |B| ∣A∣+∣B∣, GIoU 接近 0
- 当两框距离远时: ∣ C ∣ |C| ∣C∣ 远大于 ∣ A ∣ + ∣ B ∣ |A| + |B| ∣A∣+∣B∣, GIoU 接近 -1
这就是GIoU考虑相对位置的核心机制!
高中生理解 - 停车位类比:
想象你要把车停进车位:
-
IoU: 只看你的车和车位重叠了多少
- 问题: 如果完全没停进去,无论你离车位1米还是10米,IoU都是0,无法指导你往哪开
-
GIoU: 不仅看重叠,还看你的车和车位需要多大的"包围区域"
- 离车位1米: 包围区域小,GIoU = -0.1 (还不错)
- 离车位10米: 包围区域大,GIoU = -0.8 (很差)
- GIoU能告诉你: 往车位方向开,GIoU会变大!
GIoU的优势总结:
- ✅ 始终有梯度: 即使不重叠,也能指导优化方向
- ✅ 考虑距离: 通过空白区域间接衡量两框距离
- ✅ 考虑形状: 包围矩形的大小反映了两框的相对位置和形状关系
- ✅ 尺度不变: 对大框和小框一视同仁
代价计算:
C giou = − GIoU ( b ^ i , b j ) \mathcal{C}_{\text{giou}} = -\text{GIoU}(\hat{b}_i, b_j) Cgiou=−GIoU(b^i,bj)
- GIoU越大(框越接近),代价越小
- GIoU = 1 → 代价 = -1 (最优匹配)
- GIoU = -1 → 代价 = 1 (最差匹配)
总匹配代价:
C match ( i , j ) = λ class C class + λ bbox C bbox + λ giou C giou \mathcal{C}_{\text{match}}(i, j) = \lambda_{\text{class}} \mathcal{C}_{\text{class}} + \lambda_{\text{bbox}} \mathcal{C}_{\text{bbox}} + \lambda_{\text{giou}} \mathcal{C}_{\text{giou}} Cmatch(i,j)=λclassCclass+λbboxCbbox+λgiouCgiou
默认权重: λ class = 1 \lambda_{\text{class}} = 1 λclass=1, λ bbox = 5 \lambda_{\text{bbox}} = 5 λbbox=5, λ giou = 2 \lambda_{\text{giou}} = 2 λgiou=2
匈牙利算法:
给定代价矩阵 C ∈ R 100 × N \mathcal{C} \in \mathbb{R}^{100 \times N} C∈R100×N (100个预测,N个真实目标),找到最优匹配:
σ ^ = arg min σ ∈ S N ∑ i = 1 N C match ( i , σ ( i ) ) \hat{\sigma} = \arg\min_{\sigma \in \mathfrak{S}_N} \sum_{i=1}^{N} \mathcal{C}_{\text{match}}(i, \sigma(i)) σ^=argσ∈SNmini=1∑NCmatch(i,σ(i))
其中 S N \mathfrak{S}_N SN 是所有可能的匹配排列。
高中生理解:
想象你有100个学生和3个奖品,每个学生对每个奖品都有一个"想要程度"(代价)。匈牙利算法帮你找到最优的分配方案,使得总的"不满意度"(总代价)最小。
4.2 损失函数计算
匹配完成后,计算三个损失:
1. 分类损失 (Classification Loss):
使用交叉熵损失:
L ce = − ∑ i = 1 100 log p ^ σ ^ ( i ) ( c i ) \mathcal{L}_{\text{ce}} = -\sum_{i=1}^{100} \log \hat{p}_{\hat{\sigma}(i)}(c_i) Lce=−i=1∑100logp^σ^(i)(ci)
其中:
- 对于匹配的预测,目标类别是真实类别 c i c_i ci
- 对于未匹配的预测,目标类别是"无目标"类 ∅ \emptyset ∅
交叉熵公式详解:
对于单个样本:
CE ( y , y ^ ) = − ∑ k = 1 K y k log ( y ^ k ) \text{CE}(y, \hat{y}) = -\sum_{k=1}^{K} y_k \log(\hat{y}_k) CE(y,y^)=−k=1∑Kyklog(y^k)
其中:
- y k y_k yk: 真实标签(one-hot编码,只有正确类别为1,其他为0)
- y ^ k \hat{y}_k y^k: 预测概率
- K K K: 类别总数
为什么用交叉熵?
交叉熵衡量两个概率分布的差异:
- 当预测概率接近真实标签时,损失小
- 当预测错误时,损失大
- 使用log是因为它能放大小概率的惩罚
类别不平衡处理:
由于大部分预测会匹配到"无目标"类,DETR对"无目标"类降权:
w ∅ = 0.1 w_{\emptyset} = 0.1 w∅=0.1
2. 边界框L1损失 (Box L1 Loss):
L bbox = ∑ i = 1 N ∥ b i − b ^ σ ^ ( i ) ∥ 1 \mathcal{L}_{\text{bbox}} = \sum_{i=1}^{N} \|b_i - \hat{b}_{\hat{\sigma}(i)}\|_1 Lbbox=i=1∑N∥bi−b^σ^(i)∥1
只对匹配的预测计算(N个真实目标)。
3. GIoU损失 (GIoU Loss):
L giou = ∑ i = 1 N ( 1 − GIoU ( b i , b ^ σ ^ ( i ) ) ) \mathcal{L}_{\text{giou}} = \sum_{i=1}^{N} \left(1 - \text{GIoU}(b_i, \hat{b}_{\hat{\sigma}(i)})\right) Lgiou=i=1∑N(1−GIoU(bi,b^σ^(i)))
为什么需要两个边界框损失?
- L1损失: 关注绝对位置误差,对所有尺度的框一视同仁
- GIoU损失: 关注相对重叠,对不同尺度的框更公平
总损失函数:
L total = λ ce L ce + λ bbox L bbox + λ giou L giou \mathcal{L}_{\text{total}} = \lambda_{\text{ce}} \mathcal{L}_{\text{ce}} + \lambda_{\text{bbox}} \mathcal{L}_{\text{bbox}} + \lambda_{\text{giou}} \mathcal{L}_{\text{giou}} Ltotal=λceLce+λbboxLbbox+λgiouLgiou
默认权重: λ ce = 1 \lambda_{\text{ce}} = 1 λce=1, λ bbox = 5 \lambda_{\text{bbox}} = 5 λbbox=5, λ giou = 2 \lambda_{\text{giou}} = 2 λgiou=2
4.3 辅助损失 (Auxiliary Losses)
DETR在每个解码器层都计算损失,加速训练:
L total = ∑ l = 1 6 L layer l \mathcal{L}_{\text{total}} = \sum_{l=1}^{6} \mathcal{L}_{\text{layer}_l} Ltotal=l=1∑6Llayerl
5. 代码实现分析
5.1 模型前向传播流程
# 来自 models/detr.py
def forward(self, samples):
# 1. CNN提取特征
features, pos = self.backbone(samples) # [B, 2048, H/32, W/32]
# 2. 降维投影
src = self.input_proj(features[-1]) # [B, 256, H/32, W/32]
# 3. Transformer编码-解码
hs = self.transformer(src, mask, self.query_embed.weight, pos[-1])[0]
# hs: [6, B, 100, 256] (6层解码器输出)
# 4. 预测头
outputs_class = self.class_embed(hs) # [6, B, 100, 91]
outputs_coord = self.bbox_embed(hs).sigmoid() # [6, B, 100, 4]
# 5. 返回最后一层的预测
return {
'pred_logits': outputs_class[-1], # [B, 100, 91]
'pred_boxes': outputs_coord[-1] # [B, 100, 4]
}
5.2 匈牙利匹配实现
# 来自 models/matcher.py
class HungarianMatcher(nn.Module):
def forward(self, outputs, targets):
bs, num_queries = outputs["pred_logits"].shape[:2] # [B, 100]
# 1. 展平预测
out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1) # [B*100, 91]
out_bbox = outputs["pred_boxes"].flatten(0, 1) # [B*100, 4]
# 2. 拼接所有真实目标
tgt_ids = torch.cat([v["labels"] for v in targets]) # [N_total]
tgt_bbox = torch.cat([v["boxes"] for v in targets]) # [N_total, 4]
# 3. 计算代价矩阵
# 分类代价
cost_class = -out_prob[:, tgt_ids] # [B*100, N_total]
# L1代价
cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1) # [B*100, N_total]
# GIoU代价
cost_giou = -generalized_box_iou(
box_cxcywh_to_xyxy(out_bbox),
box_cxcywh_to_xyxy(tgt_bbox)
) # [B*100, N_total]
# 4. 总代价
C = self.cost_bbox * cost_bbox + \
self.cost_class * cost_class + \
self.cost_giou * cost_giou
C = C.view(bs, num_queries, -1).cpu() # [B, 100, N_total]
# 5. 对每个图像应用匈牙利算法
sizes = [len(v["boxes"]) for v in targets]
indices = [linear_sum_assignment(c[i])
for i, c in enumerate(C.split(sizes, -1))]
return indices
5.3 损失函数实现
# 来自 models/detr.py
class SetCriterion(nn.Module):
def forward(self, outputs, targets):
# 1. 匈牙利匹配
indices = self.matcher(outputs, targets)
# 2. 计算目标数量(用于归一化)
num_boxes = sum(len(t["labels"]) for t in targets)
# 3. 分类损失
loss_ce = self.loss_labels(outputs, targets, indices, num_boxes)
# 4. 边界框损失
loss_bbox = self.loss_boxes(outputs, targets, indices, num_boxes)
# 5. 返回所有损失
losses = {
'loss_ce': loss_ce,
'loss_bbox': loss_bbox['loss_bbox'],
'loss_giou': loss_bbox['loss_giou']
}
return losses
def loss_labels(self, outputs, targets, indices, num_boxes):
src_logits = outputs['pred_logits'] # [B, 100, 91]
# 构建目标类别张量
target_classes = torch.full(
src_logits.shape[:2],
self.num_classes, # "无目标"类
dtype=torch.int64
)
# 填充匹配的真实类别
idx = self._get_src_permutation_idx(indices)
target_classes_o = torch.cat([
t["labels"][J] for t, (_, J) in zip(targets, indices)
])
target_classes[idx] = target_classes_o
# 计算交叉熵(带类别权重)
loss_ce = F.cross_entropy(
src_logits.transpose(1, 2),
target_classes,
self.empty_weight # "无目标"类权重为0.1
)
return loss_ce
def loss_boxes(self, outputs, targets, indices, num_boxes):
idx = self._get_src_permutation_idx(indices)
src_boxes = outputs['pred_boxes'][idx] # 匹配的预测框
target_boxes = torch.cat([
t['boxes'][i] for t, (_, i) in zip(targets, indices)
], dim=0) # 对应的真实框
# L1损失
loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none')
loss_bbox = loss_bbox.sum() / num_boxes
# GIoU损失
loss_giou = 1 - torch.diag(generalized_box_iou(
box_cxcywh_to_xyxy(src_boxes),
box_cxcywh_to_xyxy(target_boxes)
))
loss_giou = loss_giou.sum() / num_boxes
return {
'loss_bbox': loss_bbox,
'loss_giou': loss_giou
}
5.4 MLP实现细节
# 来自 models/detr.py
class MLP(nn.Module):
"""多层感知机 (Multi-Layer Perceptron)
这是一个通用的多层全连接网络,用于特征变换和回归任务。
"""
def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
"""
参数:
input_dim: 输入特征维度
hidden_dim: 隐藏层维度
output_dim: 输出维度
num_layers: 总层数
"""
super().__init__()
self.num_layers = num_layers
# 构建隐藏层维度列表
# 例如: num_layers=3, hidden_dim=256
# h = [256, 256] (中间两层都是256维)
h = [hidden_dim] * (num_layers - 1)
# 构建层序列
# zip([input_dim] + h, h + [output_dim]) 生成:
# [(input_dim, hidden_dim), (hidden_dim, hidden_dim), ..., (hidden_dim, output_dim)]
self.layers = nn.ModuleList(
nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])
)
def forward(self, x):
"""前向传播
关键点: 除了最后一层,其他层都使用ReLU激活函数
"""
for i, layer in enumerate(self.layers):
if i < self.num_layers - 1:
# 中间层: 线性变换 + ReLU激活
x = F.relu(layer(x))
else:
# 最后一层: 只做线性变换,不激活
x = layer(x)
return x
# 使用示例: 边界框预测头
bbox_embed = MLP(input_dim=256, hidden_dim=256, output_dim=4, num_layers=3)
# 具体展开:
# Layer 1: Linear(256 → 256) + ReLU
# Layer 2: Linear(256 → 256) + ReLU
# Layer 3: Linear(256 → 4) (无激活)
为什么最后一层不用激活函数?
# 边界框预测的完整流程
bbox_raw = self.bbox_embed(hs) # MLP输出: 可以是任意实数
bbox_normalized = bbox_raw.sigmoid() # Sigmoid归一化到 [0, 1]
# 如果最后一层用了ReLU:
# - ReLU会把负数变成0,限制了表达能力
# - Sigmoid之前的值域越大,梯度流动越好
不同任务的MLP配置对比:
| 任务 | 配置 | 最后一层激活 | 原因 |
|---|---|---|---|
| 边界框回归 | MLP(256, 256, 4, 3) | 无 | 需要连续值,后续用sigmoid |
| 分类 | Linear(256, 91) | 无 | 后续用softmax |
| 特征变换 | MLP(256, 2048, 256, 2) | 无 | 保持特征的完整信息 |
5.5 GIoU计算实现
# 来自 util/box_ops.py
def generalized_box_iou(boxes1, boxes2):
"""
计算Generalized IoU
参数:
boxes1: [N, 4] 第一组边界框,格式 [x0, y0, x1, y1]
boxes2: [M, 4] 第二组边界框,格式 [x0, y0, x1, y1]
返回:
giou: [N, M] GIoU矩阵,值域 [-1, 1]
GIoU公式: GIoU = IoU - (C - Union) / C
其中 C 是最小包围矩形的面积
"""
# ============ 步骤1: 计算标准IoU ============
iou, union = box_iou(boxes1, boxes2)
# iou: [N, M] 交并比
# union: [N, M] 并集面积 |A ∪ B|
# ============ 步骤2: 计算最小包围矩形 C ============
# 包围矩形的左上角: 取两框左上角的最小值(更左上)
lt = torch.min(boxes1[:, None, :2], boxes2[:, :2]) # [N, M, 2]
# 包围矩形的右下角: 取两框右下角的最大值(更右下)
rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:]) # [N, M, 2]
# 包围矩形的宽高
wh = (rb - lt).clamp(min=0) # [N, M, 2], clamp确保非负
# 包围矩形的面积 C
area_c = wh[:, :, 0] * wh[:, :, 1] # [N, M]
# ============ 步骤3: 计算GIoU ============
# 空白区域面积 = C - Union
empty_area = area_c - union # [N, M]
# 惩罚项 = 空白区域 / 包围矩形面积
penalty = empty_area / area_c # [N, M]
# GIoU = IoU - 惩罚项
giou = iou - penalty # [N, M]
return giou
def box_iou(boxes1, boxes2):
"""
计算标准IoU (Intersection over Union)
参数:
boxes1: [N, 4] 格式 [x0, y0, x1, y1]
boxes2: [M, 4] 格式 [x0, y0, x1, y1]
返回:
iou: [N, M] IoU矩阵,值域 [0, 1]
union: [N, M] 并集面积
"""
# 计算每个框的面积
area1 = box_area(boxes1) # [N]
area2 = box_area(boxes2) # [M]
# ============ 计算交集 ============
# 交集的左上角: 取两框左上角的最大值(更靠右下)
lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N, M, 2]
# 交集的右下角: 取两框右下角的最小值(更靠左上)
rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N, M, 2]
# 交集的宽高 (如果不相交,clamp会变成0)
wh = (rb - lt).clamp(min=0) # [N, M, 2]
# 交集面积
inter = wh[:, :, 0] * wh[:, :, 1] # [N, M]
# ============ 计算并集 ============
# 并集 = 面积1 + 面积2 - 交集
union = area1[:, None] + area2 - inter # [N, M]
# ============ 计算IoU ============
iou = inter / union # [N, M]
return iou, union
def box_area(boxes):
"""
计算边界框面积
参数:
boxes: [N, 4] 格式 [x0, y0, x1, y1]
返回:
area: [N] 每个框的面积
"""
return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
代码关键点解析:
1. 为什么计算包围矩形用min和max?
# 包围矩形要"包住"两个框,所以:
lt = torch.min(boxes1[:, :2], boxes2[:, :2]) # 左上角取最小(更左上)
rb = torch.max(boxes1[:, 2:], boxes2[:, 2:]) # 右下角取最大(更右下)
# 示例:
# Box1: [10, 10, 30, 30] (左上(10,10), 右下(30,30))
# Box2: [20, 20, 40, 40] (左上(20,20), 右下(40,40))
# 包围矩形: [10, 10, 40, 40] (左上取min, 右下取max)
2. 为什么计算交集用max和min?
# 交集是"重叠部分",所以:
lt = torch.max(boxes1[:, :2], boxes2[:, :2]) # 左上角取最大(更靠内)
rb = torch.min(boxes1[:, 2:], boxes2[:, 2:]) # 右下角取最小(更靠内)
# 示例:
# Box1: [10, 10, 30, 30]
# Box2: [20, 20, 40, 40]
# 交集: [20, 20, 30, 30] (左上取max, 右下取min)
3. GIoU公式的代码实现:
# 数学公式: GIoU = IoU - (C - Union) / C
giou = iou - (area_c - union) / area_c
# 等价于: GIoU = IoU - C/C + Union/C = IoU - 1 + Union/C
# 但第一种写法更直观,体现了"惩罚项"的概念
4. 为什么需要clamp(min=0)?
wh = (rb - lt).clamp(min=0)
# 当两框不相交时,rb < lt,宽高会是负数
# clamp(min=0) 确保宽高至少为0,面积为0
# 这样不相交时 inter = 0, IoU = 0
5. 广播机制 (Broadcasting):
# boxes1: [N, 4]
# boxes2: [M, 4]
# boxes1[:, None, :2]: [N, 1, 2] # 增加一个维度
# boxes2[:, :2]: [M, 2]
# 广播后: [N, M, 2] # 自动扩展,计算所有配对
# 这样一次性计算N×M对框的GIoU,非常高效!
实际使用示例:
# 预测框: [100, 4] (100个预测)
# 真实框: [5, 4] (5个真实目标)
pred_boxes = outputs['pred_boxes'] # [100, 4], 格式 (cx, cy, w, h)
target_boxes = targets['boxes'] # [5, 4], 格式 (cx, cy, w, h)
# 转换为 (x0, y0, x1, y1) 格式
pred_xyxy = box_cxcywh_to_xyxy(pred_boxes) # [100, 4]
target_xyxy = box_cxcywh_to_xyxy(target_boxes) # [5, 4]
# 计算GIoU矩阵
giou_matrix = generalized_box_iou(pred_xyxy, target_xyxy) # [100, 5]
# giou_matrix[i, j] 表示第i个预测框和第j个真实框的GIoU
# 用于匈牙利匹配的代价计算
cost_giou = -giou_matrix # 取负,因为GIoU越大越好,代价越小
6. 模型配置参数
6.1 默认超参数
| 参数 | 值 | 说明 |
|---|---|---|
hidden_dim |
256 | Transformer隐藏层维度 |
num_queries |
100 | 对象查询数量 |
nheads |
8 | 多头注意力的头数 |
num_encoder_layers |
6 | 编码器层数 |
num_decoder_layers |
6 | 解码器层数 |
dim_feedforward |
2048 | 前馈网络维度 |
dropout |
0.1 | Dropout比率 |
6.2 损失权重
| 损失类型 | 权重 | 说明 |
|---|---|---|
loss_ce |
1.0 | 分类损失权重 |
loss_bbox |
5.0 | L1边界框损失权重 |
loss_giou |
2.0 | GIoU损失权重 |
eos_coef |
0.1 | "无目标"类权重 |
6.3 匹配代价权重
| 代价类型 | 权重 | 说明 |
|---|---|---|
cost_class |
1.0 | 分类代价权重 |
cost_bbox |
5.0 | L1代价权重 |
cost_giou |
2.0 | GIoU代价权重 |
7. 训练技巧
7.1 学习率调度
# 使用带warmup的学习率调度
base_lr = 1e-4
backbone_lr = 1e-5 # 骨干网络使用更小的学习率
7.2 数据增强
- 随机水平翻转
- 随机缩放 (0.5x - 2.0x)
- 随机裁剪
- 颜色抖动
7.3 训练时长
- COCO数据集: 300 epochs
- 批量大小: 2 per GPU (使用梯度累积)
8. 优缺点分析
8.1 优点
| 优点 | 说明 |
|---|---|
| ✅ 端到端训练 | 无需手工设计的组件(锚框、NMS) |
| ✅ 简洁优雅 | 架构清晰,易于理解和扩展 |
| ✅ 全局推理 | Transformer能捕捉全局上下文 |
| ✅ 集合预测 | 直接预测目标集合,无重复检测 |
8.2 缺点
| 缺点 | 说明 |
|---|---|
| ❌ 训练时间长 | 需要300 epochs才能收敛 |
| ❌ 小目标检测弱 | 对小目标的检测性能不如传统方法 |
| ❌ 计算量大 | Transformer的自注意力复杂度为O(n²) |
| ❌ 需要大量数据 | 在小数据集上容易过拟合 |
9. 总结
9.1 DETR的核心思想
DETR将目标检测问题重新定义为集合预测问题:
传统方法: 图像 → 特征 → 密集预测 → NMS → 最终检测结果
DETR方法: 图像 → 特征 → Transformer → 直接预测固定数量的目标
9.2 关键数学公式总结表
| 组件 | 公式 | 作用 |
|---|---|---|
| 自注意力 | Attention ( Q , K , V ) = softmax ( Q K T d k ) V \text{Attention}(Q,K,V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V Attention(Q,K,V)=softmax(dkQKT)V | 捕捉全局依赖关系 |
| 位置编码 | PE ( x , y , 2 i ) = sin ( x 1000 0 2 i / d ) \text{PE}(x,y,2i) = \sin(\frac{x}{10000^{2i/d}}) PE(x,y,2i)=sin(100002i/dx) | 编码空间位置信息 |
| IoU | IoU ( A , B ) = ∣ A ∩ B ∣ ∣ A ∪ B ∣ \text{IoU}(A,B) = \frac{|A \cap B|}{|A \cup B|} IoU(A,B)=∣A∪B∣∣A∩B∣ | 衡量框重叠度 |
| GIoU | GIoU = IoU − ∣ C ∖ ( A ∪ B ) ∣ ∣ C ∣ \text{GIoU} = \text{IoU} - \frac{|C \setminus (A \cup B)|}{|C|} GIoU=IoU−∣C∣∣C∖(A∪B)∣ | 改进的IoU |
| 匹配代价 | C = λ 1 C class + λ 2 C bbox + λ 3 C giou \mathcal{C} = \lambda_1\mathcal{C}_{\text{class}} + \lambda_2\mathcal{C}_{\text{bbox}} + \lambda_3\mathcal{C}_{\text{giou}} C=λ1Cclass+λ2Cbbox+λ3Cgiou | 找最优匹配 |
| 交叉熵 | CE = − ∑ k y k log ( y ^ k ) \text{CE} = -\sum_k y_k \log(\hat{y}_k) CE=−∑kyklog(y^k) | 分类损失 |
| 总损失 | L = L ce + λ bbox L bbox + λ giou L giou \mathcal{L} = \mathcal{L}_{\text{ce}} + \lambda_{\text{bbox}}\mathcal{L}_{\text{bbox}} + \lambda_{\text{giou}}\mathcal{L}_{\text{giou}} L=Lce+λbboxLbbox+λgiouLgiou | 训练目标 |
9.3 数据流动图
输入图像 [B, 3, H, W]
↓
CNN骨干网络 (ResNet)
↓
特征图 [B, 2048, H/32, W/32]
↓
1×1卷积降维
↓
特征图 [B, 256, H/32, W/32] + 位置编码
↓
展平 → [B, 256, HW/1024]
↓
Transformer编码器 (6层)
↓
编码特征 [B, 256, HW/1024]
↓
Transformer解码器 (6层) ← 100个对象查询 [100, 256]
↓
解码特征 [B, 100, 256]
↓
├─→ 分类头 → 类别预测 [B, 100, 91]
└─→ 回归头 → 边界框预测 [B, 100, 4]
9.4 与传统方法对比
| 特性 | Faster R-CNN | YOLO | DETR |
|---|---|---|---|
| 锚框 | ✓ 需要 | ✓ 需要 | ✗ 不需要 |
| NMS | ✓ 需要 | ✓ 需要 | ✗ 不需要 |
| 训练方式 | 两阶段 | 单阶段 | 端到端 |
| 全局推理 | ✗ 局部 | ✗ 局部 | ✓ 全局 |
| 重复检测 | 可能 | 可能 | 不会 |
| 训练时间 | 中等 | 快 | 慢 |
| 推理速度 | 慢 | 快 | 中等 |
9.5 适用场景
DETR适合:
- 需要端到端训练的场景
- 有充足训练数据和计算资源
- 对训练时间不敏感
- 需要全局推理能力
DETR不适合:
- 实时性要求极高的应用
- 小数据集
- 主要检测小目标
- 计算资源受限
10. 扩展阅读
10.1 DETR的改进版本
- Deformable DETR: 使用可变形注意力,降低计算复杂度,提升小目标检测
- Conditional DETR: 改进对象查询,加速收敛
- DAB-DETR: 使用动态锚框,提升性能
- DN-DETR: 引入去噪训练,稳定训练过程
10.2 关键论文
- DETR原论文: End-to-End Object Detection with Transformers
- Transformer原论文: Attention Is All You Need
- GIoU论文: Generalized Intersection over Union
10.3 代码资源
- 官方实现: facebookresearch/detr
- 本项目: 当前目录
11. 常见问题解答 (FAQ)
Q1: 为什么DETR需要100个对象查询?
A: 100是一个经验值,需要大于图像中可能出现的最大目标数量。对于COCO数据集,大部分图像的目标数量远小于100,所以100个查询足够了。未匹配的查询会预测"无目标"类。
Q2: 为什么DETR训练这么慢?
A: 主要原因:
- Transformer的自注意力机制计算复杂度高
- 需要学习对象查询的语义(从随机初始化开始)
- 匈牙利匹配在训练初期不稳定
Q3: 如何提升DETR的小目标检测性能?
A:
- 使用多尺度特征(Deformable DETR)
- 增加图像分辨率
- 使用更多的对象查询
- 数据增强(特别是针对小目标)
Q4: DETR的对象查询是如何学习的?
A: 对象查询是可学习的嵌入向量,通过反向传播自动学习。训练过程中,不同的查询会"专注"于检测不同位置、不同类别的目标。
Q5: 为什么需要位置编码?
A: Transformer本身是位置不变的(permutation invariant),不知道输入的顺序。位置编码告诉模型每个特征在图像中的位置,这对于目标检测至关重要。
Q6: GIoU相比IoU有什么优势?
A: GIoU解决了IoU的三个关键问题:
问题1: 不重叠时无梯度
当两个框不重叠时:
- IoU = 0: 无论距离1米还是100米,梯度都是0,模型不知道往哪个方向优化
- GIoU ∈ [-1, 0]: 通过最小包围矩形的空白区域,提供距离信息和梯度
问题2: 无法区分不同的不重叠情况
场景A: 预测框紧邻真实框
真实框A: ┌──────┐
│ A │
└──────┘
┌──────┐
预测框B: │ B │
└──────┘
包围矩形C: ┌─────────────┐
│ C │ (空白区域小)
└─────────────┘
→ IoU = 0, GIoU = -0.1
场景B: 预测框远离真实框
真实框A: ┌─────┐
│ A │
└─────┘
┌─────┐
预测框B: │ B │
└─────┘
包围矩形C: ┌─────────────────────────────────┐
│ C │ (空白区域大)
└─────────────────────────────────┘
→ IoU = 0, GIoU = -0.8
IoU无法区分,GIoU能明确指出场景B更差。
问题3: 相同IoU但不同位置关系
场景C: 两框部分重叠,位置接近
真实框A: ┌─────────┐
│ A │
└─────────┘
┌─────────┐
预测框B: │ B │
└─────────┘
包围矩形C: ┌─────────────┐
│ C │ (空白区域小)
└─────────────┘
→ IoU = 0.3, GIoU = 0.2
场景D: 两框部分重叠,但整体分散
真实框A: ┌────┐
│ A │
└────┘
┌────┐
预测框B: │ B │
└────┘
包围矩形C: ┌──────────────────────────┐
│ C │ (空白区域大)
└──────────────────────────┘
→ IoU = 0.3, GIoU = -0.1
相同的IoU,但GIoU能反映出场景C的位置关系更好。
数学角度的优势:
| 特性 | IoU | GIoU |
|---|---|---|
| 值域 | [0, 1] | [-1, 1] |
| 不重叠时的值 | 恒为0 | 根据距离变化 |
| 梯度 | 不重叠时为0 | 始终非零 |
| 考虑因素 | 仅重叠 | 重叠+相对位置 |
训练角度的优势:
使用GIoU损失时:
loss_giou = 1 - GIoU(pred, target)
# 不重叠时:
# IoU = 0 → loss = 1 (所有不重叠情况损失相同,无法区分)
# GIoU ∈ [-1, 0] → loss ∈ [1, 2] (能区分远近,提供优化方向)
实际效果:
在DETR训练中,GIoU损失能够:
- ✅ 加速收敛 - 即使初期预测很差,也有明确的优化方向
- ✅ 提升精度 - 能优化到更精确的位置
- ✅ 稳定训练 - 避免梯度消失
形象类比:
想象你在黑暗中找手机:
- IoU: 只有摸到手机才有反馈(触觉),摸不到就完全没信息
- GIoU: 像有个"热度感应器",越接近手机越热,即使没摸到也知道方向
Q7: 为什么边界框预测用MLP而分类预测只用一个Linear层?
A: 这是因为任务的复杂度不同:
分类任务 (简单):
self.class_embed = nn.Linear(256, 91) # 只需要一层
- 输入: 256维的抽象语义特征
- 输出: 91个类别的分数
- 任务: 判断"这是什么物体" - 相对直接的映射
边界框回归 (复杂):
self.bbox_embed = MLP(256, 256, 4, 3) # 需要3层
- 输入: 256维的抽象语义特征
- 输出: 4个连续的坐标值
- 任务: 从抽象特征推断出精确的空间位置 - 需要更复杂的非线性变换
类比理解:
- 分类: 看一张照片,判断"这是猫还是狗" - 相对容易
- 定位: 看一张照片,说出"猫的鼻子在图像的(0.523, 0.687)位置" - 需要更精细的推理
多层MLP提供了更强的非线性拟合能力,能够学习从语义特征到精确坐标的复杂映射关系。
Q8: 匈牙利算法的时间复杂度是多少?
A: O(n³),其中n是目标数量。但由于DETR中目标数量通常很小(< 100),所以实际上很快。使用scipy.optimize.linear_sum_assignment实现。
Q9: DETR能用于其他任务吗?
A: 可以!DETR的思想已被应用于:
- 实例分割: DETR + 分割头
- 全景分割: Panoptic DETR
- 目标跟踪: TrackFormer
- 3D检测: DETR3D
- 视频理解: VisTR
12. 实践建议
12.1 如何开始使用DETR
- 环境准备:
pip install torch torchvision
pip install scipy # 用于匈牙利算法
- 加载预训练模型:
import torch
model = torch.hub.load('facebookresearch/detr', 'detr_resnet50', pretrained=True)
model.eval()
- 推理示例:
from PIL import Image
import torchvision.transforms as T
# 加载图像
img = Image.open('image.jpg')
# 预处理
transform = T.Compose([
T.Resize(800),
T.ToTensor(),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
img_tensor = transform(img).unsqueeze(0)
# 推理
with torch.no_grad():
outputs = model(img_tensor)
# 后处理
probas = outputs['pred_logits'].softmax(-1)[0, :, :-1] # 去掉"无目标"类
keep = probas.max(-1).values > 0.7 # 置信度阈值
# 获取检测结果
boxes = outputs['pred_boxes'][0, keep]
scores = probas[keep].max(-1).values
labels = probas[keep].argmax(-1)
12.2 微调DETR
# 冻结骨干网络
for param in model.backbone.parameters():
param.requires_grad = False
# 只训练Transformer和预测头
optimizer = torch.optim.AdamW([
{'params': model.transformer.parameters(), 'lr': 1e-4},
{'params': model.class_embed.parameters(), 'lr': 1e-4},
{'params': model.bbox_embed.parameters(), 'lr': 1e-4}
])
12.3 调试技巧
- 可视化注意力图: 查看模型关注图像的哪些区域
- 监控匹配质量: 检查匈牙利匹配的代价值
- 分析未匹配的查询: 了解哪些查询没有学到有用的模式
- 使用更小的模型: 先用ResNet18快速验证想法
13. 数学符号表
| 符号 | 含义 |
|---|---|
| B B B | 批量大小 (Batch Size) |
| H , W H, W H,W | 图像高度和宽度 |
| C C C | 通道数 |
| d d d | 特征维度 (通常256) |
| N N N | 真实目标数量 |
| Q , K , V Q, K, V Q,K,V | 查询、键、值矩阵 |
| y ^ \hat{y} y^ | 预测值 |
| y y y | 真实值 |
| σ \sigma σ | 匹配排列 |
| L \mathcal{L} L | 损失函数 |
| λ \lambda λ | 权重系数 |
| ∅ \emptyset ∅ | "无目标"类 |
14. 参考文献
-
Carion, N., Massa, F., Synnaeve, G., Usunier, N., Kirillov, A., & Zagoruyko, S. (2020). End-to-end object detection with transformers. In European Conference on Computer Vision (pp. 213-229).
-
Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., … & Polosukhin, I. (2017). Attention is all you need. In Advances in neural information processing systems (pp. 5998-6008).
-
Rezatofighi, H., Tsoi, N., Gwak, J., Sadeghian, A., Reid, I., & Savarese, S. (2019). Generalized intersection over union: A metric and a loss for bounding box regression. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 658-666).
-
Kuhn, H. W. (1955). The Hungarian method for the assignment problem. Naval research logistics quarterly, 2(1‐2), 83-97.
附录A: 完整的训练流程图
┌─────────────────────────────────────────────────────────────┐
│ 训练一个Batch │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 1. 数据加载: 图像 + 标注 (类别 + 边界框) │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 2. 前向传播: 模型预测 100个目标 │
│ - 类别概率: [B, 100, 91] │
│ - 边界框: [B, 100, 4] │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 3. 匈牙利匹配: 预测与真实目标一对一匹配 │
│ - 计算代价矩阵 [100, N] │
│ - 找最优匹配 │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 4. 计算损失: │
│ - 分类损失 (交叉熵) │
│ - L1边界框损失 │
│ - GIoU损失 │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 5. 反向传播: 更新模型参数 │
└─────────────────────────────────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────────────┐
│ 6. 重复步骤1-5,直到收敛 (300 epochs) │
└─────────────────────────────────────────────────────────────┘
附录B: detr.py【DETR模型和损失函数类】
https://github.com/facebookresearch/detr
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
"""
DETR模型和损失函数类。
DETR (DEtection TRansformer) 是一个端到端的目标检测模型，使用Transformer架构。
"""
import torch
import torch.nn.functional as F
from torch import nn
from util import box_ops # 边界框操作工具
from util.misc import (NestedTensor, nested_tensor_from_tensor_list, # 嵌套张量处理
accuracy, get_world_size, interpolate, # 准确率计算、分布式训练工具、插值
is_dist_avail_and_initialized) # 分布式训练检查
from .backbone import build_backbone # 构建骨干网络
from .matcher import build_matcher # 构建匈牙利匹配器
from .segmentation import (DETRsegm, PostProcessPanoptic, PostProcessSegm, # 分割相关模块
dice_loss, sigmoid_focal_loss) # 分割损失函数
from .transformer import build_transformer # 构建Transformer
class DETR(nn.Module):
"""DETR目标检测模型
这是执行目标检测的DETR模块，使用Transformer架构进行端到端的目标检测。
"""
def __init__(self, backbone, transformer, num_classes, num_queries, aux_loss=False):
"""初始化DETR模型
参数:
backbone: 骨干网络模块，用于提取图像特征。参见backbone.py
transformer: Transformer架构模块。参见transformer.py
num_classes: 目标类别数量
num_queries: 目标查询数量，即检测槽位数。这是DETR在单张图像中能检测的最大目标数量。
对于COCO数据集，推荐使用100个查询。
aux_loss: 是否使用辅助解码损失（每个解码器层的损失）
"""
super().__init__()
self.num_queries = num_queries # 查询数量（最大检测目标数）
self.transformer = transformer # Transformer模块
hidden_dim = transformer.d_model # 隐藏层维度
self.class_embed = nn.Linear(hidden_dim, num_classes + 1) # 分类头：输出类别logits（+1是no-object类）
self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3) # 边界框回归头：输出4个坐标值
self.query_embed = nn.Embedding(num_queries, hidden_dim) # 可学习的目标查询嵌入
self.input_proj = nn.Conv2d(backbone.num_channels, hidden_dim, kernel_size=1) # 输入投影：将骨干网络特征映射到Transformer维度
self.backbone = backbone # 骨干网络
self.aux_loss = aux_loss # 是否使用辅助损失
def forward(self, samples: NestedTensor):
"""前向传播：接受 NestedTensor 输入并输出预测结果字典
中文说明：
输入 `samples` 是一个 NestedTensor，内部包含：
- `samples.tensor`: 批量图像张量，形状为 [batch_size x 3 x H x W]
- `samples.mask`: 二值 mask，形状为 [batch_size x H x W]，在 padding 像素位置为 1，
用于让 Transformer 忽略填充区域。
函数返回一个字典，主要字段包括：
- `"pred_logits"`: 所有 query 的分类 logits（包含 no-object 类），
形状为 [batch_size x num_queries x (num_classes + 1)]。
- `"pred_boxes"`: 所有 query 的归一化边界框坐标，格式为
(center_x, center_y, height, width)，数值范围在 [0, 1]，
是相对于每张图像自身尺寸（不含 padding 区域）进行归一化的结果。
如何将其还原为像素级坐标可参考 PostProcess 模块。
- `"aux_outputs"`: （可选）仅在启用辅助损失时返回，
为一个列表，每个元素都是一个字典，
含有各个解码器层的 `pred_logits` 和 `pred_boxes` 中间预测，用于深度监督。
The forward expects a NestedTensor, which consists of:
- samples.tensor: batched images, of shape [batch_size x 3 x H x W]
- samples.mask: a binary mask of shape [batch_size x H x W], containing 1 on padded pixels
It returns a dict with the following elements:
- "pred_logits": the classification logits (including no-object) for all queries.
Shape= [batch_size x num_queries x (num_classes + 1)]
- "pred_boxes": The normalized boxes coordinates for all queries, represented as
(center_x, center_y, height, width). These values are normalized in [0, 1],
relative to the size of each individual image (disregarding possible padding).
See PostProcess for information on how to retrieve the unnormalized bounding box.
- "aux_outputs": Optional, only returned when auxilary losses are activated. It is a list of
dictionnaries containing the two above keys for each decoder layer.
"""
if isinstance(samples, (list, torch.Tensor)): # 如果输入是列表或张量
samples = nested_tensor_from_tensor_list(samples) # 转换为NestedTensor
# samples: torch.Size([2, 3, 768, 1024])
features, pos = self.backbone(samples) # 通过骨干网络提取特征和位置编码
src, mask = features[-1].decompose() # 分解最后一层特征：特征图和掩码
assert mask is not None # 确保掩码存在
# src.size = torch.Size([2, 2048, 24, 32])
# mask.size = torch.Size([2, 24, 32])
# self.query_embed.shape = torch.Size(100, 256)
input_proj_src = self.input_proj(src) # 将特征投影到Transformer维度 torch.Size([2, 2048, 24, 32])->torch.Size([2, 256, 24, 32])
hs = self.transformer(input_proj_src, mask, self.query_embed.weight, pos[-1])[0] # Transformer处理：投影特征 -> Transformer -> 输出隐藏状态 torch.Size([6, 2, 100, 256])
outputs_class = self.class_embed(hs) # 分类预测：[解码器层数, batch_size, num_queries, num_classes+1] torch.Size([6, 2, 100, 256]) -> torch.Size([6, 2, 100, 92])
outputs_coord = self.bbox_embed(hs).sigmoid() # 边界框预测并归一化到[0,1]：[解码器层数, batch_size, num_queries, 4] torch.Size([6, 2, 100, 4])
out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]} # 取最后一层的输出作为主预测
if self.aux_loss: # 如果使用辅助损失
out['aux_outputs'] = self._set_aux_loss(outputs_class, outputs_coord) # 添加中间层的输出
return out
@torch.jit.unused # 标记为不被TorchScript编译
def _set_aux_loss(self, outputs_class, outputs_coord):
"""设置辅助损失
这是一个让torchscript正常工作的变通方法，因为torchscript不支持包含非同质值的字典，
例如同时包含Tensor和list的字典。
参数:
outputs_class: 所有解码器层的分类输出
outputs_coord: 所有解码器层的坐标输出
返回:
包含中间层预测的字典列表（不包括最后一层）
"""
# this is a workaround to make torchscript happy, as torchscript
# doesn't support dictionary with non-homogeneous values, such
# as a dict having both a Tensor and a list.
return [{'pred_logits': a, 'pred_boxes': b} # 为每个中间解码器层创建预测字典
for a, b in zip(outputs_class[:-1], outputs_coord[:-1])] # 遍历除最后一层外的所有层
class SetCriterion(nn.Module):
"""DETR损失计算类
该类计算DETR的损失。过程分为两步:
1) 使用匈牙利算法计算真实框和模型输出之间的分配
2) 监督每对匹配的真实值/预测值（监督类别和边界框）
"""
def __init__(self, num_classes, matcher, weight_dict, eos_coef, losses):
"""创建损失函数
参数:
num_classes: 目标类别数量，不包括特殊的no-object类别
matcher: 能够计算目标和预测之间匹配的模块
weight_dict: 字典，键为损失名称，值为相应的权重
eos_coef: 应用于no-object类别的相对分类权重
losses: 要应用的所有损失的列表。参见get_loss了解可用损失列表
"""
super().__init__()
self.num_classes = num_classes # 类别数量
self.matcher = matcher # 匈牙利匹配器
self.weight_dict = weight_dict # 损失权重字典
self.eos_coef = eos_coef # no-object类别的权重系数
self.losses = losses # 损失类型列表
empty_weight = torch.ones(self.num_classes + 1) # 创建类别权重张量，所有类别初始权重为1
empty_weight[-1] = self.eos_coef # 设置no-object类别（最后一个类别）的权重
self.register_buffer('empty_weight', empty_weight) # 注册为buffer（不参与梯度更新）
def loss_labels(self, outputs, targets, indices, num_boxes, log=True):
"""分类损失（负对数似然损失 NLL）
参数:
outputs: 模型输出字典
targets: 目标字典列表，必须包含键"labels"，包含维度为[nb_target_boxes]的张量
indices: 匹配索引
num_boxes: 目标框数量（用于归一化）
log: 是否记录分类错误率
返回:
包含损失的字典
"""
assert 'pred_logits' in outputs # 确保输出包含预测logits
src_logits = outputs['pred_logits'] # 获取预测的分类logits [batch_size, num_queries, num_classes+1] torch.Size([2, 100, 92])
# indices:
# [
# (tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88]), tensor([ 2, 11, 8, 6, 12, 0, 4, 3, 9, 7, 1, 10, 5])),
# (tensor([ 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79]), tensor([ 1, 10, 7, 2, 11, 5, 3, 0, 6, 9, 4, 8]))
# ]
# 获取匹配的预测索引
idx = self._get_src_permutation_idx(indices)
# idx:
# (
# tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]),
# tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88, 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79])
# )
# 目标类别收集：将所有 batch 中、与预测成功匹配的 GT 类别拼接到一起
# 说明：
# - targets: 长度为 batch_size 的列表
# 每个元素 t 是一个字典，对应第 i 个 batch 的标注信息，例如 t["labels"] 形状为 [num_target_boxes_i]
# - indices: 长度同样为 batch_size 的列表
# 每个元素是一个二元组 (src_idx, tgt_idx)
# * src_idx: 第 i 个 batch 中被匹配到的预测索引
# * tgt_idx: 第 i 个 batch 中与这些预测对应的目标索引
# - zip(targets, indices): 逐个 batch 同时遍历标注和匹配结果
# * t: 当前 batch 的 targets 字典
# * (_ , J): 当前 batch 的匹配索引元组，其中 J 即该 batch 的 tgt_idx（目标框索引），src_idx 在这里不需要所以用 _ 占位
# - t["labels"][J]: 取出当前 batch 中，被匹配到的目标框的类别标签（按照 J 重新索引）
# - torch.cat([...]): 将所有 batch 中被匹配到的目标类别按 batch 维拼接，得到一维张量，长度为所有 batch 匹配数量之和 M
target_classes_o = torch.cat([
t["labels"][J]
for t, (_, J) in zip(targets, indices)
]) # 收集所有匹配的目标类别：形状为 [M]
# target_classes_o:
# tensor([21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 67, 67, 1, 2, 1, 1, 41, 62, 1, 62, 1, 1], device='cuda:0')
target_classes = torch.full(src_logits.shape[:2], self.num_classes, dtype=torch.int64, device=src_logits.device) # 创建目标类别张量，默认填充为no-object类 torch.Size([2, 100])
# target_classes: torch.Size([2, 100])
# tensor([[91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91],
# [91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91]
# ], device='cuda:0')
target_classes[idx] = target_classes_o # 将匹配位置的类别设置为真实类别
# target_classes:
# tensor([[91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 21, 91, 21, 21, 91,
# 91, 91, 91, 21, 91, 91, 91, 91, 91, 21, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 21, 91, 91, 91, 91, 91, 91, 91, 91, 21, 91, 91, 21, 91, 21, 91, 91, 21, 91,
# 91, 21, 91, 91, 91, 91, 21, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 21, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91],
# [91, 91, 91, 67, 91, 91, 91, 91, 91, 91, 91, 91, 67, 91, 1, 91, 91, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 2, 91, 91, 91, 91, 1, 91, 91, 91, 91, 1, 91, 91, 91,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 41, 91, 62, 91, 91, 91,
# 1, 91, 62, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 1, 91, 91, 91, 1,
# 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91]
# ], device='cuda:0')
# 将预测 logits 的形状从 [batch_size, num_queries, num_classes+1]
# 变为 [batch_size, num_classes+1, num_queries]，以满足 F.cross_entropy 的输入格式：
# - 输入: [N, C, *]，其中 C 是类别数
# - 目标: [N, *]，保存每个位置的类别索引
# 这里: N = batch_size, C = num_classes+1, * = num_queries
src_logits_transposed = src_logits.transpose(1, 2) # 形状: [2, 100, 92] -> [2, 92, 100]
# 计算分类交叉熵损失：
# - src_logits_transposed: 预测 logits，形状 [batch_size, num_classes+1, num_queries]
# - target_classes: 目标类别索引，形状 [batch_size, num_queries]
# - self.empty_weight: 每个类别的权重向量，用于降低 no-object 类的权重
# F.cross_entropy 会对最后一个维度（这里是 query 维）逐点计算带权重的交叉熵，再对所有样本与 query 做平均
loss_ce = F.cross_entropy(src_logits_transposed, target_classes, self.empty_weight) # 计算交叉熵损失，使用类别权重
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
@torch.no_grad() # 不计算梯度
def loss_cardinality(self, outputs, targets, indices, num_boxes):
"""计算基数误差，即预测的非空框数量的绝对误差
这不是真正的损失，仅用于日志记录目的。不传播梯度。
参数:
outputs: 模型输出字典
targets: 目标字典列表
indices: 匹配索引（未使用）
num_boxes: 目标框数量（未使用）
返回:
包含基数误差的字典
"""
pred_logits = outputs['pred_logits'] # 获取预测logits
device = pred_logits.device # 获取设备
tgt_lengths = torch.as_tensor([len(v["labels"]) for v in targets], device=device) # 每个样本的真实目标数量
# Count the number of predictions that are NOT "no-object" (which is the last class)
card_pred = (pred_logits.argmax(-1) != pred_logits.shape[-1] - 1).sum(1) # 统计预测为非no-object的数量
card_err = F.l1_loss(card_pred.float(), tgt_lengths.float()) # 计算预测数量和真实数量的L1误差
losses = {'cardinality_error': card_err} # 基数误差
return losses
def loss_boxes(self, outputs, targets, indices, num_boxes):
"""计算与边界框相关的损失：L1回归损失和GIoU损失
参数:
outputs: 模型输出字典
targets: 目标字典列表，必须包含键"boxes"，包含维度为[nb_target_boxes, 4]的张量
目标框格式为(center_x, center_y, w, h)，已按图像尺寸归一化
indices: 匹配索引
num_boxes: 目标框数量（用于归一化）
返回:
包含边界框损失的字典
"""
assert 'pred_boxes' in outputs # 确保输出包含预测框
idx = self._get_src_permutation_idx(indices) # 获取匹配的预测索引
src_boxes = outputs['pred_boxes'][idx] # 获取匹配的预测框
# src_boxes:
# tensor([[0.4972, 0.5158, 0.5018, 0.5080],
# [0.4942, 0.4978, 0.5222, 0.5055],
# [0.4777, 0.5094, 0.5212, 0.4961],
# [0.4899, 0.5127, 0.5149, 0.4871],
# [0.4778, 0.5005, 0.5137, 0.5174],
# [0.4885, 0.5229, 0.5071, 0.4967],
# [0.4768, 0.5098, 0.5083, 0.5039],
# [0.5014, 0.5195, 0.5129, 0.4977],
# [0.4979, 0.5107, 0.5083, 0.5072],
# [0.4737, 0.5192, 0.5154, 0.5012],
# [0.4919, 0.5125, 0.4974, 0.5019],
# [0.4953, 0.4978, 0.5224, 0.5059],
# [0.4919, 0.5226, 0.4937, 0.5085],
# [0.4857, 0.5077, 0.4904, 0.5053],
# [0.4835, 0.4912, 0.5129, 0.5028],
# [0.5082, 0.5024, 0.5084, 0.4963],
# [0.5154, 0.5059, 0.4924, 0.5045],
# [0.4781, 0.5066, 0.5033, 0.5022],
# [0.4977, 0.5118, 0.4800, 0.5093],
# [0.4917, 0.5201, 0.4916, 0.5067],
# [0.4805, 0.4948, 0.4917, 0.5141],
# [0.5075, 0.5026, 0.4805, 0.5107],
# [0.4789, 0.5088, 0.4889, 0.5079],
# [0.4944, 0.4903, 0.5201, 0.5088],
# [0.5131, 0.5018, 0.5058, 0.4997]], device='cuda:0',
# grad_fn=<IndexBackward0>)
target_boxes = torch.cat([t['boxes'][i] for t, (_, i) in zip(targets, indices)], dim=0) # 收集所有匹配的目标框
# target_boxes:
# tensor([[0.6488, 0.3405, 0.0314, 0.0298],
# [0.8460, 0.3374, 0.0607, 0.0528],
# [0.0156, 0.3558, 0.0312, 0.0353],
# [0.5540, 0.3504, 0.0437, 0.0332],
# [0.4038, 0.3242, 0.0610, 0.0445],
# [0.4000, 0.5978, 0.2528, 0.3326],
# [0.3292, 0.3587, 0.0679, 0.0407],
# [0.7485, 0.3328, 0.0739, 0.0470],
# [0.7112, 0.3571, 0.0763, 0.0353],
# [0.2084, 0.3211, 0.0684, 0.0289],
# [0.6030, 0.3414, 0.0573, 0.0913],
# [0.7914, 0.3598, 0.0588, 0.0323],
# [0.5591, 0.6029, 0.2037, 0.3217],
# [0.0656, 0.0043, 0.1277, 0.0086],
# [0.0551, 0.0701, 0.1101, 0.1317],
# [0.9522, 0.0032, 0.0957, 0.0065],
# [0.9500, 0.0141, 0.0999, 0.0281],
# [0.1575, 0.0041, 0.0802, 0.0081],
# [0.6908, 0.0668, 0.0929, 0.1336],
# [0.4039, 0.6202, 0.2538, 0.2480],
# [0.1411, 0.0690, 0.0866, 0.1127],
# [0.5867, 0.0637, 0.1029, 0.1274],
# [0.1224, 0.0277, 0.0623, 0.0555],
# [0.5196, 0.2898, 0.7307, 0.5796],
# [0.7822, 0.0681, 0.0558, 0.1361]], device='cuda:0')
loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction='none') # 计算L1损失（不进行reduction）
losses = {} # 损失字典
losses['loss_bbox'] = loss_bbox.sum() / num_boxes # L1损失归一化
# 将预测框和目标框从中心点形式 (cx, cy, w, h) 转换为角点形式 (x_min, y_min, x_max, y_max)
# generalized_box_iou 的输入要求是 [N, 4] 形式的 xyxy 坐标
src_boxes_ = box_ops.box_cxcywh_to_xyxy(src_boxes) # 预测框，形状仍为 [M, 4]
target_boxes_ = box_ops.box_cxcywh_to_xyxy(target_boxes) # 目标框，形状仍为 [M, 4]
# generalized_box_iou(src_boxes_, target_boxes_) 会返回一个 [M, M] 的矩阵 giou_matrix：
# - 第 (i, j) 个元素是第 i 个预测框与第 j 个目标框之间的 GIoU
# 在前面构造 src_boxes / target_boxes 时，第 k 个预测框与第 k 个目标框是一一对应的匹配关系，
# 因此我们只关心矩阵对角线上 (k, k) 这些成对匹配框的 GIoU 值
giou_matrix = box_ops.generalized_box_iou(src_boxes_, target_boxes_)
# giou_matrix:
# tensor([[ 0.0037, -0.1935, -0.3264, 0.0057, 0.0107, 0.3299, 0.0108, -0.0562, 0.0081, -0.1189, 0.0205, -0.1199, 0.2571, -0.5545, -0.5297, -0.5596, -0.5558, -0.4737, -0.3080, 0.2469, -0.4625, -0.3062, -0.4891, 0.2298, -0.3952],
# [ 0.0035, -0.1783, -0.3058, 0.0055, 0.0103, 0.2882, 0.0105, -0.0418, 0.0102, -0.0946, 0.0198, -0.1050, 0.2201, -0.5313, -0.5060, -0.5403, -0.5365, -0.4473, -0.2948, 0.2384, -0.4358, -0.2930, -0.4634, 0.2758, -0.3729],
# [ 0.0036, -0.1997, -0.2910, 0.0056, 0.0105, 0.3099, 0.0107, -0.0704, -0.0105, -0.0688, 0.0202, -0.1303, 0.2397, -0.5345, -0.5089, -0.5630, -0.5593, -0.4488, -0.3136, 0.2434, -0.4375, -0.3118, -0.4653, 0.2540, -0.4075],
# [ 0.0037, -0.1901, -0.3080, 0.0058, 0.0108, 0.3169, 0.0110, -0.0556, 0.0069, -0.0945, 0.0209, -0.1181, 0.2447, -0.5533, -0.5280, -0.5669, -0.5631, -0.4723, -0.3241, 0.2510, -0.4606, -0.3223, -0.4876, 0.2417, -0.4085],
# [ 0.0035, -0.2068, -0.2978, 0.0055, 0.0102, 0.3055, 0.0104, -0.0779, -0.0179, -0.0763, 0.0197, -0.1375, 0.2370, -0.5203, -0.4946, -0.5496, -0.5459, -0.4314, -0.2902, 0.2368, -0.4203, -0.2849, -0.4487, 0.2663, -0.3888],
# [ 0.0037, -0.1993, -0.3136, 0.0058, 0.0108, 0.3338, 0.0110, -0.0658, -0.0036, -0.0999, 0.0208, -0.1278, 0.2601, -0.5569, -0.5320, -0.5721, -0.5684, -0.4758, -0.3243, 0.2499, -0.4646, -0.3225, -0.4913, 0.2211, -0.4151],
# [ 0.0036, -0.2127, -0.3016, 0.0057, 0.0106, 0.3231, 0.0108, -0.0844, -0.0246, -0.0798, 0.0204, -0.1439, 0.2517, -0.5369, -0.5113, -0.5664, -0.5627, -0.4506, -0.3149, 0.2457, -0.4394, -0.3047, -0.4673, 0.2440, -0.4107],
# [ 0.0037, -0.1775, -0.3203, 0.0057, 0.0107, 0.3294, 0.0108, -0.0378, 0.0106, -0.1144, 0.0205, -0.1026, 0.2567, -0.5587, -0.5342, -0.5589, -0.5552, -0.4800, -0.3208, 0.2466, -0.4687, -0.3190, -0.4949, 0.2313, -0.3947],
# [ 0.0036, -0.1864, -0.3213, 0.0056, 0.0105, 0.3261, 0.0107, -0.0486, 0.0105, -0.1137, 0.0203, -0.1125, 0.2542, -0.5485, -0.5236, -0.5529, -0.5491, -0.4672, -0.3045, 0.2441, -0.4559, -0.3027, -0.4827, 0.2433, -0.3869],
# [ 0.0036, -0.2098, -0.2923, 0.0056, 0.0105, 0.3255, 0.0107, -0.0825, -0.0234, -0.0677, 0.0202, -0.1415, 0.2537, -0.5381, -0.5128, -0.5710, -0.5674, -0.4521, -0.3253, 0.2437, -0.4412, -0.3159, -0.4688, 0.2345, -0.4186],
# [ 0.0037, -0.2043, -0.3255, 0.0058, 0.0109, 0.3354, 0.0111, -0.0696, -0.0066, -0.1149, 0.0210, -0.1322, 0.2619, -0.5554, -0.5302, -0.5668, -0.5630, -0.4739, -0.3099, 0.2521, -0.4625, -0.3080, -0.4894, 0.2304, -0.4056],
# [ 0.0035, -0.1767, -0.3065, 0.0055, 0.0103, 0.2884, 0.0105, -0.0397, 0.0102, -0.0960, 0.0198, -0.1031, 0.2204, -0.5316, -0.5063, -0.5393, -0.5355, -0.4478, -0.2945, 0.2381, -0.4363, -0.2927, -0.4639, 0.2760, -0.3713],
# [ 0.0037, -0.2080, -0.3287, 0.0058, 0.0108, 0.3349, 0.0110, -0.0735, -0.0105, -0.1185, 0.0208, -0.1360, 0.2610, -0.5595, -0.5347, -0.5709, -0.5671, -0.4785, -0.3131, 0.2507, -0.4674, -0.3112, -0.4939, 0.2128, -0.4108],
# [ 0.0038, -0.2188, -0.3260, 0.0059, 0.0110, 0.3308, 0.0112, -0.0873, -0.0256, -0.1120, 0.0211, -0.1484, 0.2571, -0.5510, -0.5253, -0.5698, -0.5660, -0.4674, -0.3110, 0.2540, -0.4559, -0.3003, -0.4833, 0.2326, -0.4103],
# [ 0.0036, -0.2003, -0.3039, 0.0056, 0.0105, 0.2779, 0.0107, -0.0688, -0.0077, -0.0863, 0.0203, -0.1298, 0.2092, -0.5275, -0.5014, -0.5496, -0.5458, -0.4407, -0.2903, 0.2405, -0.4289, -0.2884, -0.4574, 0.2783, -0.3868],
# [ 0.0037, -0.1727, -0.3302, 0.0058, 0.0108, 0.3020, 0.0110, -0.0298, 0.0107, -0.1289, 0.0207, -0.0961, 0.2309, -0.5560, -0.5310, -0.5482, -0.5443, -0.4774, -0.3062, 0.2494, -0.4655, -0.3043, -0.4922, 0.2549, -0.3772],
# [ 0.0038, -0.1786, -0.3506, 0.0058, 0.0109, 0.3248, 0.0111, -0.0326, 0.0109, -0.1550, 0.0211, -0.1005, 0.2516, -0.5669, -0.5421, -0.5505, -0.5466, -0.4900, -0.3013, 0.2534, -0.4783, -0.2994, -0.5044, 0.2371, -0.3758],
# [ 0.0037, -0.2158, -0.3073, 0.0057, 0.0108, 0.3182, 0.0109, -0.0871, -0.0270, -0.0868, 0.0207, -0.1468, 0.2463, -0.5398, -0.5140, -0.5678, -0.5640, -0.4539, -0.3149, 0.2490, -0.4425, -0.3029, -0.4704, 0.2447, -0.4114],
# [ 0.0038, -0.2139, -0.3464, 0.0059, 0.0111, 0.3439, 0.0113, -0.0772, -0.0128, -0.1413, 0.0214, -0.1409, 0.2681, -0.5646, -0.5394, -0.5692, -0.5654, -0.4844, -0.3018, 0.2575, -0.4729, -0.2999, -0.4996, 0.2180, -0.4047],
# [ 0.0037, -0.2103, -0.3305, 0.0058, 0.0109, 0.3376, 0.0111, -0.0759, -0.0129, -0.1204, 0.0210, -0.1384, 0.2631, -0.5604, -0.5354, -0.5719, -0.5682, -0.4793, -0.3123, 0.2527, -0.4682, -0.3104, -0.4948, 0.2144, -0.4119],
# [ 0.0037, -0.2240, -0.3202, 0.0057, 0.0108, 0.3053, 0.0109, -0.0948, -0.0342, -0.1025, 0.0207, -0.1548, 0.2341, -0.5340, -0.5078, -0.5596, -0.5558, -0.4465, -0.2981, 0.2490, -0.4349, -0.2807, -0.4633, 0.2559, -0.3982],
# [ 0.0038, -0.2009, -0.3545, 0.0059, 0.0111, 0.3287, 0.0113, -0.0593, 0.0075, -0.1555, 0.0213, -0.1252, 0.2546, -0.5640, -0.5389, -0.5571, -0.5531, -0.4850, -0.2921, 0.2565, -0.4733, -0.2902, -0.4999, 0.2331, -0.3852],
# [ 0.0038, -0.2285, -0.3211, 0.0058, 0.0109, 0.3356, 0.0111, -0.1001, -0.0399, -0.1025, 0.0211, -0.1597, 0.2618, -0.5468, -0.5210, -0.5737, -0.5699, -0.4613, -0.3201, 0.2534, -0.4500, -0.2990, -0.4778, 0.2301, -0.4172],
# [ 0.0035, -0.1801, -0.3077, 0.0055, 0.0103, 0.2750, 0.0104, -0.0436, 0.0102, -0.0968, 0.0198, -0.1067, 0.2078, -0.5259, -0.5003, -0.5349, -0.5310, -0.4408, -0.2848, 0.2378, -0.4292, -0.2830, -0.4572, 0.2870, -0.3652],
# [ 0.0037, -0.1687, -0.3368, 0.0057, 0.0108, 0.3044, 0.0109, -0.0236, 0.0107, -0.1386, 0.0207, -0.0909, 0.2332, -0.5581, -0.5332, -0.5444, -0.5405, -0.4803, -0.3026, 0.2490, -0.4684, -0.3008, -0.4949, 0.2541, -0.3703]], device='cuda:0', grad_fn=<SubBackward0>)
# 只取对角线元素，得到长度为 M 的一维张量，每个元素对应一对 (预测框, 目标框) 的 GIoU
giou = torch.diag(giou_matrix)
# giou:
# tensor([ 0.0037, -0.1783, -0.2910, 0.0058, 0.0102, 0.3338, 0.0108, -0.0378, 0.0105, -0.0677, 0.0210, -0.1031, 0.2610, -0.5510, -0.5014, -0.5482, -0.5466, -0.4539, -0.3018, 0.2527, -0.4349, -0.2902, -0.4778, 0.2870, -0.3703],
# device='cuda:0', grad_fn=<DiagonalBackward0_copy>)
# 计算GIoU损失：1 - GIoU
loss_giou = 1 - giou
# loss_giou:
# tensor([0.9963, 1.1783, 1.2910, 0.9942, 0.9898, 0.6662, 0.9892, 1.0378, 0.9895, 1.0677, 0.9790, 1.1031, 0.7390, 1.5510, 1.5014, 1.5482, 1.5466, 1.4539, 1.3018, 0.7473, 1.4349, 1.2902, 1.4778, 0.7130, 1.3703],
# device='cuda:0', grad_fn=<RsubBackward1>)
losses['loss_giou'] = loss_giou.sum() / num_boxes # GIoU损失归一化
return losses
def loss_masks(self, outputs, targets, indices, num_boxes):
"""计算与掩码相关的损失：focal loss和dice loss
参数:
outputs: 模型输出字典
targets: 目标字典列表，必须包含键"masks"，包含维度为[nb_target_boxes, h, w]的张量
indices: 匹配索引
num_boxes: 目标框数量（用于归一化）
返回:
包含掩码损失的字典
"""
assert "pred_masks" in outputs # 确保输出包含预测掩码
src_idx = self._get_src_permutation_idx(indices) # 获取预测的排列索引
tgt_idx = self._get_tgt_permutation_idx(indices) # 获取目标的排列索引
src_masks = outputs["pred_masks"] # 获取预测掩码
src_masks = src_masks[src_idx] # 选择匹配的预测掩码
masks = [t["masks"] for t in targets] # 收集所有目标掩码
# TODO use valid to mask invalid areas due to padding in loss
target_masks, valid = nested_tensor_from_tensor_list(masks).decompose() # 将掩码列表转换为张量并分解
target_masks = target_masks.to(src_masks) # 将目标掩码移到与预测掩码相同的设备
target_masks = target_masks[tgt_idx] # 选择匹配的目标掩码
# upsample predictions to the target size
src_masks = interpolate(src_masks[:, None], size=target_masks.shape[-2:], # 将预测掩码上采样到目标尺寸
mode="bilinear", align_corners=False) # 使用双线性插值
src_masks = src_masks[:, 0].flatten(1) # 移除通道维度并展平
target_masks = target_masks.flatten(1) # 展平目标掩码
target_masks = target_masks.view(src_masks.shape) # 调整形状以匹配预测掩码
losses = {
"loss_mask": sigmoid_focal_loss(src_masks, target_masks, num_boxes), # Sigmoid focal loss
"loss_dice": dice_loss(src_masks, target_masks, num_boxes), # Dice loss
}
return losses
def _get_src_permutation_idx(self, indices):
"""获取预测的排列索引
根据匹配索引对预测进行排列
功能说明:
将批次级别的局部索引转换为全局索引，用于从形状为 [B, N, ...] 的张量中
提取所有批次中被匹配的预测。
例如: indices = [(tensor([2,5]), tensor([0,1])), # 批次0: 2个匹配
(tensor([1,3]), tensor([0,1]))] # 批次1: 2个匹配
输出: batch_idx = [0, 0, 1, 1] # 每个匹配所属的批次
src_idx = [2, 5, 1, 3] # 每个匹配的query索引
参数:
indices: 匹配索引列表，长度为 batch_size
每个元素为 (src_idx, tgt_idx) 元组
- src_idx: 形状 [M_i] 的张量，第 i 个批次中被匹配的预测索引
- tgt_idx: 形状 [M_i] 的张量，第 i 个批次中被匹配的目标索引
- M_i 是第 i 个批次的匹配数量
返回:
(batch_idx, src_idx): 两个一维张量的元组
- batch_idx: 形状 [M]，每个匹配所属的批次索引 (0 到 B-1)
- src_idx: 形状 [M]，每个匹配的预测query索引 (0 到 num_queries-1)
- M = sum(M_i) 是所有批次的总匹配数
使用示例:
idx = self._get_src_permutation_idx(indices)
matched_preds = pred_logits[idx] # 提取所有匹配的预测
"""
# indices:
# [
# (tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88]), tensor([ 2, 11, 8, 6, 12, 0, 4, 3, 9, 7, 1, 10, 5])),
# (tensor([ 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79]), tensor([ 1, 10, 7, 2, 11, 5, 3, 0, 6, 9, 4, 8]))
# ]
# permute predictions following indices
# 步骤1: 构建 batch_idx - 为每个匹配标记其所属的批次
batch_idx = torch.cat([ # 拼接所有批次的批次索引
torch.full_like(src, i) # 创建与 src 形状相同、值全为 i 的张量，表示这些匹配都属于第 i 个批次
for i, (src, _) in enumerate(indices) # 遍历每个批次，i 是批次索引，src 是该批次的预测索引（src_idx），_ 是该批次的目标索引 (tgt_idx)，在这里构造 batch_idx 时不需要用到目标索引，因此用 _ 作为占位变量
]) # 结果: [0,0,...,0, 1,1,...,1, ..., B-1,...,B-1]，长度为总匹配数 M，其中 M = sum_i M_i，是所有 batch 中被匹配的预测索引总数
# batch_idx:
# tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
# 步骤2: 构建 src_idx - 收集所有批次中被匹配的预测索引
src_idx = torch.cat([ # 拼接所有批次的预测索引
src # 直接取出第 i 个批次的预测索引（一维张量）
for (src, _) in indices # 遍历每个批次，提取 src（忽略 tgt）
]) # 结果: [src_0[0], src_0[1], ..., src_1[0], ..., src_{B-1}[-1]]，长度为 M
# src_idx:
# tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88, 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79])
# 返回索引对，可用于二维张量索引: tensor[batch_idx, src_idx]
return batch_idx, src_idx
def _get_tgt_permutation_idx(self, indices):
"""获取目标的排列索引
根据匹配索引对目标进行排列
功能说明:
与 _get_src_permutation_idx 类似，但处理的是目标（ground truth）索引。
将批次级别的目标索引转换为全局索引，用于从拼接后的目标张量中提取匹配的目标。
例如: indices = [(tensor([2,5]), tensor([0,1])), # 批次0: query[2,5] 匹配 target[0,1]
(tensor([1,3]), tensor([0,1]))] # 批次1: query[1,3] 匹配 target[0,1]
输出: batch_idx = [0, 0, 1, 1] # 每个匹配所属的批次
tgt_idx = [0, 1, 0, 1] # 每个匹配的目标索引
注意: batch_idx 与 _get_src_permutation_idx 返回的相同，因为是同一组匹配
参数:
indices: 匹配索引列表，长度为 batch_size
每个元素为 (src_idx, tgt_idx) 元组
- src_idx: 形状 [M_i] 的张量，第 i 个批次中被匹配的预测索引
- tgt_idx: 形状 [M_i] 的张量，第 i 个批次中被匹配的目标索引
- M_i 是第 i 个批次的匹配数量
返回:
(batch_idx, tgt_idx): 两个一维张量的元组
- batch_idx: 形状 [M]，每个匹配所属的批次索引 (0 到 B-1)
- tgt_idx: 形状 [M]，每个匹配的目标索引 (0 到 num_targets_i-1)
- M = sum(M_i) 是所有批次的总匹配数
使用示例:
idx = self._get_tgt_permutation_idx(indices)
# 先拼接所有批次的目标
target_classes = torch.cat([t["labels"] for t in targets])
# 然后提取匹配的目标
matched_targets = target_classes[idx[1]] # 只需要 tgt_idx
"""
# permute targets following indices
# 步骤1: 构建 batch_idx - 为每个匹配标记其所属的批次
batch_idx = torch.cat([ # 拼接所有批次的批次索引
torch.full_like(tgt, i) # 创建与 tgt 形状相同、值全为 i 的张量，表示这些匹配都属于第 i 个批次
for i, (_, tgt) in enumerate(indices) # 遍历每个批次，i 是批次索引，tgt 是该批次的目标索引（忽略 src）
]) # 结果: [0,0,...,0, 1,1,...,1, ..., B-1,...,B-1]，长度为总匹配数 M
# 步骤2: 构建 tgt_idx - 收集所有批次中被匹配的目标索引
tgt_idx = torch.cat([tgt for (_, tgt) in indices]) # 拼接所有批次的目标索引，结果: [tgt_0[0], tgt_0[1], ..., tgt_{B-1}[-1]]
# 返回索引对
# 注意: 通常只需要 tgt_idx，因为目标已经通过 torch.cat([t["labels"] for t in targets]) 拼接成一维
# 但返回 batch_idx 可以用于验证或特殊情况下的批次级别操作
return batch_idx, tgt_idx
def get_loss(self, loss, outputs, targets, indices, num_boxes, **kwargs):
"""根据损失名称获取并计算相应的损失
参数:
loss: 损失名称（'labels', 'cardinality', 'boxes', 'masks'之一）
outputs: 模型输出字典
targets: 目标字典列表
indices: 匹配索引
num_boxes: 目标框数量
**kwargs: 其他参数
返回:
损失字典
"""
loss_map = { # 损失名称到损失函数的映射
'labels': self.loss_labels, # 分类损失
'cardinality': self.loss_cardinality, # 基数误差
'boxes': self.loss_boxes, # 边界框损失
'masks': self.loss_masks # 掩码损失
}
assert loss in loss_map, f'do you really want to compute {loss} loss?' # 确保损失名称有效
curr_loss_func = loss_map[loss] # 获取相应的损失函数
loss_result = curr_loss_func(outputs, targets, indices, num_boxes, **kwargs) # 调用相应的损失函数
return loss_result
def forward(self, outputs, targets):
"""执行损失计算
参数:
outputs: 张量字典，格式参见模型的输出规范
targets: 字典列表，len(targets) == batch_size
每个字典中的预期键取决于应用的损失，参见各损失函数的文档
返回:
包含所有损失的字典
"""
outputs_without_aux = {k: v for k, v in outputs.items() if k != 'aux_outputs'} # 移除辅助输出，只保留主输出
# outputs_without_aux['pred_logits'].shape: torch.Size([2, 100, 92])
# outputs_without_aux['pred_boxes'].shape: torch.Size([2, 100, 4])
# Retrieve the matching between the outputs of the last layer and the targets
print("detr/models/detr.py---->进入detr/models/matcher.py---->匈牙利匹配操作：开始")
indices = self.matcher(outputs_without_aux, targets) # 使用匈牙利算法匹配最后一层输出和目标
print("detr/models/detr.py---->退出detr/models/matcher.py---->匈牙利匹配操作：结束")
print("detr/models/detr.py---->匈牙利匹配操作结果: \n", indices)
# indices:
# [
# (tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88]), tensor([ 2, 11, 8, 6, 12, 0, 4, 3, 9, 7, 1, 10, 5])),
# (tensor([ 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79]), tensor([ 1, 10, 7, 2, 11, 5, 3, 0, 6, 9, 4, 8]))
# ]
print("detr/models/detr.py---->利用匈牙利匹配操作结果计算loss: 开始")
# Compute the average number of target boxes accross all nodes, for normalization purposes
num_boxes = sum(len(t["labels"]) for t in targets) # 计算所有目标框的总数 13+12
num_boxes = torch.as_tensor([num_boxes], dtype=torch.float, device=next(iter(outputs.values())).device) # 转换为张量 tensor([13+12], device='cuda:0')
if is_dist_avail_and_initialized(): # 如果使用分布式训练
torch.distributed.all_reduce(num_boxes) # 在所有节点间同步目标框数量
num_boxes = torch.clamp(num_boxes / get_world_size(), min=1).item() # 计算每张显卡片的平均目标框数量，最小为1 tensor([13+12], device='cuda:0')
# Compute all the requested losses
losses = {} # 损失字典
# 遍历所有要计算的损失 self.losses = ['labels', 'boxes', 'cardinality']
for loss in self.losses:
curr_loss_dict = self.get_loss(loss, outputs, targets, indices, num_boxes)
losses.update(curr_loss_dict) # 计算并更新损失
# losses:
# {
# 'loss_ce': tensor(4.4531, device='cuda:0', grad_fn=<NllLoss2DBackward0>),
# 'class_error': tensor(100., device='cuda:0'),
# 'loss_bbox': tensor(1.3179, device='cuda:0', grad_fn=<DivBackward0>),
# 'loss_giou': tensor(1.1583, device='cuda:0', grad_fn=<DivBackward0>),
# 'cardinality_error': tensor(87.5000, device='cuda:0')
# }
# In case of auxiliary losses, we repeat this process with the output of each intermediate layer.
if 'aux_outputs' in outputs: # 如果有辅助输出（中间层输出）
for i, aux_outputs in enumerate(outputs['aux_outputs']): # 遍历每个中间层的输出
indices = self.matcher(aux_outputs, targets) # 为中间层输出计算匹配
for loss in self.losses: # 遍历所有损失
if loss == 'masks': # 如果是掩码损失
# Intermediate masks losses are too costly to compute, we ignore them.
continue # 中间层的掩码损失计算成本太高，跳过
kwargs = {} # 额外参数
if loss == 'labels': # 如果是分类损失
# Logging is enabled only for the last layer
kwargs = {'log': False} # 中间层不记录分类错误率
l_dict = self.get_loss(loss, aux_outputs, targets, indices, num_boxes, **kwargs) # 计算损失
l_dict = {k + f'_{i}': v for k, v in l_dict.items()} # 为损失名称添加层索引后缀
losses.update(l_dict) # 更新损失字典
print("detr/models/detr.py---->利用匈牙利匹配操作结果计算loss: 结束")
return losses
class PostProcess(nn.Module):
"""后处理模块
该模块将模型的输出转换为COCO API期望的格式
"""
@torch.no_grad() # 不计算梯度
def forward(self, outputs, target_sizes):
"""执行后处理计算
参数:
outputs: 模型的原始输出
target_sizes: 维度为[batch_size x 2]的张量，包含批次中每张图像的尺寸
对于评估，这必须是原始图像尺寸（任何数据增强之前）
对于可视化，这应该是数据增强后但填充前的图像尺寸
返回:
结果列表，每个元素是包含scores、labels和boxes的字典
"""
out_logits, out_bbox = outputs['pred_logits'], outputs['pred_boxes'] # 获取分类logits和边界框
assert len(out_logits) == len(target_sizes) # 确保批次大小匹配
assert target_sizes.shape[1] == 2 # 确保target_sizes包含宽度和高度
prob = F.softmax(out_logits, -1) # 将logits转换为概率
scores, labels = prob[..., :-1].max(-1) # 获取最高分数和对应的类别（排除no-object类）
# convert to [x0, y0, x1, y1] format
boxes = box_ops.box_cxcywh_to_xyxy(out_bbox) # 将边界框从中心格式转换为角点格式
# and from relative [0, 1] to absolute [0, height] coordinates
img_h, img_w = target_sizes.unbind(1) # 解绑图像高度和宽度
scale_fct = torch.stack([img_w, img_h, img_w, img_h], dim=1) # 创建缩放因子
boxes = boxes * scale_fct[:, None, :] # 将归一化坐标转换为绝对坐标
results = [{'scores': s, 'labels': l, 'boxes': b} for s, l, b in zip(scores, labels, boxes)] # 为每张图像创建结果字典
return results
class MLP(nn.Module):
"""多层感知机（MLP）
非常简单的多层感知机（也称为前馈网络FFN）
"""
def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
"""初始化MLP
参数:
input_dim: 输入维度
hidden_dim: 隐藏层维度
output_dim: 输出维度
num_layers: 层数
"""
super().__init__()
self.num_layers = num_layers # 层数
h = [hidden_dim] * (num_layers - 1) # 创建隐藏层维度列表
self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])) # 创建线性层列表
def forward(self, x):
"""前向传播
参数:
x: 输入张量
返回:
输出张量
"""
for i, layer in enumerate(self.layers): # 遍历所有层
x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) # 除最后一层外都使用ReLU激活
return x
def build(args):
"""构建DETR模型、损失函数和后处理器
参数:
args: 包含模型配置的参数对象
返回:
model: DETR模型
criterion: 损失函数
postprocessors: 后处理器字典
"""
# the `num_classes` naming here is somewhat misleading.
# it indeed corresponds to `max_obj_id + 1`, where max_obj_id
# is the maximum id for a class in your dataset. For example,
# COCO has a max_obj_id of 90, so we pass `num_classes` to be 91.
# As another example, for a dataset that has a single class with id 1,
# you should pass `num_classes` to be 2 (max_obj_id + 1).
# For more details on this, check the following discussion
# https://github.com/facebookresearch/detr/issues/108#issuecomment-650269223
# 注意：这里的`num_classes`命名有些误导性
# 它实际上对应`max_obj_id + 1`，其中max_obj_id是数据集中类别的最大ID
# 例如，COCO的max_obj_id为90，所以我们传递`num_classes`为91
# 再例如，对于只有一个ID为1的类别的数据集，应该传递`num_classes`为2（max_obj_id + 1）
num_classes = 20 if args.dataset_file != 'coco' else 91 # 根据数据集设置类别数：非COCO为20，COCO为91
if args.dataset_file == "coco_panoptic": # 如果是COCO全景分割数据集
# for panoptic, we just add a num_classes that is large enough to hold
# max_obj_id + 1, but the exact value doesn't really matter
num_classes = 250 # 对于全景分割，设置一个足够大的类别数，确切值不重要
device = torch.device(args.device) # 设置设备（CPU或GPU）
backbone = build_backbone(args) # 构建骨干网络
# backbone:
# Joiner(
# (0): Backbone(
# (body): IntermediateLayerGetter(
# (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
# (bn1): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
# (layer1): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer2): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (3): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer3): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (3): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (4): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (5): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer4): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# )
# )
# (1): PositionEmbeddingSine()
# )
transformer = build_transformer(args) # 构建Transformer
# transformer:
# Transformer(
# (encoder): TransformerEncoder(
# (layers): ModuleList(
# (0-5): 6 x TransformerEncoderLayer(
# (self_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (linear1): Linear(in_features=256, out_features=2048, bias=True)
# (dropout): Dropout(p=0.1, inplace=False)
# (linear2): Linear(in_features=2048, out_features=256, bias=True)
# (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (dropout1): Dropout(p=0.1, inplace=False)
# (dropout2): Dropout(p=0.1, inplace=False)
# )
# )
# )
# (decoder): TransformerDecoder(
# (layers): ModuleList(
# (0-5): 6 x TransformerDecoderLayer(
# (self_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (multihead_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (linear1): Linear(in_features=256, out_features=2048, bias=True)
# (dropout): Dropout(p=0.1, inplace=False)
# (linear2): Linear(in_features=2048, out_features=256, bias=True)
# (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (dropout1): Dropout(p=0.1, inplace=False)
# (dropout2): Dropout(p=0.1, inplace=False)
# (dropout3): Dropout(p=0.1, inplace=False)
# )
# )
# (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# )
# )
model = DETR( # 创建DETR模型
backbone, # 骨干网络
transformer, # Transformer
num_classes=num_classes, # 类别数
num_queries=args.num_queries, # 查询数量（最大检测目标数）
aux_loss=args.aux_loss, # 是否使用辅助损失
)
# model:
# DETR(
# (transformer): Transformer(
# (encoder): TransformerEncoder(
# (layers): ModuleList(
# (0-5): 6 x TransformerEncoderLayer(
# (self_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (linear1): Linear(in_features=256, out_features=2048, bias=True)
# (dropout): Dropout(p=0.1, inplace=False)
# (linear2): Linear(in_features=2048, out_features=256, bias=True)
# (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (dropout1): Dropout(p=0.1, inplace=False)
# (dropout2): Dropout(p=0.1, inplace=False)
# )
# )
# )
# (decoder): TransformerDecoder(
# (layers): ModuleList(
# (0-5): 6 x TransformerDecoderLayer(
# (self_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (multihead_attn): MultiheadAttention(
# (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
# )
# (linear1): Linear(in_features=256, out_features=2048, bias=True)
# (dropout): Dropout(p=0.1, inplace=False)
# (linear2): Linear(in_features=2048, out_features=256, bias=True)
# (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (norm3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# (dropout1): Dropout(p=0.1, inplace=False)
# (dropout2): Dropout(p=0.1, inplace=False)
# (dropout3): Dropout(p=0.1, inplace=False)
# )
# )
# (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
# )
# )
# (class_embed): Linear(in_features=256, out_features=92, bias=True)
# (bbox_embed): MLP(
# (layers): ModuleList(
# (0-1): 2 x Linear(in_features=256, out_features=256, bias=True)
# (2): Linear(in_features=256, out_features=4, bias=True)
# )
# )
# (query_embed): Embedding(100, 256)
# (input_proj): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))
# (backbone): Joiner(
# (0): Backbone(
# (body): IntermediateLayerGetter(
# (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
# (bn1): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
# (layer1): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer2): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (3): Bottleneck(
# (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer3): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (3): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (4): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (5): Bottleneck(
# (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# (layer4): Sequential(
# (0): Bottleneck(
# (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# (downsample): Sequential(
# (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
# (1): FrozenBatchNorm2d()
# )
# )
# (1): Bottleneck(
# (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# (2): Bottleneck(
# (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn1): FrozenBatchNorm2d()
# (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
# (bn2): FrozenBatchNorm2d()
# (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
# (bn3): FrozenBatchNorm2d()
# (relu): ReLU(inplace=True)
# )
# )
# )
# )
# (1): PositionEmbeddingSine()
# )
# )
if args.masks: # 如果需要分割功能
model = DETRsegm(model, freeze_detr=(args.frozen_weights is not None)) # 将模型包装为分割模型
matcher = build_matcher(args) # 构建匈牙利匹配器
weight_dict = {'loss_ce': 1, 'loss_bbox': args.bbox_loss_coef} # 初始化损失权重字典：分类损失权重为1，边界框损失权重从参数获取
weight_dict['loss_giou'] = args.giou_loss_coef # 添加GIoU损失权重
if args.masks: # 如果需要分割功能
weight_dict["loss_mask"] = args.mask_loss_coef # 添加掩码损失权重
weight_dict["loss_dice"] = args.dice_loss_coef # 添加Dice损失权重
# TODO this is a hack
if args.aux_loss: # 如果使用辅助损失
aux_weight_dict = {} # 辅助损失权重字典
for i in range(args.dec_layers - 1): # 遍历除最后一层外的所有解码器层
aux_weight_dict.update({k + f'_{i}': v for k, v in weight_dict.items()}) # 为每个中间层的损失添加权重
weight_dict.update(aux_weight_dict) # 更新权重字典
losses = ['labels', 'boxes', 'cardinality'] # 损失类型列表：分类损失、边界框损失、基数误差
if args.masks: # 如果需要分割功能
losses += ["masks"] # 添加掩码损失
criterion = SetCriterion(num_classes, matcher=matcher, weight_dict=weight_dict, eos_coef=args.eos_coef, losses=losses) # 创建损失函数
criterion.to(device) # 将损失函数移到指定设备
postprocessors = {'bbox': PostProcess()} # 创建后处理器字典，包含边界框后处理器
if args.masks: # 如果需要分割功能
postprocessors['segm'] = PostProcessSegm() # 添加分割后处理器
if args.dataset_file == "coco_panoptic": # 如果是COCO全景分割数据集
is_thing_map = {i: i <= 90 for i in range(201)} # 创建thing类别映射（ID<=90为thing类，>90为stuff类）
postprocessors["panoptic"] = PostProcessPanoptic(is_thing_map, threshold=0.85) # 添加全景分割后处理器
return model, criterion, postprocessors # 返回模型、损失函数和后处理器
_get_src_permutation_idx 和 _get_tgt_permutation_idx 详解
_get_src_permutation_idx 和 _get_tgt_permutation_idx 是 DETR 模型中用于处理匈牙利匹配结果的关键辅助函数。它们将批次级别的匹配索引转换为可以直接用于张量索引的扁平化索引对。
背景知识
匈牙利匹配
在 DETR 中，每张图像有 N q u e r i e s N_{queries} Nqueries 个预测（通常为100），但真实目标数量 N t a r g e t s N_{targets} Ntargets 是变化的。匈牙利算法为每张图像找到预测和目标之间的最优一对一匹配。
数据结构
输入 indices：长度为 batch_size 的列表
indices[i]是一个元组(src_idx, tgt_idx)src_idx: 形状为[M_i]的张量，表示第 i i i 张图中被匹配的预测索引tgt_idx: 形状为[M_i]的张量，表示第 i i i 张图中被匹配的目标索引- M i M_i Mi 是第 i i i 张图的匹配数量，等于 min ( N q u e r i e s , N t a r g e t s ( i ) ) \min(N_{queries}, N_{targets}^{(i)}) min(Nqueries,Ntargets(i))
函数详解
1. _get_src_permutation_idx(self, indices)
功能
将批次中所有匹配的预测位置转换为二维张量索引 (batch_idx, src_idx)。
数学表示
给定 indices = [(src_0, tgt_0), (src_1, tgt_1), ..., (src_{B-1}, tgt_{B-1})]
输出：
batch_idx = [ 0 , 0 , . . . , 0 , 1 , 1 , . . . , 1 , . . . , B − 1 , . . . , B − 1 ] 其中第 i 个批次有 ∣ s r c i ∣ 个元素 src_idx = [ src 0 [ 0 ] , src 0 [ 1 ] , src 0 [ 2 ] , . . . , src 1 [ 0 ] , src 1 [ 1 ] , src 1 [ 2 ] , . . . , src B − 1 [ 0 ] , src B − 1 [ 1 ] , src B − 1 [ 2 ] , . . . , src B − 1 [ − 1 ] ] \begin{aligned} \text{batch\_idx} &= [0, 0, ..., 0, 1, 1, ..., 1, ..., B-1, ..., B-1] \\ &\text{其中第 } i \text{ 个批次有 } |src_i| \text{ 个元素} \\ \text{src\_idx} &= [\text{src}_0[0], \text{src}_0[1], \text{src}_0[2], ..., \text{src}_1[0],\text{src}_1[1],\text{src}_1[2], ...,\text{src}_{B-1}[0],\text{src}_{B-1}[1],\text{src}_{B-1}[2],..., \text{src}_{B-1}[-1]] \end{aligned} batch_idxsrc_idx=[0,0,...,0,1,1,...,1,...,B−1,...,B−1]其中第 i 个批次有 ∣srci∣ 个元素=[src0[0],src0[1],src0[2],...,src1[0],src1[1],src1[2],...,srcB−1[0],srcB−1[1],srcB−1[2],...,srcB−1[−1]]
代码逐行分析
batch_idx = torch.cat([
torch.full_like(src, i) # 创建与 src 形状相同、值全为 i 的张量
for i, (src, _) in enumerate(indices)
])
步骤分解：
enumerate(indices)遍历每个批次，i是批次索引（0 到 B-1）(src, _)解包元组，src是该批次的预测索引，_忽略目标索引torch.full_like(src, i)创建形状与src相同的张量，所有值填充为itorch.cat([...])将所有批次的结果拼接成一维张量
src_idx = torch.cat([
src
for (src, _) in indices
])
步骤分解：
- 直接提取每个批次的
src索引 - 拼接成一维张量
示例
假设 batch_size = 3，匹配结果如下：
indices = [
(tensor([2, 5, 7]), tensor([0, 1, 2])), # 图0: 3个匹配
(tensor([1, 3]), tensor([0, 1])), # 图1: 2个匹配
(tensor([0, 4, 6, 9]), tensor([0, 1, 2, 3])) # 图2: 4个匹配
]
执行过程：
| 批次 i | src | torch.full_like(src, i) |
|---|---|---|
| 0 | [2, 5, 7] | [0, 0, 0] |
| 1 | [1, 3] | [1, 1] |
| 2 | [0, 4, 6, 9] | [2, 2, 2, 2] |
拼接结果：
batch_idx = tensor([0, 0, 0, 1, 1, 2, 2, 2, 2]) # 长度 = 3+2+4 = 9
src_idx = tensor([2, 5, 7, 1, 3, 0, 4, 6, 9]) # 长度 = 9
含义：
(batch_idx[0], src_idx[0])=(0, 2)→ 第0张图的第2个预测被匹配(batch_idx[1], src_idx[1])=(0, 5)→ 第0张图的第5个预测被匹配(batch_idx[3], src_idx[3])=(1, 1)→ 第1张图的第1个预测被匹配- …
使用场景
在损失计算中，用于从预测张量中提取匹配的预测：
# 预测张量形状: [batch_size, num_queries, ...]
src_logits = outputs['pred_logits'] # [B, 100, num_classes]
# 获取匹配索引
idx = self._get_src_permutation_idx(indices) # (batch_idx, src_idx)
# 提取匹配的预测
matched_logits = src_logits[idx] # [总匹配数, num_classes]
等价于：
matched_logits = src_logits[batch_idx, src_idx]
2. _get_tgt_permutation_idx(self, indices)
功能
将批次中所有匹配的目标位置转换为二维张量索引 (batch_idx, tgt_idx)。
数学表示
输出：
batch_idx = [ 0 , 0 , . . . , 0 , 1 , 1 , . . . , 1 , . . . , B − 1 , . . . , B − 1 ] 其中第 i 个批次有 ∣ t g t i ∣ 个元素 tgt_idx = [ tgt 0 [ 0 ] , tgt 0 [ 1 ] , . . . , tgt 1 [ 0 ] , . . . , tgt B − 1 [ − 1 ] ] \begin{aligned} \text{batch\_idx} &= [0, 0, ..., 0, 1, 1, ..., 1, ..., B-1, ..., B-1] \\ &\text{其中第 } i \text{ 个批次有 } |tgt_i| \text{ 个元素} \\ \text{tgt\_idx} &= [\text{tgt}_0[0], \text{tgt}_0[1], ..., \text{tgt}_1[0], ..., \text{tgt}_{B-1}[-1]] \end{aligned} batch_idxtgt_idx=[0,0,...,0,1,1,...,1,...,B−1,...,B−1]其中第 i 个批次有 ∣tgti∣ 个元素=[tgt0[0],tgt0[1],...,tgt1[0],...,tgtB−1[−1]]
代码分析
batch_idx = torch.cat([torch.full_like(tgt, i) for i, (_, tgt) in enumerate(indices)])
tgt_idx = torch.cat([tgt for (_, tgt) in indices])
与 _get_src_permutation_idx 类似，只是提取的是 tgt 而不是 src。
示例（续上例）
batch_idx = tensor([0, 0, 0, 1, 1, 2, 2, 2, 2]) # 与 src 相同
tgt_idx = tensor([0, 1, 2, 0, 1, 0, 1, 2, 3]) # 目标索引
含义：
(batch_idx[0], tgt_idx[0])=(0, 0)→ 第0张图的第0个目标被匹配(batch_idx[3], tgt_idx[3])=(1, 0)→ 第1张图的第0个目标被匹配
可视化图解
匹配过程示意图
批次 0 (3个目标):
预测: [Q0] [Q1] [Q2*] [Q3] [Q4] [Q5*] [Q6] [Q7*] [Q8] [Q9] ... [Q99]
↓ ↓ ↓
目标: [T0] [T1] [T2]
批次 1 (2个目标):
预测: [Q0] [Q1*] [Q2] [Q3*] [Q4] [Q5] ... [Q99]
↓ ↓
目标: [T0] [T1]
批次 2 (4个目标):
预测: [Q0*] [Q1] [Q2] [Q3] [Q4*] [Q5] [Q6*] [Q7] [Q8] [Q9*] ... [Q99]
↓ ↓ ↓ ↓
目标: [T0] [T1] [T2] [T3]
标记 * 的预测是被匹配的。
索引转换图
indices (列表结构):
┌─────────────────────────────────────┐
│ 批次0: (src=[2,5,7], tgt=[0,1,2]) │
│ 批次1: (src=[1,3], tgt=[0,1]) │
│ 批次2: (src=[0,4,6,9], tgt=[0,1,2,3])│
└─────────────────────────────────────┘
↓ _get_src_permutation_idx
┌─────────────────────────────────────┐
│ batch_idx: [0,0,0, 1,1, 2,2,2,2] │
│ src_idx: [2,5,7, 1,3, 0,4,6,9] │
└─────────────────────────────────────┘
↓ 用于索引
┌─────────────────────────────────────┐
│ pred_logits[batch_idx, src_idx] │
│ → 提取所有匹配的预测 │
└─────────────────────────────────────┘
实际应用示例
在损失函数中的使用
def loss_labels(self, outputs, targets, indices, num_boxes):
# 1. 获取预测 logits
src_logits = outputs['pred_logits'] # [B, num_queries, num_classes]
# 2. 获取匹配的预测索引
idx = self._get_src_permutation_idx(indices) # (batch_idx, src_idx)
# 3. 收集所有匹配的目标类别
target_classes_o = torch.cat([t["labels"][J] for t, (_, J) in zip(targets, indices)])
# 4. 创建完整的目标类别张量（未匹配的设为 no-object 类）
target_classes = torch.full(src_logits.shape[:2], self.num_classes,
dtype=torch.int64, device=src_logits.device)
# 5. 将匹配位置的类别设置为真实类别
target_classes[idx] = target_classes_o
# 6. 计算交叉熵损失
loss_ce = F.cross_entropy(src_logits.transpose(1, 2), target_classes, self.empty_weight)
完整流程图
┌──────────────────────────────────────────────────────────────┐
│ DETR 前向传播 │
│ 输入图像 → Backbone → Transformer → 预测 │
│ pred_logits: [B, 100, num_classes] │
│ pred_boxes: [B, 100, 4] │
└──────────────────────────────────────────────────────────────┘
↓
┌──────────────────────────────────────────────────────────────┐
│ 匈牙利匹配 (HungarianMatcher) │
│ 计算成本矩阵: C = w_cls·C_cls + w_bbox·C_bbox + w_giou·C_giou│
│ 求解最优分配: linear_sum_assignment(C) │
└──────────────────────────────────────────────────────────────┘
↓
┌──────────────────────────────────────────────────────────────┐
│ 匹配结果 indices │
│ indices[0] = (src_0, tgt_0) # 批次0的匹配 │
│ indices[1] = (src_1, tgt_1) # 批次1的匹配 │
│ ... │
└──────────────────────────────────────────────────────────────┘
↓
┌───────────────────┴───────────────────┐
↓ ↓
┌──────────────────────┐ ┌──────────────────────┐
│_get_src_permutation │ │_get_tgt_permutation │
│ _idx() │ │ _idx() │
│ │ │ │
│ 输出: (batch_idx, │ │ 输出: (batch_idx, │
│ src_idx) │ │ tgt_idx) │
└──────────────────────┘ └──────────────────────┘
↓ ↓
┌──────────────────────┐ ┌──────────────────────┐
│ 索引匹配的预测 │ │ 索引匹配的目标 │
│ pred[batch_idx, │ │ tgt[batch_idx, │
│ src_idx] │ │ tgt_idx] │
└──────────────────────┘ └──────────────────────┘
└───────────────────┬───────────────────┘
↓
┌───────────────────────┐
│ 计算损失函数 │
│ - 分类损失 (CE) │
│ - 边界框损失 (L1) │
│ - GIoU 损失 │
│ - 掩码损失 (可选) │
└───────────────────────┘
关键要点总结
1. 为什么需要这两个函数？
问题：匈牙利匹配返回的是每个批次独立的索引对，但 PyTorch 张量索引需要全局的批次索引。
解决：这两个函数将批次级别的局部索引转换为全局索引，使得可以一次性提取所有批次中所有匹配的预测/目标。
2. 函数的本质
这两个函数本质上是在做索引空间的转换：
局部索引空间 → 全局索引空间 \text{局部索引空间} \rightarrow \text{全局索引空间} 局部索引空间→全局索引空间
- 局部索引：
indices[i]中的索引是相对于第 i i i 个批次的 - 全局索引：
(batch_idx, src_idx)可以直接用于索引形状为[B, N, ...]的张量
3. 数学形式化
设批次大小为 B B B，第 i i i 个批次的匹配数为 M i M_i Mi，总匹配数为 M = ∑ i = 0 B − 1 M i M = \sum_{i=0}^{B-1} M_i M=∑i=0B−1Mi。
输入：
indices = { ( s i , t i ) } i = 0 B − 1 , s i , t i ∈ Z M i \text{indices} = \{(s_i, t_i)\}_{i=0}^{B-1}, \quad s_i, t_i \in \mathbb{Z}^{M_i} indices={(si,ti)}i=0B−1,si,ti∈ZMi
输出：
batch_idx ∈ Z M , batch_idx = [ 0 , . . . , 0 ⏟ M 0 , 1 , . . . , 1 ⏟ M 1 , . . . , B − 1 , . . . , B − 1 ⏟ M B − 1 ] src_idx ∈ Z M , src_idx = [ s 0 , s 1 , . . . , s B − 1 ] tgt_idx ∈ Z M , tgt_idx = [ t 0 , t 1 , . . . , t B − 1 ] \begin{aligned} \text{batch\_idx} &\in \mathbb{Z}^M, \quad \text{batch\_idx} = [\underbrace{0, ..., 0}_{M_0}, \underbrace{1, ..., 1}_{M_1}, ..., \underbrace{B-1, ..., B-1}_{M_{B-1}}] \\ \text{src\_idx} &\in \mathbb{Z}^M, \quad \text{src\_idx} = [s_0, s_1, ..., s_{B-1}] \\ \text{tgt\_idx} &\in \mathbb{Z}^M, \quad \text{tgt\_idx} = [t_0, t_1, ..., t_{B-1}] \end{aligned} batch_idxsrc_idxtgt_idx∈ZM,batch_idx=[M0
0,...,0,M1
1,...,1,...,MB−1
B−1,...,B−1]∈ZM,src_idx=[s0,s1,...,sB−1]∈ZM,tgt_idx=[t0,t1,...,tB−1]
4. 性能考虑
- 时间复杂度： O ( M ) O(M) O(M)，其中 M M M 是总匹配数
- 空间复杂度： O ( M ) O(M) O(M)
- 优化：使用
torch.cat一次性拼接，避免循环中的多次张量操作
5. 常见使用模式
# 模式 1: 提取匹配的预测
idx = self._get_src_permutation_idx(indices)
matched_predictions = predictions[idx]
# 模式 2: 提取匹配的目标
idx = self._get_tgt_permutation_idx(indices)
matched_targets = targets[idx]
# 模式 3: 同时使用两个索引
src_idx = self._get_src_permutation_idx(indices)
tgt_idx = self._get_tgt_permutation_idx(indices)
pred_boxes = outputs['pred_boxes'][src_idx]
target_boxes = torch.cat([t['boxes'] for t in targets])[tgt_idx]
loss = F.l1_loss(pred_boxes, target_boxes)
调试技巧
验证索引正确性
def verify_indices(indices, batch_size):
"""验证索引的正确性"""
src_idx = _get_src_permutation_idx(indices)
tgt_idx = _get_tgt_permutation_idx(indices)
# 检查长度一致
assert len(src_idx[0]) == len(tgt_idx[0])
# 检查批次索引范围
assert src_idx[0].max() < batch_size
assert tgt_idx[0].max() < batch_size
# 检查总匹配数
total_matches = sum(len(src) for src, _ in indices)
assert len(src_idx[0]) == total_matches
print(f"✓ 索引验证通过: {total_matches} 个匹配")
可视化匹配结果
def visualize_matching(indices, batch_idx=0):
"""可视化某个批次的匹配"""
src, tgt = indices[batch_idx]
print(f"批次 {batch_idx} 的匹配:")
for s, t in zip(src, tgt):
print(f" 预测 Query[{s}] ← 匹配 → 目标 Target[{t}]")
扩展阅读
- 匈牙利算法：理解为什么需要这种匹配方式
- DETR 论文：End-to-End Object Detection with Transformers
- Set Prediction：集合预测问题的一般性解决方案
- 二分图匹配：图论中的经典问题
两个函数的对比
| 特性 | _get_src_permutation_idx |
_get_tgt_permutation_idx |
|---|---|---|
| 提取对象 | 预测（predictions） | 目标（targets） |
| 索引来源 | indices[i][0] (src) |
indices[i][1] (tgt) |
| 应用场景 | 从预测张量中提取匹配项 | 从目标张量中提取匹配项 |
| 输出形状 | (batch_idx, src_idx) |
(batch_idx, tgt_idx) |
| 典型用法 | pred[batch_idx, src_idx] |
tgt_tensor[batch_idx, tgt_idx] |
| 返回长度 | 总匹配数 M M M | 总匹配数 M M M |
常见问题 FAQ
Q1: 为什么要用 torch.full_like 而不是直接创建张量？
A: torch.full_like(src, i) 确保创建的张量与 src 具有相同的：
- 形状（长度）
- 数据类型（dtype）
- 设备（device: CPU/GPU）
这样可以避免设备不匹配的错误。
Q2: 这两个函数的输出长度总是相同吗？
A: 是的。因为它们都是基于相同的 indices，每个匹配对应一个预测和一个目标，所以输出长度总是相等的，都等于总匹配数 M = ∑ i = 0 B − 1 M i M = \sum_{i=0}^{B-1} M_i M=∑i=0B−1Mi。
Q3: 如果某个批次没有目标怎么办？
A: 如果 targets[i] 为空（没有目标），则 indices[i] 也会是空元组 (tensor([]), tensor([]))，不会对最终结果产生影响。
Q4: 能否直接使用列表推导式而不用这两个函数？
A: 可以，但会更复杂且容易出错。这两个函数封装了常用的索引转换逻辑，提高了代码的可读性和可维护性。
# 不使用辅助函数（不推荐）
matched_preds = []
for i, (src, _) in enumerate(indices):
matched_preds.append(outputs['pred_logits'][i, src])
matched_preds = torch.cat(matched_preds)
# 使用辅助函数（推荐）
idx = self._get_src_permutation_idx(indices)
matched_preds = outputs['pred_logits'][idx]
性能分析
时间复杂度
torch.full_like: O ( M i ) O(M_i) O(Mi) 对于第 i i i 个批次torch.cat: O ( M ) O(M) O(M) 其中 M = ∑ M i M = \sum M_i M=∑Mi- 总体: O ( M ) O(M) O(M)，线性时间复杂度
空间复杂度
- 临时列表: O ( B ) O(B) O(B) 个张量
- 输出张量: O ( M ) O(M) O(M)
- 总体: O ( M ) O(M) O(M)
优化建议
对于非常大的批次，可以考虑预分配内存：
def _get_src_permutation_idx_optimized(self, indices):
# 预计算总长度
total_len = sum(len(src) for src, _ in indices)
# 预分配内存
batch_idx = torch.empty(total_len, dtype=torch.int64)
src_idx = torch.empty(total_len, dtype=torch.int64)
# 填充数据
offset = 0
for i, (src, _) in enumerate(indices):
length = len(src)
batch_idx[offset:offset+length] = i
src_idx[offset:offset+length] = src
offset += length
return batch_idx, src_idx
可视化图表
文档中包含了两个交互式 Mermaid 图表：
- DETR 索引排列函数工作流程：展示了从匈牙利匹配结果到最终索引对的完整流程
- 索引转换具体示例：使用具体数值展示了 batch_size=3 时的转换过程
这些图表可以帮助更直观地理解函数的工作原理。
参考代码位置
- 函数定义：
models/detr.py第 273-312 行 - 使用示例：
loss_labels: 第 127-155 行loss_boxes: 第 181-208 行loss_masks: 第 210-245 行
相关资源
- DETR 论文: End-to-End Object Detection with Transformers
- 匈牙利算法: 二分图最大匹配算法
- PyTorch 高级索引: 理解张量索引机制
交互式演示
本文档提供了一个交互式演示脚本，可以直观地展示这两个函数的工作原理：
# 运行演示脚本
python3 models/demo_permutation_idx.py
演示脚本包含三个示例：
- 基础用法：展示函数的基本输入输出
- 张量索引应用：展示如何使用索引提取张量元素
- 处理空批次：展示如何处理没有目标的图像
演示输出包括：
- 详细的输入输出数据
- 匹配对应关系表格
- 张量形状变化说明
附录C: matcher.py【匈牙利匹配器】
https://github.com/facebookresearch/detr
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
"""
计算匹配成本并求解相应的线性分配问题（LSAP）的模块。
使用匈牙利算法进行预测和目标之间的二分图匹配。
"""
import torch # PyTorch核心库
from scipy.optimize import linear_sum_assignment # 线性和分配算法（匈牙利算法）
from torch import nn # 神经网络模块
from util.box_ops import box_cxcywh_to_xyxy, generalized_box_iou # 边界框操作：格式转换和GIoU计算
class HungarianMatcher(nn.Module):
"""匈牙利匹配器
该类计算网络预测和目标之间的分配关系。
出于效率考虑，目标不包括no_object类。因此，通常预测数量多于目标数量。
在这种情况下，我们对最佳预测进行1对1匹配，而其他预测保持未匹配状态（因此被视为非目标）。
使用匈牙利算法（也称为Kuhn-Munkres算法）求解最优分配问题。
"""
def __init__(self, cost_class: float = 1, cost_bbox: float = 1, cost_giou: float = 1):
"""创建匹配器
参数:
cost_class: 分类误差在匹配成本中的相对权重
cost_bbox: 边界框坐标L1误差在匹配成本中的相对权重
cost_giou: 边界框GIoU损失在匹配成本中的相对权重
"""
super().__init__()
self.cost_class = cost_class # 分类成本权重
self.cost_bbox = cost_bbox # 边界框L1成本权重
self.cost_giou = cost_giou # GIoU成本权重
assert cost_class != 0 or cost_bbox != 0 or cost_giou != 0, "all costs cant be 0" # 确保至少有一个成本权重非零
@torch.no_grad() # 不计算梯度，因为匹配过程不需要反向传播
def forward(self, outputs, targets):
"""执行匹配操作
参数:
outputs: 包含至少以下条目的字典:
"pred_logits": 维度为[batch_size, num_queries, num_classes]的分类logits张量
"pred_boxes": 维度为[batch_size, num_queries, 4]的预测边界框坐标张量
targets: 目标列表(len(targets) = batch_size)，每个目标是包含以下内容的字典:
"labels": 维度为[num_target_boxes]的类别标签张量
(num_target_boxes是目标中真实目标的数量)
"boxes": 维度为[num_target_boxes, 4]的目标边界框坐标张量
返回:
大小为batch_size的列表，包含(index_i, index_j)元组，其中:
- index_i是选中的预测的索引（按顺序）
- index_j是对应的选中目标的索引（按顺序）
对于每个批次元素，满足:
len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
"""
bs, num_queries = outputs["pred_logits"].shape[:2] # 获取批次大小和查询数量 bs = 2, num_queries = 100
# We flatten to compute the cost matrices in a batch
out_prob = outputs["pred_logits"].flatten(0, 1).softmax(-1) # 展平并应用softmax，形状为[batch_size * num_queries, num_classes] torch.Size([200, 92])
out_bbox = outputs["pred_boxes"].flatten(0, 1) # 展平预测框，形状为[batch_size * num_queries, 4] torch.Size([200, 4])
# Also concat the target labels and boxes
tgt_ids = torch.cat([v["labels"] for v in targets]) # 连接所有批次的目标类别标签 torch.Size([13+12])
tgt_bbox = torch.cat([v["boxes"] for v in targets]) # 连接所有批次的目标边界框 torch.Size([13+12, 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.
# 计算分类成本。与损失不同，我们不使用负对数似然，而是用1 - proba[目标类别]来近似
# 常数1不会改变匹配结果，可以省略
# 这里 out_prob 的形状是 [batch_size * num_queries, num_classes]，tgt_ids 的形状是 [num_targets]
# 使用 out_prob[:, tgt_ids]：列维度 tgt_ids：用 GT 的类别 ID 当作列索引，从列中“抽取出这些类别对应的概率”。每个图片从92个概率中选出每一个目标（25个）类别所对应的概率值，tgt_ids就是索引值
# 相当于对每个预测(query)，取出所有目标类别 ID 对应的概率，得到一个 [batch_size * num_queries, num_targets] 的矩阵，其中第 i 行第 j 列是: 第 i 个预测属于第 j 个目标类别的概率 proba_{i,j}。
# 为了将“概率越大越好”转成“代价越小越好”，这里取负号：cost_class = -proba_{i,j}，
# 这样在后续匈牙利算法中，较高的类别匹配概率会对应更小的代价值，从而更倾向于被匹配。
cost_class = -out_prob[:, tgt_ids] # 分类成本矩阵：取目标类别概率并取负， 形状为 [batch_size * num_queries, num_targets] torch.Size([100, 92]) -> torch.Size([100, 13])
# 计算边界框之间的L1距离（曼哈顿距离）【Compute the L1 cost between boxes】
cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1) # 形状为[batch_size * num_queries, num_targets]
# 计算GIoU成本（负的GIoU值）【Compute the giou cost betwen boxes】
cost_giou = -generalized_box_iou(box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)) # 形状为[batch_size * num_queries, num_targets]
# 加权组合三种成本，得到最终成本矩阵【Final cost matrix】
C = self.cost_bbox * cost_bbox + self.cost_class * cost_class + self.cost_giou * cost_giou # 形状为 torch.Size([200, 25])
C = C.view(bs, num_queries, -1).cpu() # 重塑为[batch_size, num_queries, num_targets]并移到CPU 形状为 torch.Size([2, 100, 25])
sizes = [len(v["boxes"]) for v in targets] # 获取每个批次样本的目标数量 [13, 12]
C_list = C.split(sizes, -1) # [torch.Size([2, 100, 13]), torch.Size([2, 100, 12])]
indices = [linear_sum_assignment(c[i]) for i, c in enumerate(C_list)] # 对每个批次样本使用匈牙利算法在该图的代价矩阵上求解最优匹配
# indices 是一个长度为 batch_size 的列表，indices[k] 对应第 k 张图上的匹配结果
# 其中 indices[k] 是一个 (row_ind, col_ind) 元组：
# - row_ind：被选中的预测框索引（在该图的 num_queries 个预测中的索引，如 0~99），对应 C[k] 的行索引
# - col_ind：与之匹配的 GT 目标索引（在该图 targets[k]["boxes"] / targets[k]["labels"] 中的索引，如 0~(num_targets_k-1)），对应 C[k] 的列索引
# 例如：
# indices[0] = (array([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88]),
# array([ 2, 11, 8, 6, 12, 0, 4, 3, 9, 7, 1, 10, 5]))
# 表示：在第 0 张图中，query 索引 15 匹配第 0 张图的第 2 个 GT，query 索引 17 匹配第 11 个 GT，……，长度为 13，等于该图的 GT 数量
# indices[1] = (array([ 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79]),
# array([ 1, 10, 7, 2, 11, 5, 3, 0, 6, 9, 4, 8]))
# 表示：在第 1 张图中，query 索引 3 匹配第 1 张图的第 1 个 GT，query 索引 12 匹配第 10 个 GT，……，长度为 12，等于该图的 GT 数量
result = [(torch.as_tensor(i, dtype=torch.int64), torch.as_tensor(j, dtype=torch.int64)) for i, j in indices] # 将每张图的 (query索引, GT索引) 匹配结果转换为张量并返回
# result:
# [
# (tensor([15, 17, 18, 23, 29, 41, 50, 53, 55, 58, 61, 66, 88]), tensor([ 2, 11, 8, 6, 12, 0, 4, 3, 9, 7, 1, 10, 5])),
# (tensor([ 3, 12, 14, 26, 31, 36, 54, 56, 60, 62, 75, 79]), tensor([ 1, 10, 7, 2, 11, 5, 3, 0, 6, 9, 4, 8]))
# ]
return result
def build_matcher(args):
"""构建匈牙利匹配器
参数:
args: 包含匹配器配置的参数对象，需要包含：
- set_cost_class: 分类成本权重
- set_cost_bbox: 边界框L1成本权重
- set_cost_giou: GIoU成本权重
返回:
HungarianMatcher实例
"""
return HungarianMatcher(cost_class=args.set_cost_class, cost_bbox=args.set_cost_bbox, cost_giou=args.set_cost_giou) # 创建并返回匹配器实例
DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐
28
0- 0
已为社区贡献94条内容
所有评论(0)