|hShdZddlZddlmZddlZddlZddlmZdZ d"dZ GddejZ Gdd e Z Gd d ejZGd d e ZGddej ZGddejZGddejZGddejZGddejZGddejZGddejZGddejZGddejZGd d!ejZy)#zConvolution modules.N)List)ConvConv2 LightConvDWConvDWConvTranspose2d ConvTransposeFocus GhostConvChannelAttentionSpatialAttentionCBAMConcatRepConvIndexc|dkDr4t|tr ||dz zdzn|Dcgc] }||dz zdzc}}|(t|tr|dzn|Dcgc]}|dz c}}|Scc}wcc}w)zPad to 'same' shape outputs.) isinstanceint)kpdxs Z/var/www/html/test/engine/venv/lib/python3.12/site-packages/ultralytics/nn/modules/conv.pyautopadrss1u)!S1AQK!OQR7SAQU a7Sy C(AFq.A!qAv.A H8T.As A& A+cReZdZdZej Zdfd ZdZdZ xZ 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). c Rt |tj||||t |||||d|_tj ||_|dur|j|_ yt|tjr||_ ytj|_ y)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__nnConv2drconv BatchNorm2dbn default_actrModuleIdentityact selfc1c2rsrgrr- __class__s rr$z Conv.__init__3s IIb"aGAq!, __classcell__r4s@rrr&s'"'')Km& / &r5rc6eZdZdZdfd ZdZdZdZxZS)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. c t |||||||||tj||d|t d||||d|_y)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. r3rr-rFrN)r#r$r%r&rcv2r.s rr$zConv2.__init__jsL RAqA<99RQ71a+;APQX]^r5c|j|j|j||j|zSr7)r-r)r'rKr9s rr:z Conv2.forward{s1xx ! txx{ :;<zConv2.forward_fuser;r5ctj|jjj}|j ddDcgc]}|dz }}|j jjj|dddd|d|ddz|d|ddzf<|jjxj|z c_|jd|j|_ ycc}w)zFuse parallel convolutions.rNrrrK) torch zeros_liker'weightdatashaperKclone __delattr__r>r:)r/wris r fuse_convszConv2.fuse_convss   TYY--22 3WWQR[ )Q!V ) )48HHOO4H4H4N4N4P!Q!qtax1!q 01 " (( *s C.)rNrrT) rArBrCrDr$r:r>rXrFrGs@rrr_s_" = /)r5rcLeZdZdZdej ffd ZdZxZS)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. rcrt|t||dd|_t |||||_y)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. rFr-N)r#r$rconv1rconv2)r/r0r1rr-r4s rr$zLightConv.__init__s4 "b!/ BA3/ r5cB|j|j|S)z Apply 2 convolutions to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r^r]r9s rr:zLightConv.forwardszz$**Q-((r5) rArBrCrDr%ReLUr$r:rFrGs@rrrs!"# 0 )r5rc$eZdZdZdfd ZxZS)rzDepth-wise convolution module.c Zt|||||tj||||y)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. rJNr#r$mathgcd)r/r0r1rr2rr-r4s rr$zDWConv.__init__s, RA"b)9QCHr5rrrTrArBrCrDr$rFrGs@rrrs( I Ir5rc$eZdZdZdfd ZxZS)rz(Depth-wise transpose convolution module.c Zt|||||||tj||y)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 Nrc)r/r0r1rr2p1p2r4s rr$zDWConvTranspose2d.__init__s, RAr2dhhr26FGr5)rrrrrgrGs@rrrs2 H Hr5rcReZdZdZej Zdfd ZdZdZ xZ S)r as 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). cft|tj|||||| |_|rtj |ntj |_|dur|j|_ yt|tjr||_ ytj |_ y)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(r,r)r*rr+r-) r/r0r1rr2rr)r-r4s rr$zConvTranspose.__init__s  00RAq2vN(*"..$ '*d{4##z#ryy?Y_a_j_j_lr5c`|j|j|j|S)z Apply transposed convolution, batch normalization and activation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r-r)rpr9s rr:zConvTranspose.forwards'xx 3 3A 6788r5cB|j|j|S)z Apply activation and convolution transpose operation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r-rpr9s rr>zConvTranspose.forward_fusesxx++A.//r5)rrrTTr@rGs@rr r s'"'')Km$ 9 0r5r c*eZdZdZdfd ZdZxZS)r z Focus module for concentrating feature information. Slices input tensor into 4 parts and concatenates them in the channel dimension. Attributes: conv (Conv): Convolution layer. c Vt|t|dz|||||||_y)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. r\N)r#r$rr') r/r0r1rr2rr3r-r4s rr$zFocus.__init__)s, aQ1aS9 r5c |jtj|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'rOcatr9s rr:z Focus.forward:syyAc3Q3!m$4aQTT3Q36G3PSRSPSUVUYXYUY>IZ\]^acdcgfgcgijimlmim^m\n#oqrsttr5)rrNrTrArBrCrDr$r:rFrGs@rr r s:" ur5r c*eZdZdZdfd ZdZxZS)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 c t||dz}t||||d|||_t||ddd|||_y)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. rNr\r)r#r$rcv1rK) r/r0r1rr2r3r-c_r4s rr$zGhostConv.__init__XsI  1WB1dA37B1dBC8r5cr|j|}tj||j|fdS)z Apply Ghost Convolution to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor with concatenated features. r)r|rOrwrK)r/rys rr:zGhostConv.forwardis/ HHQKyy!TXXa[)1--r5rfrxrGs@rr r Js 9" .r5r cteZdZdZej Zd fd ZdZdZ dZ e dZ dZ dZxZS) 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 c t ||dk(r|dk(sJ||_||_||_|dur |j n/t |tjr|ntj|_ | r ||k(r|dk(rtj|nd|_ t||||||d|_t||d|||dzz |d|_y) a 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. rYrT) num_featuresNF)rr3r-r)r#r$r3r0r1r*rr%r+r,r-r(r)rr]r^) r/r0r1rr2rr3rr-r)deployr4s rr$zRepConv.__init__s Av!q&  '*d{4##z#ryy?Y_a_j_j_l57B"Ha"..b1UY"b!Q!qe< "b!Q1qAv:!G r5cB|j|j|S)z Forward pass for deploy mode. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. r=r9s rr>zRepConv.forward_fuser?r5c|jdn|j|}|j|j||j|z|zS)z Forward pass for training mode. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. r)r)r-r]r^)r/rid_outs rr:zRepConv.forwardsDggo4771:xx 1  1 5>??r5c|j|j\}}|j|j\}}|j|j\}}||j |z|z||z|zfS)z Calculate equivalent kernel and bias by fusing convolutions. Returns: (torch.Tensor): Equivalent kernel (torch.Tensor): Equivalent bias )_fuse_bn_tensorr]r^r)_pad_1x1_to_3x3_tensor)r/ kernel3x3bias3x3 kernel1x1bias1x1kernelidbiasids rget_equivalent_kernel_biasz"RepConv.get_equivalent_kernel_biass{"11$**= 7!11$**= 7//8&466yAAHLgX_N_bhNhhhr5c`|ytjjj|gdS)z Pad a 1x1 kernel to 3x3 size. Args: kernel1x1 (torch.Tensor): 1x1 convolution kernel. Returns: (torch.Tensor): Padded 3x3 kernel. r)rrrr)rOr% functionalpad)rs rrzRepConv._pad_1x1_to_3x3_tensors*  88&&**9lC Cr5c|yt|tr|jj}|jj }|jj }|jj}|jj}|jj}nt|tjrt|ds|j|jz}tj|j|ddftj } t#|jD]} d| | | |zddf<t%j&| j)|jj*|_|j,}|j }|j }|j}|j}|j}zj/} | z j1dddd} | z|z| z z fS)a Fuse batch normalization with convolution weights. Args: branch (Conv | nn.BatchNorm2d | None): Branch to fuse. Returns: kernel (torch.Tensor): Fused kernel. bias (torch.Tensor): Fused bias. )rr id_tensorrY)dtyper)rrr'rQr) running_mean running_varr"epsr%r(hasattrr0r3npzerosfloat32rangerO from_numpytodevicersqrtreshape) r/branchkernelrrgammabetar input_dim kernel_valuerWstdts rrzRepConv._fuse_bn_tensors > fd #[[''F!9911L ))//KII$$E99>>D))--C  /4- GGtvv- !xx)Q(B"**U tww=A;r:r staticmethodrrrXrFrGs@rrrwsO "'')KH6 & @ i D D#=J*r5rcdeZdZdZdeddffd ZdejdejfdZxZ 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 channelsreturnNct|tjd|_tj ||dddd|_tj|_y)z{ Initialize Channel-attention module. Args: channels (int): Number of input channels. rrTrnN) r#r$r%AdaptiveAvgPool2dpoolr&fcSigmoidr-)r/rr4s rr$zChannelAttention.__init__,sI ((+ ))Hh1adC::<r5rcf||j|j|j|zS)z Apply channel attention to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Channel-attended output tensor. )r-rrr9s rr:zChannelAttention.forward8s)488DGGDIIaL1222r5) rArBrCrDrr$rOTensorr:rFrGs@rr r s6        3 3%,, 3r5r c*eZdZdZdfd ZdZxZS)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. ct||dvsJd|dk(rdnd}tjdd||d|_tj |_y ) z Initialize Spatial-attention module. Args: kernel_size (int): Size of the convolutional kernel (3 or 7). >rYzkernel size must be 3 or 7rrYrrF)rr"N)r#r$r%r&r|rr-)r/rrr4s rr$zSpatialAttention.__init__PsW f$B&BB$"a'!Q99Q;eL::<r5c ||j|jtjtj|ddtj |dddgdzS)z Apply spatial attention to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Spatial-attended output tensor. rT)keepdimr)r-r|rOrwmeanmaxr9s rr:zSpatialAttention.forward]sX488DHHUYY 1a0NPUPYPYZ[]^hlPmnoPp/qst%uvwwwr5rrxrGs@rr r Es   xr5r c*eZdZdZdfd ZdZxZS)ra- 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. cbt|t||_t ||_y)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)r/r0rr4s rr$z CBAM.__init__us* !1"!5!1+!>r5cB|j|j|S)z Apply channel and spatial attention sequentially to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Attended output tensor. )rrr9s rr:z CBAM.forwards %%d&<&rs   $ 6&2996&r;)D;)|#) #)LITI$H**H$50BII50p'uBII'uV*. *.Zc*biic*L%3ryy%3P"xryy"xJ!A299!AH$RYY$>BIIr5