Bỏ để qua phần nội dung

Tài liệu tham khảo cho ultralytics/nn/modules/conv.py

Ghi

Tệp này có sẵn tại https://github.com/ultralytics/ultralytics/blob/main/ultralytics/nn/mô-đun/conv.py. Nếu bạn phát hiện ra một vấn đề, vui lòng giúp khắc phục nó bằng cách đóng góp Yêu cầu 🛠️ kéo. Cảm ơn bạn 🙏 !



ultralytics.nn.modules.conv.Conv

Căn cứ: Module

Tích chập tiêu chuẩn với args (ch_in, ch_out, hạt nhân, sải chân, đệm, nhóm, giãn nở, kích hoạt).

Mã nguồn trong ultralytics/nn/modules/conv.py
class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""

    default_act = nn.SiLU()  # default activation

    def __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))

__init__(c1, c2, k=1, s=1, p=None, g=1, d=1, act=True)

Khởi tạo lớp Conv với các đối số đã cho bao gồm kích hoạt.

Mã nguồn trong 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 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()

forward(x)

Áp dụng tích chập, chuẩn hóa hàng loạt và kích hoạt cho đầu vào tensor.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Apply convolution, batch normalization and activation to input tensor."""
    return self.act(self.bn(self.conv(x)))

forward_fuse(x)

Thực hiện hoán vị tích chập của dữ liệu 2D.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward_fuse(self, x):
    """Perform transposed convolution of 2D data."""
    return self.act(self.conv(x))



ultralytics.nn.modules.conv.Conv2

Căn cứ: Conv

Mô-đun RepConv được đơn giản hóa với Conv fusing.

Mã nguồn trong ultralytics/nn/modules/conv.py
class Conv2(Conv):
    """Simplified RepConv module with Conv fusing."""

    def __init__(self, c1, c2, k=3, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        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 forward(self, x):
        """Apply convolution, batch normalization and activation to input 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."""
        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

__init__(c1, c2, k=3, s=1, p=None, g=1, d=1, act=True)

Khởi tạo lớp Conv với các đối số đã cho bao gồm kích hoạt.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=3, s=1, p=None, g=1, d=1, act=True):
    """Initialize Conv layer with given arguments including activation."""
    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

forward(x)

Áp dụng tích chập, chuẩn hóa hàng loạt và kích hoạt cho đầu vào tensor.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Apply convolution, batch normalization and activation to input tensor."""
    return self.act(self.bn(self.conv(x) + self.cv2(x)))

forward_fuse(x)

Áp dụng tích chập hợp nhất, chuẩn hóa hàng loạt và kích hoạt cho đầu vào tensor.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward_fuse(self, x):
    """Apply fused convolution, batch normalization and activation to input tensor."""
    return self.act(self.bn(self.conv(x)))

fuse_convs()

Hợp nhất các kết cấu song song.

Mã nguồn trong ultralytics/nn/modules/conv.py
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



ultralytics.nn.modules.conv.LightConv

Căn cứ: Module

Tích chập ánh sáng với args (ch_in, ch_out, kernel).

https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py

Mã nguồn trong ultralytics/nn/modules/conv.py
class LightConv(nn.Module):
    """
    Light convolution with args(ch_in, ch_out, kernel).

    https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py
    """

    def __init__(self, c1, c2, k=1, act=nn.ReLU()):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv1 = Conv(c1, c2, 1, act=False)
        self.conv2 = DWConv(c2, c2, k, act=act)

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

__init__(c1, c2, k=1, act=nn.ReLU())

Khởi tạo lớp Conv với các đối số đã cho bao gồm kích hoạt.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=1, act=nn.ReLU()):
    """Initialize Conv layer with given arguments including activation."""
    super().__init__()
    self.conv1 = Conv(c1, c2, 1, act=False)
    self.conv2 = DWConv(c2, c2, k, act=act)

forward(x)

