多视图，BEV，occupancy

最新推荐文章于 2024-08-28 22:22:37 发布

骆驼穿针眼

最新推荐文章于 2024-08-28 22:22:37 发布

阅读量857

点赞数 8

分类专栏： Occupancy 文章标签：人工智能 3d

本文链接：https://blog.csdn.net/weixin_55982578/article/details/136852006

版权

Occupancy 专栏收录该内容

21 篇文章 6 订阅

订阅专栏

nuScence 的数据输入到bev
在这里插入图片描述

相机转3D：
英语： https://web.archive.org/web/20190817222512/http://epixea.com/research/multi-view-coding-thesisch2.html

中文：连接

Occupancy 和 BEV的框架

在这里插入图片描述
在理解鸟瞰视图（BEV）架构与占用率检测（Occupancy）的关系时，这个过程通常可以概括为以下四个核心步骤：

图像视图编码器（Image-view Encoder）：此步骤涉及提取多帧RGB图像的特征，为后续的空间转换和特征编码打下基础。
视图转换器（View Transformer）：该环节负责将图像视图空间（Image View Space）转换到鸟瞰视图空间（BEV Space），以便更准确地理解和处理物体在三维空间中的位置和布局。
BEV/占用率编码器（BEV/Occupancy Encoder）：在处理占用率检测任务时，此步骤会将特征编码为三维（3D）特征，即特征在垂直方向（z方向）上的张量维度不为1，从而明显区别于BEV的二维（2D）特征。
占用率头（Occupancy Head）：得益于上述编码器的处理，我们便可以接入占用率头来进行损失计算，以评估和优化模型对占用空间检测的准确性。

通过这一系列精心设计的步骤，可以有效地理解并实现BEV架构与占用率检测之间的关系，为自动驾驶系统中的空间理解提供强大的支持。

BEV到 Occupancy
在这里插入图片描述

Lift
- Depthnet: (N, C + D, H, W)，N为相机数量，D为离散深度，C为特征通道数
- → (N, D, H, W) X (N, H, W, C) = (N, D, H, W, C)

深度图如何在多视角中运用

LSS 说明
在这里插入图片描述
LSS 的细节

在这里插入图片描述

参考学习笔记

在这里插入图片描述

论文

《BEVDet4D》是一篇发表于2022年7月的文章，它在鸟瞰视图检测（BEVDet）框架中引入了时序信息，通过以下三个关键步骤实现了这一目标：

对齐（Align）：该步骤通过将历史帧的特征通过变换矩阵（RT矩阵）转换到当前帧，实现时间维度上的信息对齐。这一过程使得模型能够考虑到物体随时间的运动和变化，从而提升了对动态环境的理解能力。

特征分离（Feature Detach）：为了防止过去的特征通过反向传播对模型训练产生不利影响，采用了特征分离技术。这确保了模型能够集中关注当前帧的信息，同时利用但不被历史信息所束缚。

连接（Concat）：通过将对齐后的历史特征与当前帧的特征进行连接，模型能够综合利用时空信息，增强对场景的整体理解。这种方式不仅提升了检测的准确性，也为理解复杂动态场景提供了新的视角

通过forward project的 Occupancy 方法

BEVFormer
在这里插入图片描述
这段代码用于获取BEV（鸟瞰图）特征，并处理与自我运动（ego motion）相关的旋转角度和位移。

在这里插入图片描述

"""
获取鸟瞰图（BEV）特征。
"""

# 获取多层特征的批次大小
bs = mlvl_feats[0].size(0)
# 将BEV查询（bev_queries）沿批次维度复制，以匹配特征维度
bev_queries = bev_queries.unsqueeze(1).repeat(1, bs, 1)
# 处理BEV位置信息，为之后的特征提取做准备
bev_pos = bev_pos.flatten(2).permute(2, 0, 1)

# 根据ego motion获取旋转角度和位移变化
# 从输入参数中提取车辆的横向（delta_x）和纵向（delta_y）位移
delta_x = np.array([each['can_bus'][0] for each in kwargs['img_metas']])
delta_y = np.array([each['can_bus'][1] for each in kwargs['img_metas']])
# 计算ego角度，即车辆的朝向变化
ego_angle = np.array([each['can_bus'][-2] / np.pi * 180 for each in kwargs['img_metas']])
# BEV网格的长和宽
grid_length_y = grid_length[0]
grid_length_x = grid_length[1]
# 计算总位移长度
translation_length = np.sqrt(delta_x ** 2 + delta_y ** 2)
# 计算位移方向角度
translation_angle = np.arctan2(delta_y, delta_x) / np.pi * 180
# 计算BEV角度，考虑了车辆朝向和位移方向的差异
bev_angle = ego_angle - translation_angle
# 根据角度和位移计算在BEV图上的x和y方向上的位移
shift_y = translation_length * np.cos(bev_angle / 180 * np.pi) / grid_length_y / bev_h
shift_x = translation_length * np.sin(bev_angle / 180 * np.pi) / grid_length_x / bev_w
# 根据配置决定是否使用位移
shift_y = shift_y * self.use_shift
shift_x = shift_x * self.use_shift
# 将计算出的位移转换为张量格式，以便后续使用
shift = bev_queries.new_tensor([shift_x, shift_y]).permute(1, 0)  # xy, bs -> bs, xy

