DETR：端到端目标检测Transformer

可视化演示

演示DETR端到端目标检测Transformer的核心机制：编码器-解码器架构、二分图匹配、目标查询和与传统检测器对比，通过交互式动画展示DETR的创新设计。

1. 传统检测的“贴纸困境”

旧厨房里，服务生为了不放过任何一道菜，会在餐桌上铺满密密麻麻的贴纸。每张贴纸就是一个“锚框”（Anchor Box），它有自己的位置、宽高和比例。问题是：贴纸铺多少、铺多大、怎么铺，全凭大厨的经验——这正是传统检测器最令人头疼的地方。

在 CNN 目标检测里，Anchor 是预先定义好的一组候选框，密集地铺在特征图的每个位置上。以 Faster R-CNN 为例，一张输入图片经过骨干网络后，特征图只有几十乘几十的分辨率，但每个位置要铺多个不同尺寸比例的锚框，候选框数量轻松达到数万个，其中绝大多数都是背景。

$$\displaystyle N_{\text{anchor}} = H \times W \times A$$

1. H（特征图高度）：餐桌横排格子的数量，对应特征图的高这一维度。

$$H$$

2. W（特征图宽度）：餐桌竖排格子的数量，对应特征图的宽这一维度。

$$W$$

3. A（每格贴纸数）：每个格子铺几张贴纸，通常取 3 到 9 个不同尺寸比例。

$$A$$

4. 相乘（总贴纸数）：三者相乘就得到需要逐一判断“有没有物体”的候选框总量。

$$H \times W \times A$$

锚框铺完，还要面对“正负样本不均”：成千上万个锚框里只有几十个真正框住物体，其余全是负样本，训练时必须精心设计采样策略。更麻烦的是，同一个物体常被多个锚框同时命中，于是需要 NMS 按得分排序、反复抑制重复框。这一整套手工设计（锚框尺寸、比例、IoU 阈值、NMS 阈值）又脆又繁——换一个数据集，往往就要从头再调一遍。

贴纸困境的根源，是“先在局部乱猜、再全局收拾残局”的两段式思路。DETR 要做的，就是请一位不一样的厨师，用全新的配菜逻辑一次性解决问题。

2. Transformer 大厨的“全局视野”

要摆脱贴纸困境，先得有一位能“一眼看全桌”的大厨。普通的 CNN 大厨只能看到自己拳头大小的一块区域（局部感受野），想看全桌得一层层叠高、不断“垫脚”。Transformer 的自注意力机制则不同，它像大厨的目光在整张餐桌上来回扫视，任何两道菜之间都能直接建立联系。

自注意力是 Transformer 的灵魂。特征序列中的每个位置都生成三个向量：查询（Query）、键（Key）、值（Value）。查询与所有键做相似度打分，打分越高的位置，其值在加权求和时占的比重越大。一句话：让每个位置都能“盯着全场说话”。

$$\displaystyle \mathrm{Attention}(Q,K,V) = \mathrm{softmax}\left(\frac{QK^\top}{\sqrt{d_k}}\right)V$$

1. Q（查询向量）：大厨的目光，代表“我在找什么”。

$$Q$$

2. K（键向量）：每道菜的标签，代表“我是什么”。

$$K$$

3. QK^T（相似度打分）：目光与全场标签逐一比对，得到匹配分数。

$$QK^\top$$

4. 1/√d_k（缩放因子）：防止点积数值过大导致 softmax 进入饱和区、梯度消失。

$$\frac{1}{\sqrt{d_k}}$$

5. softmax（归一化为权重）：把分数变成一组加起来等于 1 的“注意力权重”。

$$\mathrm{softmax}(\cdot)$$

6. ×V（加权求和）：按权重汇总全场的值向量，得到融合全局信息的输出。

$$V$$

自注意力的计算复杂度是 O(n²)，n 是序列长度。在 DETR 里，图像被展平成几千个特征块，两两之间都要计算关系，这正是“全局推理”的来源——远处的两个物体能不能同时出现、有没有遮挡，大厨一目了然。代价是计算量大，但这换来了端到端建模的能力。

有了全局视野的大厨，DETR 终于可以放心地撤掉桌面上所有贴纸。接下来，我们看看这套新厨房的完整流水线。

3. 新厨房流水线：DETR 整体架构

新厨房的流水线分四段：备菜、摆上传送带、大厨烹饪、装盘出菜。备菜师傅是 CNN 骨干网络（如 ResNet），把原始图像加工成特征图；接着特征图被“展平”成一长条序列，并贴上座位号（位置编码）；然后送进 Transformer 编码器，让大厨反复全局扫视；最后解码器结合“空盘子”逐盘确认装什么菜、摆在哪里。

