Reference for ultralytics/nn/modules/conv.py

def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
    """
    Initialize Conv layer with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p (int, optional): Padding.
        g (int): Groups.
        d (int): Dilation.
        act (bool | nn.Module): Activation function.
    """
    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 __init__(self, c1, c2, k=3, s=1, p=None, g=1, d=1, act=True):
    """
    Initialize Conv2 layer with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p (int, optional): Padding.
        g (int): Groups.
        d (int): Dilation.
        act (bool | nn.Module): Activation function.
    """
    super().__init__(c1, c2, k, s, p, g=g, d=d, act=act)
    self.cv2 = nn.Conv2d(c1, c2, 1, s, autopad(1, p, d), groups=g, dilation=d, bias=False)  # add 1x1 conv

def __init__(self, c1, c2, k=1, act=nn.ReLU()):
    """
    Initialize LightConv layer with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size for depthwise convolution.
        act (nn.Module): Activation function.
    """
    super().__init__()
    self.conv1 = Conv(c1, c2, 1, act=False)
    self.conv2 = DWConv(c2, c2, k, act=act)

def __init__(self, c1, c2, k=1, s=1, d=1, act=True):
    """
    Initialize depth-wise convolution with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        d (int): Dilation.
        act (bool | nn.Module): Activation function.
    """
    super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)

def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0):
    """
    Initialize depth-wise transpose convolution with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p1 (int): Padding.
        p2 (int): Output padding.
    """
    super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))

def __init__(self, c1, c2, k=2, s=2, p=0, bn=True, act=True):
    """
    Initialize ConvTranspose layer with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p (int): Padding.
        bn (bool): Use batch normalization.
        act (bool | nn.Module): Activation function.
    """
    super().__init__()
    self.conv_transpose = nn.ConvTranspose2d(c1, c2, k, s, p, bias=not bn)
    self.bn = nn.BatchNorm2d(c2) if bn else nn.Identity()
    self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):
    """
    Initialize Focus module with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p (int, optional): Padding.
        g (int): Groups.
        act (bool | nn.Module): Activation function.
    """
    super().__init__()
    self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)

def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
    """
    Initialize Ghost Convolution module with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        g (int): Groups.
        act (bool | nn.Module): Activation function.
    """
    super().__init__()
    c_ = c2 // 2  # hidden channels
    self.cv1 = Conv(c1, c_, k, s, None, g, act=act)
    self.cv2 = Conv(c_, c_, 5, 1, None, c_, act=act)

def __init__(self, c1, c2, k=3, s=1, p=1, g=1, d=1, act=True, bn=False, deploy=False):
    """
    Initialize RepConv module with given parameters.

    Args:
        c1 (int): Number of input channels.
        c2 (int): Number of output channels.
        k (int): Kernel size.
        s (int): Stride.
        p (int): Padding.
        g (int): Groups.
        d (int): Dilation.
        act (bool | nn.Module): Activation function.
        bn (bool): Use batch normalization for identity branch.
        deploy (bool): Deploy mode for inference.
    """
    super().__init__()
    assert k == 3 and p == 1
    self.g = g
    self.c1 = c1
    self.c2 = c2
    self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

    self.bn = nn.BatchNorm2d(num_features=c1) if bn and c2 == c1 and s == 1 else None
    self.conv1 = Conv(c1, c2, k, s, p=p, g=g, act=False)
    self.conv2 = Conv(c1, c2, 1, s, p=(p - k // 2), g=g, act=False)

def __init__(self, channels: int) -> None:
    """
    Initialize Channel-attention module.

    Args:
        channels (int): Number of input channels.
    """
    super().__init__()
    self.pool = nn.AdaptiveAvgPool2d(1)
    self.fc = nn.Conv2d(channels, channels, 1, 1, 0, bias=True)
    self.act = nn.Sigmoid()

def __init__(self, kernel_size=7):
    """
    Initialize Spatial-attention module.

    Args:
        kernel_size (int): Size of the convolutional kernel (3 or 7).
    """
    super().__init__()
    assert kernel_size in {3, 7}, "kernel size must be 3 or 7"
    padding = 3 if kernel_size == 7 else 1
    self.cv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False)
    self.act = nn.Sigmoid()

def __init__(self, c1, kernel_size=7):
    """
    Initialize CBAM with given parameters.

    Args:
        c1 (int): Number of input channels.
        kernel_size (int): Size of the convolutional kernel for spatial attention.
    """
    super().__init__()
    self.channel_attention = ChannelAttention(c1)
    self.spatial_attention = SpatialAttention(kernel_size)

def __init__(self, dimension=1):
    """
    Initialize Concat module.

    Args:
        dimension (int): Dimension along which to concatenate tensors.
    """
    super().__init__()
    self.d = dimension

def __init__(self, index=0):
    """
    Initialize Index module.

    Args:
        index (int): Index to select from input.
    """
    super().__init__()
    self.index = index