YOLOv5代碼詳解（common.py部分）

4. common.py

該部分是backbone各個模塊參數講解。

4.1 卷積層

4.1.1 深度分離卷積層

深度分離(DepthWise)卷積層，是GCONV的極端情況，分組數量等於輸入通道數量，即每個通道作爲一個小組分別進行卷積，結果聯結作爲輸出，Cin = Cout = g，沒有bias項。參考鏈接

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)

k=1是卷積核kenel，s=1是步長stride，math.gcd() 返回的是最大公約數。

4.1.1 標準卷積層

class Conv(nn.Module):
    # Standard convolution
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, 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.LeakyReLU(0.1, inplace=True) if act 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))

• g=1表示從輸入通道到輸出通道的阻塞連接數爲1。
• autopad(k, p)此處換成自動填充。
• 標準卷積層包括conv+BN+Leaky relu。
  

nn.Conv2d函數基本參數是：
nn.Conv2d(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')

參數：nn.Conv參考鏈接

• in_channel:輸入數據的通道數，例RGB圖片通道數爲3。
• out_channel: 輸出數據的通道數，這個根據模型調整。
• kennel_size: 卷積核大小，可以是int，或tuple；kennel_size=2,意味着卷積大小(2,2)，kennel_size=（2,3），意味着卷積大小（2，3）即非正方形卷積。
• stride：步長，默認爲1，與kennel_size類似，stride=2,意味着步長上下左右掃描皆爲2，stride=（2,3），左右掃描步長爲2，上下爲3。
• padding：零填充。
• groups：從輸入通道到輸出通道的阻塞連接數。
• bias：如果爲“True“，則向輸出添加可學習的偏置。

4.2 標準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(Bottleneck, self).__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))

4.3 BottleneckCSP

這部分是幾個標準Bottleneck的堆疊+幾個標準卷積層。

class BottleneckCSP(nn.Module):
    # CSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super(BottleneckCSP, self).__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = nn.Conv2d(c1, c_, 1, 1, bias=False)
        self.cv3 = nn.Conv2d(c_, c_, 1, 1, bias=False)
        self.cv4 = Conv(2 * c_, c2, 1, 1)
        self.bn = nn.BatchNorm2d(2 * c_)  # applied to cat(cv2, cv3)
        self.act = nn.LeakyReLU(0.1, inplace=True)
        self.m = nn.Sequential(*[Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)])

    def forward(self, x):
        y1 = self.cv3(self.m(self.cv1(x)))
        y2 = self.cv2(x)
        return self.cv4(self.act(self.bn(torch.cat((y1, y2), dim=1))))

4.4 SPP

SPP是空間金字塔池化的縮寫。

class SPP(nn.Module):
    # Spatial pyramid pooling layer used in YOLOv3-SPP
    def __init__(self, c1, c2, k=(5, 9, 13)):
        super(SPP, self).__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * (len(k) + 1), c2, 1, 1)
        self.m = nn.ModuleList([nn.MaxPool2d(kernel_size=x, stride=1, padding=x // 2) for x in k])

    def forward(self, x):
        x = self.cv1(x)
        return self.cv2(torch.cat([x] + [m(x) for m in self.m], 1))

torch.cat() 是將兩個tensor橫着拼接在一起。
補充：或者是list列表中的tensor。參考鏈接

4.5 Flatten

在全局平均池化以後使用，去掉2個維度。

class Flatten(nn.Module):
    # Use after nn.AdaptiveAvgPool2d(1) to remove last 2 dimensions
    def forward(self, x):
        return x.view(x.size(0), -1)

x.size(0)是batch的大小。

4.6 Focus

把寬度w和高度h的信息整合到c空間中。

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)

    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))

需要注意的是，concat的獲取如下圖所示。圖參考鏈接

4.7 Concat

拼接函數，將兩個tensor進行拼接起來。

class Concat(nn.Module):
    # Concatenate a list of tensors along dimension
    def __init__(self, dimension=1):
        super(Concat, self).__init__()
        self.d = dimension

    def forward(self, x):
        return torch.cat(x, self.d)

覺得好的話，記得給個贊哦~
有什麼錯誤，請在評論區指出。轉載請註明出處，謝謝啦！