StreamPETR Exploring Object-Centric Temporal Modeling for Efficient Multi-View 3D Object Detection

Task: Multi-View 3D Object Detection with Temporal Modeling
Method: Object-Centric Temporal Modeling, Memory Queue, Motion-Aware Layer Normalization
Venue: ICCV
Year: 2023
Paper: https://arxiv.org/abs/2303.11926
Code: https://github.com/exiawsh/StreamPETR

摘要

本文提出了 StreamPETR，一个用于多视图 3D 物体检测的长序列建模框架。该方法基于 PETR 系列的稀疏查询设计，系统性地开发了以物体为中心的时间机制（object-centric temporal modeling）。与现有基于 BEV 或透视图的时序融合方法不同，StreamPETR 使用稀疏物体查询作为时序传播的隐状态，以在线方式运行，通过物体查询逐帧传播长期历史信息。此外，该方法引入了运动感知层归一化（Motion-Aware Layer Normalization, MLN）来显式建模物体的运动，解耦自车运动与周围物体运动的影响。在仅增加可忽略计算成本的前提下，StreamPETR 实现了显著的性能提升。在 nuScenes 基准上，该方法成为首个达到与激光雷达方法相当性能的在线多视图方法。

核心论点：多视图 3D 检测的时序建模应从”特征级融合”转向”物体级传播”——StreamPETR 通过将历史物体查询作为隐状态递归传播，实现了高效的长序列建模，同时通过运动感知层归一化解耦自车与物体运动，在几乎不增加计算成本的情况下达到激光雷达级别的性能。

问题与动机

多视图 3D 目标检测的时序建模旨在利用多帧信息提升检测性能，尤其对于运动物体和被遮挡物体。现有时序融合方案可分为三类：

BEV 时序融合（代表作：BEVDet4D、BEVFormer）：受 BEV 高度结构化限制，需要很大感受野建模运动目标；仅考虑静态 BEV 特征，忽视物体运动
透视图时序融合（代表作：PETRv2）：基于 DETR，将稀疏查询与多视图多帧图像交互，计算代价高；需进行多帧重复的特征聚合
查询融合（代表作：Sparse4D）：查询交互复杂，时序传播机制不够系统化

现有方法存在两个核心痛点：

特征级融合的局限性：BEV 方法仅考虑静态特征，无法有效建模运动物体；透视图方法需要多帧重复特征聚合，计算开销大
运动建模不足：现有方法未显式解耦自车运动与周围物体运动，导致时序对齐误差

核心痛点：如何在不显著增加计算成本的前提下，实现高效的长序列时序建模，并准确建模物体运动？

核心洞察

洞察 1：以物体为中心的时序传播比特征级融合更高效

传统做法是在 BEV 空间或透视图空间进行特征级融合（feature-level fusion），需要对多帧特征进行对齐和聚合。本文提出使用物体查询作为时序传播的隐状态，直接在物体级别进行信息传递。

设透视图特征为 $F_{2d}=\{F_{2d}^0,\cdots,F_{2d}^t\}$ ，BEV 特征为 $F_{bev}=\{F_{bev}^0,\cdots,F_{bev}^t\}$ ，稀疏物体查询为 $F_{obj}=\{F_{obj}^0,\cdots,F_{obj}^t\}$ ，三种时序建模范式可表示为：

BEV 时序融合：$\tilde{F}_{bev}^t=\phi(F_{bev}^{t-1}, F_{bev}^t)$ — 仅考虑静态 BEV 特征
透视图时序融合：$\tilde{F}_{obj}^t=\sum\phi(F_{2d}^{t-k}, F_{obj}^t)$ — 多帧重复特征聚合，计算代价高
以物体为中心：$\tilde{F}_{obj}^t=\phi(\tilde{F}_{obj}^{t-1}, F_{obj}^t)$ — 高效，StreamPETR 采用

以物体为中心的方法仅需在当前帧物体查询和历史物体查询之间进行交互，避免了多帧特征的重复杂询和聚合。

