BEVDet4D: Exploit Temporal Cues in Multi-camera 3D Object Detection

Posted on 2023-08-06 Edited on 2025-10-23 In BEV Valine:

URL

paper: https://arxiv.org/pdf/2203.17054.pdf
code: https://github.com/HuangJunJie2017/BEVDet

TL;DR

BEVDet4D 是基于 BEVDet 加入了时序信息的一篇论文
具体来说就是将上一帧的 BEV Feature 和本帧的 BEV Feature 对齐后 Concat 到一起送入 BEV Encoder 中进行 BEV 视角下的 3D 目标检测
BEVDet 论文中的 image encoder + view transformer 完全保持不变
由于有两帧的信息，所以对速度的预测相较于单帧有较大提升

Algorithm

整体流程

在 BEV Feature 层面（View Transformer 的输出）融合两帧信息

算法的伪代码表示

class BEVDet4D:
    def __init__(self):
        # 初始化相关的编码器、转换器和其他必要的组件
        self.image_view_encoder = ImageViewEncoder()
        self.view_transformer = ViewTransformer()
        self.bev_encoder = BEVEncoder()
        self.head = DetectionHead()
        self.previous_bev_feature = None
    def spatial_alignment(self, feature):
        # 这里执行空间对齐操作，具体细节可能需要根据原始论文进行补充
        # 实际代码中这里似乎没有开，即上一帧的 BEV feature 直接和本帧 BEV feature map concat
        aligned_feature = ... 
        return aligned_feature
    def forward(self, current_image):
        # 使用图像视图编码器和视图转换器处理当前图像
        image_feature = self.image_view_encoder(current_image)
        transformed_feature = self.view_transformer(image_feature)
        # 使用BEV编码器获取当前帧的BEV特征
        current_bev_feature = self.bev_encoder(transformed_feature)
        # 如果存在前一帧的BEV特征，则进行空间对齐和融合
        if self.previous_bev_feature:
            aligned_previous_feature = self.spatial_alignment(self.previous_bev_feature)
            fused_feature = concatenate(aligned_previous_feature, current_bev_feature)
        else:
            fused_feature = current_bev_feature
        # 使用检测头部进行3D物体检测
        detections = self.head(fused_feature)
        # 保存当前帧的BEV特征以供下一帧使用
        self.previous_bev_feature = current_bev_feature
        return detections
# 实例化BEVDet4D并进行前向传递
bevdet4d = BEVDet4D()
detections = bevdet4d.forward(current_image)

result

效果比 BEVDet 好了不少，尤其是 mAVE (速度误差)

Thought

没有很大的创新点，更像是 BEVDet 的一个使用 trick
BEVDet 的计算量主要分布在 image encoder 和 view transformer，所以复用上一帧的 BEV feature 即充分利用了上一帧的计算量，对当前帧引入的额外计算量也比较可控（BEV encoder 和 task head 都比较轻量）

BEVDet: High-Performance Multi-Camera 3D Object Detection in Bird-Eye-View

Posted on 2023-08-06 Edited on 2025-10-23 In BEV Valine:

URL

paper: https://arxiv.org/pdf/2112.11790.pdf
code: https://github.com/HuangJunJie2017/BEVDet

TL;DR

本文介绍了一种 BEV 视角下的 3D 障碍物检测算法，该算法的输入是由多张（6张）图片组成的车身环视视角，输出为车身周围障碍物的 3D bbox
与 LSS（lift-splat-shoot） 算法较为相似，但任务不同，LSS 想要解决的是 BEV 视角下的分割问题，BEVDet 想要解决的是 3D 障碍物检测问题
与 FCOS3D 等单目 3D 障碍物检测的任务类型相似，区别在于：单目 3D 障碍物检测对每个视角做 3D 障碍物检测后，需要使用后处理融合跨视角的物体，BEVDet 可以将跨视角融合问题内嵌到模型中（BEV）

Algorithm

总体结构

由上图可以看出，模型主要由四个部分组成，分别是：