Áp dụng 2 tích chập cho đầu vào tensor.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Apply 2 convolutions to input tensor."""
    return self.conv2(self.conv1(x))



ultralytics.nn.modules.conv.DWConv

Căn cứ: Conv

Tích chập khôn ngoan.

Mã nguồn trong ultralytics/nn/modules/conv.py
class DWConv(Conv):
    """Depth-wise convolution."""

    def __init__(self, c1, c2, k=1, s=1, d=1, act=True):  # ch_in, ch_out, kernel, stride, dilation, activation
        """Initialize Depth-wise convolution with given parameters."""
        super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)

__init__(c1, c2, k=1, s=1, d=1, act=True)

Khởi tạo Depth-wise convolution với các tham số đã cho.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=1, s=1, d=1, act=True):  # ch_in, ch_out, kernel, stride, dilation, activation
    """Initialize Depth-wise convolution with given parameters."""
    super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)



ultralytics.nn.modules.conv.DWConvTranspose2d

Căn cứ: ConvTranspose2d

Độ sâu hoán đổi tích chập.

Mã nguồn trong ultralytics/nn/modules/conv.py
class DWConvTranspose2d(nn.ConvTranspose2d):
    """Depth-wise transpose convolution."""

    def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0):  # ch_in, ch_out, kernel, stride, padding, padding_out
        """Initialize DWConvTranspose2d class with given parameters."""
        super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))

__init__(c1, c2, k=1, s=1, p1=0, p2=0)

Khởi tạo lớp DWConvTranspose2d với các tham số đã cho.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=1, s=1, p1=0, p2=0):  # ch_in, ch_out, kernel, stride, padding, padding_out
    """Initialize DWConvTranspose2d class with given parameters."""
    super().__init__(c1, c2, k, s, p1, p2, groups=math.gcd(c1, c2))



ultralytics.nn.modules.conv.ConvTranspose

Căn cứ: Module

Convolution transpose layer 2d.

Mã nguồn trong ultralytics/nn/modules/conv.py
class ConvTranspose(nn.Module):
    """Convolution transpose 2d layer."""

    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=2, s=2, p=0, bn=True, act=True):
        """Initialize ConvTranspose2d layer with batch normalization and 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 forward(self, x):
        """Applies transposed convolutions, batch normalization and activation to input."""
        return self.act(self.bn(self.conv_transpose(x)))

    def forward_fuse(self, x):
        """Applies activation and convolution transpose operation to input."""
        return self.act(self.conv_transpose(x))

__init__(c1, c2, k=2, s=2, p=0, bn=True, act=True)

Khởi tạo lớp ConvTranspose2d với chức năng chuẩn hóa và kích hoạt hàng loạt.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=2, s=2, p=0, bn=True, act=True):
    """Initialize ConvTranspose2d layer with batch normalization and 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()

forward(x)

Áp dụng các kết cấu hoán vị, chuẩn hóa hàng loạt và kích hoạt cho đầu vào.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Applies transposed convolutions, batch normalization and activation to input."""
    return self.act(self.bn(self.conv_transpose(x)))

forward_fuse(x)

Áp dụng thao tác kích hoạt và chuyển vị tích chập cho đầu vào.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward_fuse(self, x):
    """Applies activation and convolution transpose operation to input."""
    return self.act(self.conv_transpose(x))



ultralytics.nn.modules.conv.Focus

Căn cứ: Module

Tập trung thông tin wh vào không gian c.

Mã nguồn trong ultralytics/nn/modules/conv.py
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):
        """Initializes Focus object with user defined channel, convolution, padding, group and activation values."""
        super().__init__()
        self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)
        # self.contract = Contract(gain=2)

    def forward(self, x):
        """
        Applies convolution to concatenated tensor and returns the output.

        Input shape is (b,c,w,h) and output shape is (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))

__init__(c1, c2, k=1, s=1, p=None, g=1, act=True)

Khởi tạo đối tượng Focus với các giá trị kênh, tích chập, đệm, nhóm và kích hoạt do người dùng xác định.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):
    """Initializes Focus object with user defined channel, convolution, padding, group and activation values."""
    super().__init__()
    self.conv = Conv(c1 * 4, c2, k, s, p, g, act=act)

forward(x)

Áp dụng tích chập cho ghép nối tensor và trả về đầu ra.

Hình dạng đầu vào là (b, c, w, h) và hình dạng đầu ra là (b, 4c, w / 2, h / 2).

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """
    Applies convolution to concatenated tensor and returns the output.

    Input shape is (b,c,w,h) and output shape is (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))



ultralytics.nn.modules.conv.GhostConv

Căn cứ: Module

Ma tích chập https://github.com/huawei-noah/ghostnet.

Mã nguồn trong ultralytics/nn/modules/conv.py
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):
        """Initializes the GhostConv object with input channels, output channels, kernel size, stride, groups and
        activation.
        """
        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 forward(self, x):
        """Forward propagation through a Ghost Bottleneck layer with skip connection."""
        y = self.cv1(x)
        return torch.cat((y, self.cv2(y)), 1)

__init__(c1, c2, k=1, s=1, g=1, act=True)