形式化地，输入图像 x 先经过 CNN 得到特征图，展平后加上位置编码，成为编码器的输入序列。位置编码至关重要——如果没有座位号，展平后的特征块就分不清“原来在图像的哪个位置”，全局视野就变成了“脸盲”。

$$\displaystyle z_0 = \mathrm{Flatten}(\mathrm{CNN}(x)) + \mathrm{PE}$$

1. CNN(x)（特征提取）：备菜师傅把原始图像切成长宽缩小、通道变深的特征图。

$$\mathrm{CNN}(x)$$

2. Flatten（序列化展平）：把二维特征图拉直，变成一长串“食材块”序列。

$$\mathrm{Flatten}(\cdot)$$

3. PE（位置编码）：给每个食材块贴上“原来在哪”的座位号，保留空间信息。

$$\mathrm{PE}$$

4. z₀（编码器输入）：特征与座位号相加后的结果，是编码器读到的第一行“菜谱”。

$$z_0$$

编码器由多层 Transformer Encoder 堆叠而成，每层都做自注意力。解码器则不同：它不只读特征序列，还要读一组“目标查询”（Object Queries）。DETR 的预测头很简单——每个查询对应一个类别 logits 和一个 4 维边框（中心 x、中心 y、宽、高），直接输出即可。

流水线从原始图像到最终预测，一气呵成、没有任何中间后处理模块。这正是“端到端”的字面含义：输入像素、输出预测，中间所有环节联合训练、可微传播。

4. 100 个“空盘子”：目标查询机制

新厨房里最显眼的，是备餐台上那 100 个一模一样的空盘子，这就是“目标查询”。它们不是普通盘子，而是 100 个可学习的向量嵌入，从训练开始到结束都在不断“进化”，逐渐学会“我负责找哪种类型的菜”。

与传统的滑窗或锚框不同，目标查询不需要分布在具体位置上——它分布在“语义空间”里。解码器每一层都会让这些查询去“读取”编码器的特征，每个查询最终输出一个预测。由于查询是固定数量的（默认 100），DETR 最多检测 100 个物体，这对绝大多数场景绰绰有余。

$$\displaystyle O = \mathrm{Decoder}(Q_{\text{query}},\; z_0)$$

1. Q_query（目标查询矩阵）：100 个可学习的空盘子，它们不是固定位置，而是可进化的语义向量。

$$Q_{\text{query}}$$

2. z₀（编码器记忆）：编码器输出的全局特征“菜谱”，包含整张图的上下文信息。

$$z_0$$

3. Decoder（解码器）：大厨对照菜谱给每个盘子配菜的过程，通常堆叠 6 层。

$$\mathrm{Decoder}(\cdot)$$

4. O（解码输出）：装好盘的 100 份预测，每份可拆成类别 logits 和边框坐标。

$$O$$

并行解码是 DETR 的另一特点：100 个查询同时被解码，不需要像 NLP 那样一个一个“吐词”。但并行解码有个隐患——如果不加约束，多个查询可能抢同一道菜。DETR 的解决办法，就是下一节的主角：二分图匹配。

空盘子不是万能的，但配合匹配机制后，它们成了绝妙的“席位预约系统”：座位固定、数量固定、每座一客，从根源上消灭了重复预订。

5. 上菜的艺术：二分图匹配

有了 100 个盘子和若干道真实菜品，怎么决定“哪个盘子端哪道菜”？DETR 的做法是：把这个问题当成一场“最佳配对”——每道菜最多进一个盘子，每个盘子最多端一道菜，让总体的“默契分”最高。这就是二分图匹配，用匈牙利算法求解。

训练时，DETR 把预测的 100 份结果和真实的物体集合（通常不到 100 个）组成一个二分图：左边是预测，右边是真值（外加若干“空位”）。每一条边都有一个成本——分类不匹配的代价加上边框不重合的代价。匈牙利算法一次性求出全局最优的配对方案，保证每个真值只被一个查询负责。

$$\displaystyle \hat{\sigma} = \arg\min_{\sigma \in \mathfrak{S}_N} \sum_{i=1}^{N} \mathcal{L}_{\text{match}}(y_i,\; \hat{y}_{\sigma(i)})$$

1. N（预测数量）：预测总数等于目标查询数，DETR 默认取 100。

$$N = 100$$

2. σ（一个配对方案）：一种把预测和真值对应起来的排列，回答“哪个盘子端哪道菜”。

$$\sigma$$

3. S_N（所有排列的集合）：全部可能的配对方案，共 N! 种。

$$\mathfrak{S}_N$$

4. L_match（匹配成本）：单个配对“不默契”的代价，由分类错误和边框偏差共同构成。

$$\mathcal{L}_{\text{match}}(y_i,\; \hat{y}_{\sigma(i)})$$

