सामग्री पर जाएं

के लिए संदर्भ ultralytics/nn/modules/conv.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/nn/modules/conv.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.nn.modules.conv.Conv

का रूप: Module

आर्ग्स (ch_in, ch_out, कर्नेल, स्ट्राइड, पैडिंग, समूह, फैलाव, सक्रियण) के साथ मानक कनवल्शन।

में स्रोत कोड ultralytics/nn/modules/conv.py
36 बांग्लादेश 37 38 39 40 41 42 43 44 45 46 47484950 515253 54
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)

सक्रियण सहित दिए गए तर्कों के साथ Conv परत को प्रारंभ करें।

में स्रोत कोड 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)

इनपुट के लिए कनवल्शन, बैच सामान्यीकरण और सक्रियण लागू करें tensor.

में स्रोत कोड 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)

2D डेटा का ट्रांसपोज़्ड कनवल्शन करें।

में स्रोत कोड 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

का रूप: Conv

कन्व फ्यूज़िंग के साथ सरलीकृत RepConv मॉड्यूल।

में स्रोत कोड ultralytics/nn/modules/conv.py
57 58 59 60 61 62 63 64 65 66 67 68 69 70 7172737475767778 7980
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)

सक्रियण सहित दिए गए तर्कों के साथ Conv परत को प्रारंभ करें।

में स्रोत कोड 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)

इनपुट के लिए कनवल्शन, बैच सामान्यीकरण और सक्रियण लागू करें tensor.

में स्रोत कोड 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)

इनपुट के लिए फ्यूज्ड कनवल्शन, बैच सामान्यीकरण और सक्रियण लागू करें tensor.

में स्रोत कोड 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()

समानांतर convolutions फ्यूज।

में स्रोत कोड 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

का रूप: Module

आर्ग्स (ch_in, ch_out, कर्नेल) के साथ प्रकाश कनवल्शन।

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

में स्रोत कोड ultralytics/nn/modules/conv.py
83 84 85 86 87 88 89 90 91 92 939495969798
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())

सक्रियण सहित दिए गए तर्कों के साथ Conv परत को प्रारंभ करें।

में स्रोत कोड 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)

इनपुट के लिए 2 convolutions लागू करें tensor.

में स्रोत कोड 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

का रूप: Conv

गहराई के अनुसार कनवल्शन।

में स्रोत कोड ultralytics/nn/modules/conv.py
101 102 103 104 105 106
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)

दिए गए मापदंडों के साथ गहराई-वार कनवल्शन को इनिशियलाइज़ करें।

में स्रोत कोड 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

का रूप: ConvTranspose2d

गहराई के अनुसार कन्वल्शन ट्रांसपोज करें।

में स्रोत कोड ultralytics/nn/modules/conv.py
109 110 111 112 113 114
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)

दिए गए मापदंडों के साथ DWConvTranspose2d क्लास प्रारंभ करें।

में स्रोत कोड 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

का रूप: Module

कनवल्शन 2d परत को स्थानांतरित करता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
117 118 119 120 121 122 123 124 125 126 127 128129 130 131 132 133134 135
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)

बैच सामान्यीकरण और सक्रियण फ़ंक्शन के साथ ConvTranspose2d परत प्रारंभ करें।

में स्रोत कोड ultralytics/nn/modules/conv.py
122 123 124 125 126 127
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)

इनपुट के लिए ट्रांसपोज़्ड convolutions, बैच सामान्यीकरण और सक्रियण लागू करता है।

में स्रोत कोड 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)

इनपुट के लिए सक्रियण और कनवल्शन ट्रांसपोज़ ऑपरेशन लागू करता है।

में स्रोत कोड 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

का रूप: Module

सी-स्पेस में जानकारी पर ध्यान दें।

में स्रोत कोड ultralytics/nn/modules/conv.py
138 139 140 141 142 143 144 145 146 147 148149 150 151 152 153
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)

उपयोगकर्ता परिभाषित चैनल, कनवल्शन, पैडिंग, समूह और सक्रियण मानों के साथ फोकस ऑब्जेक्ट को इनिशियलाइज़ करता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
141 142 143 144
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)

concatenated करने के लिए कनवल्शन लागू करता है tensor और आउटपुट लौटाता है।

इनपुट आकार (बी, सी, डब्ल्यू, एच) है और आउटपुट आकार (बी, 4 सी, डब्ल्यू / 2, एच / 2) है।

में स्रोत कोड 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

का रूप: Module

भूत कनवल्शन https://github.com/huawei-noah/ghostnet।

में स्रोत कोड ultralytics/nn/modules/conv.py
157 158 159 160 161 162 163 164 165 166 167 168 169 170171172
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)