洞察 2：物体查询是图像特征的”有损压缩”，天然适合做时序载体

传统方法受限于滑动窗口机制，只能利用有限帧的历史信息，且存储完整的 BEV 或透视图特征代价高昂。本文的关键发现是：物体查询本身就是对多视图图像特征的低秩近似。

从矩阵分解的视角看（参考 Is Attention Better Than Matrix Decomposition），cross-attention 可视为将 $N_{img} \times C$ 的图像特征矩阵通过 $K \times C$ 的 query 矩阵做低秩分解——虽然只保存了 256 个 object query，但实际上保留了图像特征中绝大部分与检测相关的有效信息。这解释了为什么 object query 时序传播 + perspective 时序交互并不会进一步涨点（Table 8 最后一行）：两种方式传递的是同一份信息的不同表示。

基于这一认知，StreamPETR 设计了一个 $N \times K$ 的递归更新记忆队列（Memory Queue），默认 $N=4$ ，$K=256$ 。在预设的存储时间间隔 $\tau$ 后，选择前 $K$ 个分类分数最高的前景物体查询进行存储，包含以下信息：

相对时间间隔 $\Delta t$
上下文嵌入 $Q_c$
物体中心 $Q_p$
速度 $v$
自车姿态矩阵 $E$

由于物体查询已经是压缩表示，即使使用很小的队列（N=2，约 1 秒）性能就基本饱和——这正是”低秩近似”视角的直接预测。

洞察 3：用条件归一化隐式编码运动，比显式补偿更鲁棒

传统方法在进行时序对齐时，通常使用显式的运动补偿（如坐标变换），但这在训练早期容易导致错误传播——位置预测不准时，运动补偿反而引入更大的对齐误差。

MLN 的设计灵感来自 GAN 中的条件归一化（Conditional Normalization）。在生成模型领域，SPADE、AdaIN 等方法已广泛使用”将条件信息注入归一化层的仿射参数”这一技巧。StreamPETR 将同样的思路迁移到运动建模：**不直接对坐标做刚体变换，而是将运动信息（自车姿态、物体速度、时间间隔）编码为归一化层的 $\gamma$ 和 $\beta$ **，让网络自己学习如何利用这些运动线索。

MLN 的计算过程如下：

计算自车变换矩阵：$E_{t-1}^t = E_t^{-1}E_{t-1}$
静态物体对齐：$\tilde{Q}_p^{t-1} = E_{t-1}^t Q_p^{t-1}$
运动特征编码：$$\gamma = \xi_1(E_{t-1}^t, v, \Delta t)$$ $$\beta = \xi_2(E_{t-1}^t, v, \Delta t)$$
仿射变换得到运动感知嵌入：$$\tilde{Q}_{pe}^t = \gamma \cdot LN(\psi(\tilde{Q}_p^t)) + \beta$$ $$\tilde{Q}_c^t = \gamma \cdot LN(\tilde{Q}_c^t) + \beta$$

其中 $\psi$ 为位置编码 MLP；当前帧物体查询的 $v$ 与 $\Delta t$ 均设置为 0。通过隐式编码，MLN 能够更稳健地处理运动信息。

要记住的 3 个数字：

67.6% NDS：StreamPETR 在 nuScenes 测试集上的检测分数，首个达到与激光雷达方法相当的在线多视图方法
65.3% AMOTA：多目标跟踪精度，同样达到激光雷达级别性能
31.7 FPS：轻量版 StreamPETR 在 nuScenes val（R50，256x704）的推理速度（SOLOFusion：11.4 FPS）

方法设计

4.1 整体架构

