yolov5里面的一些module

未完，想起来就更一下~

Conv

就是yaml结构图里的CBL(conv,bn,relu)
这里用Silu替代了ReLu。#后面记得要整理一下常用的激活函数。

就是做了个卷积+BN+激活
yolov5中也用到进行下采样

class Conv(nn.Module):
    # Standard convolution
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super(Conv, self).__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def fuseforward(self, x):
        return self.act(self.conv(x))

Fouse

隔一个拿一个，按dim=1拼接后成为新的特征图，再调用上面说到的Conv。这里需要把输入通道扩大四倍，原因如图所示。

其实就是隔着像素拿，再去进行卷积。 这个过程中通道变大，特征图变小。不会损失任何信息。

class Focus(nn.Module):
    # Focus wh information into c-space
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super(Focus, self).__init__()
        self.conv = Conv(c1 * 4, c2, k, s, p, g, act)
        # self.contract = Contract(gain=2)
    def forward(self, x):  # x(b,c,w,h) -> y(b,4c,w/2,h/2)
        return self.conv(torch.cat([x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]], 1))
        # return self.conv(self.contract(x))

Bottleneck

两边通道宽。中间通道小。
能减少参数量。

class Bottleneck(nn.Module):
    # Standard bottleneck
    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_, c2, 3, 1, g=g)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))

输入x
1* 1卷积，缩小通道
3* 3恢复通道，
再上+x

ResNet中的Bottleneck layer

如图所示分别是有bottleneck和没有bottleneck的ResNet模块。

DepthWise Separable Convolution

深度可分离卷积。将卷积操作分为两部分。
代码实现：

class DepthWise_Separable_Conv2d(nn.Module):
    def __init__(self, n_in, n_out):
        super(DepthWise_Separable_Conv2d, self).__init__()
        self.depth_wise = nn.Conv2d(n_in, n_in, kernel_size=3, padding=1, groups=n_in)
        self.point_wise = nn.Conv2d(n_in, n_out, kernel_size=1)
 
    def forward(self, x):
        out = self.depth_wise(x)
        out = self.point_wise(out)
        return out

yolov5里只写了Depthwise。

Depthwise Convolution

在二维平面内分别做3*3卷积，这一步不改变通道数，只在w,h维度上运算。

yolov5里的代码：

def DWConv(c1, c2, k=1, s=1, act=True):
    # Depthwise convolution
    return Conv(c1, c2, k, s, g=math.gcd(c1, c2), act=act)

Pointwise Convolution

利用1* 1卷积改变通道数.（1*1卷积的深度为Depthwise Convolution的输出）