Khởi tạo đối tượng GhostConv với các kênh đầu vào, kênh đầu ra, kích thước kernel, sải chân, nhóm và kích hoạt.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
    """Initializes the GhostConv object with input channels, output channels, kernel size, stride, groups and
    activation.
    """
    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)

forward(x)

Chuyển tiếp lan truyền thông qua một lớp Ghost Bottleneck với kết nối bỏ qua.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Forward propagation through a Ghost Bottleneck layer with skip connection."""
    y = self.cv1(x)
    return torch.cat((y, self.cv2(y)), 1)



ultralytics.nn.modules.conv.RepConv

Bases: Module

RepConv là một khối kiểu rep cơ bản, bao gồm trạng thái đào tạo và triển khai.

Mô-đun này được sử dụng trong RT-DETR. Dựa trên https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py

Mã nguồn trong ultralytics/nn/modules/conv.py
class RepConv(nn.Module):
    """
    RepConv is a basic rep-style block, including training and deploy status.

    This module is used in RT-DETR.
    Based on https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py
    """

    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=3, s=1, p=1, g=1, d=1, act=True, bn=False, deploy=False):
        """Initializes Light Convolution layer with inputs, outputs & optional activation function."""
        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 forward_fuse(self, x):
        """Forward process."""
        return self.act(self.conv(x))

    def forward(self, x):
        """Forward process."""
        id_out = 0 if self.bn is None else self.bn(x)
        return self.act(self.conv1(x) + self.conv2(x) + id_out)

    def get_equivalent_kernel_bias(self):
        """Returns equivalent kernel and bias by adding 3x3 kernel, 1x1 kernel and identity kernel with their biases."""
        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 _pad_1x1_to_3x3_tensor(self, kernel1x1):
        """Pads a 1x1 tensor to a 3x3 tensor."""
        if kernel1x1 is None:
            return 0
        else:
            return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])

    def _fuse_bn_tensor(self, branch):
        """Generates appropriate kernels and biases for convolution by fusing branches of the neural network."""
        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

    def fuse_convs(self):
        """Combines two convolution layers into a single layer and removes unused attributes from the class."""
        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")

__init__(c1, c2, k=3, s=1, p=1, g=1, d=1, act=True, bn=False, deploy=False)

Khởi tạo lớp Light Convolution với đầu vào, đầu ra & chức năng kích hoạt tùy chọn.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, c2, k=3, s=1, p=1, g=1, d=1, act=True, bn=False, deploy=False):
    """Initializes Light Convolution layer with inputs, outputs & optional activation function."""
    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)

forward(x)

Quá trình chuyển tiếp.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Forward process."""
    id_out = 0 if self.bn is None else self.bn(x)
    return self.act(self.conv1(x) + self.conv2(x) + id_out)

forward_fuse(x)

Quá trình chuyển tiếp.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward_fuse(self, x):
    """Forward process."""
    return self.act(self.conv(x))

fuse_convs()

Kết hợp hai lớp tích chập thành một lớp duy nhất và loại bỏ các thuộc tính không sử dụng khỏi lớp.

Mã nguồn trong ultralytics/nn/modules/conv.py
def fuse_convs(self):
    """Combines two convolution layers into a single layer and removes unused attributes from the class."""
    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")

get_equivalent_kernel_bias()

Trả về kernel và bias tương đương bằng cách thêm kernel 3x3, kernel 1x1 và kernel identity với độ lệch của chúng.

Mã nguồn trong ultralytics/nn/modules/conv.py
def get_equivalent_kernel_bias(self):
    """Returns equivalent kernel and bias by adding 3x3 kernel, 1x1 kernel and identity kernel with their biases."""
    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



ultralytics.nn.modules.conv.ChannelAttention

Căn cứ: Module

Mô-đun chú ý kênh https://github.com/open-mmlab/mmdetection/tree/v3.0.0rc1/configs/rtmdet.

Mã nguồn trong ultralytics/nn/modules/conv.py
class ChannelAttention(nn.Module):
    """Channel-attention module https://github.com/open-mmlab/mmdetection/tree/v3.0.0rc1/configs/rtmdet."""

    def __init__(self, channels: int) -> None:
        """Initializes the class and sets the basic configurations and instance variables required."""
        super().__init__()
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Conv2d(channels, channels, 1, 1, 0, bias=True)
        self.act = nn.Sigmoid()

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """Applies forward pass using activation on convolutions of the input, optionally using batch normalization."""
        return x * self.act(self.fc(self.pool(x)))

__init__(channels)