StreamPETR 的核心流程可概括为：图像特征提取 → 物体查询初始化 → 记忆队列检索 → 传播 Transformer → 检测头输出。

   多视图图像 (6 视角)
           │
           ▼
  ┌─────────────────┐
  │   图像编码器      │  (ResNet-50/101, V2-99, ViT)
  │  Image Encoder  │
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐
  │  物体查询初始化   │  (900 queries)
  │  Query Init     │
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐     ┌───────────────────┐
  │   记忆队列       │◄────│  历史物体查询存储    │
  │  Memory Queue   │     │  (K objects/frame)│
  │  (N × K)        │     │  Δt, Qc, Qp, v, E │
  └────────┬────────┘     └───────────────────┘
           │
           ▼
  ┌─────────────────────────────────────────────────────────┐
  │              Propagation Transformer                    │
  │  ┌─────────────────┐  ┌─────────────────┐               │
  │  │ Motion-aware    │  │ Hybrid          │               │
  │  │ Layer Norm      │→ │ Attention       │               │
  │  │ (MLN)           │  │ (Q: current+prev│               │
  │  │                 │  │  K,V: memory)   │               │
  │  └─────────────────┘  └────────┬────────┘               │
  │                                │                        │
  │                       ┌────────▼────────┐               │
  │                       │ Cross Attention │               │
  │                       │ (特征聚合)       │               │
  │                       └────────┬────────┘               │
  └────────────────────────────────┼────────────────────────┘
                                   │
                                   ▼
                          ┌─────────────────┐
                          │   检测头         │
                          │ Detection Head  │
                          │ (分类 + 回归)    │
                          └────────┬────────┘
                                   │
                                   ▼
           3D 边界框输出 (x, y, z, w, l, h, yaw, velocity)

架构关键参数：

输入：6 视角图像，分辨率根据配置（如 256×704、512×1408 或 640×1600）
Backbone：ResNet-50 / ResNet-101 / V2-99 / ViT-Large
物体查询数量：900（标准版，其中 644 个随机初始化 + 256 个上一帧传播查询）/ 428（轻量版，其中 300 个随机初始化 + 128 个传播查询）
记忆队列容量：$N \times K$ ，默认 $N=4$ （帧数），$K=256$ （每帧物体数）
输出：3D 边界框（8 自由度：x, y, z, w, l, h, yaw, velocity）

4.2 关键组件

传播 Transformer（Propagation Transformer）

传播 Transformer 的数据流为 MLN → Hybrid Attention → Cross Attention，各组件的设计动机已在洞察 2-3 中详述。此处补充实现层面的关键细节：

组件	输入 Q / K,V	输出	计算量占比
MLN	当前帧查询 / N/A	运动感知嵌入 $\tilde{Q}_{pe}^t, \tilde{Q}_c^t$	可忽略
Hybrid Attention	当前帧查询 / 记忆队列 + 当前帧拼接（约 $2K$ tokens）	时序增强的物体查询	可忽略（远小于 cross-attn）
Cross Attention	物体查询 / 图像特征	融合图像信息的物体查询	主要计算量

损失函数：

StreamPETR 沿用 PETR 系列的损失函数，包括：

分类损失：Focal Loss
回归损失：L1 Loss + 3D IoU Loss

损失函数公式：

$$\mathcal{L} = \lambda_{cls}\mathcal{L}_{cls} + \lambda_{reg}\mathcal{L}_{reg} + \lambda_{iou}\mathcal{L}_{iou}$$

4.3 关键代码

代码来自官方仓库 projects/mmdet3d_plugin/models/：

文件	类/函数	功能
`utils/misc.py`	`MLN`	Motion-Aware Layer Normalization
`dense_heads/streampetr_head.py`	`StreamPETRHead.temporal_alignment`	时序对齐 + MLN 编码
`dense_heads/streampetr_head.py`	`StreamPETRHead.post_update_memory`	记忆队列 FIFO 更新

📄 点击展开 MLN (Motion-Aware Layer Normalization) 代码

（来源：misc.py）

