论文学习12：LSKANet: Long Strip Kernel Attention Network for Robotic Surgical Scene Segmentation

代码来源

https://github.com/YubinHan73/LSKANet

模块作用

解决了机器人辅助手术中由于局部特征相似性（例如，不同解剖组织之间的相似性）、术中复杂的伪影以及难以区分的边界，给精确分割带来的挑战。论文提出了长条形核注意力网络（LSKANet），该网络包括两个精心设计的模块：双块大核注意力模块（DLKA）和多尺度亲和特征融合模块（MAFF），能够实现手术图像的精确分割。DLKA能够充分利用区域性和条形手术特征，提取视觉和结构信息，从而减少因局部特征相似性导致的错误分割。在MAFF中，从多尺度特征图计算出的亲和矩阵被用作特征融合权重，有助于通过抑制无关区域的激活来解决伪影的干扰。此外，论文还提出了结合边界引导头（BGH）的混合损失函数，帮助网络有效分割难以区分的边界。

模块结构

Dual-block Large Kernel Attention (DLKA) 模块

DLKA 模块旨在捕捉手术图像中的区域和条状特征，减少因局部特征相似导致的错误分割。其架构包括两个块：

• 级联块：使用条状卷积（strip convolutions）以级联方式排列，输出逐级传递。这种拓扑适合捕捉顺序模式或拉长的结构，如血管或工具。
• 并行块：条状卷积以并行方式处理，允许网络独立处理不同输入部分后再合并，适合捕捉并行特征。
• 两者都采用大内核设计，大内核提供了更宽的感受野，能够捕捉更多的上下文信息，帮助区分相似的区域。

原理上，DLKA 通过结合级联和并行拓扑，以及大内核设计，充分利用了手术图像中的多样化特征结构，特别是在处理局部特征相似性时表现优异。

Multiscale Affinity Feature Fusion (MAFF) 模块

MAFF 模块负责融合不同尺度的特征，以处理图像中不同大小的对象。其工作原理可能包括：

• 从网络的不同层提取多尺度特征。
• 计算特征间的亲和性（affinity），即某种相似性度量，用于加权融合。
• 通过这种方式，MAFF 结合了局部细节和全局结构信息，提升了分割的精度和鲁棒性。

这种多尺度融合特别适合手术场景，其中工具和组织可能在图像中呈现出显著的大小差异。

Boundary Guided Head (BGH)

BGH 是一个专门关注边界像素的网络组件，旨在改善难以区分的边界分割。其与混合损失函数结合使用，优化网络在边界区域的性能。原理上，BGH 提供了一个额外的输出头，专注于边界检测，而混合损失函数确保网络同时优化整体分割和边界准确性。

代码

class ins_block(BaseModule):
    def __init__(self, dim):
        super().__init__()
        self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)

        self.conv1_1 = nn.Conv2d(dim, dim, (1, 11), padding=(0, 5), groups=dim)
        self.conv1_2 = nn.Conv2d(dim, dim, (11, 1), padding=(5, 0), groups=dim)

        self.conv2_1 = nn.Conv2d(dim, dim, (1, 21), padding=(0, 10), groups=dim)
        self.conv2_2 = nn.Conv2d(dim, dim, (21, 1), padding=(10, 0), groups=dim)

        self.conv3_1 = nn.Conv2d(dim, dim, (1, 31), padding=(0, 15), groups=dim)
        self.conv3_2 = nn.Conv2d(dim, dim, (31, 1), padding=(15, 0), groups=dim)

        self.conv3 = nn.Conv2d(dim, dim, 1)

    def forward(self, x):
        u = x.clone()
        attn = self.conv0(x)

        attn_1_1 = self.conv1_1(attn)
        attn_1_2 = self.conv1_2(attn)
        attn_1 = attn_1_1 + attn_1_2

        attn_2_1 = self.conv2_1(attn)
        attn_2_2 = self.conv2_2(attn)
        attn_2 = attn_2_1 + attn_2_2

        attn_3_1 = self.conv3_1(attn)
        attn_3_2 = self.conv3_2(attn)
        attn_3 = attn_3_1 + attn_3_2

        attn = attn + attn_1 + attn_2 + attn_3

        attn = self.conv3(attn)

        return attn * u


