YOLOv5代码详解(common.py部分)

11 篇文章 0 订阅

目录

 

4. common.py

4.1 卷积层

4.1.1 深度分离卷积层

4.1.1 标准卷积层

4.2 标准Bottleneck

4.3 BottleneckCSP

4.4 SPP

4.5 Flatten

4.6 Focus

4.7 Concat


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)


觉得好的话,记得给个赞哦~
有什么错误,请在评论区指出。转载请注明出处,谢谢啦!
————————————————
版权声明:本文为CSDN博主「Liaojiajia2019」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/mary_0830/article/details/107125686

  • 20
    点赞
  • 93
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
CSPDarkNet 是一个深度神经网络模型,它是 YOLOv4 目标检测算法的基础模型之一,其核心是 CSP 模块(Cross Stage Partial Network)。它具有以下特点: 1. 使用 CSP 模块分离卷积计算,减少了计算量和参数数量。 2. 采用 DarkNet53 作为主干网络,具有较高的精度和速度。 3. 通过 SPP、PAN 等技术增强了模型的感受野和多尺度特征表达能力。 4. 基于 YOLOv4 的思想,使用 Mish 激活函数和多尺度训练等技术进一步提升了精度。 下面是 CSPDarkNet 的代码实现: ```python import torch import torch.nn as nn import torch.nn.functional as F class CSPBlock(nn.Module): def __init__(self, in_channels, out_channels, n=1, shortcut=True): super(CSPBlock, self).__init__() self.shortcut = shortcut hidden_channels = out_channels // 2 self.conv1 = nn.Conv2d(in_channels, hidden_channels, 1, bias=False) self.bn1 = nn.BatchNorm2d(hidden_channels) self.conv2 = nn.Conv2d(in_channels, hidden_channels, 1, bias=False) self.bn2 = nn.BatchNorm2d(hidden_channels) self.conv3 = nn.Conv2d(hidden_channels, hidden_channels, 3, padding=1, groups=n, bias=False) self.bn3 = nn.BatchNorm2d(hidden_channels) self.conv4 = nn.Conv2d(hidden_channels, hidden_channels, 1, bias=False) self.bn4 = nn.BatchNorm2d(hidden_channels) self.conv5 = nn.Conv2d(hidden_channels, hidden_channels, 3, padding=1, groups=n, bias=False) self.bn5 = nn.BatchNorm2d(hidden_channels) self.conv6 = nn.Conv2d(hidden_channels, out_channels, 1, bias=False) self.bn6 = nn.BatchNorm2d(out_channels) self.act = nn.LeakyReLU(0.1, inplace=True) def forward(self, x): if self.shortcut: shortcut = x else: shortcut = 0 x1 = self.conv1(x) x1 = self.bn1(x1) x1 = self.act(x1) x2 = self.conv2(x) x2 = self.bn2(x2) x2 = self.act(x2) x3 = self.conv3(x2) x3 = self.bn3(x3) x3 = self.act(x3) x4 = self.conv4(x3) x4 = self.bn4(x4) x4 = self.act(x4) x5 = self.conv5(x4) x5 = self.bn5(x5) x5 = self.act(x5) x6 = self.conv6(x5) x6 = self.bn6(x6) x6 = self.act(x6) out = torch.cat([x1, x6], dim=1) return out + shortcut class CSPDarkNet(nn.Module): def __init__(self, num_classes=80): super(CSPDarkNet, self).__init__() self.stem = nn.Sequential( nn.Conv2d(3, 32, 3, padding=1, bias=False), nn.BatchNorm2d(32), nn.LeakyReLU(0.1, inplace=True), nn.Conv2d(32, 64, 3, stride=2, padding=1, bias=False), nn.BatchNorm2d(64), nn.LeakyReLU(0.1, inplace=True) ) self.layer1 = nn.Sequential( CSPBlock(64, 64, n=1, shortcut=False), *[CSPBlock(64, 64, n=1) for _ in range(1, 3)] ) self.layer2 = nn.Sequential( CSPBlock(64, 128, n=2, shortcut=False), *[CSPBlock(128, 128, n=2) for _ in range(1, 9)] ) self.layer3 = nn.Sequential( CSPBlock(128, 256, n=4, shortcut=False), *[CSPBlock(256, 256, n=4) for _ in range(1, 9)] ) self.layer4 = nn.Sequential( CSPBlock(256, 512, n=8, shortcut=False), *[CSPBlock(512, 512, n=8) for _ in range(1, 5)], nn.Conv2d(512, 1024, 1, bias=False), nn.BatchNorm2d(1024), nn.LeakyReLU(0.1, inplace=True) ) self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.fc = nn.Linear(1024, num_classes) def forward(self, x): x = self.stem(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = self.avgpool(x) x = x.view(x.size(0), -1) x = self.fc(x) return x ```
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值