class MLN(nn.Module):
    ''' Motion-Aware Layer Normalization
    Args:
        c_dim (int): dimension of motion attributes (经 NeRF PE 后的维度)
        f_dim (int): feature dimension
    '''
    def __init__(self, c_dim, f_dim=256):
        super().__init__()
        self.c_dim = c_dim
        self.f_dim = f_dim

        self.reduce = nn.Sequential(
            nn.Linear(c_dim, f_dim),
            nn.ReLU(),
        )
        self.gamma = nn.Linear(f_dim, f_dim)
        self.beta = nn.Linear(f_dim, f_dim)
        # 关键：关闭默认仿射变换，由运动属性控制
        self.ln = nn.LayerNorm(f_dim, elementwise_affine=False)
        self.reset_parameters()

    def reset_parameters(self):
        # 初始化为恒等变换：gamma=1, beta=0
        nn.init.zeros_(self.gamma.weight)
        nn.init.zeros_(self.beta.weight)
        nn.init.ones_(self.gamma.bias)
        nn.init.zeros_(self.beta.bias)

    def forward(self, x, c):
        x = self.ln(x)                    # 无仿射的 LayerNorm
        c = self.reduce(c)                # 运动属性降维
        gamma = self.gamma(c)             # 条件 scale
        beta = self.beta(c)               # 条件 shift
        out = gamma * x + beta            # 条件仿射变换
        return out

📄 点击展开 temporal_alignment 代码

（来源：streampetr_head.py）

def temporal_alignment(self, query_pos, tgt, reference_points):
    B = query_pos.size(0)

    # 历史 query 的 3D 中心归一化到 [0,1]
    temp_reference_point = (self.memory_reference_point - self.pc_range[:3]) / \
                           (self.pc_range[3:6] - self.pc_range[0:3])
    temp_pos = self.query_embedding(pos2posemb3d(temp_reference_point))
    temp_memory = self.memory_embedding

    rec_ego_pose = torch.eye(4, device=query_pos.device).unsqueeze(0) \
                   .unsqueeze(0).repeat(B, query_pos.size(1), 1, 1)

    if self.with_ego_pos:
        # 当前帧 queries：用单位自车运动编码（无历史运动）
        rec_ego_motion = torch.cat(
            [torch.zeros_like(reference_points[..., :3]),
             rec_ego_pose[..., :3, :].flatten(-2)], dim=-1)
        rec_ego_motion = nerf_positional_encoding(rec_ego_motion)
        # MLN 编码当前帧 query
        tgt = self.ego_pose_memory(tgt, rec_ego_motion)
        query_pos = self.ego_pose_pe(query_pos, rec_ego_motion)

        # 历史 queries：用实际运动属性编码（速度 + 时间 + 自车位姿）
        memory_ego_motion = torch.cat(
            [self.memory_velo, self.memory_timestamp,
             self.memory_egopose[..., :3, :].flatten(-2)], dim=-1).float()
        memory_ego_motion = nerf_positional_encoding(memory_ego_motion)
        # MLN 编码历史 queries
        temp_pos = self.ego_pose_pe(temp_pos, memory_ego_motion)
        temp_memory = self.ego_pose_memory(temp_memory, memory_ego_motion)

    # 时间编码：当前帧 Δt=0，历史帧为实际时间间隔
    query_pos += self.time_embedding(
        pos2posemb1d(torch.zeros_like(reference_points[..., :1])))
    temp_pos += self.time_embedding(
        pos2posemb1d(self.memory_timestamp).float())

    # 拼接传播 queries（上一帧 top-256）到当前帧
    if self.num_propagated > 0:
        tgt = torch.cat([tgt, temp_memory[:, :self.num_propagated]], dim=1)
        query_pos = torch.cat([query_pos, temp_pos[:, :self.num_propagated]], dim=1)
        reference_points = torch.cat(
            [reference_points, temp_reference_point[:, :self.num_propagated]], dim=1)
        # 剩余历史 queries 进入 Hybrid Attention 的 key/value
        temp_memory = temp_memory[:, self.num_propagated:]
        temp_pos = temp_pos[:, self.num_propagated:]

    return tgt, query_pos, reference_points, temp_memory, temp_pos, rec_ego_pose

📄 点击展开 post_update_memory 代码

（来源：streampetr_head.py）