这段代码首先准备了BEV查询向量，使其尺寸与输入特征相匹配。随后，它利用车辆CAN总线数据中的位移和旋转信息，计算出自我运动导致的在BEV坐标系下的位移。这一处理对于理解和预测在连续帧之间由于车辆运动引起的场景变化是非常重要的。通过这种方式，模型能够考虑到自身的运动，更好地对环境进行解释和预测。

在这里插入图片描述

时序注意力
projects/mmdet3d_plugin/bevformer/modules/temporal_self_attention.py

    # 将处理好的value通过一个投影层
    query = torch.cat([value[:bs], query], -1)
    value = self.value_proj(value)

    # 如果存在键填充掩码，则在value上应用掩码操作
    if key_padding_mask is not None:
        value = value.masked_fill(key_padding_mask[..., None], 0.0)

    # 重新调整value的形状，为后续的操作做准备
    value = value.reshape(bs*self.num_bev_queue, num_value, self.num_heads, -1)

    # 计算采样偏移量
    sampling_offsets = self.sampling_offsets(query)
    sampling_offsets = sampling_offsets.view(bs, num_query, self.num_heads,  self.num_bev_queue, self.num_levels, self.num_points, 2)

    # 计算注意力权重
    attention_weights = self.attention_weights(query).view(bs, num_query, self.num_heads, self.num_bev_queue, self.num_levels * self.num_points)
    attention_weights = attention_weights.softmax(-1)

    # 调整注意力权重的形状，为采样位置计算做准备
    attention_weights = attention_weights.view(bs, num_query, self.num_heads, self.num_bev_queue, self.num_levels, self.num_points)
    attention_weights = attention_weights.permute(0, 3, 1, 2, 4, 5).reshape(bs*self.num_bev_queue, num_query, self.num_heads, self.num_levels, self.num_points).contiguous()

    # 调整采样偏移量的形状
    sampling_offsets = sampling_offsets.permute(0, 3, 1, 2, 4, 5, 6).reshape(bs*self.num_bev_queue, num_query, self.num_heads, self.num_levels, self.num_points, 2)

    # 计算采样位置
    if reference_points.shape[-1] == 2:
        offset_normalizer = torch.stack([spatial_shapes[..., 1], spatial_shapes[..., 0]], -1)
        sampling_locations = reference_points[:, :, None, :, None, :] + sampling_offsets / offset_normalizer[None, None, None, :, None, :]
    elif reference_points.shape[-1] == 4:
        sampling_locations = reference_points[:, :, None, :, None, :2] + sampling_offsets / self.num_points * reference_points[:, :, None, :, None, 2:] * 0.5
    else:
        raise ValueError('最后一个维度的参考点必须是2或4，但是得到了 {reference_points.shape[-1]}。')

    # 根据是否使用CUDA以及值的数据类型，选择合适的多尺度可变形注意力计算方法
    if torch.cuda.is_available() and value.is_cuda:
        if value.dtype == torch.float16:
            MultiScaleDeformableAttnFunction = MultiScaleDeformableAttnFunction_fp32
        else:
            MultiScaleDeformableAttnFunction = MultiScaleDeformableAttnFunction_fp32
        output = MultiScaleDeformableAttnFunction.apply(value, spatial_shapes, level_start_index, sampling_locations, attention_weights, self.im2col_step)
    else:
        output = multi_scale_deformable_attn_pytorch(value, spatial_shapes, sampling_locations, attention_weights)

    # 调整输出的形状，将历史值和当前值融合
    output = output.permute(1, 2, 0)
    output = output.view(num_query, embed_dims, bs, self.num_bev_queue)
    output = output.mean(-1)

    # 最终调整输出形状，并通过一个输出投影层
    output = output.permute(2, 0, 1)
    output = self.output_proj(output)

    # 如果不是以批次为首的数据格式，调整数据格式
    if not self.batch_first:
        output = output.permute(1, 0, 2)

    # 返回经过dropout处理并与identity相加的最终结果
    return self.dropout(output) + identity

projects/mmdet3d_plugin/bevformer/modules/spatial_cross_attention.py
在这里插入图片描述

公式：
在这里插入图片描述