Image-view Encoder：图像特征提取（backbone + neck），6个视角分别做特征提取，不做视角间特征融合
View Transformer：视角变换（同时也实现了图像间信息融合），从图像视角转换为 BEV 视角，使用的方法和 LSS 方法一样，输出为 BEV feature
BEV Encoder：对 BEV feature 用一个较小的 BEV backbone 做特征提取
Head：任务头，预测 3D bbox 等，本文使用了 CenterPoint Head

算法流程的伪代码表示

# 定义输入，shape: (8, 6, 256, 704, 3) [batch, camera, H, W, C]
input_images = get_input_images()
# 图像视图编码器，输出shape: (8, 6, 16, 44, 256) [batch, camera, H//16, W//16, C]
image_view_features = image_view_encoder(input_images)
# 视图变换器，输出shape: (8, 64, 128, 128) [batch, C, Bev_H, Bev_W]
transformed_features = view_transformer(image_view_features)
# BEV编码器，输出shape: (8, 256, 64, 64) [batch, C, Bev_H//2, Bev_W//2]
encoded_bev_features = bev_encoder(transformed_features)
# 任务特定头部进行3D物体检测，输出shape: (8, num_objects, object_info)
detection_results = task_specific_head(encoded_bev_features)
# 返回3D物体检测结果
return detection_results

数据增广方法

独立图片空间数据增广：图片的翻转、裁剪和旋转可以用 3x3 矩阵表示，在 View Transformer 的时候需要做对应逆变换，即 同时更改图片和 View Transformer 过程
BEV视角下的数据增广：在BEV空间的学习中，数据量少于图像视图空间，因为每个样本包含多个摄像机图像，所以更容易过拟合；该增广方法遵循常见的 LiDAR 方法，采用了 2D 空间中的常见数据增广操作，如翻转、缩放和旋转，需要对应修改目标 3D bbox，即 同时更改 BEV Feature 和 3D bbox GT

`Scale-NMS`

由于 BEV 空间中不同类别的空间分布与图像视图空间中的分布非常不同，所以作者提出了 Scale-NMS，在执行经典的 NMS 算法之前根据每个对象的类别来缩放每个对象的大小，可显著提高了对小面积类别（如行人和交通锥）的预测性能

Thought

从模型结构和数据增广方式看 BEVDet 本质是一个二阶段算法：
- image Encode + View Transformer：环视图像编码到 BEV 空间
- BEV Encoder + Task Head：BEV 空间下的 3D 障碍物检测
但第一阶段输出的 BEV Feature 没有用 LiDAR 点云监督就有点怪…（后续的改进算法加了）

MOTR: End-to-End Multiple-Object Tracking with Transformer

Posted on 2023-07-29 Edited on 2025-10-23 In Transformer Valine:

URL

paper: https://arxiv.org/pdf/2105.03247.pdf
code: https://github.com/megvii-research/MOTR

TL;DR

提出了一个完全端到端的多目标跟踪框架
将多目标跟踪问题形式化为一组序列预测问题
引入了跟踪感知的标签分配
提出了用于时间建模的集体平均损失和时间聚合网络方法

Algorithm

MOTR 整体流程

特征提取：用 CNN backbone 提取连续帧中每一帧的特征（上图中的 Enc）
查询生成：用 Deformable Transformer 对第一步提取的特征进行查询（上图中的 Dec）
- 对于视频第一帧，只解码 object detection query （上图中的 $q_d$ ）得到 hidden state
- 对于非第一帧，将 object detection query （上图中的 $q_d$ ）和上一帧的 tracking query （上图中的 $q_{tr}$ ）先 concat 再进行解码得到 hidden state
预测结果生成：用一个简单的结构将上一步得到的 hidden state 映射到任务空间，预测结果包含 object detection results 和 tracking results
得到下一帧的 tracking query：用 QIM (Query Interaction Module, 查询交互模块) 将上一步得到的预测结果映射为下一帧的 tracking query
计算损失 / 输出预测结果：对于训练，计算集体平均损失（CAL, Collective Average Loss）;对于预测，直接输出第 3 步得到的结果

描述 MOTR 过程的伪代码

