text: from models.common import *
  import numpy as np
  
  class Sum(nn.Module):
      # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
      def __init__(self, n, weight=False):  # n: number of inputs
          super(Sum, self).__init__()
          self.weight = weight  # apply weights boolean
          self.iter = range(n - 1)  # iter object
          if weight:
              self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True)  # layer weights
  
      def forward(self, x):
          y = x[0]  # no weight
          if self.weight:
              w = torch.sigmoid(self.w) * 2
              for i in self.iter:
                  y = y + x[i + 1] * w[i]
          else:
              for i in self.iter:
                  y = y + x[i + 1]
          return y
  
  
  class GhostConv(nn.Module):
      # Ghost Convolution https://github.com/huawei-noah/ghostnet
      def __init__(self, c1, c2, k=1, s=1, g=1, act=True):  # ch_in, ch_out, kernel, stride, groups
          super(GhostConv, self).__init__()
          c_ = c2 // 2  # hidden channels
          self.cv1 = Conv(c1, c_, k, s, g, act)
          self.cv2 = Conv(c_, c_, 5, 1, c_, act)
  
      def forward(self, x):
          y = self.cv1(x)
          return torch.cat([y, self.cv2(y)], 1)
  
  
  class GhostBottleneck(nn.Module):
      # Ghost Bottleneck https://github.com/huawei-noah/ghostnet
      def __init__(self, c1, c2, k, s):
          super(GhostBottleneck, self).__init__()
          c_ = c2 // 2
          self.conv = nn.Sequential(GhostConv(c1, c_, 1, 1),  # pw
                                    DWConv(c_, c_, k, s, act=False) if s == 2 else nn.Identity(),  # dw
                                    GhostConv(c_, c2, 1, 1, act=False))  # pw-linear
          self.shortcut = nn.Sequential(DWConv(c1, c1, k, s, act=False),
                                        Conv(c1, c2, 1, 1, act=False)) if s == 2 else nn.Identity()
  
      def forward(self, x):
          return self.conv(x) + self.shortcut(x)
  
  
  class ConvPlus(nn.Module):
      # Plus-shaped convolution
      def __init__(self, c1, c2, k=3, s=1, g=1, bias=True):  # ch_in, ch_out, kernel, stride, groups
          super(ConvPlus, self).__init__()
          self.cv1 = nn.Conv2d(c1, c2, (k, 1), s, (k // 2, 0), groups=g, bias=bias)
          self.cv2 = nn.Conv2d(c1, c2, (1, k), s, (0, k // 2), groups=g, bias=bias)
  
      def forward(self, x):
          return self.cv1(x) + self.cv2(x)
  
  
  class MixConv2d(nn.Module):
      # Mixed Depthwise Conv https://arxiv.org/abs/1907.09595
      def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
          super(MixConv2d, self).__init__()
          groups = len(k)
          if equal_ch:  # equal c_ per group
              i = torch.linspace(0, groups - 1E-6, c2).floor()  # c2 indices
              c_ = [(i == g).sum() for g in range(groups)]  # intermediate channels
          else:  # equal weight.numel() per group
              b = [c2] + [0] * groups
              a = np.eye(groups + 1, groups, k=-1)
              a -= np.roll(a, 1, axis=1)
              a *= np.array(k) ** 2
              a[0] = 1
              c_ = np.linalg.lstsq(a, b, rcond=None)[0].round()  # solve for equal weight indices, ax = b
  
          self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
          self.bn = nn.BatchNorm2d(c2)
          self.act = nn.LeakyReLU(0.1, inplace=True)
  
      def forward(self, x):
          return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
  