Khởi tạo lớp và thiết lập các cấu hình cơ bản và các biến phiên bản cần thiết.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, channels: int) -> None:
    """Initializes the class and sets the basic configurations and instance variables required."""
    super().__init__()
    self.pool = nn.AdaptiveAvgPool2d(1)
    self.fc = nn.Conv2d(channels, channels, 1, 1, 0, bias=True)
    self.act = nn.Sigmoid()

forward(x)

Áp dụng chuyển tiếp vượt qua bằng cách sử dụng kích hoạt trên các kết cấu của đầu vào, tùy chọn sử dụng chuẩn hóa hàng loạt.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x: torch.Tensor) -> torch.Tensor:
    """Applies forward pass using activation on convolutions of the input, optionally using batch normalization."""
    return x * self.act(self.fc(self.pool(x)))



ultralytics.nn.modules.conv.SpatialAttention

Căn cứ: Module

Mô-đun chú ý không gian.

Mã nguồn trong ultralytics/nn/modules/conv.py
class SpatialAttention(nn.Module):
    """Spatial-attention module."""

    def __init__(self, kernel_size=7):
        """Initialize Spatial-attention module with kernel size argument."""
        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 forward(self, x):
        """Apply channel and spatial attention on input for feature recalibration."""
        return x * self.act(self.cv1(torch.cat([torch.mean(x, 1, keepdim=True), torch.max(x, 1, keepdim=True)[0]], 1)))

__init__(kernel_size=7)

Khởi tạo mô-đun Spatial-attention với đối số kích thước kernel.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, kernel_size=7):
    """Initialize Spatial-attention module with kernel size argument."""
    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()

forward(x)

Áp dụng sự chú ý của kênh và không gian trên đầu vào để hiệu chỉnh lại tính năng.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Apply channel and spatial attention on input for feature recalibration."""
    return x * self.act(self.cv1(torch.cat([torch.mean(x, 1, keepdim=True), torch.max(x, 1, keepdim=True)[0]], 1)))



ultralytics.nn.modules.conv.CBAM

Căn cứ: Module

Mô-đun chú ý khối chập.

Mã nguồn trong ultralytics/nn/modules/conv.py
class CBAM(nn.Module):
    """Convolutional Block Attention Module."""

    def __init__(self, c1, kernel_size=7):
        """Initialize CBAM with given input channel (c1) and kernel size."""
        super().__init__()
        self.channel_attention = ChannelAttention(c1)
        self.spatial_attention = SpatialAttention(kernel_size)

    def forward(self, x):
        """Applies the forward pass through C1 module."""
        return self.spatial_attention(self.channel_attention(x))

__init__(c1, kernel_size=7)

Khởi tạo CBAM với kênh đầu vào (c1) và kích thước kernel nhất định.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, c1, kernel_size=7):
    """Initialize CBAM with given input channel (c1) and kernel size."""
    super().__init__()
    self.channel_attention = ChannelAttention(c1)
    self.spatial_attention = SpatialAttention(kernel_size)

forward(x)

Áp dụng chuyển tiếp qua mô-đun C1.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Applies the forward pass through C1 module."""
    return self.spatial_attention(self.channel_attention(x))



ultralytics.nn.modules.conv.Concat

Căn cứ: Module

Nối một danh sách các tensor dọc theo kích thước.

Mã nguồn trong ultralytics/nn/modules/conv.py
class Concat(nn.Module):
    """Concatenate a list of tensors along dimension."""

    def __init__(self, dimension=1):
        """Concatenates a list of tensors along a specified dimension."""
        super().__init__()
        self.d = dimension

    def forward(self, x):
        """Forward pass for the YOLOv8 mask Proto module."""
        return torch.cat(x, self.d)

__init__(dimension=1)

Nối một danh sách các tensor dọc theo một kích thước xác định.

Mã nguồn trong ultralytics/nn/modules/conv.py
def __init__(self, dimension=1):
    """Concatenates a list of tensors along a specified dimension."""
    super().__init__()
    self.d = dimension

forward(x)

Chuyền về phía trước cho YOLOv8 mô-đun mặt nạ Proto.

Mã nguồn trong ultralytics/nn/modules/conv.py
def forward(self, x):
    """Forward pass for the YOLOv8 mask Proto module."""
    return torch.cat(x, self.d)



ultralytics.nn.modules.conv.autopad(k, p=None, d=1)

Pad để đầu ra hình dạng 'giống nhau'.

Mã nguồn trong ultralytics/nn/modules/conv.py
def 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-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p





Created 2023-11-12, Updated 2024-06-02
Authors: glenn-jocher (5), Burhan-Q (1)