5. argmin（选最优）：在所有方案中挑出总成本最低的那个，记为 σ̂。

$$\arg\min_{\sigma}$$

匹配完成后，才计算真正的检测损失。匹配损失只用于“找人”，而最终的训练损失是对齐后每一对的分类损失加边框损失（L1 + GIoU）之和。更重要的是：因为匹配是“一对一”的，预测天然没有重复框——测试时直接用匹配好的查询输出即可，NMS 被彻底请出厨房。

二分图匹配的精髓是“全局最优的一对一分配”。它把“去重”从后处理变成了训练目标的一部分，这正是 DETR 敢宣称端到端的底气。

6. 与大厨 Faster R-CNN 过招

老牌大厨 Faster R-CNN 功勋卓著，但它的厨房里摆满了各类“秘制道具”：锚框生成器、RPN 区域建议网络、RoI 池化、NMS 去重……每一步都是独立调参的模块，误差会层层累积。DETR 把它们全部精简为“一张编码器-解码器的桌子 + 100 个空盘子”。

从数量上看差距震撼：传统检测器的候选锚框动辄数万甚至十万个，而 DETR 的候选“盘子”只有 100 个。

$$\displaystyle N_{\text{query}} = 100 \ll N_{\text{anchor}} \approx 10^5$$

1. N_query（查询数量）：DETR 的候选盘子数，默认固定为 100。

$$N_{\text{query}} = 100$$

2. N_anchor（锚框数量）：传统检测器的贴纸数，高分辨率输入下可达十万数量级。

$$N_{\text{anchor}} \approx 10^5$$

3. ≪（远小于）：表示两者相差约三个数量级，也暗示设计哲学的差异。

$$\ll$$

但 DETR 并非完美。它的老毛病有三：其一，小目标检测弱——特征图分辨率有限，小物体信息在多次下采样后难以保留；其二，收敛特别慢——需要约 500 个 epoch 才能媲美 Faster R-CNN，而后者通常十几个 epoch 就初见成效；其三，计算量大，自注意力的二次复杂度在高分辨率输入上非常昂贵。

好在后续改进者层出不穷：Deformable DETR 用可变形注意力聚焦稀疏的关键点、引入多尺度特征，把小目标短板补上大半，同时把收敛提速约 10 倍。这说明：DETR 的“端到端”范式是对的，工程上的短板正在被逐一攻克。

7. 端到端：一个范式的诞生

把 DETR 的所有零件拼起来，你会看到一幅简洁的图画：输入图像 x，直接输出预测 y，中间的 CNN、Transformer、匹配机制全部作为一个整体进行训练。没有任何手工后处理，没有不可微的模块——这就是端到端。

$$\displaystyle y = f_{\theta}(x), \qquad \theta^{\ast} = \arg\min_{\theta} \mathcal{L}(y,\; y_{\text{gt}})$$

1. x（输入图像）：原始像素，不经过任何手工特征工程。

$$x$$

2. f_θ（整体网络）：CNN 骨干 + Transformer 编码器/解码器 + 预测头，全部参数由 θ 表示。

$$f_{\theta}$$

3. y（输出预测）：一组“类别 + 边框”的集合，直接可用。

$$y$$

4. θ*（最优参数）：通过最小化损失函数学习到的最终参数。

$$\theta^{\ast} = \arg\min_{\theta} \mathcal{L}$$

端到端带来的红利是多维的：去掉了锚框和 NMS，新类别扩展不再需要重新设计锚框比例；全局匹配让模型自动学会“一个物体只有一个预测”；统一的可微流程让研究者可以像搭积木一样替换组件（换骨干、换解码器、换匹配成本），而不用推翻整个系统。

从工程角度，DETR 把检测任务从“分类+回归+后处理”三段式，压缩成了“一个模型、一个损失、一次前向”。这大幅降低了部署和调参成本——以前调 NMS 阈值、锚框比例的经验活，现在都变成了数据驱动。

回看整篇文章的比喻：旧厨房满桌贴纸、人工撕重复；新厨房 100 个空盘子、大厨全局扫视、一次配菜到位。DETR 告诉我们的不只是“换了个模型”，而是：当你能把任务定义成“一一对应”的匹配问题时，很多繁琐的中间环节都可以直接消失。

AI 应用场景

Python 演示

