SK attention

SK Attention是一种注意力机制，它在图像处理中被广泛应用。SK Attention借鉴了SENet的思想，通过动态计算每个卷积核得到通道的权重，然后动态地将各个卷积核的结果进行融合。这种注意力机制可以让网络更加关注待检测目标，从而提高检测效果。

以下是SK Attention的示例代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

class SKConv(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, M=2, r=16, L=32):
        super(SKConv, self).__init__()
        d = max(in_channels // r, L)
        self.M = M
        self.out_channels = out_channels
        self.conv = nn.ModuleList()
        for i in range(M):
            self.conv.append(nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1 + i, dilation=1 + i, bias=False),
                nn.BatchNorm2d(out_channels),
                nn.ReLU(inplace=True)
            ))
        self.global_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(out_channels, d, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(d, out_channels * M, bias=False)
        )
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        batch_size = x.size(0)
        output = []
        for i, conv in enumerate(self.conv):
            output.append(conv(x))
        U = sum(output)
        s = self.global_pool(U).view(batch_size, -1)
        z = self.fc(s).view(batch_size, self.M, self.out_channels)
        a_b = self.softmax(z)
        a_b = list(a_b.chunk(self.M, dim=1))
        V = sum([a * b for a, b in zip(output, a_b)])
        return V

# 使用SK Attention
sk_conv = SKConv(in_channels=64, out_channels=128)
input = torch.randn(1, 64, 32, 32)
output = sk_conv(input)
print(output.shape)  # 输出：torch.Size([1, 128, 32, 32])