YOLOV8源码解读-c2模块-以及Bottleneck

先给出一键三连模块  包含卷积-BN-激活函数

def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p


class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))

1、C2模块

c2模块的构成：c2模块中用到了Bottleneck模块

1.1、Bottleneck模块源码

class Bottleneck(nn.Module):
    """Standard bottleneck."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
        expansion.
        """
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

       

        如果输入通道数和输出通道数相同并且启用Shorcut，那么就会有ADD，相当于一个小的残差网络。

        如果输入通道和最终输出通道数不相同，那么他就是个简单的卷积模块。

1.2、c2模块源码

class C2(nn.Module):
    """CSP Bottleneck with 2 convolutions."""

    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        """Initializes the CSP Bottleneck with 2 convolutions module with arguments ch_in, ch_out, number, shortcut,
        groups, expansion.
        """
        super().__init__()
        self.c = int(c2 * e)  # 通道数默认减半，可以自行调节数量
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)#利用上面的得到的c，进行通道数调整
        self.cv2 = Conv(2 * self.c, c2, 1)  #optional act=FReLU(c2)
        # self.attention = ChannelAttention(2 * self.c)  # or SpatialAttention()
        self.m = nn.Sequential(*(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n)))

    def forward(self, x):
        """Forward pass through the CSP bottleneck with 2 convolutions."""
        a, b = self.cv1(x).chunk(2, 1)
        return self.cv2(torch.cat((self.m(a), b), 1))

c2模块就比较有意思了，他的主要目的是减少计算量。将输入一分为二，只计算其中一部分。

那个chunk函数就是划分用的，平均划分为2段，沿着通道维度。还有一个函数叫spilt，它是可以自定义划分大小的。

2、chunk和split举例

例子是最好的老师，有些函数可以通过一些例子来理解，下面将举2个例子来帮助了解chunk 和split

chunk举例子：

x = torch.zeros(1, 20, 256, 256)
A = torch.chunk(x, chunks=10, dim=1)
for i in A:
    print(i.size())

上述创建了一个（1,10,256,256）的张量，利用chunk将他分成10份。因为是平均分，所以每份大小为（1，2,256,256），因为只使用了1个变量A接收,所以A是一个元组，里面包含了10个张量，利用循环查看每个张量的大小，以验证chunk。

split举例子：

x = torch.zeros(1, 20, 256, 256)
split_list = [1, 3, 2, 4, 10]
A = torch.split(x, split_list ,dim=1)
for i in A:
    print(i.size())

split可以指定大小划分了，比如上面split_list中定义了每个张量的大小，并通过split划分大小，不过这个split_list中的数加起来一定要等于那个维度上的数，例如1+3+2+4+10=20.如果不等于会报错。