"""
An implementation of GhostNet Model as defined in:
GhostNet: More Features from Cheap Operations. https://arxiv.org/abs/1911.11907
The train script of the model is similar to that of MobileNetV3
Original model: https://github.com/huawei-noah/CV-backbones/tree/master/ghostnet_pytorch
"""
import math
from functools import partial
import torch
import torch.nn as nn
import torch.nn.functional as F
from timm.layers import drop_path, SqueezeExcite
from timm.models.layers import CondConv2d, hard_sigmoid, DropPath__all__ = ['C3_GhostModule']_SE_LAYER = partial(SqueezeExcite, gate_fn=hard_sigmoid, divisor=4)class DynamicConv(nn.Module):""" Dynamic Conv layer"""def __init__(self, in_features, out_features, kernel_size=1, stride=1, padding='', dilation=1,groups=1, bias=False, num_experts=4):super().__init__()self.routing = nn.Linear(in_features, num_experts)self.cond_conv = CondConv2d(in_features, out_features, kernel_size, stride, padding, dilation,groups, bias, num_experts)def forward(self, x):pooled_inputs = F.adaptive_avg_pool2d(x, 1).flatten(1)  # CondConv routingrouting_weights = torch.sigmoid(self.routing(pooled_inputs))x = self.cond_conv(x, routing_weights)return xclass ConvBnAct(nn.Module):""" Conv + Norm Layer + Activation w/ optional skip connection"""def __init__(self, in_chs, out_chs, kernel_size, stride=1, dilation=1, pad_type='',skip=False, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, drop_path_rate=0., num_experts=4):super(ConvBnAct, self).__init__()self.has_residual = skip and stride == 1 and in_chs == out_chsself.drop_path_rate = drop_path_rate# self.conv = create_conv2d(in_chs, out_chs, kernel_size, stride=stride, dilation=dilation, padding=pad_type)self.conv = DynamicConv(in_chs, out_chs, kernel_size, stride, dilation=dilation, padding=pad_type,num_experts=num_experts)self.bn1 = norm_layer(out_chs)self.act1 = act_layer()def feature_info(self, location):if location == 'expansion':  # output of conv after act, same as block coutputinfo = dict(module='act1', hook_type='forward', num_chs=self.conv.out_channels)else:  # location == 'bottleneck', block outputinfo = dict(module='', hook_type='', num_chs=self.conv.out_channels)return infodef forward(self, x):shortcut = xx = self.conv(x)x = self.bn1(x)x = self.act1(x)if self.has_residual:if self.drop_path_rate > 0.:x = drop_path(x, self.drop_path_rate, self.training)x += shortcutreturn xclass GhostModule(nn.Module):def __init__(self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, act_layer=nn.ReLU, num_experts=4):super(GhostModule, self).__init__()self.oup = oupinit_channels = math.ceil(oup / ratio)new_channels = init_channels * (ratio - 1)self.primary_conv = nn.Sequential(DynamicConv(inp, init_channels, kernel_size, stride, kernel_size // 2, bias=False, num_experts=num_experts),nn.BatchNorm2d(init_channels),act_layer() if act_layer is not None else nn.Sequential(),)self.cheap_operation = nn.Sequential(DynamicConv(init_channels, new_channels, dw_size, 1, dw_size // 2, groups=init_channels, bias=False,num_experts=num_experts),nn.BatchNorm2d(new_channels),act_layer() if act_layer is not None else nn.Sequential(),)def forward(self, x):x1 = self.primary_conv(x)x2 = self.cheap_operation(x1)out = torch.cat([x1, x2], dim=1)return out[:, :self.oup, :, :]class GhostBottleneck(nn.Module):""" Ghost bottleneck w/ optional SE"""def __init__(self, in_chs, out_chs, dw_kernel_size=3,stride=1, act_layer=nn.ReLU, se_ratio=0., drop_path=0., num_experts=4):super(GhostBottleneck, self).__init__()has_se = se_ratio is not None and se_ratio > 0.self.stride = stridemid_chs = in_chs * 2# Point-wise expansionself.ghost1 = GhostModule(in_chs, mid_chs, act_layer=act_layer, num_experts=num_experts)# Depth-wise convolutionif self.stride > 1:self.conv_dw = nn.Conv2d(mid_chs, mid_chs, dw_kernel_size, stride=stride,padding=(dw_kernel_size - 1) // 2, groups=mid_chs, bias=False)self.bn_dw = nn.BatchNorm2d(mid_chs)else:self.conv_dw = Noneself.bn_dw = None# Squeeze-and-excitationself.se = _SE_LAYER(mid_chs, se_ratio=se_ratio,act_layer=act_layer if act_layer is not nn.GELU else nn.ReLU) if has_se else None# Point-wise linear projectionself.ghost2 = GhostModule(mid_chs, out_chs, act_layer=None, num_experts=num_experts)# shortcutif in_chs == out_chs and self.stride == 1:self.shortcut = nn.Sequential()else:self.shortcut = nn.Sequential(DynamicConv(in_chs, in_chs, dw_kernel_size, stride=stride,padding=(dw_kernel_size - 1) // 2, groups=in_chs, bias=False, num_experts=num_experts),nn.BatchNorm2d(in_chs),DynamicConv(in_chs, out_chs, 1, stride=1, padding=0, bias=False, num_experts=num_experts),nn.BatchNorm2d(out_chs),)self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()def forward(self, x):shortcut = x# 1st ghost bottleneckx = self.ghost1(x)# Depth-wise convolutionif self.conv_dw is not None:x = self.conv_dw(x)x = self.bn_dw(x)# Squeeze-and-excitationif self.se is not None:x = self.se(x)# 2nd ghost bottleneckx = self.ghost2(x)x = self.shortcut(shortcut) + self.drop_path(x)return xdef 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-sizeif p is None:p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-padreturn pclass Conv(nn.Module):"""Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""default_act = nn.SiLU()  # default activationdef __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)))def forward_fuse(self, x):"""Perform transposed convolution of 2D data."""return self.act(self.conv(x))class C3_GhostModule(nn.Module):# CSP Bottleneck with 3 convolutionsdef __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansionsuper().__init__()c_ = int(c2 * e)  # hidden channelsself.cv1 = Conv(c1, c_, 1, 1)self.cv2 = Conv(c1, c_, 1, 1)self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)self.m = nn.Sequential(*(GhostModule(c_, c_) for _ in range(n)))def forward(self, x):return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))if __name__ == "__main__":# Generating Sample imageimage_size = (1, 64, 224, 224)image = torch.rand(*image_size)# Modelmodel = C3_GhostModule(64, 64)out = model(image)print(out.size())

