hhRdZddlmZmZmZddlZddlmZddlmcm Z ddl m Z ddl mZmZmZmZmZmZddlmZdZGd d ej.ZGd d ej.ZGd dej.ZGddej.ZGddej.ZGddej.ZGddej.ZGddej.ZGddej.Z Gddej.Z!Gdde!Z"Gdd ej.Z#Gd!d"e!Z$Gd#d$e!Z%Gd%d&ej.Z&Gd'd(ej.Z'Gd)d*ej.Z(Gd+d,ej.Z)Gd-d.ej.Z*Gd/d0ej.Z+Gd1d2ej.Z,Gd3d4ej.Z-Gd5d6ej.Z.Gd7d8ej.Z/Gd9d:e'Z0Gd;dej.Z2Gd?d@e2Z3GdAdBej.Z4GdCdDej.Z5GdEdFej.Z6GdGdHej.Z7GdIdJej.Z8GdKdLej.Z9GdMdNe Z:GdOdPe!Z;GdQdRejj.Z<GdSdTej.Z=GdUdVe Z>GdWdXej.Z?GdYdZej.Z@Gd[d\ej.ZAGd]d^ej.ZBGd_d`e ZCGdadbej.ZDGdcddej.ZEGdedfej.ZFGdgdhej.ZGGdidjej.ZHGdkdlej.ZIGdmdnej.ZJGdodpej.ZKy)qzBlock modules.)ListOptionalTupleN)fuse_conv_and_bn)ConvDWConv GhostConv LightConvRepConvautopad)TransformerBlock)'DFLHGBlockHGStemSPPSPPFC1C2C3C2fC2fAttnImagePoolingAttnContrastiveHeadBNContrastiveHeadC3xC3TRC3GhostGhostBottleneck Bottleneck BottleneckCSPProtoRepC3 ResNetLayer RepNCSPELAN4ELAN1ADownAConvSPPELANCBFuseCBLinearC3k2C2fPSAC2PSARepVGGDWCIBC2fCIB AttentionPSASCDown TorchVisioncbeZdZdZddeffd ZdejdejfdZxZ S)rz Integral module of Distribution Focal Loss (DFL). Proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391 c1cdt|tj|dddj d|_t j|t j}tj|jd|dd|j jjdd||_ y)z Initialize a convolutional layer with a given number of input channels. Args: c1 (int): Number of input channels. rFbias)dtypeN)super__init__nnConv2drequires_grad_convtorcharangefloat Parameterviewweightdatar7)selfr7x __class__s Z/var/www/html/dev/engine/venv/lib/python3.12/site-packages/ultralytics/nn/modules/block.pyr=z DFL.__init__As~ IIb!QU3BB5I LL5;; /#%<<q"a0C#D a rJreturnc|j\}}}|j|j|d|j|j ddj dj|d|S)zCApply the DFL module to input tensor and return transformed output.r)shaperArFr7 transposesoftmax)rIrJb_as rLforwardz DFL.forwardNs]''1ayy1dggq1;;AqAII!LMRRSTVWYZ[[rM) __name__ __module__ __qualname____doc__intr=rBTensorrX __classcell__rKs@rLrr:s2 3 \\%,,\rMrcjeZdZdZd dededeffd ZdejdejfdZxZ S) r"zBUltralytics YOLO models mask Proto module for segmentation models.r7c_c2ct|t||d|_t j ||dddd|_t||d|_t|||_y)a Initialize the Ultralytics YOLO models mask Proto module with specified number of protos and masks. Args: c1 (int): Input channels. c_ (int): Intermediate channels. c2 (int): Output channels (number of protos). )krQrTr9N) r<r=rcv1r>ConvTranspose2dupsamplecv2cv3)rIr7rdrerKs rLr=zProto.__init__XsY B!$**2r1aF B!$B<rMrJrNc ~|j|j|j|j|S)zEPerform a forward pass through layers using an upsampled input image.)rmrlrkrirIrJs rLrXz Proto.forwardgs+xxtxx{!;<==rM) rZrbs@rLr"r"Us;L  3  C  3  >>%,,>rMr"cheZdZdZdededeffd ZdejdejfdZxZ S) rz StemBlock of PPHGNetV2 with 5 convolutions and one maxpool2d. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py r7cmrec t|t||ddtj|_t||dzdddtj|_t|dz|dddtj|_t|dz|ddtj|_t||ddtj|_ tjdddd|_ y) z Initialize the StemBlock of PPHGNetV2. Args: c1 (int): Input channels. cm (int): Middle channels. c2 (int): Output channels. rgrQactrrT) kernel_sizestridepadding ceil_modeN) r<r=rr>ReLUstem1stem2astem2bstem3stem4 MaxPool2dpool)rIr7rsrerKs rLr=zHGStem.__init__ss "b!QBGGI6 2rQw1aRWWY? 27B1aRWWY? "q&"a : "b!QBGGI6 LLQq!tT rMrJrNcd|j|}tj|gd}|j|}tj|gd}|j |}|j |}t j||gd}|j|}|j|}|S)+Forward pass of a PPHGNetV2 backbone layer.)rrrrrdim) r|Fpadr}r~rrBcatrr)rIrJx2x1s rLrXzHGStem.forwards JJqM EE!\ " [[^ UU2| $ [[_ YYq\ IIr2hA & JJqM JJqMrMrZrbs@rLrrlsA U3UCUSU"  %,, rMrceZdZdZddddej fdedededed ed ed ed ejffd Z de jde jfdZ xZ S)rz HG_Block of PPHGNetV2 with 2 convolutions and LightConv. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py rgFr7rsrerhn lightconvshortcutrvc 0 t ||rtnt t j  fdt |D|_t|zz|dzdd|_t|dz|dd|_ |xr|k(|_ y)a Initialize HGBlock with specified parameters. Args: c1 (int): Input channels. cm (int): Middle channels. c2 (int): Output channels. k (int): Kernel size. n (int): Number of LightConv or Conv blocks. lightconv (bool): Whether to use LightConv. shortcut (bool): Whether to use shortcut connection. act (nn.Module): Activation function. c3DK|]}|dk(rnyw)rrhrvN).0irvblockr7rsrhs rL z#HGBlock.__init__..s(_QRu16Rr2LL_ rQrruN) r<r=r rr> ModuleListrangemscecadd) rIr7rsrerhrrrrvrrKs `` ` `@rLr=zHGBlock.__init__s~0 & D_V[\]V^__rAF{B!GQs;rQwAqc2(brMrJrNc|gjfd|jD|j|jt j d|j r|zSS)rc34K|]}|dywNrrrys rLrz"HGBlock.forward..*a1R5*r)extendrrrrBrrrIrJrs @rLrXzHGBlock.forwardsV C *466** GGDGGEIIaO, -q1u'a'rM)r[r\r]r^r>r{r_boolModuler=rBr`rXrarbs@rLrrs ) ) )  )  )  )))YY)>((%,,(rMrc teZdZdZd dededeedfffd Zdejdejfd Z xZ S) rzDSpatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729.r7rerh.c "t||dz}t||dd|_t|t |dzz|dd|_t j|Dcgc]}t j|d|dzc}|_ ycc}w)z Initialize the SPP layer with input/output channels and pooling kernel sizes. Args: c1 (int): Input channels. c2 (int): Output channels. k (tuple): Kernel sizes for max pooling. rQrrwrxryN) r<r=rrilenrlr>rrr)rIr7rerhrdrJrKs rLr=z SPP.__init__s|  1WB1%c!fqj)2q!4_`aZ[ 1aSTf Uabas"B rJrNc |j|}|jtj|g|jDcgc] }|| c}zdScc}w)zBForward pass of the SPP layer, performing spatial pyramid pooling.r)rirlrBrr)rIrJrs rLrXz SPP.forwardsF HHQKxx 1#tvv(>!1(>">BCC(>sA)) ) r[r\r]r^r_rr=rBr`rXrarbs@rLrrsJN c3 cC cE#s(O cDD%,,DrMrcjeZdZdZd dededeffd ZdejdejfdZxZ S) rzGSpatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher.r7rerhct||dz}t||dd|_t|dz|dd|_t j |d|dz|_y)a' Initialize the SPPF layer with given input/output channels and kernel size. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. Notes: This module is equivalent to SPP(k=(5, 9, 13)). rQrrPrN)r<r=rrirlr>rr)rIr7rerhrdrKs rLr=z SPPF.__init__sY  1WB1%QAq)!AqAvFrMrJrNcj|gjfdtdDjt j dS)zRApply sequential pooling operations to input and return concatenated feature maps.c3FK|]}jdywrr)rrVrIrs rLrzSPPF.forward..s11"1s!rgr)rirrrlrBrrs` @rLrXz SPPF.forwardsA XXa[M 1a11xx !Q((rMrrZrbs@rLrrs?QG3GCGCG$))%,,)rMrcjeZdZdZd dededeffd ZdejdejfdZxZ S) rz"CSP Bottleneck with 1 convolution.r7rerct|t|dd|_t j fdt |D|_y)z Initialize the CSP Bottleneck with 1 convolution. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of convolutions. rc38K|]}tdyw)rgN)r)rrVres rLrzC1.__init__..s CQb"a CsN)r<r=rrir> Sequentialrr)rIr7rerrKs ` rLr=z C1.__init__s< B1% C%( CDrMrJrNcL|j|}|j||zS)z:Apply convolution and residual connection to input tensor.)rirrs rLrXz C1.forwards! HHQKvvay1}rMrrZrbs@rLrrs?, E3 EC EC E%,,rMrc veZdZdZd dedededededef fd Zd ejd ejfd Z xZ S) rz#CSP Bottleneck with 2 convolutions.r7rerrgec"tt||z_t |djzdd_t djz|d_tjfdt|D_ y)ah Initialize a CSP Bottleneck with 2 convolutions. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. rQrc 3hK|])}tjjdd+yw)rgrgr?rhrNr crrVrrIrs rLrzC2.__init__..s. vhiDFFDFFHaK[_b!c!c v/2N r<r=r_rrrirlr>rrrrIr7rerrrrrKs` `` rLr=z C2.__init__ sn R!VAJ1-DFF B* vmrstmu vwrMrJrNc|j|jdd\}}|jtj|j ||fdS)z.9.tfgz$&&$&&(AIY]`aatrN) r<r=r_rrrirlr>rrrrs` `` rLr=z C2f.__init__)ss R!VAJ1-Q$&&("a0tkpqrksttrMrJrNct|j|jddjfd|jD|j t jdS)zForward pass through C2f layer.rQrc34K|]}|dywrrrs rLrzC2f.forward..>rr)listrirrrrlrBrrs @rLrXz C2f.forward;sQ !""1a( ) *466**xx !Q((rMc|j|j|j|jfdddgjfd|jD|j t jdS).Forward pass using split() instead of chunk().rrc34K|]}|dywrrrs rLrz$C2f.forward_split..Err)risplitrrrrlrBrrs @rL forward_splitzC2f.forward_splitAsj HHQK  tvvtvv. 2 qT1Q4L *466**xx !Q((rMrFrr r[r\r]r^r_rrDr=rBr`rXrrarbs@rLrr&stFu3uCuCutuPSu\au$))%,,) )u||) )rMrc veZdZdZd dedededededef fd Zd ejd ejfd Z xZ S) rz#CSP Bottleneck with 3 convolutions.r7rerrrrct|t||zt|dd|_t|dd|_tdz|d|_tjfdt|D|_ y)aj Initialize the CSP Bottleneck with 3 convolutions. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. rrQc 3@K|]}tddyw)))rrrrrNr rrVrdrrs rLrzC3.__init__..]s& n`aBHaCSWZ![![ nN) r<r=r_rrirlrmr>rrr rIr7rerrrrrdrKs `` @rLr=z C3.__init__Lsr  a[B1%B1%BA& nejklem norMrJrNc |jtj|j|j ||j |fdS)zeZdZdZd dedededededef fd ZxZS) rz"C3 module with cross-convolutions.r7rerrrrct||||t||z_t j fdt |D_y)ae Initialize C3 module with cross-convolutions. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. c 3hK|])}tjjdd+yw)))rrgrgrrrN)r rdrs rLrzC3x.__init__..us. vhiDGGTWWhM]ab!c!c vrN)r<r=r_rdr>rrrrs` `` rLr=z C3x.__init__gsH RHa3b1f+ vmrstmu vwrMr r[r\r]r^r_rrDr=rarbs@rLrrdsC,x3xCxCxtxsx[`xxrMrc neZdZdZd dedededeffd Zdejdejfd Z xZ S) r#zRep C3.r7rerrc ht|t||z}t||dd|_t||dd|_t jt|Dcgc]}t||c}|_ ||k7rt||dd|_ yt j|_ ycc}w)z Initialize CSP Bottleneck with a single convolution. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of RepConv blocks. e (float): Expansion ratio. rN) r<r=r_rrirlr>rrr rIdentityrm)rIr7rerrrdrVrKs rLr=zRepC3.__init__{s  a[B1%B1%%( CQR CD)+r4B1%r{{}!Ds B/rJrNc|j|j|j||j|zS)zForward pass of RepC3 module.)rmrrirlros rLrXz RepC3.forwards/xxtxx{+dhhqk9::rM)rgr r[r\r]r^r_rDr=rBr`rXrarbs@rLr#r#xsGE3ECECEE";;%,,;rMr#c >eZdZdZd dedededededef fd ZxZS) rz"C3 module with TransformerBlock().r7rerrrrcpt|||||||t||z}t||d||_y)ad Initialize C3 module with TransformerBlock. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Transformer blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. rPN)r<r=r_rrrs rLr=z C3TR.__init__s; RHa3 a[!"b!Q/rMrrrbs@rLrrs;,030C0C0t0s0[`00rMrc >eZdZdZd dedededededef fd ZxZS) rz!C3 module with GhostBottleneck().r7rerrrrct|||||||t||ztjfdt |D|_y)ah Initialize C3 module with GhostBottleneck. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Ghost bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. c36K|]}tyw)N)r)rrVrds rLrz#C3Ghost.__init__..s KQR!8 KsNr<r=r_r>rrrrs @rLr=zC3Ghost.__init__sC RHa3 a[ K%( KLrMrrrbs@rLrrsC+M3MCMCMtMsM[`MMrMrc neZdZdZd dedededeffd Zdejdejfd ZxZ S) rzGGhost Bottleneck https://github.com/huawei-noah/Efficient-AI-Backbones.r7rerhsc t||dz}tjt ||dd|dk(rt ||||dntj t ||ddd|_|dk(r8tjt ||||dt||ddd|_ ytj |_ y)z Initialize Ghost Bottleneck module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rQrFruN) r<r=r>rr r rrArr)rIr7rerhrrdrKs rLr=zGhostBottleneck.__init__s  1WMM b"a #/0AvF2r1aU +2;;= b"a .  ^_bc]cBMM&RA594B1RW;X Y ikititiv rMrJrNcH|j||j|zS)z8Apply skip connection and concatenation to input tensor.)rArros rLrXzGhostBottleneck.forwardsyy|dmmA...rMrrZrbs@rLrrsBQ 3 C C  *//%,,/rMrc eZdZdZ d dededededeeefdef fd Zd e jd e jfd Z xZ S) r zStandard bottleneck.r7rerrrhrct|t||z}t|||dd|_t|||dd||_|xr||k(|_y)ac Initialize a standard bottleneck module. Args: c1 (int): Input channels. c2 (int): Output channels. shortcut (bool): Whether to use shortcut connection. g (int): Groups for convolutions. k (tuple): Kernel sizes for convolutions. e (float): Expansion ratio. rrrN)r<r=r_rrirlr rIr7rerrrhrrdrKs rLr=zBottleneck.__init__s[  a[B!a(B!a1-(brMrJrNc|jr#||j|j|zS|j|j|S)z3Apply bottleneck with optional shortcut connection.)rrlriros rLrXzBottleneck.forwards:,0HHq488DHHQK((O$((488A;:OOrMTrrr) r[r\r]r^r_rrrDr=rBr`rXrarbs@rLr r silo)))*.):=)FKCQTHo)ch)(PP%,,PrMr c veZdZdZd dedededededef fd Zd ejd ejfd Z xZ S) r!zGCSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks.r7rerrrrct|t||zt|dd|_t j |ddd|_t j ddd|_tdz|dd|_ t jdz|_ t j|_ t jfdt|D|_y)aR Initialize CSP Bottleneck. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. rFr9rQc3>K|]}tdywrrNrrs rLrz)BottleneckCSP.__init__.. s! ZABHa3!G!G ZN)r<r=r_rrir>r?rlrmcv4 BatchNorm2dbnSiLUrvrrrrs `` @rLr=zBottleneckCSP.__init__s  a[B1%99RQ699RQ6BAq)..R(779 ZQVWXQY Z[rMrJrNc  |j|j|j|}|j|}|j |j |j tj||fdS)z)Apply CSP bottleneck with 3 convolutions.r) rmrrirlr rvrrBr)rIrJy1y2s rLrXzBottleneckCSP.forward s^ XXdffTXXa[) * XXa[xxB8Q)?!@ABBrMrrrbs@rLr!r!s[Q\3\C\C\t\s\[`\,CC%,,CrMr!c neZdZdZd dedededeffd Zdejdejfd ZxZ S) ResNetBlockz.ResNet block with standard convolution layers.r7rerrc Bt|||z}t||ddd|_t||d|dd|_t||dd|_|dk7s||k7r)t jt||d|d|_ yt j|_ y) z Initialize ResNet block. Args: c1 (int): Input channels. c2 (int): Output channels. s (int): Stride. e (int): Expansion ratio. rTrhrrvrgrhrprvFrN) r<r=rrirlrmr>rrr)rIr7rerrc3rKs rLr=zResNetBlock.__init__s  VB!qd3B!qA48B!/LMQRFVX\^V^ d2rQ!&GH dfdododq rMrJrNc tj|j|j|j ||j |zS)z&Forward pass through the ResNet block.)rrelurmrlrirros rLrXzResNetBlock.forward&s9vvdhhtxx 45 a8HHIIrM)rrPrZrbs@rLrrsJ8r3rCrCrr"JJ%,,JrMrc veZdZdZd dedededededef fd Zd ejd ejfd Z xZ S) r$z)ResNet layer with multiple ResNet blocks.r7reris_firstrrc t |||_|jrAtjt ||ddddtj ddd|_y t||||g}|jt|dz Dcgc]}t||z|d|c}tj||_y cc}w) a5 Initialize ResNet layer. Args: c1 (int): Input channels. c2 (int): Output channels. s (int): Stride. is_first (bool): Whether this is the first layer. n (int): Number of ResNet blocks. e (int): Expansion ratio. rQrgTrrrr N) r<r=rr>rrrlayerrrr) rIr7rerrrrblocksrVrKs rLr=zResNetLayer.__init__.s   ==RqA5r||PQZ[ef7gDJ""b!q12F MME!a%LQq;q2vr1:Q R/DJRsCrJrNc$|j|S)z&Forward pass through the ResNet layer.)r ros rLrXzResNetLayer.forwardFszz!}rM)rFrrP r[r\r]r^r_rr=rBr`rXrarbs@rLr$r$+sR3030C0C0t0PS0\_00%,,rMr$c eZdZdZd dedededededef fd Zd ejd ejd ejfd Z xZ S)MaxSigmoidAttnBlockzMax Sigmoid attention block.r7renhrgcscalect|||_||z|_||k7rt ||ddnd|_t j|||_t jtj||_ t ||ddd|_ |r1t jtjd|dd|_yd|_y)aH Initialize MaxSigmoidAttnBlock. Args: c1 (int): Input channels. c2 (int): Output channels. nh (int): Number of heads. ec (int): Embedding channels. gc (int): Guide channels. scale (bool): Whether to use learnable scale parameter. rFrNrgrr)r<r=r&hcrrr>LinearglrErBzerosr: proj_convonesr()rIr7rer&rr'r(rKs rLr=zMaxSigmoidAttnBlock.__init__Ns (24($r2.))B#LLR1 b"QE:>CR\\%**QAq"9:  rMrJguiderNc|j\}}}}|j|}|j||jd|j|j}|j |j |n|}|j||j|j||}t jd||}|jdd}||jdzz }||jdddddfz}|j|jz}|j|}|j||jd||}||jdz}|j|d||S) z Forward pass of MaxSigmoidAttnBlock. Args: x (torch.Tensor): Input tensor. guide (torch.Tensor): Guide tensor. Returns: (torch.Tensor): Output tensor after attention. rNzbmchw,bnmc->bmhwnrrrrrQ)rRr,rFr&r*rrBeinsummaxr:sigmoidr(r. unsqueeze) rIrJr0bsrVhwembedaws rLrXzMaxSigmoidAttnBlock.forwardcs4gg Aq! 2u{{1~tww@"gg1 q 2twwA6 \\-ue < VVV^A  477C<  $))D!T4/0 0 ZZ\DJJ & NN1  FF2twwAq )  Q vvb"a##rM)rFr#rbs@rLr%r%Ksc&M3MCMSM#MM[_M*$$ell$u||$rMr%ceZdZdZ ddededededededed ed effd Zd ejd ejdejfdZ d ejd ejdejfdZ xZ S)rz*C2f module with an additional attn module.r7rerrr&r'rrrc t t|| z_t |djzdd_t d|zjz|d_tjfdt|D_ tjj|||_ y)a Initialize C2f module with attention mechanism. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. ec (int): Embedding channels for attention. nh (int): Number of heads for attention. gc (int): Guide channels for attention. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. rQrrgc 3hK|])}tjjdd+ywrrrs rLrz#C2fAttn.__init__..rr)r'rr&N) r<r=r_rrrirlr>rrrr%attn) rIr7rerrr&r'rrrrKs ` `` rLr=zC2fAttn.__init__s4 R!VAJ1-Q$&&("a0tkpqrkstt'2"L rMrJr0rNc2t|j|jddjfd|jDj |j d||jtjdS)a Forward pass through C2f layer with attention. Args: x (torch.Tensor): Input tensor. guide (torch.Tensor): Guide tensor for attention. Returns: (torch.Tensor): Output tensor after processing. rQrc34K|]}|dywrrrs rLrz"C2fAttn.forward..rrr) rrirrrappendr@rlrBrrIrJr0rs @rLrXzC2fAttn.forwardsn !""1a( ) *466** 1R5%()xx !Q((rMc^t|j|j|j|jfdj fd|j Dj |jd||jtjdS)a Forward pass using split() instead of chunk(). Args: x (torch.Tensor): Input tensor. guide (torch.Tensor): Guide tensor for attention. Returns: (torch.Tensor): Output tensor after processing. rc34K|]}|dywrrrs rLrz(C2fAttn.forward_split..rrr) rrirrrrrCr@rlrBrrDs @rLrzC2fAttn.forward_splits{ !""DFFDFF#3Q7 8 *466** 1R5%()xx !Q((rM)rr;rr<Frrrrbs@rLrrs4 M M M  M  M  M MM M MB))ell)u||) )u||)ELL)U\\)rMrc eZdZdZ ddedeedfdedededef fd Zd ee jd e jd e jfd Z xZ S)rzKImagePoolingAttn: Enhance the text embeddings with image-aware information.rch.ctr&rhr(c t |t|}tjtj |tj |||_tjtj |tj |||_tjtj |tj |||_ tj |||_ |r+tjtjdgdnd|_tj|Dcgc]}tj ||dc}|_tjt%|D cgc]} tj&||fc} |_||_||_||_||z|_||_ycc}wcc} w)a Initialize ImagePoolingAttn module. Args: ec (int): Embedding channels. ch (tuple): Channel dimensions for feature maps. ct (int): Channel dimension for text embeddings. nh (int): Number of attention heads. k (int): Kernel size for pooling. scale (bool): Whether to use learnable scale parameter. gT requires_gradrr)rwN)r<r=rr>r LayerNormr+querykeyvalueprojrErBtensorr(rr? projectionsrAdaptiveMaxPool2dim_poolsrr&nfr*rh) rIrrHrIr&rhr(rV in_channelsrVrKs rLr=zImagePoolingAttn.__init__sJ  W]]2<<#3RYYr25FG ==b!1299R3DE]]2<<#3RYYr25FG IIb"% NSR\\%,,u"5TJY\ ==gi)jXc"))KQR*S)jk USUY&Wr';';QF'C&WX ( *k&Ws G G rJtextrNc |djd}t||jk(sJ|jdz}t ||j |j Dcgc]%\}}}|||j|d|'c}}}}tj|djdd}|j|}|j|}|j|} |j|d|j|j }|j|d|j|j }| j|d|j|j } tj"d||} | |j dzz } t%j&| d} tj"d| | }|j)|j|d|j*}||j,z|zScc}}}w) z Forward pass of ImagePoolingAttn. Args: x (List[torch.Tensor]): List of input feature maps. text (torch.Tensor): Text embeddings. Returns: (torch.Tensor): Enhanced text embeddings. rrQrrrzbnmc,bkmc->bmnkrzbmnk,bkmc->bnmc)rRrrVrhziprSrUrFrBrrSrNrOrPreshaper&r*r2rrTrQrr() rIrJrXr6 num_patchesrQrqrhvr:s rLrXzImagePoolingAttn.forwardsqTZZ]1v   ffai LOPQSWScSceiererLs t t!T4T$q']  B 4 t IIaR * *1a 0 JJt  HHQK JJqM IIb"dggtww / IIb"dggtww / IIb"dggtww / \\+Q 2 477C<  YYrr " LL*B 2 IIaiiB0 14::~$$# us!*G7)rprr<rgF) r[r\r]r^r_rrr=rrBr`rXrarbs@rLrrsuUns!&sCx;>JMVYfj<%ell+%5<<%ELL%rMrcreZdZdZfdZdej dej dej fdZxZS)rzZImplements contrastive learning head for region-text similarity in vision-language models.c t|tjt j dg|_tjt jgt j djz|_ y)zBInitialize ContrastiveHead with region-text similarity parameters.$g$I$I,@N) r<r=r>rErBrRr:r/log logit_scale)rIrKs rLr=zContrastiveHead.__init__ sY LLug!67 << 2h9O9S9S9U(UVrMrJr8rNctj|dd}tj|dd}tjd||}||jj z|j zS)z Forward function of contrastive learning. Args: x (torch.Tensor): Image features. w (torch.Tensor): Text features. Returns: (torch.Tensor): Similarity scores. rrQrrrbchw,bkc->bkhw)r normalizerBr2rdexpr:rIrJr8s rLrXzContrastiveHead.forwards^ KKqA & KKrQ ' LL)1a 04##''))DII55rM) r[r\r]r^r=rBr`rXrarbs@rLrr s2dW66%,,65<<6rMrceZdZdZdeffd ZdZdejdejdejfdZ dejdejdejfd Z xZ S) rz Batch Norm Contrastive Head using batch norm instead of l2-normalization. Args: embed_dims (int): Embed dimensions of text and image features. embed_dimsct|tj||_tj t jdg|_tj dt jgz|_ y)z Initialize BNContrastiveHead. Args: embed_dims (int): Embedding dimensions for features. rbgN) r<r=r>r normrErBrRr:r/rd)rIrlrKs rLr=zBNContrastiveHead.__init__,sY NN:. LLug!67 <<uzz"~(=>rMc2|`|`|`|j|_y)zCFuse the batch normalization layer in the BNContrastiveHead module.N)rnr:rd forward_fuserX)rIs rLfusezBNContrastiveHead.fuse:s I I  (( rMrJr8rNc|S)zPasses input out unchanged.rrjs rLrpzBNContrastiveHead.forward_fuseAsrMc|j|}tj|dd}tjd||}||j j z|jzS)z Forward function of contrastive learning with batch normalization. Args: x (torch.Tensor): Image features. w (torch.Tensor): Text features. Returns: (torch.Tensor): Similarity scores. rrQrfrg)rnrrhrBr2rdrir:rjs rLrXzBNContrastiveHead.forwardEsY IIaL KKrQ ' LL)1a 04##''))DII55rM) r[r\r]r^r_r=rqrBr`rprXrarbs@rLrr$se ?3 ?)ellu|| 66%,,65<<6rMrc JeZdZdZ d dededededeeefdef fd ZxZ S) RepBottleneckzRep bottleneck.r7rerrrhrcvt|||||||t||z}t|||dd|_y)aT Initialize RepBottleneck. Args: c1 (int): Input channels. c2 (int): Output channels. shortcut (bool): Whether to use shortcut connection. g (int): Groups for convolutions. k (tuple): Kernel sizes for convolutions. e (float): Expansion ratio. rrN)r<r=r_r rirs rLr=zRepBottleneck.__init__Zs? R1a3 a[2r1Q4+rMr) r[r\r]r^r_rrrDr=rarbs@rLruruWsPlo,,,*.,:=,FKCQTHo,ch,,rMruc >eZdZdZd dedededededef fd ZxZS) RepCSPzXRepeatable Cross Stage Partial Network (RepCSP) module for efficient feature extraction.r7rerrrrct|||||t||ztjfdt |D|_y)aS Initialize RepCSP layer. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of RepBottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. c3>K|]}tdywr )rurs rLrz"RepCSP.__init__..~s! ]qr2xc!J!J ]r Nrrs `` @rLr=zRepCSP.__init__psF RHa3 a[ ]TYZ[T\ ]^rMrrrbs@rLrxrxmsCb_3_C_C_t_s_[`__rMrxc eZdZdZd dededededef fd Zdejd ejfd Zdejd ejfd Z xZ S) r%z CSP-ELAN.r7rerc4rc \t||dz|_t||dd|_t j t|dz||t||dd|_t j t|||t||dd|_ t|d|zz|dd|_ y)a Initialize CSP-ELAN layer. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. c4 (int): Intermediate channels for RepCSP. n (int): Number of RepCSP blocks. rQrrgN) r<r=rrrir>rrxrlrmr )rIr7rerr|rrKs rLr=zRepNCSPELAN4.__init__s qB1%==aQ!7b"a9KL==B!2DRA4FGa"f r1a0rMrJrNct|j|jddjfd|j|j fD|j tjdS)z(Forward pass through RepNCSPELAN4 layer.rQrc34K|]}|dywrrrs rLrz'RepNCSPELAN4.forward..s:!AbE(:r) rrirrrlrmr rBrrs @rLrXzRepNCSPELAN4.forwardsZ !""1a( ) :dhh%9::xx !Q((rMc.t|j|j|j|jfdj fd|j |j fD|jtjdS)rrc34K|]}|dywrrrs rLrz-RepNCSPELAN4.forward_split..s8a1R58r) rrirrrrlrmr rBrrs @rLrzRepNCSPELAN4.forward_splitsg !""DFFDFF#3Q7 8 8DHHdhh#788xx !Q((rMr) r[r\r]r^r_r=rBr`rXrrarbs@rLr%r%sd131C1S1c1c1$))%,,) )u||) )rMr%c4eZdZdZdedededeffd ZxZS)r&z!ELAN1 module with 4 convolutions.r7rerr|ct||||||dz|_t||dd|_t|dz|dd|_t||dd|_t|d|zz|dd|_y)z Initialize ELAN1 layer. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. c4 (int): Intermediate channels for convolutions. rQrrgN)r<r=rrrirlrmr )rIr7rerr|rKs rLr=zELAN1.__init__sw RR(qB1%aQ*B1%a"f r1a0rM)r[r\r]r^r_r=rarbs@rLr&r&s,+131C1S1c11rMr&cdeZdZdZdedeffd ZdejdejfdZxZ S)r(zAConv.r7recJt|t||ddd|_y)z Initialize AConv module. Args: c1 (int): Input channels. c2 (int): Output channels. rgrQrN)r<r=rrirIr7rerKs rLr=zAConv.__init__s$ B1a(rMrJrNctjjj|ddddd}|j |S)z!Forward pass through AConv layer.rQrrFT)rBr> functional avg_pool2driros rLrXz AConv.forwards4 HH   * *1aAud Cxx{rMrZrbs@rLr(r(s4 )3 )C )%,,rMr(cdeZdZdZdedeffd ZdejdejfdZxZ S)r'zADown.r7rect||dz|_t|dz|jddd|_t|dz|jddd|_y)z Initialize ADown module. Args: c1 (int): Input channels. c2 (int): Output channels. rQrgrrN)r<r=rrrirlrs rLr=zADown.__init__sS qaAq1aAq1rMrJrNcTtjjj|ddddd}|j dd\}}|j |}tjjj |ddd}|j|}tj||fdS)z!Forward pass through ADown layer.rQrrFTrg) rBr>rrrri max_pool2drlr)rIrJrrs rLrXz ADown.forwards HH   * *1aAud CAB XXb\ XX + +B1a 8 XXb\yy"b1%%rMrZrbs@rLr'r's4 23 2C 2&&%,,&rMr'c neZdZdZd dedededeffd Zdejdejfd ZxZ S) r)z SPP-ELAN.r7rerrhcBt|||_t||dd|_t j |d|dz|_t j |d|dz|_t j |d|dz|_ td|z|dd|_ y)z Initialize SPP-ELAN block. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. k (int): Kernel size for max pooling. rrQrrPN) r<r=rrrir>rrlrmr cv5)rIr7rerrhrKs rLr=zSPPELAN.__init__s B1%<.sBa1R5Brr)rirrlrmr rrBrrs @rLrXzSPPELAN.forwardsP XXa[M BDHHdhh#ABBxx !Q((rMrrZrbs@rLr)r)sB*3*C*S*S*$))%,,)rMr)c eZdZdZd dedeedededeedef fd Zd ejd eejfd Z xZ S) r+z CBLinear.r7c2srhrrrc t|||_tj|t |||t |||d|_y)a Initialize CBLinear module. Args: c1 (int): Input channels. c2s (List[int]): List of output channel sizes. k (int): Kernel size. s (int): Stride. p (int | None): Padding. g (int): Groups. T)groupsr:N)r<r=rr>r?sumr rA)rIr7rrhrrrrKs rLr=zCBLinear.__init__s> IIb#c(Aq'!Q-PTU rMrJrNcZ|j|j|jdS)z$Forward pass through CBLinear layer.rr)rArrros rLrXzCBLinear.forwards$yy|!!$((!22rM)rrNr) r[r\r]r^r_rrr=rBr`rXrarbs@rLr+r+sfV3VT#YV3VsV8TW=VdgV 33$u||*<3rMr+cleZdZdZdeeffd ZdeejdejfdZ xZ S)r*zCBFuse.idxc0t|||_y)zv Initialize CBFuse module. Args: idx (List[int]): Indices for feature selection. N)r<r=r)rIrrKs rLr=zCBFuse.__init__s rMxsrNc |djdd}t|ddDcgc]-\}}tj||j||d/}}}t j t j||ddzdScc}}w)z Forward pass through CBFuse layer. Args: xs (List[torch.Tensor]): List of input tensors. Returns: (torch.Tensor): Fused output tensor. rrQNnearest)sizemoderr)rR enumerater interpolaterrBrstack)rIr target_sizerrJress rLrXzCBFuse.forward'sfll12& [deghkikel[mnSWSTVWq}}Qtxx{^+INnnyyS2bc7]3;;os2B  r[r\r]r^rr_r=rBr`rXrarbs@rLr*r*s6DI <$u||, < .Js&l^_z"b(AAQUXYYlrN) r<r=r_rrirlrmr>rrrrs `` @rLr=z C3f.__init__9sv  a[B1%B1%Q" b!,lchijckllrMrJrNc|j||j|gjfd|jD|j t j dS)zForward pass through C3f layer.c34K|]}|dywrrrs rLrzC3f.forward..Orrr)rlrirrrmrBrrs @rLrXz C3f.forwardLsL XXa[$((1+ & *466**xx !Q((rMrrrbs@rLrr6sYFm3mCmCmtmPSm\am&))%,,)rMrcDeZdZdZ d dededededededeffd ZxZS) r,rr7rerc3krrrct||||tjfdt |D_y)aw Initialize C3k2 module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of blocks. c3k (bool): Whether to use C3k blocks. e (float): Expansion ratio. g (int): Groups for convolutions. shortcut (bool): Whether to use shortcut connections. c3K|]K}r#tjjdn!tjjMyw)rQN)C3krr )rrVrrrIrs rLrz C3k2.__init__..fsG hi3C8Q /JtvvtvvW_abrrr) rIr7rerrrrrrKs ` ` ``rLr=z C3k2.__init__Vs? RHa3 mrstmu  rM)rFrrTrrbs@rLr,r,SsOFmq   #& 15 BG RU ei  rMr,cBeZdZdZd dededededededeffd ZxZS) rzhC3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks.r7rerrrrrhct |||||t||ztjfdt |D|_y)ap Initialize C3k module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. k (int): Kernel size. c 3DK|]}tfdyw)rrNr)rrVrdrrhrs rLrzC3k.__init__..~s( dVWBHaAq6S!Q!Q drNr) rIr7rerrrrrhrdrKs `` `@rLr=z C3k.__init__nsF RHa3 a[ d[`ab[c derM)rTrrrgrrbs@rLrrksLrf3fCfCftfsf[`fknffrMrceZdZdZdeddffd ZdejdejfdZdejdejfdZ ejd Z xZ S) r/zfRepVGGDW is a class that represents a depth wise separable convolutional block in RepVGG architecture.edrNNc t|t||ddd|d|_t||ddd|d|_||_t j|_y)zm Initialize RepVGGDW module. Args: ed (int): Input and output channels. rrrgFrrvN) r<r=rrAconv1rr>rrv)rIrrKs rLr=zRepVGGDW.__init__sT RAqBE: "b!QRU; 779rMrJcf|j|j||j|zS)z Perform a forward pass of the RepVGGDW block. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after applying the depth wise separable convolution. )rvrArros rLrXzRepVGGDW.forwards(xx ! tzz!}455rMcB|j|j|S)a  Perform a forward pass of the RepVGGDW block without fusing the convolutions. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after applying the depth wise separable convolution. )rvrAros rLrpzRepVGGDW.forward_fusesxx ! %%rMcFt|jj|jj}t|jj|jj}|j}|j }|j}|j }t jjj|gd}||z}||z}|jjj||j jj|||_|`y)z Fuse the convolutional layers in the RepVGGDW block. This method fuses the convolutional layers and updates the weights and biases accordingly. )rQrQrQrQN) rrArrrGr:rBr>rrrHcopy_) rIrArconv_wconv_bconv1_wconv1_b final_conv_w final_conv_bs rLrqz RepVGGDW.fuses   = $**--@,,**((%%))'<@' '  |, \* JrM) r[r\r]r^r_r=rBr`rXrpno_gradrqrarbs@rLr/r/skp 3 4  6 6%,, 6 &ell &u|| &U]]_rMr/c reZdZdZd dededededef fd Zdejd ejfd Z xZ S) r0a Conditional Identity Block (CIB) module. Args: c1 (int): Number of input channels. c2 (int): Number of output channels. shortcut (bool, optional): Whether to add a shortcut connection. Defaults to True. e (float, optional): Scaling factor for the hidden channels. Defaults to 0.5. lk (bool, optional): Whether to use RepVGGDW for the third convolutional layer. Defaults to False. r7rerrlkc Nt|t||z}tjt ||d|t |d|zd|rt d|znt d|zd|zdd|zt d|z|dt ||d||_|xr||k(|_y)a! Initialize the CIB module. Args: c1 (int): Input channels. c2 (int): Output channels. shortcut (bool): Whether to use shortcut connection. e (float): Expansion ratio. lk (bool): Whether to use RepVGGDW. rgrrQrN) r<r=r_r>rrr/rir)rIr7rerrrrdrKs rLr=z CIB.__init__s  a[== Rb ! QVQ  "HQV QVQVQ!b&(I RQ  Rb !  (brMrJrNcd|jr||j|zS|j|S)z Forward pass of the CIB module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )rriros rLrXz CIB.forwards)#'((q488A;; ;rM)TrFrrbs@rLr0r0sL )3)C)4)5)TX). < <%,, .s)]qs4664668srJJ]s.1Nr) rIr7rerrrrrrKs ` `` rLr=zC2fCIB.__init__s9 RHa3]TYZ[T\]]rM)rFFrrrrbs@rLr1r1sZ nq^^^#&^6:^HL^Y\^ej^^rMr1cjeZdZdZd dededeffd ZdejdejfdZ xZ S) r2a Attention module that performs self-attention on the input tensor. Args: dim (int): The input tensor dimension. num_heads (int): The number of attention heads. attn_ratio (float): The ratio of the attention key dimension to the head dimension. Attributes: num_heads (int): The number of attention heads. head_dim (int): The dimension of each attention head. key_dim (int): The dimension of the attention key. scale (float): The scaling factor for the attention scores. qkv (Conv): Convolutional layer for computing the query, key, and value. proj (Conv): Convolutional layer for projecting the attended values. pe (Conv): Convolutional layer for positional encoding. r num_heads attn_ratiocPt|||_||z|_t |j|z|_|j dz|_|j |z}||dzz}t||dd|_t||dd|_ t||dd|d|_ y) z Initialize multi-head attention module. Args: dim (int): Input dimension. num_heads (int): Number of attention heads. attn_ratio (float): Attention ratio for key dimension. rQrFrurgrN) r<r=rhead_dimr_key_dimr(rqkvrQpe)rIrrrnh_kdr7rKs rLr=zAttention.__init__(s "y( 4==:56 \\4'  y( %!)OQu-c1%0 sCA%8rMrJrNc P|j\}}}}||z}|j|}|j||j|jdz|j z|j |j|j|j gd\}} } |jdd| z|jz} | jd} | | jddzj|||||j| j||||z}|j|}|S)z Forward pass of the Attention module. Args: x (torch.Tensor): The input tensor. Returns: (torch.Tensor): The output tensor after self-attention. rQrr) rRrrFrrrrrSr(rTrr[rQ) rIrJBCHWNrr]rhr^r@s rLrXzAttention.forward<s WW 1a Ehhqk((1dnndllQ.>.NPQRXX \\4<< 7QY 1a B#a'4::5|||# B' ' - -aAq 9DGGAIIaQRTUWXDY>> psablock = PSABlock(c=128, attn_ratio=0.5, num_heads=4, shortcut=True) >>> input_tensor = torch.randn(1, 128, 32, 32) >>> output_tensor = psablock(input_tensor) rrrrrNNc t|t||||_t j t ||dzdt |dz|dd|_||_y)a& Initialize the PSABlock. Args: c (int): Input and output channels. attn_ratio (float): Attention ratio for key dimension. num_heads (int): Number of attention heads. shortcut (bool): Whether to use shortcut connections. rrrQrFruN) r<r=r2r@r>rrffnr)rIrrrrrKs rLr=zPSABlock.__init__jsU aJ)L ==aQ!2DQ1%4PQrMrJc|jr||j|zn|j|}|jr||j|z}|S|j|}|S)z Execute a forward pass through PSABlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after attention and feed-forward processing. )rr@rros rLrXzPSABlock.forwardzsV!%A ! diil#xxA O.2XXa[rM)rrPT) r[r\r]r^r_rDrr=rBr`rXrarbs@rLrrTsM*#53VZfj  %,, rMrcjeZdZdZd dededeffd ZdejdejfdZ xZ S) r3a PSA class for implementing Position-Sensitive Attention in neural networks. This class encapsulates the functionality for applying position-sensitive attention and feed-forward networks to input tensors, enhancing feature extraction and processing capabilities. Attributes: c (int): Number of hidden channels after applying the initial convolution. cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c. cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c. attn (Attention): Attention module for position-sensitive attention. ffn (nn.Sequential): Feed-forward network for further processing. Methods: forward: Applies position-sensitive attention and feed-forward network to the input tensor. Examples: Create a PSA module and apply it to an input tensor >>> psa = PSA(c1=128, c2=128, e=0.5) >>> input_tensor = torch.randn(1, 128, 64, 64) >>> output_tensor = psa.forward(input_tensor) r7rerc t|||k(sJt||z|_t |d|jzdd|_t d|jz|d|_t|jd|jdz|_tjt |j|jdzdt |jdz|jdd|_ y) z Initialize PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. e (float): Expansion ratio. rQrr@rFruN) r<r=r_rrrirlr2r@r>rr)rIr7rerrKs rLr=z PSA.__init__s RxxR!VAJ1-DFF B*dff" M ==dffdffqj!!derMrJrNc|j|j|j|jfd\}}||j|z}||j |z}|j t j||fdS)z Execute forward pass in PSA module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after attention and feed-forward processing. rr)rirrr@rrlrBrrs rLrXz PSA.forwardssxx{  $&&$&&!1q 91  !   Oxx 1a&!,--rM)rrrbs@rLr3r3sA.f3fCfEf$ . .%,, .rMr3c neZdZdZd dedededeffd Zdejdejfd Z xZ S) r.aL C2PSA module with attention mechanism for enhanced feature extraction and processing. This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations. Attributes: c (int): Number of hidden channels. cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c. cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c. m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations. Methods: forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations. Notes: This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules. Examples: >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5) >>> input_tensor = torch.randn(1, 256, 64, 64) >>> output_tensor = c2psa(input_tensor) r7rerrc(t||k(sJt||z_t |djzdd_t djz|d_tjfdt|D_ y)z Initialize C2PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. rQrc3hK|])}tjdjdz+ywrrrNrrrrVrIs rLrz!C2PSA.__init__..s+ l^_$&&SDFFVXL!Y!Y lrNrrIr7rerrrKs` rLr=zC2PSA.__init__sy RxxR!VAJ1-DFF B* lchijck lmrMrJrNc|j|j|j|jfd\}}|j|}|j t j ||fdS)z Process the input tensor through a series of PSA blocks. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. rr)rirrrrlrBrrs rLrXz C2PSA.forwards]xx{  $&&$&&!1q 91 FF1Ixx 1a&!,--rMrrrrbs@rLr.r.sI0n3nCnCnn$ . .%,, .rMr.c 6eZdZdZddedededeffd ZxZS)r-a C2fPSA module with enhanced feature extraction using PSA blocks. This class extends the C2f module by incorporating PSA blocks for improved attention mechanisms and feature extraction. Attributes: c (int): Number of hidden channels. cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c. cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c. m (nn.ModuleList): List of PSA blocks for feature extraction. Methods: forward: Performs a forward pass through the C2fPSA module. forward_split: Performs a forward pass using split() instead of chunk(). Examples: >>> import torch >>> from ultralytics.models.common import C2fPSA >>> model = C2fPSA(c1=64, c2=64, n=3, e=0.5) >>> x = torch.randn(1, 64, 128, 128) >>> output = model(x) >>> print(output.shape) r7rerrc||k(sJt||||tjfdt |D_y)z Initialize C2fPSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. )rrc3hK|])}tjdjdz+ywrrrs rLrz"C2fPSA.__init__.."s+j\]x3$&&TV,WWjrNrrs` rLr=zC2fPSA.__init__sCRxx R1*jafghaijjrMr)r[r\r]r^r_rDr=rarbs@rLr-r-s40 k3 kC kC k k krMr-cleZdZdZdedededeffd Zdejdejfd ZxZ S) r4a< SCDown module for downsampling with separable convolutions. This module performs downsampling using a combination of pointwise and depthwise convolutions, which helps in efficiently reducing the spatial dimensions of the input tensor while maintaining the channel information. Attributes: cv1 (Conv): Pointwise convolution layer that reduces the number of channels. cv2 (Conv): Depthwise convolution layer that performs spatial downsampling. Methods: forward: Applies the SCDown module to the input tensor. Examples: >>> import torch >>> from ultralytics import SCDown >>> model = SCDown(c1=64, c2=128, k=3, s=2) >>> x = torch.randn(1, 64, 128, 128) >>> y = model(x) >>> print(y.shape) torch.Size([1, 128, 64, 64]) r7rerhrctt|t||dd|_t|||||d|_y)z Initialize SCDown module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rF)rhrrrvN)r<r=rrirl)rIr7rerhrrKs rLr=zSCDown.__init__=s8 B1%B!qBE:rMrJrNcB|j|j|S)z Apply convolution and downsampling to the input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Downsampled output tensor. )rlriros rLrXzSCDown.forwardKsxx $$rMrZrbs@rLr4r4%sD. ;3 ;C ;C ;C ; % %%,, %rMr4c teZdZdZ d dededededef fd Zdejd ejfd Z xZ S) r5aZ TorchVision module to allow loading any torchvision model. This class provides a way to load a model from the torchvision library, optionally load pre-trained weights, and customize the model by truncating or unwrapping layers. Attributes: m (nn.Module): The loaded torchvision model, possibly truncated and unwrapped. Args: model (str): Name of the torchvision model to load. weights (str, optional): Pre-trained weights to load. Default is "DEFAULT". unwrap (bool, optional): If True, unwraps the model to a sequential containing all but the last `truncate` layers. Default is True. truncate (int, optional): Number of layers to truncate from the end if `unwrap` is True. Default is 2. split (bool, optional): Returns output from intermediate child modules as list. Default is False. modelweightsunwraptruncatercddl}t| t|jdr#|jj |||_n.|jj|t||_|rt|j j}t|dtjr#gt|dj|dd}tj|r|d| n||_||_yd|_tjx|j _|j _y)an Load the model and weights from torchvision. Args: model (str): Name of the torchvision model to load. weights (str): Pre-trained weights to load. unwrap (bool): Whether to unwrap the model. truncate (int): Number of layers to truncate. split (bool): Whether to split the output. rN get_model)r) pretrainedrF) torchvisionr<r=hasattrmodelsrr__dict__rrchildren isinstancer>rrrheadheads) rIrrrrrrlayersrKs rLr=zTorchVision.__init__is   ;%%{ 3 ''11%1IDF7[''0074=QDF $&&//+,F&)R]]3C4q 2 2 45Cqr C]]8VJhY%7QDFDJDJ)+ 6DFFK$&&,rMrJrNc|jr)|gjfd|jDS|j|S)z Forward pass through the model. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor | List[torch.Tensor]): Output tensor or list of tensors. c34K|]}|dywrrrs rLrz&TorchVision.forward..s.!QquX.r)rrrrs @rLrXzTorchVision.forwardsD ::A HH.tvv. .q ArM)DEFAULTTrQF) r[r\r]r^strrr_r=rBr`rXrarbs@rLr5r5XsW"kp77#&7<@7SV7cg7<%,,rMr5cjeZdZdZd dededeffd ZdejdejfdZxZ S) AAttna Area-attention module for YOLO models, providing efficient attention mechanisms. This module implements an area-based attention mechanism that processes input features in a spatially-aware manner, making it particularly effective for object detection tasks. Attributes: area (int): Number of areas the feature map is divided. num_heads (int): Number of heads into which the attention mechanism is divided. head_dim (int): Dimension of each attention head. qkv (Conv): Convolution layer for computing query, key and value tensors. proj (Conv): Projection convolution layer. pe (Conv): Position encoding convolution layer. Methods: forward: Applies area-attention to input tensor. Examples: >>> attn = AAttn(dim=256, num_heads=8, area=4) >>> x = torch.randn(1, 256, 32, 32) >>> output = attn(x) >>> print(output.shape) torch.Size([1, 256, 32, 32]) rrareac t|||_||_||zx|_}||jz}t ||dzdd|_t ||dd|_t ||ddd|d|_y)a' Initialize an Area-attention module for YOLO models. Args: dim (int): Number of hidden channels. num_heads (int): Number of heads into which the attention mechanism is divided. area (int): Number of areas the feature map is divided. rgrFrurrN) r<r=rrrrrrQr)rIrrrr all_head_dimrKs rLr=zAAttn.__init__s~  "#&)#33 $..0 \A-qe<sA59 |S!QSeDrMrJrNc|j\}}}}||z}|j|jdjdd}|jdkDr@|j ||jz||jz|dz}|j\}}}|j |||j|jdzjddddj|j|j|jgd\} } } | jdd| z|jdzz} | jd} | | jddz}|jdddd}| jdddd} |jdkDrj|j ||jz||jz|}| j ||jz||jz|} |j\}}}|j ||||jddddj}| j ||||jddddj} ||j| z}|j|S) z Process the input tensor through the area-attention. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention. rQrrgrrrrr)rRrflattenrSrr[rFrrpermuterrT contiguousrrQ) rIrJrrrrrrrVr]rhr^r@s rLrXz AAttn.forwards)WW 1a Ehhqk!!!$..q!4 99q=++a$))mQ$))^QUCCiiGAq! HHQ4>>4==1+< = WQ1a UDMM4==$--@aU H 1a  B#a'DMM4,?@|||# r2& & IIaAq ! IIaAq ! 99q= !tyy.!dii-;A !tyy.!dii-;AggGAq! IIaAq ! ) )!Q1 5 @ @ B IIaAq ! ) )!Q1 5 @ @ B  Nyy|rMrrZrbs@rLr r sA2ECECEsE(%%%,,%rMr c eZdZdZd dedededeffd ZdejfdZ d e jd e jfd Z xZ S) ABlocka Area-attention block module for efficient feature extraction in YOLO models. This module implements an area-attention mechanism combined with a feed-forward network for processing feature maps. It uses a novel area-based attention approach that is more efficient than traditional self-attention while maintaining effectiveness. Attributes: attn (AAttn): Area-attention module for processing spatial features. mlp (nn.Sequential): Multi-layer perceptron for feature transformation. Methods: _init_weights: Initializes module weights using truncated normal distribution. forward: Applies area-attention and feed-forward processing to input tensor. Examples: >>> block = ABlock(dim=256, num_heads=8, mlp_ratio=1.2, area=1) >>> x = torch.randn(1, 256, 32, 32) >>> output = block(x) >>> print(output.shape) torch.Size([1, 256, 32, 32]) rr mlp_ratiorc t|t||||_t ||z}t j t||dt||dd|_|j|jy)ae Initialize an Area-attention block module. Args: dim (int): Number of input channels. num_heads (int): Number of heads into which the attention mechanism is divided. mlp_ratio (float): Expansion ratio for MLP hidden dimension. area (int): Number of areas the feature map is divided. )rrrFruN) r<r=r r@r_r>rrmlpapply _init_weights)rIrrrrmlp_hidden_dimrKs rLr=zABlock.__init__si #> S9_-==c>1!=tNTWYZ`e?fg 4%%&rMrct|tjrctjj |j d|j +tjj|j dyyy)z Initialize weights using a truncated normal distribution. Args: m (nn.Module): Module to initialize. g{Gz?)stdNr)rr>r?init trunc_normal_rGr: constant_)rIrs rLrzABlock._init_weightssY a # GG ! !!(( ! 5vv!!!!&&!," $rMrJrNcR||j|z}||j|zS)z Forward pass through ABlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention and feed-forward processing. )r@rros rLrXzABlock.forward%s(  ! 488A;rM)g333333?r)r[r\r]r^r_rDr=r>rrrBr`rXrarbs@rLrrsT.'C'C'E's'$ -ryy -  %,, rMrceZdZdZ ddededededededed ed ed effd Zd ejdejfdZ xZ S)A2C2fa Area-Attention C2f module for enhanced feature extraction with area-based attention mechanisms. This module extends the C2f architecture by incorporating area-attention and ABlock layers for improved feature processing. It supports both area-attention and standard convolution modes. Attributes: cv1 (Conv): Initial 1x1 convolution layer that reduces input channels to hidden channels. cv2 (Conv): Final 1x1 convolution layer that processes concatenated features. gamma (nn.Parameter | None): Learnable parameter for residual scaling when using area attention. m (nn.ModuleList): List of either ABlock or C3k modules for feature processing. Methods: forward: Processes input through area-attention or standard convolution pathway. Examples: >>> m = A2C2f(512, 512, n=1, a2=True, area=1) >>> x = torch.randn(1, 512, 32, 32) >>> output = m(x) >>> print(output.shape) torch.Size([1, 512, 32, 32]) r7rera2rresidualrrrrc  t |t||z dzdk(sJdt| dd|_td|z z|d|_r/|r-t jdtj|zdnd|_ t j  fd t|D|_ y) a Initialize Area-Attention C2f module. Args: c1 (int): Number of input channels. c2 (int): Number of output channels. n (int): Number of ABlock or C3k modules to stack. a2 (bool): Whether to use area attention blocks. If False, uses C3k blocks instead. area (int): Number of areas the feature map is divided. residual (bool): Whether to use residual connections with learnable gamma parameter. mlp_ratio (float): Expansion ratio for MLP hidden dimension. e (float): Channel expansion ratio for hidden channels. g (int): Number of groups for grouped convolutions. shortcut (bool): Whether to use shortcut connections in C3k blocks. rqrz(Dimension of ABlock be a multiple of 32.rg{Gz?TrKNc3K|];}r&tjfdtdDntd=yw)c3@K|]}tdzyw)rqN)r)rrVrrdrs rLrz+A2C2f.__init__...ps TaF2rRxDATrrQN)r>rrr)rrVr%rrdrrrs rLrz!A2C2f.__init__..osI  MMT5QR8T URQ!, - sAA)r<r=r_rrirlr>rErBr/gammarrr) rIr7rerr%rr&rrrrrdrKs `` ` ``@rLr=zA2C2f.__init__Ks8  a[Bw!|GGG|B1%Q" b!,PRW_R\\$B"7tLei   1X   rMrJrNcD|j|gjfd|jD|jt j d|j 7||j jdt|j ddzzSS)z Forward pass through A2C2f layer. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. c34K|]}|dywrrrs rLrz A2C2f.forward..rrrr) rirrrlrBrr*rFrrs @rLrXz A2C2f.forwardvs|XXa[M *466** HHUYYq!_ % :: !tzzr3tzz?AqAAEE ErM)rTrFg@rrTrrbs@rLr$r$3s6) )  )   )  )  ) ) )  )  ) ) V%,,rMr$c neZdZdZd dedededdffd Zdejdejfd ZxZ S) SwiGLUFFNz@SwiGLU Feed-Forward Network for transformer-based architectures.r'rrrNNct|tj|||z|_tj||zdz||_y)z Initialize SwiGLU FFN with input dimension, output dimension, and expansion factor. Args: gc (int): Guide channels. ec (int): Embedding channels. e (int): Expansion factor. rQN)r<r=r>r+w12w3)rIr'rrrKs rLr=zSwiGLUFFN.__init__s@ 99RR())AFaK,rMrJc|j|}|jdd\}}tj||z}|j |S)z.Apply SwiGLU transformation to input features.rQrr)r0rrsilur1)rIrJx12rrhiddens rLrXzSwiGLUFFN.forwardsDhhqk1"%BbwwvrM)rPrZrbs@rLr.r.sBJ -3 -C -C - -%,,rMr.cxeZdZdZdej ddffd ZdejdejfdZ xZ S)Residualz7Residual connection wrapper for neural network modules.rrNNc$t|||_tjj |jj jtjj |jj jy)z Initialize residual module with the wrapped module. Args: m (nn.Module): Module to wrap with residual connection. N) r<r=rr>rzeros_r1r:rG)rIrrKs rLr=zResidual.__init__sS  tvvyy~~& tvvyy''(rMrJc*||j|zS)z,Apply residual connection to input features.rros rLrXzResidual.forwards466!9}rM) r[r\r]r^r>rr=rBr`rXrarbs@rLr7r7s8A )")) ) )%,,rMr7ceZdZdZdeededeffd Zdeejdejdejfd Z xZ S) SAVPEzESpatial-Aware Visual Prompt Embedding module for feature enhancement.rHrr9c t|tjfdt |D|_tjfdt |D|_d|_tjdz|d|_ tjdz|jdd|_ tjd|jdd|_ tjtd|jz|jdtj|j|jdd|_y) a Initialize SAVPE module with channels, intermediate channels, and embedding dimension. Args: ch (List[int]): List of input channel dimensions. c3 (int): Intermediate channels. embed (int): Embedding dimension. c 3K|]c\}}tjt|dtd|dvrtj|dzntjeyw)rgrrQrQ scale_factorNr>rrUpsamplerrrrJrs rLrz!SAVPE.__init__..sa! 1 MMQARQTUY_T_!a%1Pegepeper ! sA)A,c3K|]W\}}tjt|d|dvrtj|dzntjYyw)rr?rQr@NrBrDs rLrz!SAVPE.__init__..sP! 1 MM$q"a.QRX["++1q5*I^`^i^i^k l! sAA rYrgr)ryrQN)r<r=r>rrrirlrr?rmr rrrcv6)rIrHrr9rKs ` rLr=zSAVPE.__init__s ==! "" !  ==! !" !   99QVUA.99QVTVVQ:99Q15==a$&&j$&&!!efrMrJvprNct|Dcgc]\}}|j||}}}|jtj|d}t|Dcgc]\}}|j ||}}}|j tj|d}|j\}}}} |jd} |j||d}|j|d|j|| jd| dddj|| z|j|| }|j|| d|| j|| zd|| }|jtj||j|fd}|j|| |jd}|j|| dd}||ztj|tj|j j"zz} t%j&| dtj(j+| j } | j-dd|j||j||jzdj-ddz} t%j.| j-ddj|| dddScc}}wcc}}w) zJProcess input features and visual prompts to generate enhanced embeddings.rrr)rr;rrQrf)rrlr rBrrirmrRrFr[rexpandrFr logical_notfinfor;minrrTrDtorSrh) rIrJrGrxirrrrrQscore aggregateds rLrXz SAVPE.forwardsO*3A, 7B[TXXa[_ 7 7 HHUYYqa( )*3A, 7B[TXXa[_ 7 7 HHUYYqa( )WW 1a HHQK FF1a  IIaDFFAq ) 0 0QB C K KAPQESWSYSY[\^_ ` ZZ1aA & . .q1uaA > HHUYY488B<0a8 9 IIaDFFB ' ZZ1a $B**2.QWW1E1I1III %Ru{{;>>u{{K__R,qyyDFFAKQS/T/^/^_ace/ff {{://B7??1bIrUVWW5 8 8s K%Krrbs@rLr<r<sWOg49g#gcg8Xell+XX%,,XrMr<)Lr^typingrrrrBtorch.nnr>torch.nn.functionalrrultralytics.utils.torch_utilsrrArr r r r r transformerr__all__rrr"rrrrrrrrrr#rrrr r!rr$r%rrrrrurxr%r&r(r'r)r+r*rr,rr/r0r1r2rr3r.r-r4r5r rr$r.r7r<rrMrLrYs(( :FF)( V\"))\6>BII>.#RYY#L+(bii+(\D"))D0)299)8,668 )")) )FJJ6x"x(;BII;2020(MbM(/bii/:PP8CBIIC@J"))J2"))@3$"))3$lB)biiB)J@%ryy@%F6bii6606 06f,J,,_R_()299)D1L1*BII(&BII&4)bii)83ryy30"))>BSBIISlARYYAHRBIIRj 0ryy,;XBII;XrM