Reference for ultralytics/nn/modules/conv.py

def forward(self, x):
    """
    Apply convolution, batch normalization and activation to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.bn(self.conv(x)))

def forward_fuse(self, x):
    """
    Apply convolution and activation without batch normalization.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.conv(x))

def forward(self, x):
    """
    Apply convolution, batch normalization and activation to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.bn(self.conv(x) + self.cv2(x)))

def forward_fuse(self, x):
    """
    Apply fused convolution, batch normalization and activation to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.bn(self.conv(x)))

def fuse_convs(self):
    """Fuse parallel convolutions."""
    w = torch.zeros_like(self.conv.weight.data)
    i = [x // 2 for x in w.shape[2:]]
    w[:, :, i[0] : i[0] + 1, i[1] : i[1] + 1] = self.cv2.weight.data.clone()
    self.conv.weight.data += w
    self.__delattr__("cv2")
    self.forward = self.forward_fuse

def forward(self, x):
    """
    Apply 2 convolutions to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.conv2(self.conv1(x))

def forward(self, x):
    """
    Apply transposed convolution, batch normalization and activation to input.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.bn(self.conv_transpose(x)))

def forward_fuse(self, x):
    """
    Apply activation and convolution transpose operation to input.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.conv_transpose(x))

def forward(self, x):
    """
    Apply Focus operation and convolution to input tensor.

    Input shape is (b,c,w,h) and output shape is (b,4c,w/2,h/2).

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.conv(torch.cat((x[..., ::2, ::2], x[..., 1::2, ::2], x[..., ::2, 1::2], x[..., 1::2, 1::2]), 1))

def forward(self, x):
    """
    Apply Ghost Convolution to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor with concatenated features.
    """
    y = self.cv1(x)
    return torch.cat((y, self.cv2(y)), 1)

def _fuse_bn_tensor(self, branch):
    """
    Fuse batch normalization with convolution weights.

    Args:
        branch (Conv | nn.BatchNorm2d | None): Branch to fuse.

    Returns:
        (tuple): Tuple containing:
            - Fused kernel (torch.Tensor)
            - Fused bias (torch.Tensor)
    """
    if branch is None:
        return 0, 0
    if isinstance(branch, Conv):
        kernel = branch.conv.weight
        running_mean = branch.bn.running_mean
        running_var = branch.bn.running_var
        gamma = branch.bn.weight
        beta = branch.bn.bias
        eps = branch.bn.eps
    elif isinstance(branch, nn.BatchNorm2d):
        if not hasattr(self, "id_tensor"):
            input_dim = self.c1 // self.g
            kernel_value = np.zeros((self.c1, input_dim, 3, 3), dtype=np.float32)
            for i in range(self.c1):
                kernel_value[i, i % input_dim, 1, 1] = 1
            self.id_tensor = torch.from_numpy(kernel_value).to(branch.weight.device)
        kernel = self.id_tensor
        running_mean = branch.running_mean
        running_var = branch.running_var
        gamma = branch.weight
        beta = branch.bias
        eps = branch.eps
    std = (running_var + eps).sqrt()
    t = (gamma / std).reshape(-1, 1, 1, 1)
    return kernel * t, beta - running_mean * gamma / std

@staticmethod
def _pad_1x1_to_3x3_tensor(kernel1x1):
    """
    Pad a 1x1 kernel to 3x3 size.

    Args:
        kernel1x1 (torch.Tensor): 1x1 convolution kernel.

    Returns:
        (torch.Tensor): Padded 3x3 kernel.
    """
    if kernel1x1 is None:
        return 0
    else:
        return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])

def forward(self, x):
    """
    Forward pass for training mode.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    id_out = 0 if self.bn is None else self.bn(x)
    return self.act(self.conv1(x) + self.conv2(x) + id_out)

def forward_fuse(self, x):
    """
    Forward pass for deploy mode.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Output tensor.
    """
    return self.act(self.conv(x))

def fuse_convs(self):
    """Fuse convolutions for inference by creating a single equivalent convolution."""
    if hasattr(self, "conv"):
        return
    kernel, bias = self.get_equivalent_kernel_bias()
    self.conv = nn.Conv2d(
        in_channels=self.conv1.conv.in_channels,
        out_channels=self.conv1.conv.out_channels,
        kernel_size=self.conv1.conv.kernel_size,
        stride=self.conv1.conv.stride,
        padding=self.conv1.conv.padding,
        dilation=self.conv1.conv.dilation,
        groups=self.conv1.conv.groups,
        bias=True,
    ).requires_grad_(False)
    self.conv.weight.data = kernel
    self.conv.bias.data = bias
    for para in self.parameters():
        para.detach_()
    self.__delattr__("conv1")
    self.__delattr__("conv2")
    if hasattr(self, "nm"):
        self.__delattr__("nm")
    if hasattr(self, "bn"):
        self.__delattr__("bn")
    if hasattr(self, "id_tensor"):
        self.__delattr__("id_tensor")

def get_equivalent_kernel_bias(self):
    """
    Calculate equivalent kernel and bias by fusing convolutions.

    Returns:
        (tuple): Tuple containing:
            - Equivalent kernel (torch.Tensor)
            - Equivalent bias (torch.Tensor)
    """
    kernel3x3, bias3x3 = self._fuse_bn_tensor(self.conv1)
    kernel1x1, bias1x1 = self._fuse_bn_tensor(self.conv2)
    kernelid, biasid = self._fuse_bn_tensor(self.bn)
    return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid

def forward(self, x: torch.Tensor) -> torch.Tensor:
    """
    Apply channel attention to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Channel-attended output tensor.
    """
    return x * self.act(self.fc(self.pool(x)))

def forward(self, x):
    """
    Apply spatial attention to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Spatial-attended output tensor.
    """
    return x * self.act(self.cv1(torch.cat([torch.mean(x, 1, keepdim=True), torch.max(x, 1, keepdim=True)[0]], 1)))

def forward(self, x):
    """
    Apply channel and spatial attention sequentially to input tensor.

    Args:
        x (torch.Tensor): Input tensor.

    Returns:
        (torch.Tensor): Attended output tensor.
    """
    return self.spatial_attention(self.channel_attention(x))

def forward(self, x):
    """
    Concatenate input tensors along specified dimension.

    Args:
        x (List[torch.Tensor]): List of input tensors.

    Returns:
        (torch.Tensor): Concatenated tensor.
    """
    return torch.cat(x, self.d)

def forward(self, x):
    """
    Select and return a particular index from input.

    Args:
        x (List[torch.Tensor]): List of input tensors.

    Returns:
        (torch.Tensor): Selected tensor.
    """
    return x[self.index]