def forward(self,
            query,
            key,
            value,
            residual=None,
            query_pos=None,
            key_padding_mask=None,
            reference_points=None,
            spatial_shapes=None,
            reference_points_cam=None,
            bev_mask=None,
            level_start_index=None,
            flag='encoder',
            **kwargs):
    """
    参数:
        query (Tensor): 转换器中的查询张量，形状为 (num_query, bs, embed_dims)。
        key (Tensor): 键张量，形状为 `(num_key, bs, embed_dims)`。
        value (Tensor): 值张量，形状为 `(num_key, bs, embed_dims)`。
        residual (Tensor): 用于加法的张量，与 `query` 形状相同。默认为 None，如果为 None，则使用 `query`。
        query_pos (Tensor): `query`的位置编码。默认为 None。
        key_padding_mask (Tensor): `query`的字节掩码，形状为 [bs, num_key]。
        reference_points (Tensor): 归一化的参考点，形状为 (bs, num_query, 4)，所有元素范围在 [0, 1] 之间，包括左上角 (0,0) 和右下角 (1, 1)，及填充区域。
        spatial_shapes (Tensor): 不同层级的空间形状，形状为 (num_levels, 2)，最后一个维度表示 (h, w)。
        reference_points_cam (Tensor): 相机参考点，与 `reference_points` 类似，但可能包含针对每个相机的特定信息。
        bev_mask (Tensor): BEV查询的掩码，用于识别有效的查询点。
        level_start_index (Tensor): 每个层级的起始索引，形状为 (num_levels)。
        flag (str): 表示该模块是用于编码器还是解码器的标志，默认为 'encoder'。

    返回:
        Tensor: 前向传播结果，形状为 [num_query, bs, embed_dims]。
    """

    # 如果key或value未指定，则分别使用query和key作为它们的值
    if key is None:
        key = query
    if value is None:
        value = key

    # 处理残差连接
    if residual is None:
        inp_residual = query
        slots = torch.zeros_like(query)
    if query_pos is not None:
        query = query + query_pos

    # 获取批次大小、查询数量等信息
    bs, num_query, _ = query.size()

    # 根据bev_mask处理查询，确保每个相机只与其对应的BEV查询交互，以节省GPU内存
    D = reference_points_cam.size(3)
    indexes = []
    for i, mask_per_img in enumerate(bev_mask):
        index_query_per_img = mask_per_img[0].sum(-1).nonzero().squeeze(-1)
        indexes.append(index_query_per_img)
    max_len = max([len(each) for each in indexes])

    queries_rebatch = query.new_zeros([bs, self.num_cams, max_len, self.embed_dims])
    reference_points_rebatch = reference_points_cam.new_zeros([bs, self.num_cams, max_len, D, 2])
    
    # 对查询和参考点进行重排列，以便进行后续处理
    for j in range(bs):
        for i, reference_points_per_img in enumerate(reference_points_cam):   
            index_query_per_img = indexes[i]
            queries_rebatch[j, i, :len(index_query_per_img)] = query[j, index_query_per_img]
            reference_points_rebatch[j, i, :len(index_query_per_img)] = reference_points_per_img[j, index_query_per_img]

    # 调整key和value的
    num_cams, l, bs, embed_dims = key.shape

    # 将key和value的维度进行调整，以适配注意力机制的输入要求
    key = key.permute(2, 0, 1, 3).reshape(bs * self.num_cams, l, self.embed_dims)
    value = value.permute(2, 0, 1, 3).reshape(bs * self.num_cams, l, self.embed_dims)

    # 使用可变形注意力机制处理查询，key和value
    queries = self.deformable_attention(
        query=queries_rebatch.view(bs*self.num_cams, max_len, self.embed_dims),
        key=key,
        value=value,
        reference_points=reference_points_rebatch.view(bs*self.num_cams, max_len, D, 2),
        spatial_shapes=spatial_shapes,
        level_start_index=level_start_index
    ).view(bs, self.num_cams, max_len, self.embed_dims)

    # 根据之前生成的索引，将注意力机制的输出重新分配给对应的查询位置
    for j in range(bs):
        for i, index_query_per_img in enumerate(indexes):
            slots[j, index_query_per_img] += queries[j, i, :len(index_query_per_img)]

    # 计算每个查询点的覆盖次数，以便进行平均化处理
    count = bev_mask.sum(-1) > 0
    count = count.permute(1, 2, 0).sum(-1)
    count = torch.clamp(count, min=1.0)  # 防止除以零

    # 对slots进行平均化处理，确保每个查询位置的特征是所有相关相机视角特征的平均值
    slots = slots / count[..., None]

    # 通过输出投影层对slots进行处理
    slots = self.output_proj(slots)

    # 将处理后的slots与输入的残差相加，并应用dropout，作为最终的输出
    return self.dropout(slots) + inp_residual