o W hqS@s2dZddlZddlZddlZddlmZdZd#ddZGdddej Z Gd d d e Z Gd d d ej Z Gd dde Z GdddejZGdddej ZGdddej ZGdddej ZGdddej ZGdddej ZGdddej ZGdddej ZGdd d ej ZGd!d"d"ej ZdS)$zConvolution modules.N)ConvConv2 LightConvDWConvDWConvTranspose2d ConvTransposeFocus GhostConvChannelAttentionSpatialAttentionCBAMConcatRepConvIndexcs`dkrt|tr|ddnfdd|D}|dur.t|tr'|dndd|D}|S)zPad to 'same' shape outputs.rcsg|] }|ddqSr.0xdrO/var/www/vscode/kcb/lib/python3.10/site-packages/ultralytics/nn/modules/conv.py szautopad..NcSg|]}|dqSrrrrrrr!) isinstanceint)kprrrrautopads , r"c:eZdZdZeZd fdd ZddZd d Z Z S) ra? Standard convolution module with batch normalization and activation. Attributes: conv (nn.Conv2d): Convolutional layer. bn (nn.BatchNorm2d): Batch normalization layer. act (nn.Module): Activation function layer. default_act (nn.Module): Default activation function (SiLU). rNTc srttj||||t|||||dd|_t||_|dur'|j|_ dSt |tj r2||_ dSt |_ dS)a 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. FgroupsdilationbiasTN) super__init__nnConv2dr"conv BatchNorm2dbn default_actrModuleIdentityact selfc1c2r sr!grr2 __class__rrr)2s $ 8z Conv.__init__cC||||Sz Apply convolution, batch normalization and activation to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. r2r.r,r4rrrrforwardE z Conv.forwardcC|||S)z Apply convolution and activation without batch normalization. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. r2r,r>rrr forward_fuseQ zConv.forward_fuse)rrNrrT __name__ __module__ __qualname____doc__r*SiLUr/r)r?rC __classcell__rrr9rr%s   rcs:eZdZdZdfdd Zdd Zd d Zd d ZZS)ra' Simplified RepConv module with Conv fusing. Attributes: conv (nn.Conv2d): Main 3x3 convolutional layer. cv2 (nn.Conv2d): Additional 1x1 convolutional layer. bn (nn.BatchNorm2d): Batch normalization layer. act (nn.Module): Activation function layer. rNTc sDtj||||||||dtj||d|td||||dd|_dS)a 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. r8rr2rFr$N)r(r)r*r+r"cv2r3r9rrr)is(zConv2.__init__cCs ||||||Sr<)r2r.r,rNr>rrrr?zs z Conv2.forwardcCr;)z Apply fused convolution, batch normalization and activation to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. r=r>rrrrCr@zConv2.forward_fusecCst|jjj}dd|jddD}|jjj|dddd|d|dd|d|ddf<|jjj|7_|d|j |_ dS)zFuse parallel convolutions.cSrrrrrrrrrz$Conv2.fuse_convs..rNrrrN) torch zeros_liker,weightdatashaperNclone __delattr__rCr?)r4wirrr fuse_convss B  zConv2.fuse_convs)rLrNrrT) rFrGrHrIr)r?rCrXrKrrr9rr^s    rcs2eZdZdZdeffdd ZddZZS)ra Light convolution module with 1x1 and depthwise convolutions. This implementation is based on the PaddleDetection HGNetV2 backbone. Attributes: conv1 (Conv): 1x1 convolution layer. conv2 (DWConv): Depthwise convolution layer. rcs2tt||ddd|_t||||d|_dS)a! 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. rFr2N)r(r)rconv1rconv2)r4r5r6r r2r9rrr)s zLightConv.__init__cCrA)z Apply 2 convolutions to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r[rZr>rrrr?rDzLightConv.forward) rFrGrHrIr*ReLUr)r?rKrrr9rrs rc"eZdZdZdfdd ZZS)rzDepth-wise convolution module.rTc s&tj||||t||||ddS)aQ 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. rMNr(r)mathgcd)r4r5r6r r7rr2r9rrr)& zDWConv.__init__rrrTrFrGrHrIr)rKrrr9rrrcr])rz(Depth-wise transpose convolution module.rrc s&tj||||||t||ddS)aH 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. )r%Nr^)r4r5r6r r7p1p2r9rrr)razDWConvTranspose2d.__init__)rrrrrcrrr9rrrdrcr#) ras Convolution transpose module with optional batch normalization and activation. Attributes: conv_transpose (nn.ConvTranspose2d): Transposed convolution layer. bn (nn.BatchNorm2d | nn.Identity): Batch normalization layer. act (nn.Module): Activation function layer. default_act (nn.Module): Default activation function (SiLU). rrTcstttj|||||| d|_|rt|nt|_|dur(|j|_ dSt |tj r3||_ dSt|_ dS)a} 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. r'TN) r(r)r*ConvTranspose2dconv_transposer-r1r.r/rr0r2)r4r5r6r r7r!r.r2r9rrr)s 8zConvTranspose.__init__cCr;)z Apply transposed convolution, batch normalization and activation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r2r.rir>rrrr?r@zConvTranspose.forwardcCrA)z Apply activation and convolution transpose operation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r2rir>rrrrCrDzConvTranspose.forward_fuse)rrrTTrErrr9rrs   rcs*eZdZdZd fdd ZddZZS) rz Focus module for concentrating feature information. Slices input tensor into 4 parts and concatenates them in the channel dimension. Attributes: conv (Conv): Convolution layer. rNTc s*tt|d||||||d|_dS)am 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. rYN)r(r)rr,)r4r5r6r r7r!r8r2r9rrr)(s zFocus.__init__c Csr|t|dddddddf|dddddddf|dddddddf|dddddddffdS)a 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. .Nrr)r,rOcatr>rrrr?9sr z Focus.forward)rrNrTrFrGrHrIr)r?rKrrr9rrs rcs*eZdZdZdfdd ZddZZS) r a+ Ghost Convolution module. Generates more features with fewer parameters by using cheap operations. Attributes: cv1 (Conv): Primary convolution. cv2 (Conv): Cheap operation convolution. References: https://github.com/huawei-noah/Efficient-AI-Backbones rTc sFt|d}t||||d||d|_t||ddd||d|_dS)aQ 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. rNrYr)r(r)rcv1rN)r4r5r6r r7r8r2c_r9rrr)Ws zGhostConv.__init__cCs ||}t|||fdS)z Apply Ghost Convolution to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor with concatenated features. r)rnrOrkrN)r4ryrrrr?hs zGhostConv.forwardrbrlrrr9rr Is r cs^eZdZdZeZdfdd Zdd Zd d Z d d Z e ddZ ddZ ddZZS)ra  RepConv module with training and deploy modes. This module is used in RT-DETR and can fuse convolutions during inference for efficiency. Attributes: conv1 (Conv): 3x3 convolution. conv2 (Conv): 1x1 convolution. bn (nn.BatchNorm2d, optional): Batch normalization for identity branch. act (nn.Module): Activation function. default_act (nn.Module): Default activation function (SiLU). References: https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py rLrTFc st|dkr |dksJ||_||_||_|dur|jn t|tjr'|nt |_ | r<||kr<|dkrrrrrCrDzRepConv.forward_fusecCs6|jdurdn||}||||||S)z Forward pass for training mode. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. Nr)r.r2rZr[)r4rid_outrrrr?s zRepConv.forwardcCsN||j\}}||j\}}||j\}}|||||||fS)z Calculate equivalent kernel and bias by fusing convolutions. Returns: (torch.Tensor): Equivalent kernel (torch.Tensor): Equivalent bias )_fuse_bn_tensorrZr[r._pad_1x1_to_3x3_tensor)r4 kernel3x3bias3x3 kernel1x1bias1x1kernelidbiasidrrrget_equivalent_kernel_biassz"RepConv.get_equivalent_kernel_biascCs |durdStjj|gdS)z Pad a 1x1 kernel to 3x3 size. Args: kernel1x1 (torch.Tensor): 1x1 convolution kernel. Returns: (torch.Tensor): Padded 3x3 kernel. Nr)rrrr)rOr* functionalpad)rxrrrrus zRepConv._pad_1x1_to_3x3_tensorc Cs|durdSt|tr$|jj}|jj}|jj}|jj}|jj}|jj}nMt|t j rqt |ds_|j |j }tj|j |ddftjd} t|j D] } d| | | |ddf<qGt| |jj|_|j}|j}|j}|j}|j}|j}||} || dddd} || |||| fS)z Fuse batch normalization with convolution weights. Args: branch (Conv | nn.BatchNorm2d | None): Branch to fuse. Returns: (torch.Tensor): Fused kernel (torch.Tensor): Fused bias N)rr id_tensorrL)dtyper)rrr,rQr. running_mean running_varr'epsr*r-hasattrr5r8npzerosfloat32rangerO from_numpytodevicersqrtreshape) r4branchkernelrrgammabetar input_dim kernel_valuerWstdtrrrrts2       zRepConv._fuse_bn_tensorc Cst|drdS|\}}tj|jjj|jjj|jjj|jjj |jjj |jjj |jjj dd d|_||jj_||jj_|D]}|qA|d|dt|dr\|dt|d rf|d t|d rr|d dSdS) zLFuse convolutions for inference by creating a single equivalent convolution.r,NT) in_channels out_channels kernel_sizestridepaddingr&r%r'FrZr[nmr.r)rr|r*r+rZr,rrrrrr&r%requires_grad_rQrRr' parametersdetach_rU)r4rr'pararrrrXs8             zRepConv.fuse_convs)rLrrrrTFF)rFrGrHrIr*rJr/r)rCr?r| staticmethodrurtrXrKrrr9rrvs   %rcs@eZdZdZdeddffdd Zdejdejfdd ZZ S) r a Channel-attention module for feature recalibration. Applies attention weights to channels based on global average pooling. Attributes: pool (nn.AdaptiveAvgPool2d): Global average pooling. fc (nn.Conv2d): Fully connected layer implemented as 1x1 convolution. act (nn.Sigmoid): Sigmoid activation for attention weights. References: https://github.com/open-mmlab/mmdetection/tree/v3.0.0rc1/configs/rtmdet channelsreturnNcs<ttd|_tj||ddddd|_t|_dS)z{ Initialize Channel-attention module. Args: channels (int): Number of input channels. rrTrgN) r(r)r*AdaptiveAvgPool2dpoolr+fcSigmoidr2)r4rr9rrr)+s  zChannelAttention.__init__rcCs|||||S)z Apply channel attention to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Channel-attended output tensor. )r2rrr>rrrr?7s zChannelAttention.forward) rFrGrHrIrr)rOTensorr?rKrrr9rr s r c*eZdZdZdfdd ZddZZS)r a& Spatial-attention module for feature recalibration. Applies attention weights to spatial dimensions based on channel statistics. Attributes: cv1 (nn.Conv2d): Convolution layer for spatial attention. act (nn.Sigmoid): Sigmoid activation for attention weights. csNt|dvs Jd|dkrdnd}tjdd||dd|_t|_d S) z Initialize Spatial-attention module. Args: kernel_size (int): Size of the convolutional kernel (3 or 7). >rLrzkernel size must be 3 or 7rrLrrF)rr'N)r(r)r*r+rnrr2)r4rrr9rrr)Os zSpatialAttention.__init__c Cs<|||ttj|dddtj|ddddgdS)z Apply spatial attention to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Spatial-attended output tensor. rT)keepdimr)r2rnrOrkmeanmaxr>rrrr?\s< zSpatialAttention.forwardrrlrrr9rr Ds  r cr)r a- Convolutional Block Attention Module. Combines channel and spatial attention mechanisms for comprehensive feature refinement. Attributes: channel_attention (ChannelAttention): Channel attention module. spatial_attention (SpatialAttention): Spatial attention module. rcs"tt||_t||_dS)z Initialize CBAM with given parameters. Args: c1 (int): Number of input channels. kernel_size (int): Size of the convolutional kernel for spatial attention. N)r(r)r channel_attentionr spatial_attention)r4r5rr9rrr)ts  z CBAM.__init__cCrA)z Apply channel and spatial attention sequentially to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Attended output tensor. )rrr>rrrr?rDz CBAM.forwardrrlrrr9rr is  r cr)r z Concatenate a list of tensors along specified dimension. Attributes: d (int): Dimension along which to concatenate tensors. rct||_dS)z Initialize Concat module. Args: dimension (int): Dimension along which to concatenate tensors. N)r(r)r)r4 dimensionr9rrr)  zConcat.__init__cCst||jS)z Concatenate input tensors along specified dimension. Args: x (List[torch.Tensor]): List of input tensors. Returns: (torch.Tensor): Concatenated tensor. )rOrkrr>rrrr?s zConcat.forwardrrlrrr9rr  r cr)rzt Returns a particular index of the input. Attributes: index (int): Index to select from input. rcr)zn Initialize Index module. Args: index (int): Index to select from input. N)r(r)index)r4rr9rrr)rzIndex.__init__cCs ||jS)z Select and return a particular index from input. Args: x (List[torch.Tensor]): List of input tensors. Returns: (torch.Tensor): Selected tensor. )rr>rrrr?s z Index.forward)rrlrrr9rrrr)Nr)rIr_numpyrrOtorch.nnr*__all__r"r0rrrrrhrrrr rr r r r rrrrrs,   9>&8+-'(%$