​

# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
anchors:- [10,13, 16,30, 33,23]  # P3/8- [30,61, 62,45, 59,119]  # P4/16- [116,90, 156,198, 373,326]  # P5/32# YOLOv5 v6.0 backbone
backbone:# [from, number, module, args][[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2[-1, 1, Conv, [128, 3, 2]], # 1-P2/4[-1, 3, C3_GhostModule, [128]],[-1, 1, Conv, [256, 3, 2]], # 3-P3/8[-1, 6, C3_GhostModule, [256]],[-1, 1, Conv, [512, 3, 2]], # 5-P4/16[-1, 9, C3_GhostModule, [512]],[-1, 1, Conv, [1024, 3, 2]], # 7-P5/32[-1, 3, C3_GhostModule, [1024]],[-1, 1, SPPF, [1024, 5]], # 9]# YOLOv5 v6.0 head
head: [[-1, 1, Conv, [512, 1, 1]],[-1, 1, nn.Upsample, [None, 2, "nearest"]],[[-1, 6], 1, Concat, [1]], # cat backbone P4[-1, 3, C3_GhostModule, [512, False]], # 13[-1, 1, Conv, [256, 1, 1]],[-1, 1, nn.Upsample, [None, 2, "nearest"]],[[-1, 4], 1, Concat, [1]], # cat backbone P3[-1, 3, C3_GhostModule, [256, False]], # 17 (P3/8-small)[-1, 1, Conv, [256, 3, 2]],[[-1, 14], 1, Concat, [1]], # cat head P4[-1, 3, C3_GhostModule, [512, False]], # 20 (P4/16-medium)[-1, 1, Conv, [512, 3, 2]],[[-1, 10], 1, Concat, [1]], # cat head P5[-1, 3, C3_GhostModule, [1024, False]], # 23 (P5/32-large)[[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)]