import numpy as npimport torchimport torch.nn as nn  def simple_position(h, w, device):    """极简位置编码: 把特征块序号归一化, 广播到所有通道"""    pos = torch.arange(h * w, device=device).float() / (h * w)    return pos.unsqueeze(0).unsqueeze(-1)  class MiniBackbone(nn.Module):    """迷你CNN骨干: 把224x224x3图像变成14x14x256特征图"""    def __init__(self, in_ch=3, feat=256):        super().__init__()        self.net = nn.Sequential(            nn.Conv2d(in_ch, 64, 3, 2, 1), nn.ReLU(),            nn.Conv2d(64, 128, 3, 2, 1), nn.ReLU(),            nn.Conv2d(128, feat, 3, 2, 1), nn.ReLU(),            nn.Conv2d(feat, feat, 3, 2, 1), nn.ReLU(),        )        self.proj = nn.Conv2d(feat, feat, 1)     def forward(self, x):        return self.proj(self.net(x))  class MiniDETR(nn.Module):    """迷你DETR: CNN骨干 + 编码器 + 解码器 + 预测头"""    def __init__(self, num_queries=100, num_classes=80, feat=256):        super().__init__()        self.backbone = MiniBackbone(feat=feat)        enc_layer = nn.TransformerEncoderLayer(feat, 8, batch_first=True)        self.encoder = nn.TransformerEncoder(enc_layer, num_layers=6)        dec_layer = nn.TransformerDecoderLayer(feat, 8, batch_first=True)        self.decoder = nn.TransformerDecoder(dec_layer, num_layers=6)        self.queries = nn.Parameter(torch.randn(num_queries, feat))        self.class_head = nn.Linear(feat, num_classes + 1)        self.box_head = nn.Linear(feat, 4)     def forward(self, x):        f = self.backbone(x)                  # (B,256,14,14) 备菜        b, _, h, w = f.shape        z = f.flatten(2).transpose(1, 2)      # (B,196,256) 展平传送带        pos = simple_position(h, w, x.device)        mem = self.encoder(z + pos)           # 编码器全局扫视        q = self.queries.unsqueeze(0).repeat(b, 1, 1)        out = self.decoder(q, mem)            # (B,100,256) 并行装盘        logits = self.class_head(out)         # (B,100,C+1)        boxes = self.box_head(out).sigmoid()  # (B,100,4)        return logits, boxes  def hungarian_match(pred_logits, pred_boxes, gt_boxes, gt_labels):    """二分图匹配: 为每个真值框找一个最优查询"""    n_pred = pred_logits.shape[0]    n_gt = gt_boxes.shape[0]    cost = np.zeros((n_pred, n_gt))    for i in range(n_pred):        for j in range(n_gt):            cls_cost = -np.log(pred_logits[i, gt_labels[j]] + 1e-8)            box_cost = np.abs(pred_boxes[i] - gt_boxes[j]).sum()            cost[i, j] = cls_cost + box_cost    try:        from scipy.optimize import linear_sum_assignment        row, col = linear_sum_assignment(cost)        return list(zip(row, col))    except ImportError:        matches, used = [], set()        for _ in range(n_gt):            i, j = min(                ((i, j) for i in range(n_pred) for j in range(n_gt)                 if i not in [m[0] for m in matches] and j not in used),                key=lambda ij: cost[ij[0], ij[1]])            matches.append((i, j))            used.add(j)        return matches  def main():    torch.manual_seed(0)    model = MiniDETR(num_queries=10, num_classes=3)    images = torch.randn(2, 3, 224, 224)    logits, boxes = model(images)    print("输出形状:", tuple(logits.shape), tuple(boxes.shape))     pred_logits = torch.softmax(logits[0], dim=-1).detach().numpy()    pred_boxes = boxes[0].detach().numpy()    gt_boxes = np.array([[0.10, 0.20, 0.30, 0.40], [0.55, 0.45, 0.20, 0.30]])    gt_labels = np.array([1, 2])    matches = hungarian_match(pred_logits, pred_boxes, gt_boxes, gt_labels)    print("二分图匹配结果(查询索引, 真值索引):", matches)  if __name__ == "__main__":    main()

1. f = self.backbone(x)CNN 备菜师傅把原始图像切成特征图。
2. z = f.flatten(2).transpose(1, 2)把特征图展平成一长条“食材传送带”，形状变成 (196, 256)。
3. pos = simple_position(h, w, x.device)给每块食材贴座位号，也就是位置编码。
4. mem = self.encoder(z + pos)编码器让大厨在整张图上反复全局扫视。
5. q = self.queries.unsqueeze(0).repeat(b, 1, 1)端出固定数量的空盘子（目标查询）。
6. out = self.decoder(q, mem)解码器并行装盘：每个盘子同时读取全局特征。
7. logits = self.class_head(out)判断每道菜的类别，输出 C+1 个类别分数。
8. boxes = self.box_head(out).sigmoid()输出每道菜的摆盘位置，归一化到 0~1。
9. cost[i, j] = cls_cost + box_cost计算“菜-盘子”配对的联合成本。
10. row, col = linear_sum_assignment(cost)匈牙利算法求出全局最优的一对一匹配。

常见误区

面试题