def process_frame(frame, detect_queries, track_queries=None, ground_truths=None):
    # 使用CNN提取帧特征
    # frame shape: (height, width, channels)
    frame_features = extract_frame_features(frame)  # Shape: (height, width, channels)
    if track_queries is None:
        # 使用Deformable DETR解码器生成隐藏状态
        # detect_queries shape: (num_queries, query_dim)
        # frame_features shape: (height, width, channels)
        hidden_states = deformable_detr_decoder(detect_queries, frame_features)  # Shape: (num_queries, hidden_dim)
    else:
        queries = concatenate(track_queries, detect_queries)  # Shape: (num_queries + num_tracks, query_dim)
        hidden_states = deformable_detr_decoder(queries, frame_features)  # Shape: (num_queries + num_tracks, hidden_dim)
    # 生成预测
    # hidden_states shape: (num_queries, hidden_dim)
    predictions = predict(hidden_states)  # Shape: (num_queries + num_tracks, num_classes + 4)
    # 使用Query Interaction Module (QIM)生成下一帧的跟踪查询
    # hidden_states shape: (num_queries, hidden_dim)
    track_queries = qim(hidden_states)  # Shape: (num_tracks, query_dim)
    if ground_truths is not None:
        # 使用Collective Average Loss (CAL)进行训练
        # predictions shape: (num_queries, num_classes + 4)
        # ground_truths shape: (num_objects, num_classes + 4)
        loss = cal(predictions, ground_truths)
        backpropagate(loss)
    return predictions, track_queries  # Shape: (num_queries + num_tracks, num_classes + 4), (num_tracks, query_dim)
def process_video(video, ground_truths=None):
    # 初始化检测查询
    # 返回形状：(num_queries, query_dim)
    detect_queries = initialize_detect_queries()  
    track_queries = None  # Shape: (num_tracks, query_dim)
    for frame in video:
        predictions, track_queries = process_frame(frame, detect_queries, track_queries, ground_truths)
        if ground_truths is None:
            yield predictions

查询交互模块

查询交互模块 Query Interaction Module (QIM) 是 MOTR 中的一个关键组件，它负责处理物体的进入和退出，以及增强长期的时间关系建模
QIM 的输入是当前帧预测的 detection result 和 tracking result，输出是下一帧的 tacking query
通俗来说，QIM 是根据当前帧预测的结果，给出下一帧的 “提问”
QIM 过程的伪代码

def query_interaction_module(hidden_states, scores, tau_en, tau_ex, M):
    # hidden_states shape: (num_queries, hidden_dim)
    # scores shape: (num_queries, num_classes)
    # tau_en, tau_ex: entrance and exit thresholds
    # M: number of consecutive frames for exit threshold
    # Object Entrance
    entrance_mask = scores.max(dim=1) > tau_en  # Shape: (num_queries,)
    hidden_states = hidden_states[entrance_mask]  # Shape: (num_entrance_queries, hidden_dim)
    # Temporal Aggregation Network (TAN)，主要目的是融合时序信息，本文是用了一个 Multi-Head Self-Attention 实现
    hidden_states = temporal_aggregation_network(hidden_states)  # Shape: (num_entrance_queries, hidden_dim)
    # Object Exit
    exit_mask = scores.max(dim=1) < tau_ex  # Shape: (num_entrance_queries,)
    exit_mask = exit_mask.rolling(window=M).sum() > 0  # Shape: (num_entrance_queries,)
    hidden_states = hidden_states[~exit_mask]  # Shape: (num_track_queries, hidden_dim)
    return hidden_states  # Shape: (num_track_queries, hidden_dim)

集体平均损失

集体平均损失（Collective Average Loss，CAL）是 MOTR 算法中用于训练的损失函数。不同于传统的逐帧计算损失，CAL 收集整个视频剪辑的所有预测，然后基于整个视频剪辑计算总体损失
集体平均损失的代码描述