def post_update_memory(self, data, rec_ego_pose, all_cls_scores,
                       all_bbox_preds, outs_dec, mask_dict):
    # 取最后一层 decoder 的输出
    rec_reference_points = all_bbox_preds[..., :3][-1]
    rec_velo = all_bbox_preds[..., -2:][-1]
    rec_memory = outs_dec[-1]
    rec_score = all_cls_scores[-1].sigmoid().topk(1, dim=-1).values[..., 0:1]
    rec_timestamp = torch.zeros_like(rec_score, dtype=torch.float64)

    # 选取 top-K (256) 前景 queries
    _, topk_indexes = torch.topk(rec_score, self.topk_proposals, dim=1)
    rec_reference_points = topk_gather(rec_reference_points, topk_indexes).detach()
    rec_memory = topk_gather(rec_memory, topk_indexes).detach()
    rec_velo = topk_gather(rec_velo, topk_indexes).detach()

    # FIFO 入队：新 queries 拼接到队列头部
    self.memory_embedding = torch.cat([rec_memory, self.memory_embedding], dim=1)
    self.memory_timestamp = torch.cat([rec_timestamp, self.memory_timestamp], dim=1)
    self.memory_egopose = torch.cat([rec_ego_pose, self.memory_egopose], dim=1)
    self.memory_reference_point = torch.cat(
        [rec_reference_points, self.memory_reference_point], dim=1)
    self.memory_velo = torch.cat([rec_velo, self.memory_velo], dim=1)

    # 变换到世界坐标系存储（下一帧再变换到新的自车坐标系）
    self.memory_reference_point = transform_reference_points(
        self.memory_reference_point, data['ego_pose'], reverse=False)
    self.memory_timestamp -= data['timestamp'].unsqueeze(-1).unsqueeze(-1)
    self.memory_egopose = data['ego_pose'].unsqueeze(1) @ self.memory_egopose

实验与分析

5.1 主要结果

与 SOTA 方法对比：

方法	类型	Backbone	NDS	mAP	FPS
SOLOFusion（val，256×704）	BEV 时序	R50	53.4	42.7	11.4
BEVPoolv2（val，256×704）	BEV 时序	R50	52.6	40.6	16.6
StreamPETR（val，256×704，900q）	物体中心	R50	54.0	43.2	27.1
StreamPETR（val，256×704，428q）	物体中心	R50	55.0	45.0	31.7
SOLOFusion（test）	BEV 时序	ConvNeXt-B	61.9	54.0	-
StreamPETR（test）	物体中心	V2-99	63.6	55.0	-
CenterPoint（test）	激光雷达	-	67.3	60.3	-
StreamPETR（test）	物体中心	ViT-Large	67.6	62.0	-

完整的 TP 指标（mATE, mASE, mAOE, mAVE, mAAE）和各 backbone 配置详情见论文 Table 1-2。FPS 测试环境：RTX 3090，batch=1（6 视角），FP32，无 flash attention。

跟踪结果：

方法	模态	AMOTA	RECALL
CenterPoint	LiDAR	63.8	67.5%
ByteTrackv2	Camera	56.4	63.5%
StreamPETR	Camera	65.3	73.3%

关键发现：

首个追平激光雷达的在线纯视觉方法：67.6% NDS vs CenterPoint 67.3% NDS
同条件下 SOLOFusion 的 2.8× 速度、更高精度：val R50 下 StreamPETR（428q）以 31.7 FPS 对 11.4 FPS，NDS 高 1.6%（55.0 vs 53.4）
跟踪超越激光雷达：65.3% AMOTA 超越 CenterPoint（63.8%），比 Camera 第二名 ByteTrackv2 高 8.9%

5.2 消融实验：验证三个洞察

验证洞察 1：以物体为中心的时序传播（Table 8）

以下对比 object query 时序与 perspective 时序的精度-速度权衡。

Perspective	Object	Propagated	mAP	NDS	FPS	验证洞察
			31.7	37.2	27.7	—
✓		✓	36.1	45.9	18.9	—
	✓	✓	40.2	50.5	27.1	洞察 1
✓	✓	✓	40.2	50.3	18.6	—