GhostConv ऑब्जेक्ट को इनपुट चैनल, आउटपुट चैनल, कर्नेल आकार, स्ट्राइड, समूह और सक्रियण।

में स्रोत कोड ultralytics/nn/modules/conv.py
160 161 162 163 164 165 166 167
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)

स्किप कनेक्शन के साथ घोस्ट बॉटलनेक लेयर के माध्यम से फॉरवर्ड प्रसार।

में स्रोत कोड 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

का रूप: Module

RepConv एक बुनियादी प्रतिनिधि-शैली ब्लॉक है, जिसमें प्रशिक्षण और तैनाती की स्थिति शामिल है।

इस मॉड्यूल का उपयोग किया जाता है RT-DETR. https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py आधार पर

में स्रोत कोड ultralytics/nn/modules/conv.py
175 176 177 178 179 180 181 182 183 184 185 186 187 188189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204205 206207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228229 230231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258259 260261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
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)

इनपुट, आउटपुट और वैकल्पिक सक्रियण फ़ंक्शन के साथ लाइट कनवल्शन लेयर को इनिशियलाइज़ करता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
185 186 187 188 189 190 191 192 193 194 195196
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)

आगे की प्रक्रिया।

में स्रोत कोड ultralytics/nn/modules/conv.py
202 203 204 205
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)

आगे की प्रक्रिया।

में स्रोत कोड ultralytics/nn/modules/conv.py
def forward_fuse(self, x):
    """Forward process."""
    return self.act(self.conv(x))

fuse_convs()

दो कनवल्शन परतों को एक परत में जोड़ता है और कक्षा से अप्रयुक्त विशेषताओं को हटा देता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268269 270271 272 273 274 275
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()

समतुल्य कर्नेल और बायस को उनके पूर्वाग्रहों के साथ 3x3 कर्नेल, 1x1 कर्नेल और पहचान कर्नेल जोड़कर लौटाता है.

में स्रोत कोड 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

का रूप: Module

चैनल-ध्यान मॉड्यूल https://github.com/open-mmlab/mmdetection/tree/v3.0.0rc1/configs/rtmdet।

में स्रोत कोड ultralytics/nn/modules/conv.py
278 279 280 281 282 283 284 285 286 287 288289 290
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)

क्लास को इनिशियलाइज़ करता है और आवश्यक बेसिक कॉन्फ़िगरेशन और इंस्टेंस वैरिएबल सेट करता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
281 282 283 284 285 286
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)

इनपुट के कनवल्शन पर सक्रियण का उपयोग करके फॉरवर्ड पास लागू करता है, वैकल्पिक रूप से बैच सामान्यीकरण का उपयोग करता है।

में स्रोत कोड 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

का रूप: Module

स्थानिक-ध्यान मॉड्यूल।

में स्रोत कोड ultralytics/nn/modules/conv.py
293 294 295 296 297 298299 300 301 302 303304305 306
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)

कर्नेल आकार तर्क के साथ स्थानिक-ध्यान मॉड्यूल प्रारंभ करें।

में स्रोत कोड ultralytics/nn/modules/conv.py
296 297 298299 300 301302
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)

सुविधा पुनर्गणना के लिए इनपुट पर चैनल और स्थानिक ध्यान लागू करें।

में स्रोत कोड 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

का रूप: Module

दृढ़ ब्लॉक ध्यान मॉड्यूल।

में स्रोत कोड ultralytics/nn/modules/conv.py
309 310 311 312 313 314 315 316 317 318319 320
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)

दिए गए इनपुट चैनल (c1) और कर्नेल आकार के साथ CBAM को इनिशियलाइज़ करें।

में स्रोत कोड ultralytics/nn/modules/conv.py
312 313 314 315 316
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)

C1 मॉड्यूल के माध्यम से आगे के पास को लागू करता है।

में स्रोत कोड 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

का रूप: Module

आयाम के साथ टेंसर की एक सूची को संयोजित करें।

में स्रोत कोड ultralytics/nn/modules/conv.py
323 324 325 326 327328329 330 331 332 333 
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)

एक निर्दिष्ट आयाम के साथ टेंसर की एक सूची को जोड़ता है।

में स्रोत कोड ultralytics/nn/modules/conv.py
326 327 328 329
def __init__(self, dimension=1):
    """Concatenates a list of tensors along a specified dimension."""
    super().__init__()
    self.d = dimension

forward(x)

के लिए फॉरवर्ड पास YOLOv8 मास्क प्रोटो मॉड्यूल।

में स्रोत कोड 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)

पैड से 'समान' आकार का आउटपुट देता है।

में स्रोत कोड 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





2023-11-12 बनाया गया, अपडेट किया गया 2023-11-25
लेखक: ग्लेन-जोचर (3)