/jbRFdZddlmZddlZddlZddlZddlmZdZ d#dZ Gddej Z Gd d e Z Gd d ej ZGd de ZGddejZGddej ZGddej ZGddej ZGddej ZGddej ZGddej ZGddej ZGdd ej ZGd!d"ej ZdS)$zConvolution modules.) annotationsN)CBAMChannelAttentionConcatConvConv2 ConvTransposeDWConvDWConvTranspose2dFocus GhostConvIndex LightConvRepConvSpatialAttentioncdkr.t|tr |dz zdzn fd|D}|&t|tr|dzn d|D}|S)zPad to 'same' shape outputs.rc&g|] }|dz zdzSr).0xds `/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/ultralytics/nn/modules/conv.py zautopad..!s%7S7S7SAQU a7S7S7SNcg|]}|dzSrrrrs rrzautopad..#s.A.A.A!qAv.A.A.Ar) isinstanceint)kprs `rautopadr%s{1uu)!S11 SAQK!OO7S7S7S7SQR7S7S7Sy C(( AAFF.A.Aq.A.A.A HrcNeZdZdZejZdfd 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). rNTc Xttj||||t |||||d|_tj||_|dur|jn.t|tj r|ntj |_ dS)aInitialize 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_actr!ModuleIdentityact selfc1c2r#sr$grr6 __class__s rr-z Conv.__init__3s Ib"aGAq!,<,.s ) ) )Q!V ) ) )rrNrrrT) torch zeros_liker0weightdatashaperTclone __delattr__rFrB)r8wis r fuse_convszConv2.fuse_convss  TY-2 3 3 ) )QWQRR[ ) ) )48HO4H4N4N4P4P!!!QQQ!qtax1!q 01 " ( r)rQrNrrT) rIrJrKrLr-rBrFrbrNrOs@rrr\sz______ = = = / / /)))))))rrcHeZdZdZdejffd ZdZxZS)raLight 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. rctt||dd|_t |||||_dS)aInitialize 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. rFr6N)r,r-rconv1r conv2)r8r9r:r#r6r=s rr-zLightConv.__init__sO "b!/// BA3/// rcR|||S)zApply 2 convolutions to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )rgrfrAs rrBzLightConv.forwards zz$**Q--(((r) rIrJrKrLr.ReLUr-rBrNrOs@rrrse"# 0 0 0 0 0 0 ) ) ) ) ) ) )rrc$eZdZdZdfd ZxZS)r zDepth-wise convolution module.rTc ~t||||tj||||dS)aHInitialize 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. rSNr,r-mathgcd)r8r9r:r#r;rr6r=s rr-zDWConv.__init__s> RA"b)9)9QCHHHHHrrrrTrIrJrKrLr-rNrOs@rr r sM(( I I I I I I I I I Irr c$eZdZdZdfd ZxZS)r z(Depth-wise transpose convolution module.rrc ~t||||||tj||dS)a?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)Nrl)r8r9r:r#r;p1p2r=s rr-zDWConvTranspose2d.__init__s> RAr2dhr26F6FGGGGGr)rrrrrprOs@rr r sM22 H H H H H H H H H Hrr cNeZdZdZejZdfd ZdZdZ xZ S) r anConvolution 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). rrTcbttj|||||| |_|rtj|ntj|_|dur|jn.t|tj r|ntj|_ dS)atInitialize 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_transposer1r5r2r3r!r4r6) r8r9r:r#r;r$r2r6r=s rr-zConvTranspose.__init__s  0RAq2vNNN(*=".$$$ '*d{{4##z#ry?Y?Y8l_a_j_l_lrcx||||S)zApply transposed convolution, batch normalization and activation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r6r2ryrAs rrBzConvTranspose.forwards0xx 3 3A 6 677888rcR|||S)zApply convolution transpose and activation to input. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )r6ryrAs rrFzConvTranspose.forward_fuses$xx++A..///r)rrrTTrHrOs@rr r sz"'))Kmmmmmm" 9 9 9 0 0 0 0 0 0 0rr c*eZdZdZdfd ZdZxZS)r zFocus module for concentrating feature information. Slices input tensor into 4 parts and concatenates them in the channel dimension. Attributes: conv (Conv): Convolution layer. rNTc tt|dz|||||||_dS)adInitialize 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. reN)r,r-rr0) r8r9r:r#r;r$r<r6r=s rr-zFocus.__init__sA aQ1aS999 rc |tj|dddddddf|dddddddf|dddddddf|dddddddffdS)aApply Focus operation and convolution to input tensor. Input shape is (B, C, H, W) and output shape is (B, c2, H/2, W/2). Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. .Nrr)r0rYcatrAs rrBz Focus.forward(syyAc33Q3!m$4aQTT33Q36G3PSPSRSPSUVUYXYUY>IZ\]^acdcgfgcgijimlmim^m\n#oqrsstttr)rrNrTrIrJrKrLr-rBrNrOs@rr r s] : : : : : : u u u u u u urr 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 rTc t|dz}t||||d|||_t||ddd|||_dS)aHInitialize 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. rNrer)r,r-rcv1rT) r8r9r:r#r;r<r6c_r=s rr-zGhostConv.__init__Dsd  1WB1dA3777B1dBC888rc||}tj|||fdS)zApply Ghost Convolution to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor with concatenated features. r)rrYrrT)r8rys rrBzGhostConv.forwardTs4 HHQKKy!TXXa[[)1---rrorrOs@rr r 7sV  999999 . . . . . . .rr cveZdZdZejZd fd ZdZdZ d Z e d Z d Z d ZxZS)raRepConv 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 rQrTFc t|dkr|dksJ||_||_||_|dur|jn.t |tjr|ntj |_ | r!||kr|dkrtj |nd|_ t||||||d|_t||d|||dzz |d|_dS) aInitialize 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. rQrT) num_featuresNF)r$r<r6r)r,r-r<r9r:r3r!r.r4r5r6r1r2rrfrg) r8r9r:r#r;r$r<rr6r2deployr=s rr-zRepConv.__init__ss Avv!q&&& '*d{{4##z#ry?Y?Y8l_a_j_l_l57YB"HHa".b1111UY"b!Q!qe<<< "b!Q1qAv:!GGG rcR|||S)zForward pass for deploy mode. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. rErAs rrFzRepConv.forward_fuserGrc|jdn||}|||||z|zS)zForward pass for training mode. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. Nr)r2r6rfrg)r8rid_outs rrBzRepConv.forwardsMgo4771::xx 1  1 5>???rc||j\}}||j\}}||j\}}|||z|z||z|zfS)zCalculate equivalent kernel and bias by fusing convolutions. Returns: (torch.Tensor): Equivalent kernel (torch.Tensor): Equivalent bias )_fuse_bn_tensorrfrgr2_pad_1x1_to_3x3_tensor)r8 kernel3x3bias3x3 kernel1x1bias1x1kernelidbiasids rget_equivalent_kernel_biasz"RepConv.get_equivalent_kernel_biass"11$*== 7!11$*== 7//88&466yAAAHLgX_N_bhNhhhrcX|dStjj|gdS)zPad a 1x1 kernel to 3x3 size. Args: kernel1x1 (torch.Tensor): 1x1 convolution kernel. Returns: (torch.Tensor): Padded 3x3 kernel. Nr)rrrr)rYr. functionalpad)rs rrzRepConv._pad_1x1_to_3x3_tensors.  18&**9lllCC Crc|dSt|trI|jj}|jj}|jj}|jj}|jj}|jj}nt|tj rt|ds|j |j z}tj|j |ddftj} t#|j D]} d| | | |zddf<t%j| |jj|_|j}|j}|j}|j}|j}|j}||z} || z dddd} || z|||z| z z fS)zFuse 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. N)rr id_tensorrQ)dtyper)r!rr0r[r2 running_mean running_varr+epsr.r1hasattrr9r<npzerosfloat32rangerY from_numpytodevicersqrtreshape) r8branchkernelrrgammabetar input_dim kernel_valuerastdts rrzRepConv._fuse_bn_tensors >4 fd # # ['F!91L )/KI$E9>D)-CC  / / 4-- Y Gtv- !x)Q(B"*UUU tw==A;rQrzkernel size must be 3 or 7rrQrrF)rr+N)r,r-r.r/rrr6)r8rrr=s rr-zSpatialAttention.__init__/su f$$$&B$$$"a''!!Q9Q;eLLL:<<rc |||tjtj|ddtj|dddgdzS)zApply spatial attention to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Spatial-attended output tensor. rT)keepdimr)r6rrYrmeanmaxrAs rrBzSpatialAttention.forward;sf488DHHUY 1a0N0N0NPUPYZ[]^hlPmPmPmnoPp/qst%u%uvvwwwwrrrrOs@rrr%s]        x x x x x x xrrc*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. rctt||_t ||_dS)zInitialize 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-rchannel_attentionrspatial_attention)r8r9rr=s rr-z CBAM.__init__QsA !1"!5!5!1+!>!>rcR|||S)zApply channel and spatial attention sequentially to input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Attended output tensor. )rrrAs rrBz CBAM.forward\s&%%d&<&rs""""""   $    2&2&2&2&2&292&2&2&j7)7)7)7)7)D7)7)7)t ) ) ) ) ) ) ) )FIIIIITIII"HHHHH*HHH"1010101010BI101010h$u$u$u$u$uBI$u$u$uP'.'.'.'.'. '.'.'.T\*\*\*\*\*bi\*\*\*~"3"3"3"3"3ry"3"3"3JxxxxxryxxxDAAAAA29AAAB$$$$$RY$$$8BIr