Object query 时序以 27.1 FPS 达到 50.5 NDS，而 perspective 时序以 18.9 FPS 仅达到 45.9 NDS——**精度高 4.6%，速度快 43%**。最后一行证明两者组合无增益（50.3 vs 50.5），与洞察 2 中”低秩近似”的解释一致。

验证洞察 2：记忆队列容量分析（Table 7）

以下验证性能随队列帧数 N 的变化趋势。

帧数 N	mAP	NDS	FPS	验证洞察
0（单帧基线）	31.7	37.2	27.7	—
1	39.4	50.1	27.7	洞察 2
2	40.1	50.5	27.4	洞察 2
4	40.2	50.5	27.1	洞察 2

性能在 N=2（约 1 秒）时已基本饱和。为什么这么快就饱和？ 作者在 rebuttal 中对 nuScenes 的 tracking 数据做了遮挡帧数统计——绝大部分物体的遮挡持续时间在 10 帧（约 2 秒）以内，N=2-4 已经覆盖了大多数需要时序补偿的遮挡场景。此外，由于物体查询本身是递归传播的（洞察 2 中的”低秩近似”视角），即使 N=1 时也已包含了更早帧的信息残留。增大记忆队列带来的计算成本可忽略（27.7 → 27.1 FPS），论文默认使用 N=4。

验证洞察 3：运动感知层归一化（Table 6）

MC	LN	Ego Pose	$\Delta t$	$v$	mAP	NDS	mATE	mAVE	验证洞察
					37.8	48.3	0.697	0.354	—
✓					38.0	48.1	0.693	0.379	洞察 3
	✓				37.5	48.1	0.702	0.370	—
	✓	✓			39.8	50.1	0.667	0.316	洞察 3
	✓		✓		38.1	48.8	0.697	0.354	洞察 3
	✓			✓	38.6	48.9	0.690	0.373	洞察 3
	✓	✓	✓	✓	40.2	50.5	0.660	0.316	洞察 3

上表中有一个关键的反直觉结果：显式运动补偿（MC）不仅没帮忙，NDS 反而略降（48.1 vs 48.3）。原因在于 vanilla attention 本身就具备一定的动态建模能力——attention 权重会自动关注位置最相关的历史 query，即使没有显式补偿也能完成粗糙对齐。而显式 MC 在训练早期（位置预测不准时）反而引入系统性误差。

MLN 通过条件归一化隐式编码自车姿态后，mAP 提升 2.0%（39.8 vs 37.8），NDS 提升 1.8%（50.1 vs 48.3）——这是整个消融实验中最大的单项提升，验证了洞察 3 中”隐式优于显式”的核心判断。进一步编码 $\Delta t$ 和 $v$ 后，mAP/NDS 分别再提升 0.4%。

训练帧数的影响（Table 5）

以下对比 sliding window（W）和 streaming video（V）两种测试方式在不同训练帧数下的表现。

训练帧数	Sliding Window mAP/NDS	Streaming Video mAP/NDS
1	—	31.7 / 37.2
4	37.7 / 48.3	36.6 / 47.5
8	39.6 / 50.1	40.2 / 50.5
12	40.3 / 50.7	40.2 / 50.9

8 帧时 streaming video 反超 sliding window（50.5 vs 50.1 NDS），说明递归传播在充分训练后能有效建立长期时序依赖。12 帧提升有限，论文默认使用 8 帧。

5.3 失效场景与性能瓶颈

根据论文 Sec 5.5 分析，StreamPETR 仍存在以下挑战：

运动物体仍是短板：即使有时序建模，运动物体（速度 > 1m/s）的检测性能仍明显低于静止物体（论文 Figure 5），但 StreamPETR 对两者的提升均远超 BEV 方法
远距离物体的误检：30m 以外存在大量 False Positives（重复预测），这是基于相机方法的通病
训练测试帧率不一致：部署时使用非关键帧（10-25Hz）导致时间 PE 外推失效，性能显著下降（详见 6.4 FAQ Q1）

工程实践

6.1 训练配置