def collective_average_loss(predictions, ground_truths, matching_results):
    total_loss = 0
    total_objects = 0
    for i in range(len(predictions)):
        pred_tracked = predictions[i]['tracked']
        pred_detected = predictions[i]['detected']
        gt_tracked = ground_truths[i]['tracked']
        gt_detected = ground_truths[i]['detected']
        match_tracked = matching_results[i]['tracked']
        match_detected = matching_results[i]['detected']
        total_loss += single_frame_loss(pred_tracked, match_tracked, gt_tracked)
        total_loss += single_frame_loss(pred_detected, match_detected, gt_detected)
        total_objects += len(gt_tracked) + len(gt_detected)
    return total_loss / total_objects

Thought

以一种非常优雅的方式解决了端到端多目标追踪的任务，打破了之前 NN detection + Hard logic code tracking 的 tracking 范式
这种非黑盒的（显式监督 detecion bbox）复杂任务端到端训练，启发了后续的许多更复杂的端到端任务，例如 UniAD

Deformable DETR: Deformable Transformers for End-to-end Object Detection

Posted on 2023-07-29 Edited on 2025-10-23 In Transformer Valine:

URL

TL;DR

提出了 Deformable DETR：这是一种新的目标检测模型，解决了现有 DETR 模型的收敛速度慢和特征空间分辨率有限的问题。
使用可变形的注意力模块：这些模块只关注参考点周围的一小部分关键采样点，从而在更少的训练周期内提高了性能，尤其是对小对象的检测。
结合了可变形卷积的稀疏空间采样和 Transformer 的关系建模能力：这使得模型能够在处理大规模数据时保持高效，同时还能捕捉到复杂的上下文关系。
引入了一种两阶段的变体：在这个变体中，区域提议由 Deformable DETR 生成，然后进行迭代的细化。这使得模型能够更精确地定位和识别目标。

Algorithm

Deformable DETR 整体结构图

Deformabel Attention Block

