04 感知：3D目标检测 注意力机制
1. DETR 2020（DEtection TRansformer）End-to-End Object Detection with Transformers
可以将DETR视为一个从图像序列到一个集合序列的转换过程。该集合实际上就是一个可学习的位置编码（文章中也称为object queries或者output positional encoding，代码中叫作query_embed）。
1. pos_embed （位置编码）
transformer位置编码:
\[\begin{cases}
PE(pos, 2i) = sin(pos/10000^{2i/d_{model}}) \\
PE(pos, 2i+1) = cos(pos/10000^{2i/d_{model}})
\end{cases}
\]
pos是词向量在序列中的位置，i是channel的索引。
DETR中位置编码：为二维特征在图像x和y方向分别编码，每个维度编码长度为特征向量长度一半。这样两个维度编码特征拼接后，构成和图像特征长度相等的向量。
class PositionEmbeddingSine(nn.Module):
"""
This is a more standard version of the position embedding, very similar to the one
used by the Attention is all you need paper, generalized to work on images.
"""
def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
super().__init__()
self.num_pos_feats = num_pos_feats
self.temperature = temperature
self.normalize = normalize
if scale is not None and normalize is False:
raise ValueError("normalize should be True if scale is passed")
if scale is None:
scale = 2 * math.pi
self.scale = scale
def forward(self, tensor_list: NestedTensor):
x = tensor_list.tensors
mask = tensor_list.mask
assert mask is not None
not_mask = ~mask
y_embed = not_mask.cumsum(1, dtype=torch.float32)
x_embed = not_mask.cumsum(2, dtype=torch.float32)
if self.normalize:
eps = 1e-6
y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
pos_x = x_embed[:, :, :, None] / dim_t
pos_y = y_embed[:, :, :, None] / dim_t
pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
return pos
2. object queries (query_embed)
这里query_embed的作用表现的和位置编码类似
# embedding_layer = nn.Embedding(num_embeddings=3, embedding_dim=2)
self.query_embed = nn.Embedding(num_queries, hidden_dim)
object queries在经过decoder的计算以后，会输出一个形状为T,N,C的数组，其中T是object queries的序列长度，即100，N是batch size，C是特征channel。
最后通过一个Linear层输出class预测，通过一个多层感知机结构输出box预测：
'''
torch.nn.Linear(in_features, out_features, bias=True)
- 输入形状：(batch_size, in_features)
- (batch_size, out_features)
'''
# MLP (also called FFN)
class MLP(nn.Module):
""" Very simple multi-layer perceptron (also called 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)
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):
x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
return x
self.class_embed = nn.Linear(hidden_dim, num_classes + 1)
self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3)
#forward
hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0]
outputs_class = self.class_embed(hs)
outputs_coord = self.bbox_embed(hs).sigmoid()
out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]}
3. 为什么DETR不需要NMS处理
假如有N个目标，那么100个object predictions中就会有N个能够匹配到这N个ground truth，其他的都会和“no object”匹配成功，这些predictions的类别label就会被分配为num_classes，即表示该prediction是背景。这样的设计是很不错的，理论上每个object query都有唯一匹配的目标，不会存在重叠，所以DETR不需要nms进行后处理。
补充：
1. nn.Embedding
- nn.Embedding 是一个预定义的层，专门用于将 离散的整数索引（比如单词ID、类别ID）转换为 稠密向量。
- 它内部维护一个可学习的“向量表”（类似字典），通过查表的方式将索引映射成向量。
- 可学习：向量表中的每个向量都是 nn.Parameter，会被优化器更新。
- 专为离散设计：适合处理文本、类别等离散数据。
- nn.Embedding：就像一本字典，每个单词对应一页解释（向量），这本字典的内容会在训练中不断优化，让解释更准确。
2. 匈牙利匹配算法（带权二分图最大匹配 KM算法）
1. 匈牙利匹配算法
交替路和增广路是用来解决新配对的时候发生冲突的问题。
交替路：就是依次经过非匹配边、匹配边的路
- （非匹配边） (匹配边) (非匹配边)：B--------------a----------------A-----------------c
- B和c都是没有被匹配过的点，而它又是这条交替路的起点和终点。这条交替路就是增广路。
现在我们要做一个取反操作，怎么取呢，就是将上面这条增广路的匹配边变成不匹配边，不匹配边变成匹配边。
- （匹配边） (非匹配边) (匹配边)：B--------------a----------------A-----------------c
增广路的核心特点就是“起点终点都是非匹配点”，这样就导致非匹配边比匹配边多了一条。增广路建立连接时，必须建立在两者有意向的基础上。这样我们取反，也就是交换匹配和非匹配边的身份。我们就多得到了一条匹配边。这个取反的过程，就是把原本匹配上的两个人拆散，给第三个人腾位置。
参考：Raf 1
2. KM算法
参考：Ref 2
2. DAB-DETR (收敛慢因为： 没有提供位置先验的 learnable queries)
3. DN-DETR (收敛慢因为：匈牙利匹配的离散性和模型训练的随机性，导致了 query 对 gt 的匹配变成了一个动态的、不稳定的过程)
4. Deformable DETR 2021()
Code URL: https://github.com/fundamentalvision/Deformable-DETR
改进：
- 减少训练时长：将全局attention转为局部attention
- 提升小物体检测准确率：采用多尺度特征图
原始图片上一个目标物体太小，它在压缩后的特征图上可能就几乎找不到了，因此我们很难将其检测出来。所以一般情况下，小物体我们需要更大尺寸的特征图。想法：让不同尺寸的特征图都参与训练，提高一个物体被检测出来的可能。
1. Deformable attention计算
# ! 此部分代码不完整，完整代码解析查看参考资料：Ref 4.
class MSDeformAttn(nn.Module):
def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4):
"""
Multi-Scale Deformable Attention Module
:param d_model hidden dimension
:param n_levels number of feature levels （特征图的数量）
:param n_heads number of attention heads
:param n_points number of sampling points per attention head per feature level
"""
super().__init__()
if d_model % n_heads != 0:
raise ValueError('d_model must be divisible by n_heads, but got {} and {}'.format(d_model, n_heads))
_d_per_head = d_model // n_heads
# you'd better set _d_per_head to a power of 2 which is more efficient in our CUDA implementation
if not _is_power_of_2(_d_per_head):
warnings.warn("You'd better set d_model in MSDeformAttn to make the dimension of each attention head a power of 2 "
"which is more efficient in our CUDA implementation.")
2. Reference points/ off set 如何产生？
3. Corase2Fine如何实现？
Reference
- 简单理解增广路与匈牙利算法：https://zhuanlan.zhihu.com/p/208596378
- 从匈牙利算法到KM算法：ttps://zhuanlan.zhihu.com/p/214072424
- 理解DETR：https://zhuanlan.zhihu.com/p/348060767
- 再读deformable detr：https://zhuanlan.zhihu.com/p/700776674
浙公网安备 33010602011771号