配置项	R50 标准版	R50 轻量版	V2-99 版	ViT-Large 版
Backbone	ResNet-50	ResNet-50	V2-99	ViT-Large
输入分辨率	256×704	256×704	640×1600	800×1600
物体查询数	900（644+256）	428（300+128）	900	900
预训练	ImageNet	NuImg	FCOS3D / DD3D	Objects365+COCO
学习率调度	90ep	60ep	24ep	24ep
训练时间	36 hours（8×2080ti）	26 hours（8×2080ti）	13 hours（8×2080ti）	-
优化器	AdamW, lr=4e-4, cosine annealing	同左	同左	同左
Batch Size	16	16	16	16
数据增强	时序数据增广（随机跳过 1 帧）	同左	同左	同左
其他	无 CBGS，辅助 2D 监督	同左	同左	仅训练 24ep 防止过拟合

6.2 复现要点

记忆队列初始化：队列初始为空，需要若干帧预热后才能存储有效历史信息
梯度分离策略：训练时分离前 6 帧的梯度，仅计算最后 2 帧的梯度和损失，加速收敛
Flash Attention：可用 Flash Attention 节省显存（V2-99 640×1600 配置下，显存从 61G 降至 27G），但测速时需关闭
Query Denoising：沿用 PETRv2 的查询去噪策略
存储时间间隔 τ：需要根据数据集帧率调整；Waymo 测试时 τ=5，调整为 τ=1 时性能仅有微小下降
时序数据增广：训练序列中随机跳过 1 帧，增强模型对帧率变化的鲁棒性
前景物体选择：仅存储分类分数最高的前 K（256）个前景物体查询，记忆队列遵循 FIFO 规则

6.3 性能优化方向

精度提升：

增加记忆队列容量：性能随容量增加而提升（最终饱和），但会增加内存占用
使用更强 Backbone：ViT-Large 相比 ResNet-50 有显著提升，但训练时间更长
增加训练帧数：增大训练帧数能显著提升性能，缩小与滑动窗口方法的差距
辅助监督：Streaming 训练比 sliding window 更难收敛，添加 2D 监督、深度监督或 query denoising 可显著改善

速度优化：

减少物体查询数量：轻量版（428q）相比标准版（900q）速度提升（31.7 vs 27.1 FPS），性能接近（NDS 55.0 vs 54.0）
使用轻量 Backbone：ResNet-50 相比 V2-99 推理速度更快（27.1 vs 12.5 FPS）
降低输入分辨率：256×704 相比 512×1408 速度显著提升（27.1 vs 6.4 FPS）

研究启示

7.1 可迁移的思想

以物体为中心的时序传播：将时序建模从特征级转向物体级，可应用于其他时序检测/跟踪任务，如视频目标检测、多目标跟踪
记忆队列递归更新：战略性存储历史信息而非简单滑动窗口，可应用于需要长期依赖的序列建模任务
运动感知层归一化：通过隐式编码运动信息而非显式补偿，可应用于其他涉及运动建模的任务，如光流估计、视频预测
解耦自车与物体运动：在自动驾驶场景中，显式区分自车运动和周围物体运动是通用设计原则

7.2 方法局限

依赖物体查询质量：记忆队列仅存储前景物体查询，如果初始查询质量差，会影响时序传播效果
训练预热需求：记忆队列需要若干帧预热才能建立有效历史信息，冷启动阶段性能可能不稳定
超参数敏感：存储时间间隔 τ、队列容量等超参数需要根据具体场景调整

7.3 技术影响

首个激光雷达级别的在线多视图方法：在 nuScenes 上首次证明纯视觉方法可以达到激光雷达方法的性能（67.6% NDS, 65.3% AMOTA）
开创 object-centric 时序建模路线：与 BEVFormer 的 BEV 时序、PETRv2 的透视图时序并列，形成多视图 3D 检测的三大时序范式
推动 query-based 检测器的时序扩展：StreamPETR 的 object-centric 设计可直接应用于 DETR3D（Stream-DETR3D +4.9% mAP），后续 Sparse4Dv2、SparseBEV 等均借鉴了 query 传播的思路