Multi-Head Attention:
$MultiHeadAtten(z_q, x) = \sum_{m=1}^MW_m[\sum_{k\in\Omega_k}A_{mqk}\cdot W_m'x_k]$ $M u l t i H e a d A t t e n (z_{q}, x) = \sum_{m = 1}^{M} W_{m} [\sum_{k \in Ω_{k}} A_{m q k} \cdot W_{m}^{'} x_{k}]$
- 输入为一个 query 的表征 $z_q$ ，以及总特征 x，输出为 query 查询结果向量
- M 表示 number of head
- $A_{mqk}$ 表示 $softmax(\frac{QK^T}{\sqrt{d}})$
- $W_m'x_k$ 实际上就是 self-attention 中的 $V$
Deformable Attention:
$DeformableAtten(z_q,p_q,x) = \sum_{m=1}^MW_m[\sum_{k=1}^KA_{mqk}\cdot W_m'x(p_q + \Delta p_{mqk})]$ $D e f o r m a b l e A t t e n (z_{q}, p_{q}, x) = \sum_{m = 1}^{M} W_{m} [\sum_{k = 1}^{K} A_{m q k} \cdot W_{m}^{'} x (p_{q} + Δ p_{m q k})]$
- 输入为一个 query 的表征 $z_q$ ，总特征 x，以及 query 对应的 预设采样位置，输出为 query 查询结果向量
- $\Delta p_{mqk}$ 表示由 $z_q$ 计算得到的 基于预设查询位置的横纵偏移
- $A_{mqk} = softmax(z_qW_a)\ \ ,W_a\in\mathbb{R}^{dim\times num\_points}\ \ ,z_q\in\mathbb{R}^{dim}$ ，即 point position attention 是由 query 线性映射得到的 ，因此 Deformable Attention 没有 Key 的存在，只有 Query 和 Value
- K 表示 number of points，即采样点个数
Multi-Scale Deformable Attention：
$MSDeformableAtten(z_q,\hat{p}_q,\{x\}_{l=1}^L) = \sum_{m=1}^MW_m[\sum_{l=1}^L\sum_{k=1}^KA_{mlqk}\cdot W_m'x^l(\phi_l(\hat{p}_q) + \Delta p_{mlqk})]$ $MSDeformableAtten(zq,p^q,{x}l=1L)=∑m=1MWm[∑l=1L∑k=1KAmlqk⋅Wm′xl(ϕl(p^q)+Δpmlqk)]$
- 与 Deformable Attention 不同的是，输入的 x 变成了多尺度特征（例如 backbone 不同深度的特征），更贴近实际视觉工程化应用场景
- point 采样范围是所有 level 的 feature map，即 MSDefromableAttention 有全局 attention 信息
Deformable Attention 和 Self Attention 对比

import torch
import torch.nn.functional as F
import math
def attention(query, key, value):
    # query, key, value shapes: (batch_size, sequence_length, embedding_dim)
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(query.size(-1))
    # scores shape: (batch_size, sequence_length, sequence_length)
    probs = F.softmax(scores, dim=-1)
    # probs shape: (batch_size, sequence_length, sequence_length)
    output = torch.matmul(probs, value)
    # output shape: (batch_size, sequence_length, embedding_dim)
    return output
def deformable_attention(query, value, reference_points, num_sampling_points, atten_linear, offset_linear):
    # query shape: (batch_size, sequence_length, embedding_dim)
    # value shape: (batch_size, sequence_length, embedding_dim)
    # reference_points shape: (batch_size, sequence_length, 2)
    # num_sampling_points: integer, number of points to sample around each reference point
    
    batch_size, seq_len, embed_dim = query.size()
    
    # Calculate offsets
    # offset_linear is a linear layer that predicts the offsets
    offsets = offset_linear(reference_points).view(batch_size, seq_len, num_sampling_points, 2)
    # offsets shape: (batch_size, sequence_length, num_sampling_points, 2)
    
    # Calculate sampling positions based on reference points
    sampling_positions = reference_points.unsqueeze(2) + offsets
    # sampling_positions shape: (batch_size, sequence_length, num_sampling_points, 2)
    
    # Sample values (this is simplified; you might need interpolation)
    # Here, we assume value and reference_points are in the same space for simplicity
    sampling_values = value.gather(1, sampling_positions.long())
    # sampling_values shape: (batch_size, sequence_length, num_sampling_points, embedding_dim)
    
    # Calculate scores
    # atten_linear is a linear layer that transforms the query for calculating attention scores
    scores = atten_linear(query).view(batch_size, seq_len, num_sampling_points)
    # scores shape: (batch_size, sequence_length, num_sampling_points)
    
    # Softmax to get attention probabilities
    probs = F.softmax(scores, dim=-1)
    # probs shape: (batch_size, sequence_length, num_sampling_points)
    
    # Calculate output
    output = torch.matmul(probs, sampling_values)
    # output shape: (batch_size, sequence_length, embedding_dim)
    
    return output

Thought

用 query 线性映射代替 query 和 key 外积做 attention 数学上可解释性会变差，计算复杂度会降低
Deformable Conv 是典型的对 NPU 不友好，Deformable Attention 会更复杂，~~被代季峰支配的恐惧~~
用 Multi-scale 做各特征尺度上的信息融合，开创了一个 CNN 做 backbone + Deformable Transformer 做 head 的计算机视觉任务模型新范式，甚至省去了 FPN
总之是用各种便宜的计算来近似复杂的全局 attention，复杂度从 H*W --> K，即 $O(n^2) -> O(K)$

一些高效backbone设计思想

Posted on 2023-07-18 Edited on 2025-10-23 In CNN Architecture Design Valine:

TL;DR

本文介绍了 YOLO 系列几种高效的 backbone 设计，主要包括：VoVNet、PRN、CSPNet、ELAN、E-ELAN 等

Algorithm

1. VoVNet

paper: https://arxiv.org/pdf/1904.09730.pdf
作者认为 densenet 存在问题：每一层 Conv 都使用之前所有层的输出，因此会导致当前 Conv 的 input channel 很大，输出到 output channel 却较小
因此，作者只在 VoVNet Block 的最后一个 Conv 才用之前所有层的输出
相同计算量下，效果优于 Resnet 和 DenseNet

2. PRN

paper: https://openaccess.thecvf.com/content_ICCVW_2019/papers/LPCV/Wang_Enriching_Variety_of_Layer-Wise_Learning_Information_by_Gradient_Combination_ICCVW_2019_paper.pdf
code: https://github.com/WongKinYiu/PartialResidualNetworks/tree/master
PRN 全称是 Partial Residule Networks, 在 PRN 中，将 identity 连接乘以二进制 Mask，并且只允许将某些通道的特征映射添加到计算块的输出中

3. CSPNet（YOLOV5）

paper: https://arxiv.org/pdf/1911.11929.pdf
code: https://github.com/WongKinYiu/CrossStagePartialNetworks
CPSNet 的全称是 Cross Stage Partial Networks, 本质是把模型分成两部分，其中一部分经过计算（几层 Conv）后和另外一部分合起来，相当于第二部分和第一部分模型深度不同

4. ELAN

paper: https://arxiv.org/pdf/2211.04800.pdf
ELAN 全称是 Efficient Layer Aggregation Network, 作者以 VoVNet 和 ResNet 做对比，VoVNet 在叠加更多 block 时表现要比 ResNet 更差，作者分析是因为 VoVNet 结构中存在过多的 transition layers，这导致在叠加 block 时最短梯度路径（ the shortest gradient path ）不断增加，从而使得 block 增加时训练难度上升
PRN 相比 ResNet，使用 mask 让输入只有部分 channel 通过 identity connection，丰富了梯度来源；
CSPNet 通过将 channel split，一方面增加了梯度信息（同 PRN），另一方面减少了 computational block 中的计算量；
ELAN 的思想是：搭建网络时需要考虑每一层的最短最长梯度路径，还要考虑整个网络的最长梯度路径。

5. E-ELAN（YOLOV7）

paper: https://arxiv.org/pdf/2207.02696.pdf
code: https://github.com/WongKinYiu/yolov7
E-ELAN 是 extended ELAN，在不改变 gradient path 的情况下，加入了 Group Conv、Shuffle and merge Conv 等操作，极大的提高了模型表现能力，成就了 YOLOV7 又快又好的效果！

UniAD: Planning-oriented Autonomous Driving

Posted on 2023-07-16 Edited on 2025-10-23 In Autonomous Driving Planning Valine:

URL

paper: https://arxiv.org/pdf/2212.10156.pdf
slides: https://opendrivelab.com/e2ead/UniAD_plenary_talk_slides.pdf
code: https://github.com/OpenDriveLab/UniAD

TL;DR

本文提出一种以自动驾驶规划为目的的神经网络架构，该架构对每个感知子任务显式监督，合理的将子任务连接起来，增加了子任务之间的协调性，并增加了模型的可解释性

WIP

GPT-4 Technical Report

Posted on 2023-07-03 Edited on 2025-10-23 In Self-Supervised Learning Valine:

URL

paper: https://arxiv.org/pdf/2303.08774.pdf

TL;DR

使用预测下一个词（语言建模 language modeling）任务进行自监督预训练
预训练的模型需要使用 reinforement learning with human feedback（RLHF） 进行对齐（align），这个过程不会在测试数据集上提高模型表现，但可以更好的对齐人类的意图和三观
模型输入可以是图片和文本，输出为文本

Details

使用了很强大的基建，可以做到准确预测模型训练的最终效果（scaling），可以以较小的代价和较快的时间找到最合适的模型架构和超参数设置
为模型引入了 steerability（操纵性），可以在模型的 prompt 中加入一些 System message，让模型回复风格拥有某种特质（比如老师、政客等）
GPT-4 使用了很多机制提高了模型的安全性

Thought

这篇技术报告更多是对模型效果的分析，基本没有模型细节的描述
大模型逐渐变成大厂垄断，普通研究者能摸到的最后只剩下一个 API …

GPT3:Language Models are Few-Shot Learners

Posted on 2023-06-30 Edited on 2025-10-23 In Self-Supervised Learning Valine:

URL

paper: https://arxiv.org/pdf/2005.14165.pdf

TL;DR

作者团队训练了一个 96 层 Transformer 共 1750 亿参数的超大模型（GPT2 只有约 15 亿参数），在下游任务上无需 fine-tuning 即可得到很好的效果。
本质是 GPT2 的放大版（参数量放大了一百多倍）

Algorithm

在下游任务上，可以使用 Zero Shot、One Shot、Few Shot 三种方式推理模型，下图以英语翻译法语的例子介绍三者的区别：
GPT3 系列模型详细设置：
GPT3 自监督训练数据：

使用了 common crawl 数据集，由于 common crawl 数据集很脏，所以训练是数据采样率并不高

下图是在几个下游任务上和 SOTA 算法的比较：

从普遍表现看，GPT3 few shot 效果 > one shot > zero shot，不一定比 SOTA 点高（SOTA 普遍使用了 fine tuning，直接比较不公平）

Thought

在某些任务上，GPT3 few shot 效果可媲美 fine tuning SOTA，可以说明 GPT3 还是非常强大的
比上一代参数量提高一百多倍，开启了大模型时代…

Segment Anything

Posted on 2023-05-25 Edited on 2025-10-23 In Semantic Segmentation Valine:

URL

paper: https://arxiv.org/pdf/2304.02643.pdf
code: https://github.com/facebookresearch/segment-anything
demo: https://segment-anything.com/demo

TL;DR

本文提出一种类似 chatGPT 的交互式 Zero-shot 分割算法，用户给出一个 prompt（支持 point / box / mask / text），模型会根据 Prompt 语义完成分割，无需在特定分割任务数据上 fine-tuning（类似于 GPT2 和之后的系列模型）
本文一个非常重要的理念是 Data Centric，即以数据为中心而不是以模型为中心，这一点和 GPT 系列也不谋而合
- 传统视觉算法是在固定的数据集上修改模型结构实现模型效果的提升，实际是以模型为中心
- 数据为中心的算法通常固定模型结构，通过例如 RLHF（reinforcement learning from human feedback） 的方法，使用模型辅助标注员高效标注大量数据（11 亿个 mask 区域），重复迭代提高效果
模型本身由三部分组成：
- image_encoder：提取图片特征，使用的是 ViT 模型，在交互过程中只需要推理一次
- prompt_encoder：提取 prompt 特征，将人的输入（例如点或框）编码到特征空间
- mask_decoder：输入为图片特征和 prompt 特征，融合后输出分割 mask

Algorithm

任务定义

理论上支持 point / box / mask / text，但 demo 和 code 都只包含了 point / box / mask

模型结构

image encoder 是 VIT
prompt encoder 对于 box / point prompt 只是简单的位置编码；对于 mask 是几层简单的卷积
lightweight mask decoder 是轻量级 transformer

Data centric

模型为中心和数据为中心的对比

使用效果

图中的框为用户输入的 prompt，模型会根据 prompt 输出分割结果

Thought

Data centric 感觉一定是未来，但形式一定不会以 RLHF 形式存在，而更多的以自监督形式存在
prompt 未来会取代 fine-tuning 这个词

GPT2: Language Models are Unsupervised Multitask Learners

Posted on 2023-05-16 Edited on 2025-10-23 In Self-Supervised Learning Valine:

URL

TL;DR

继 Bert 全方位打败 GPT 之后，OpenAI 推出了参数量更大的 GPT2
但 GPT2 与之前所有的 NLP 预训练模型使用的 自监督预训练 + 任务相关 fine-tuning 范式不同，GPT2 不再需要任何数据相关 fine-tuning，而是使用 prompt（提示词）
prompt（提示词） 是一段在模型推理阶段用于描述任务的文本，通常加在问题之前，起到提示模型的作用

Algorithm

GPT2 很大程度上只是 GPT 的放大版，所引入的创新并不多

使用了 Byte Pair Encoding（BPE） 分词算法，本质是一种贪心算法
由于自回归（auto-regression）模型推理容易出现死循环，所以本文提出一种 top-k 输出按 softmax 概率采样的 trick，增加模型的随机性

Thought

GPT2 最重要的作用是提出了使用 Prompt 替代 fine-tuning 的范式，为之后的 AIGC 大面积推广扫平了障碍