class ana_block(BaseModule):
    def __init__(self, dim):
        super().__init__()
        self.conv0 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim)

        self.conv1_1 = nn.Conv2d(dim, dim, (1, 11), padding=(0, 5), groups=dim)
        self.conv1_2 = nn.Conv2d(dim, dim, (11, 1), padding=(5, 0), groups=dim)

        self.conv2_1 = nn.Conv2d(dim, dim, (1, 21), padding=(0, 10), groups=dim)
        self.conv2_2 = nn.Conv2d(dim, dim, (21, 1), padding=(10, 0), groups=dim)

        self.conv3_1 = nn.Conv2d(dim, dim, (1, 31), padding=(0, 15), groups=dim)
        self.conv3_2 = nn.Conv2d(dim, dim, (31, 1), padding=(15, 0), groups=dim)

        self.conv3 = nn.Conv2d(dim, dim, 1)

    def forward(self, x):
        u = x.clone()
        attn = self.conv0(x)

        attn_1 = self.conv1_1(attn)
        attn_1 = self.conv1_2(attn_1)

        attn_2 = self.conv2_1(attn)
        attn_2 = self.conv2_2(attn_2)

        attn_3 = self.conv3_1(attn)
        attn_3 = self.conv3_2(attn_3)

        attn = attn + attn_1 + attn_2 + attn_3
        attn = self.conv3(attn)

        return attn * u


class LSKAttention(BaseModule):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim
        self.proj_1 = nn.Conv2d(dim, dim, 1)
        self.activation = nn.ReLU()
        self.ins_block = ins_block(dim)
        self.ana_block = ana_block(dim)
        self.proj_2 = nn.Conv2d(dim, dim, 1)

    def forward(self, x):
        shorcut = x.clone()

        x = self.proj_1(x)
        x = self.activation(x)

        x_ins = self.ins_block(x)
        x_ins = self.proj_2(x_ins)

        x_ana = self.ana_block(x)
        x_ana = self.proj_2(x_ana)

        x = shorcut + x_ins + x_ana
        return x

class Affinity(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.Sigmoid = nn.Sigmoid()
        self.relu = nn.ReLU(inplace=True)
        self.conv = ConvBN(dim, 1, kernel_size=1, stride=1, padding=0)

    def forward(self, x1, x2):
        aff_ = self.relu(x1 + x2)
        aff = self.conv(aff_)
        aff = self.Sigmoid(aff)
        return aff

总结

本文提出了一种手术场景分割网络LSKANet，该网络结合了DLKA以充分利用区域和条带状手术特征并减少局部特征相似性导致的错误识别，MAFF以在亲和矩阵的指导下融合多尺度特征图并抑制术中伪影的干扰，以及BGH的混合损失函数，以实现更准确的边界分割。在不同场景的三个数据集（EndoVis2018，CaDIS和论文中的MILS）上进行的大量实验验证了所提方法的有效性。文中的方法在这三个数据集上都取得了新的SOTA结果，并有相当大的改进。此外，LSKANet与不同的骨干网络兼容，可以显着提高它们的性能。

与当前的SOTA方法相比，所提出的LSKANet表现出令人印象深刻的性能和改进的推理速度。然而，此方法的推理速度仍然需要提高。因此，在保证准确性的同时提高LSKANet的推理速度是近期的研究重点。作者计划将 LSKANet 与 Segment Anything Model等基础模型相结合，探索如何有效利用基础模型进行手术场景分割。此外，另一个有趣的未来方向是将对抗性防御和可解释的深度学习技术结合起来，以增强方法的鲁棒性和可解释性。