.hJdZddlmZddlZddlmZddlmcmZddl m Z ddl m Z m Z mZmZmZmZddlmZdZGd d ej*ZGd d ej*ZGd dej*ZGddej*ZGddej*ZGddej*ZGddej*ZGddej*ZGddej*ZGddej*ZGddeZ Gdd ej*Z!Gd!d"eZ"Gd#d$eZ#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%Z.Gd;dej*Z0Gd?d@e0Z1GdAdBej*Z2GdCdDej*Z3GdEdFej*Z4GdGdHej*Z5GdIdJej*Z6GdKdLej*Z7GdMdNeZ8GdOdPeZ9GdQdRej j*Z:GdSdTej*Z;GdUdVeZ<GdWdXej*Z=GdYdZej*Z>Gd[d\ej*Z?Gd]d^ej*Z@Gd_d`eZAGdadbej*ZBGdcddej*ZCGdedfej*ZDGdgdhej*ZEGdidjej*ZFGdkdlej*ZGGdmdnej*ZHGdodpej*ZIy)qzBlock modules.) annotationsN)fuse_conv_and_bn)ConvDWConv GhostConv LightConvRepConvautopad)TransformerBlock)'DFLHGBlockHGStemSPPSPPFC1C2C3C2fC2fAttnImagePoolingAttnContrastiveHeadBNContrastiveHeadC3xC3TRC3GhostGhostBottleneck Bottleneck BottleneckCSPProtoRepC3 ResNetLayer RepNCSPELAN4ELAN1ADownAConvSPPELANCBFuseCBLinearC3k2C2fPSAC2PSARepVGGDWCIBC2fCIB AttentionPSASCDown TorchVisionc.eZdZdZddfd ZddZxZS)r z Integral module of Distribution Focal Loss (DFL). Proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391 cdt|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 Parameterviewweightdatac1)selfrFx __class__s Z/var/www/html/ai-service/venv/lib/python3.12/site-packages/ultralytics/nn/modules/block.pyr:z DFL.__init__As~ IIb!QU3BB5I LL5;; /#%<<q"a0C#D a c|j\}}}|j|j|d|j|j ddj dj|d|S)zCApply the DFL module to input tensor and return transformed output.r)shaper>rCrF transposesoftmax)rGrHb_as rJforwardz DFL.forwardNs]''1ayy1dggq1;;AqAII!LMRRSTVWYZ[[rK))rFintrH torch.TensorreturnrY__name__ __module__ __qualname____doc__r:rU __classcell__rIs@rJr r :s \rKr c.eZdZdZddfd ZddZxZS)r zBUltralytics YOLO models mask Proto module for segmentation models.ct|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). )krNrTr6N) r9r:rcv1r;ConvTranspose2dupsamplecv2cv3)rGrFc_c2rIs rJr:zProto.__init__XsY B!$**2r1aF B!$B<rKc ~|j|j|j|j|S)zEPerform a forward pass through layers using an upsampled input image.)rjrirhrfrGrHs rJrUz Proto.forwardgs+xxtxx{!;<==rK) )rFrWrkrWrlrWrXr[ras@rJr r UsL  >rKr c,eZdZdZdfd ZddZxZS)rz StemBlock of PPHGNetV2 with 5 convolutions and one maxpool2d. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py c 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. rdrNactrrT) kernel_sizestridepadding ceil_modeN) r9r:rr;ReLUstem1stem2astem2bstem3stem4 MaxPool2dpool)rGrFcmrlrIs rJr:zHGStem.__init__ss "b!QBGGI6 2rQw1aRWWY? 27B1aRWWY? "q&"a : "b!QBGGI6 LLQq!tT rKcd|j|}tj|gd}|j|}tj|gd}|j |}|j |}t j||gd}|j|}|j|}|S)+Forward pass of a PPHGNetV2 backbone layer.)rrrrrdim) rzFpadr{r|rr?catr}r~)rGrHx2x1s rJrUzHGStem.forwards JJqM EE!\ " [[^ UU2| $ [[_ YYq\ IIr2hA & JJqM JJqMrK)rFrWrrWrlrWrXr[ras@rJrrls U" rKrcteZdZdZddddej f dfd ZddZxZS) rz HG_Block of PPHGNetV2 with 2 convolutions and LightConv. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py rdFc 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)rrertN).0irtblockrFrres rJ z#HGBlock.__init__..s(_QRu16Rr2LL_ rNrrsN) r9r:r rr; ModuleListrangemscecadd) rGrFrrlren lightconvshortcutrtrrIs `` ` `@rJr:zHGBlock.__init__s~0 & D_V[\]V^__rAF{B!GQs;rQwAqc2(brKc|gjfd|jD|j|jt j d|j r|zSS)rc34K|]}|dywNrrrys rJrz"HGBlock.forward..*a1R5*r)extendrrrr?rrrGrHrs @rJrUzHGBlock.forwardsV C *466** GGDGGEIIaO, -q1u'a'rK)rFrWrrWrlrWrerWrrWrboolrrrt nn.ModulerX) r\r]r^r_r;ryr:rUr`ras@rJrrsy ) ) )  )  )  ))))>(rKrc.eZdZdZddfd ZddZxZS)rzDSpatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729.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. rNrrurvrwN) r9r:rrflenrir;rrr)rGrFrlrerkrHrIs rJr:z SPP.__init__s|  1WB1%c!fqj)2q!4_`aZ[ 1aSTf Uabas"B c |j|}|jtj|g|jDcgc] }|| c}zdScc}w)zBForward pass of the SPP layer, performing spatial pyramid pooling.r)rfrir?rr)rGrHrs rJrUz SPP.forwardsF HHQKxx 1#tvv(>!1(>">BCC(>sA)) )rFrWrlrWretuple[int, ...]rXr[ras@rJrrsN cDrKrc.eZdZdZddfd ZddZxZS)rzGSpatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher.ct||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)). rNrrMrN)r9r:rrfrir;rr)rGrFrlrerkrIs rJr:z SPPF.__init__sY  1WB1%QAq)!AqAvFrKcj|gjfdtdDjt j dS)zRApply sequential pooling operations to input and return concatenated feature maps.c3FK|]}jdywrr)rrSrGrs rJrzSPPF.forward..s11"1s!rdr)rfrrrir?rrs` @rJrUz SPPF.forwardsA XXa[M 1a11xx !Q((rKr)rFrWrlrWrerWrXr[ras@rJrrsQG$)rKrc.eZdZdZddfd ZddZxZS)rz"CSP Bottleneck with 1 convolution.ct|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)rdN)r)rrSrls rJrzC1.__init__..s CQb"a CsN)r9r:rrfr; Sequentialrr)rGrFrlrrIs ` rJr:z C1.__init__s< B1% C%( CDrKcL|j|}|j||zS)z:Apply convolution and residual connection to input tensor.)rfrrs rJrUz C1.forwards! HHQKvvay1}rKr)rFrWrlrWrrWrXr[ras@rJrrs, ErKrc.eZdZdZddfd ZddZxZS)rz#CSP Bottleneck with 2 convolutions.c"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. rNrc 3hK|])}tjjdd+yw)rdrdr?reeNrcrrSgrGrs rJrzC2.__init__..s. vhiDFFDFFHaK[_b!c!c v/2N r9r:rWrrrfrir;rrrrGrFrlrrrrrIs` `` rJr:z C2.__init__ sn R!VAJ1-DFF B* vmrstmu vwrKc|j|jdd\}}|jtj|j ||fdS)z.9.tfgz$&&$&&(AIY]`aatrN) r9r:rWrrrfrir;rrrrs` `` rJr:z C2f.__init__)ss R!VAJ1-Q$&&("a0tkpqrksttrKct|j|jddjfd|jD|j t jdS)zForward pass through C2f layer.rNrc34K|]}|dywrrrs rJrzC2f.forward..>rr)listrfrrrrir?rrs @rJrUz C2f.forward;sQ !""1a( ) *466**xx !Q((rKc|j|j|j|jfdddgjfd|jD|j t jdS).Forward pass using split() instead of chunk().rrc34K|]}|dywrrrs rJrz$C2f.forward_split..Err)rfsplitrrrrir?rrs @rJ forward_splitzC2f.forward_splitAsj HHQK  tvvtvv. 2 qT1Q4L *466**xx !Q((rKrFrrrrXr\r]r^r_r:rUrr`ras@rJrr&sFu$) )rKrc.eZdZdZddfd ZddZxZS)rz#CSP Bottleneck with 3 convolutions.ct|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. rrNc 3@K|]}tddyw)))rrrrrNrrrSrkrrs rJrzC3.__init__..]s& n`aBHaCSWZ![![ nN) r9r:rWrrfrirjr;rrr rGrFrlrrrrrkrIs `` @rJr:z C3.__init__Lsr  a[B1%B1%BA& nejklem norKc |jtj|j|j ||j |fdS)z.us. vhiDGGTWWhM]ab!c!c vrN)r9r:rWrkr;rrrrs` `` rJr:z C3x.__init__gsH RHa3b1f+ vmrstmu vwrKrrr\r]r^r_r:r`ras@rJrrds,xxrKrc.eZdZdZddfd ZddZxZS)r!zRep C3.c 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) r9r:rWrrfrir;rrr rIdentityrj)rGrFrlrrrkrSrIs rJr:zRepC3.__init__{s  a[B1%B1%%( CQR CD)+r4B1%r{{}!Ds B/c|j|j|j||j|zS)zForward pass of RepC3 module.)rjrrfrirns rJrUz RepC3.forwards/xxtxx{+dhhqk9::rK)rdrrFrWrlrWrrWrrArXr[ras@rJr!r!xsE";rKr!c&eZdZdZddfd ZxZS)rz"C3 module with TransformerBlock().cpt|||||||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. rMN)r9r:rWr rrs rJr:z C3TR.__init__s; RHa3 a[!"b!Q/rKrrrras@rJrrs,00rKrc&eZdZdZddfd ZxZS)rz!C3 module with GhostBottleneck().ct|||||||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)rrSrks rJrz#C3Ghost.__init__..s KQR!8 KsNr9r:rWr;rrrrs @rJr:zC3Ghost.__init__sC RHa3 a[ K%( KLrKrrrras@rJrrs+MMrKrc.eZdZdZddfd ZddZxZS)rzGGhost Bottleneck https://github.com/huawei-noah/Efficient-AI-Backbones.c 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. rNrFrsN) r9r:r;rrrrr>rr)rGrFrlresrkrIs rJr:zGhostBottleneck.__init__s  1WMM b"a #/0AvF2r1aU +2;;= b"a .  ^_bc]cBMM&RA594B1RW;X Y ikititiv rKcH|j||j|zS)z8Apply skip connection and concatenation to input tensor.)r>rrns rJrUzGhostBottleneck.forwardsyy|dmmA...rKrrFrWrlrWrerWrrWrXr[ras@rJrrsQ */rKrcFeZdZdZ d dfd ZddZxZS)rzStandard bottleneck.ct|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)r9r:rWrrfrir rGrFrlrrrerrkrIs rJr:zBottleneck.__init__s[  a[B!a(B!a1-(brKc|jr#||j|j|zS|j|j|S)z3Apply bottleneck with optional shortcut connection.)rrirfrns rJrUzBottleneck.forwards:,0HHq488DHHQK((O$((488A;:OOrKTrrr rFrWrlrWrrrrWreztuple[int, int]rrArXr[ras@rJrrsHlo)))*.):=)FU)ch)(PrKrc.eZdZdZddfd ZddZxZS)rzGCSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks.ct|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. rFr6rNc3>K|]}tdywrrNrrs rJrz)BottleneckCSP.__init__.. s! ZABHa3!G!G ZN)r9r:rWrrfr;r<rirjcv4 BatchNorm2dbnSiLUrtrrrrs `` @rJr:zBottleneckCSP.__init__s  a[B1%99RQ699RQ6BAq)..R(779 ZQVWXQY Z[rKc  |j|j|j|}|j|}|j |j |j tj||fdS)z)Apply CSP bottleneck with 3 convolutions.r) rjrrfrirrtrr?r)rGrHy1y2s rJrUzBottleneckCSP.forward s^ XXdffTXXa[) * XXa[xxB8Q)?!@ABBrKrrrXr[ras@rJrrsQ\,CrKrc.eZdZdZddfd ZddZxZS) ResNetBlockz.ResNet block with standard convolution layers.c 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. rTrerrtrdrerprtFrN) r9r:rrfrirjr;rrr)rGrFrlrrc3rIs rJr:zResNetBlock.__init__s  VB!qd3B!qA48B!/LMQRFVX\^V^ d2rQ!&GH dfdododq rKc tj|j|j|j ||j |zS)z&Forward pass through the ResNet block.)rrelurjrirfrrns rJrUzResNetBlock.forward&s9vvdhhtxx 45 a8HHIIrK)rrM)rFrWrlrWrrWrrWrXr[ras@rJrrs8r"JrKrc.eZdZdZddfd ZddZxZS)r"z)ResNet layer with multiple ResNet blocks.c 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. rNrdTrrrr N) r9r:is_firstr;rrrlayerrrr) rGrFrlrr!rrblocksrSrIs rJr:zResNetLayer.__init__.s   ==RqA5r||PQZ[ef7gDJ""b!q12F MME!a%LQq;q2vr1:Q R/DJRsCc$|j|S)z&Forward pass through the ResNet layer.)r"rns rJrUzResNetLayer.forwardFszz!}rK)rFrrM) rFrWrlrWrrWr!rrrWrrWrXr[ras@rJr"r"+s300rKr"c.eZdZdZddfd ZddZxZS)MaxSigmoidAttnBlockzMax Sigmoid attention block.ct|||_||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. rFrNrdrr)r9r:nhhcrrr;LinearglrBr?zerosr7 proj_convonesscale)rGrFrlr(rgcr/rIs rJr:zMaxSigmoidAttnBlock.__init__Ns (24($r2.))B#LLR1 b"QE:>CR\\%**QAq"9:  rKc|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->bmhwnrrrrrN)rOr+rCr(r)rr?einsummaxr7sigmoidr/r- unsqueeze) rGrHguidebsrShwembedaws rJrUzMaxSigmoidAttnBlock.forwardcs4gg Aq! 2u{{1~tww@"gg1 q 2twwA6 \\-ue < VVV^A  477C<  $))D!T4/0 0 ZZ\DJJ & NN1  FF2twwAq )  Q vvb"a##rK)rF) rFrWrlrWr(rWrrWr0rWr/rrHrYr6rYrZrYr[ras@rJr&r&Ks&M*$rKr&cfeZdZdZ d dfd ZddZddZxZS)rz*C2f module with an additional attn module.c 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. rNrrdc 3hK|])}tjjdd+ywrrrs rJrz#C2fAttn.__init__..rr)r0rr(N) r9r:rWrrrfrir;rrrr&attn) rGrFrlrrr(r0rrrrIs ` `` rJr:zC2fAttn.__init__s4 R!VAJ1-Q$&&("a0tkpqrkstt'2"L rKc2t|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. rNrc34K|]}|dywrrrs rJrz"C2fAttn.forward..rrr) rrfrrrappendrBrir?rrGrHr6rs @rJrUzC2fAttn.forwardsn !""1a( ) *466** 1R5%()xx !Q((rKc^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 rJrz(C2fAttn.forward_split..rrr) rrfrrrrrErBrir?rrFs @rJrzC2fAttn.forward_splits{ !""DFFDFF#3Q7 8 *466** 1R5%()xx !Q((rK)rr<rr=Frr)rFrWrlrWrrWrrWr(rWr0rWrrrrWrrAr>rras@rJrrs4 M M M  M  M  M MM M MB) )rKrcFeZdZdZ d dfd ZddZxZS)rzKImagePoolingAttn: Enhance the text embeddings with image-aware information.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)ruN)r9r:rr;r LayerNormr*querykeyvalueprojrBr?tensorr/rr< projectionsrAdaptiveMaxPool2dim_poolsrr(nfr)re) rGrchctr(rer/rV in_channelsrSrIs rJr: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 c |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. rrNrrrzbnmc,bkmc->bmnkrzbmnk,bkmc->bnmc)rOrrVreziprSrUrCr?rrPrNrOrPreshaper(r)r2rrQrQrr/) rGrHtextr7 num_patchesrQrqrevr;s rJrUzImagePoolingAttn.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)rorr=rdF) rrWrWrrXrWr(rWrerWr/r)rHlist[torch.Tensor]r]rYrZrYr[ras@rJrrsGUns!0;>JMVYfj<%rKrc*eZdZdZfdZddZxZS)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) r9r:r;rBr?rRr7r.log logit_scale)rGrIs rJr:zContrastiveHead.__init__ sY LLug!67 << 2h9O9S9S9U(UVrKctj|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. rrNrrrbchw,bkc->bkhw)r normalizer?r2rgexpr7rGrHr9s rJrUzContrastiveHead.forwards^ KKqA & KKrQ ' LL)1a 04##''))DII55rKrHrYr9rYrZrYr[ras@rJrr sdW6rKrc:eZdZdZdfd ZdZddZddZxZS)rz Batch Norm Contrastive Head using batch norm instead of l2-normalization. Args: embed_dims (int): Embed dimensions of text and image features. ct|tj||_tj t jdg|_tj dt jgz|_ y)z Initialize BNContrastiveHead. Args: embed_dims (int): Embedding dimensions for features. regN) r9r:r;rnormrBr?rRr7r.rg)rG embed_dimsrIs rJr:zBNContrastiveHead.__init__,sY NN:. LLug!67 <<uzz"~(=>rKc2|`|`|`|j|_y)zCFuse the batch normalization layer in the BNContrastiveHead module.N)rqr7rg forward_fuserU)rGs rJfusezBNContrastiveHead.fuse:s I I  (( rKc|S)zPasses input out unchanged.rrms rJrtzBNContrastiveHead.forward_fuseAsrKc|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. rrNrirj)rqrrkr?r2rgrlr7rms rJrUzBNContrastiveHead.forwardEsY IIaL KKrQ ' LL)1a 04##''))DII55rK)rrrWrn) r\r]r^r_r:rurtrUr`ras@rJrr$s ?)6rKrc>eZdZdZ d dfd ZxZS) RepBottleneckzRep bottleneck.cvt|||||||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)r9r:rWr rfrs rJr:zRepBottleneck.__init__Zs? R1a3 a[2r1Q4+rKrrrras@rJryryWsGlo,,,*.,:=,FU,ch,,rKryc&eZdZdZddfd ZxZS)RepCSPzXRepeatable Cross Stage Partial Network (RepCSP) module for efficient feature extraction.ct|||||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 )ryrs rJrz"RepCSP.__init__..~s! ]qr2xc!J!J ]r Nrrs `` @rJr:zRepCSP.__init__psF RHa3 a[ ]TYZ[T\ ]^rKrrrras@rJr|r|msb__rKr|c6eZdZdZddfd ZddZddZxZS)r#z CSP-ELAN.c \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. rNrrdN) r9r:rrrfr;rr|rirjr)rGrFrlrc4rrIs rJr:zRepNCSPELAN4.__init__s qB1%==aQ!7b"a9KL==B!2DRA4FGa"f r1a0rKct|j|jddjfd|j|j fD|j tjdS)z(Forward pass through RepNCSPELAN4 layer.rNrc34K|]}|dywrrrs rJrz'RepNCSPELAN4.forward..s:!AbE(:r) rrfrrrirjrr?rrs @rJrUzRepNCSPELAN4.forwardsZ !""1a( ) :dhh%9::xx !Q((rKc.t|j|j|j|jfdj fd|j |j fD|jtjdS)rrc34K|]}|dywrrrs rJrz-RepNCSPELAN4.forward_split..s8a1R58r) rrfrrrrirjrr?rrs @rJrzRepNCSPELAN4.forward_splitsg !""DFFDFF#3Q7 8 8DHHdhh#788xx !Q((rKr) rFrWrlrWrrWrrWrrWrXrras@rJr#r#s1$) )rKr#c$eZdZdZdfd ZxZS)r$z!ELAN1 module with 4 convolutions.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. rNrrdN)r9r:rrrfrirjr)rGrFrlrrrIs rJr:zELAN1.__init__sw RR(qB1%aQ*B1%a"f r1a0rK)rFrWrlrWrrWrrWrras@rJr$r$s+11rKr$c,eZdZdZdfd ZddZxZS)r&zAConv.cJt|t||ddd|_y)z Initialize AConv module. Args: c1 (int): Input channels. c2 (int): Output channels. rdrNrN)r9r:rrfrGrFrlrIs rJr:zAConv.__init__s$ B1a(rKctjjj|ddddd}|j |S)z!Forward pass through AConv layer.rNrrFT)r?r; functional avg_pool2drfrns rJrUz AConv.forwards4 HH   * *1aAud Cxx{rKrFrWrlrWrXr[ras@rJr&r&s )rKr&c,eZdZdZdfd ZddZxZS)r%zADown.ct||dz|_t|dz|jddd|_t|dz|jddd|_y)z Initialize ADown module. Args: c1 (int): Input channels. c2 (int): Output channels. rNrdrrN)r9r:rrrfrirs rJr:zADown.__init__sS qaAq1aAq1rKcTtjjj|ddddd}|j dd\}}|j |}tjjj |ddd}|j|}tj||fdS)z!Forward pass through ADown layer.rNrrFTrd) r?r;rrrrf max_pool2drir)rGrHrrs rJrUz ADown.forwards HH   * *1aAud CAB XXb\ XX + +B1a 8 XXb\yy"b1%%rKrrXr[ras@rJr%r%s 2&rKr%c.eZdZdZddfd ZddZxZS)r'z SPP-ELAN.cBt|||_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. rrNrrMN) r9r:rrrfr;rrirjrcv5)rGrFrlrrerIs rJr:zSPPELAN.__init__s B1%<.sBa1R5Brr)rfrrirjrrr?rrs @rJrUzSPPELAN.forwardsP XXa[M BDHHdhh#ABBxx !Q((rKr)rFrWrlrWrrWrerWrXr[ras@rJr'r's*$)rKr'c.eZdZdZddfd ZddZxZS)r)z CBLinear.c 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)groupsr7N)r9r:c2sr;r<sumr r>)rGrFrrerrrrIs rJr:zCBLinear.__init__s> IIb#c(Aq'!Q-PTU rKcZ|j|j|jdS)z$Forward pass through CBLinear layer.rr)r>rrrns rJrUzCBLinear.forwards$yy|!!$((!22rK)rrNr) rFrWr list[int]rerWrrWrz int | NonerrW)rHrYrZrbr[ras@rJr)r)sV 3rKr)c,eZdZdZdfd ZddZxZS)r(zCBFuse.c0t|||_y)zv Initialize CBFuse module. Args: idx (list[int]): Indices for feature selection. N)r9r:idx)rGrrIs rJr:zCBFuse.__init__s rKc |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. rrNNnearest)sizemoderr)rO enumerater interpolaterr?rstack)rGxs target_sizerrHress rJrUzCBFuse.forward'sfll12& [deghkikel[mnSWSTVWq}}Qtxx{^+INnnyyS2bc7]3;;os2B )rr)rrbrZrYr[ras@rJr(r(s .Js&l^_z"b(AAQUXYYlrN) r9r:rWrrfrirjr;rrrrs `` @rJr:z C3f.__init__9sv  a[B1%B1%Q" b!,lchijckllrKc|j||j|gjfd|jD|j t j dS)zForward pass through C3f layer.c34K|]}|dywrrrs rJrzC3f.forward..Orrr)rirfrrrjr?rrs @rJrUz C3f.forwardLsL XXa[$((1+ & *466**xx !Q((rKrrrXr[ras@rJrr6sFm&)rKrcBeZdZdZ d dfd ZxZS)r*rct||||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)rNN)C3krr)rrSc3krrGrs rJrz C3k2.__init__..fsG hi3C8Q /JtvvtvvW_ab.~s( dVWBHaAq6S!Q!Q drNr) rGrFrlrrrrrerkrIs `` `@rJr:z C3k.__init__nsF RHa3 a[ d[`ab[c derK)rTrrrd)rFrWrlrWrrWrrrrWrrArerWrras@rJrrksrffrKrcbeZdZdZdfd ZddZddZejdZ xZ S)r-zfRepVGGDW is a class that represents a depth wise separable convolutional block in RepVGG architecture.c t|t||ddd|d|_t||ddd|d|_||_t j|_y)zm Initialize RepVGGDW module. Args: ed (int): Input and output channels. r rrdFrrtN) r9r:rr>conv1rr;rrt)rGedrIs rJr:zRepVGGDW.__init__sT RAqBE: "b!QRU; 779rKcf|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. )rtr>rrns rJrUzRepVGGDW.forwards(xx ! tzz!}455rKcB|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. )rtr>rns rJrtzRepVGGDW.forward_fusesxx ! %%rKcFt|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. )rNrNrNrNN) rr>rrrDr7r?r;rrrEcopy_) rGr>rconv_wconv_bconv1_wconv1_b final_conv_w final_conv_bs rJruz RepVGGDW.fuses   = $**--@,,**((%%))'<@' '  |, \* JrK)rrWrZNonerX) r\r]r^r_r:rUrtr?no_gradrur`ras@rJr-r-s1p  6 &U]]_rKr-c.eZdZdZddfd ZddZxZS)r.a 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. c 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. rdrrNrN) r9r:rWr;rrr-rfr)rGrFrlrrlkrkrIs rJr:z CIB.__init__s  a[== Rb ! QVQ  "HQV QVQVQ!b&(I RQ  Rb !  (brKcd|jr||j|zS|j|S)z Forward pass of the CIB module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )rrfrns rJrUz CIB.forwards)#'((q488A;; ;rK)TrF) rFrWrlrWrrrrArrrXr[ras@rJr.r.s ). .s)]qs4664668srJJ]s.1Nr) rGrFrlrrrrrrIs ` `` rJr:zC2fCIB.__init__s9 RHa3]TYZ[T\]]rK)rFFrr)rFrWrlrWrrWrrrrrrWrrArras@rJr/r/sZ nq^^^#&^6:^HL^Y\^ej^^rKr/c.eZdZdZddfd ZddZxZS)r0a 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. cPt|||_||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. rNrFrsrdrN) r9r: num_headshead_dimrWkey_dimr/rqkvrQpe)rGrr attn_rationh_kdr8rIs rJr:zAttention.__init__(s "y( 4==:56 \\4'  y( %!)OQu-c1%0 sCA%8rKc 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. rNrr) rOrrCrrrrrPr/rQrr\rQ) rGrHBCHWNrr_rer`rBs rJrUzAttention.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) c 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. rrrNrFrsN) r9r:r0rBr;rrffnr)rGrrrrrIs rJr:zPSABlock.__init__jsU aJ)L ==aQ!2DQ1%4PQrKc|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. )rrBrrns rJrUzPSABlock.forwardzsV!%A ! diil#xxA O.2XXa[rK)rrMT) rrWrrArrWrrrZrrXr[ras@rJrrTs* rKrc.eZdZdZddfd ZddZxZS)r1a 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) c 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. rNrr@rFrsN) r9r:rWrrrfrir0rBr;rr)rGrFrlrrIs rJr:z PSA.__init__s RxxR!VAJ1-DFF B*dff" M ==dffdffqj!!derKc|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)rfrrrBrrir?rrs rJrUz PSA.forwardssxx{  $&&$&&!1q 91  !   Oxx 1a&!,--rK)r)rFrWrlrWrrArXr[ras@rJr1r1s.f$ .rKr1c.eZdZdZddfd ZddZxZS)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) c(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. rNrc3hK|])}tjdjdz+ywrrrNrrrrSrGs rJrz!C2PSA.__init__..s+ l^_$&&SDFFVXL!Y!Y lrNrrGrFrlrrrIs` rJr:zC2PSA.__init__sy RxxR!VAJ1-DFF B* lchijck lmrKc|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)rfrrrrir?rrs rJrUz C2PSA.forwards]xx{  $&&$&&!1q 91 FF1Ixx 1a&!,--rKrrrrXr[ras@rJr,r,s0n$ .rKr,c&eZdZdZddfd 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) c||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 rJrz"C2fPSA.__init__.."s+j\]x3$&&TV,WWjrNrrs` rJr:zC2fPSA.__init__sCRxx R1*jafghaijjrKrrrras@rJr+r+s0 k krKr+c,eZdZdZdfd ZddZxZS)r2a< 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]) ctt|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)rerrrtN)r9r:rrfri)rGrFrlrerrIs rJr:zSCDown.__init__=s8 B1%B!qBE:rKcB|j|j|S)z Apply convolution and downsampling to the input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Downsampled output tensor. )rirfrns rJrUzSCDown.forwardKsxx $$rKrrXr[ras@rJr2r2%s. ; %rKr2cBeZdZdZ d dfd ZddZxZS)r3aZ 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. cddl}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)weights) pretrainedrF) torchvisionr9r:hasattrmodelsrr__dict__rrchildren isinstancer;rrrheadheads) rGmodelrunwraptruncaterrlayersrIs rJr:zTorchVision.__init__is   ;%%{ 3 ''11%1IDF7[''0074=QDF $&&//+,F&)R]]3C4q 2 2 45Cqr C]]8VJhY%7QDFDJDJ)+ 6DFFK$&&,rKc|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 rJrz&TorchVision.forward..s.!QquX.r)rrrrs @rJrUzTorchVision.forwardsD ::A HH.tvv. .q ArK)DEFAULTTrNF) r strrrr rr rWrrrXr[ras@rJr3r3XsA"kp77#&7<@7SV7cg7<rKr3c.eZdZdZddfd ZddZxZS)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]) c 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. rdrFrsr rN) r9r:arearrrrrQr)rGrrrr all_head_dimrIs rJr:zAAttn.__init__s~  "#&)#33 $..0 \A-qe<sA59 |S!QSeDrKc|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. rNrrdrrrrr)rOrflattenrPrr\rCrrpermuterrQ contiguousrrQ) rGrHrrrrrrrSr_rer`rBs rJrUz 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|rKr)rrWrrWrrWrXr[ras@rJrrs2E(%rKrc6eZdZdZddfd ZddZddZxZS) 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]) c 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. )rrrFrsN) r9r:rrBrWr;rrmlpapply _init_weights)rGrr mlp_ratiormlp_hidden_dimrIs rJr:zABlock.__init__si #> S9_-==c>1!=tNTWYZ`e?fg 4%%&rKct|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_rDr7 constant_)rGrs rJr zABlock._init_weightssY a # GG ! !!(( ! 5vv!!!!&&!," $rKcR||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. )rBrrns rJrUzABlock.forward%s(  ! 488A;rK)g333333?r)rrWrrWr!rArrW)rrrX)r\r]r^r_r:r rUr`ras@rJrrs.'$ - rKrcdeZdZdZ d dfd ZddZxZS)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]) c  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. rprz(Dimension of ABlock be a multiple of 32.rg{Gz?TrKNc3K|];}r&tjfdtdDntd=yw)c3@K|]}tdzyw)rpN)r)rrSrrkr!s rJrz+A2C2f.__init__...ps TaF2rRxDATrrNN)r;rrr)rrSa2rrkrr!rs rJrz!A2C2f.__init__..osI  MMT5QR8T URQ!, - sAA)r9r:rWrrfrir;rBr?r.gammarrr) rGrFrlrr.rresidualr!rrrrkrIs `` ` ``@rJr:zA2C2f.__init__Ks8  a[Bw!|GGG|B1%Q" b!,PRW_R\\$B"7tLei   1X   rKcL|j|gjfd|jD|jt j d|j ;||j jd|j jdddzzSS)z Forward pass through A2C2f layer. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. c34K|]}|dywrrrs rJrz A2C2f.forward..rrrrr) rfrrrir?rr/rCrOrs @rJrUz A2C2f.forwardvsXXa[M *466** HHUYYq!_ % :: !tzzr4::+;+;A+>1EII IrK)rTrFg@rrT)rFrWrlrWrrWr.rrrWr0rr!rArrArrWrrrXr[ras@rJr*r*3s6) )  )   )  )  ) ) )  )  ) ) VrKr*c.eZdZdZddfd ZddZxZS) SwiGLUFFNz@SwiGLU Feed-Forward Network for transformer-based architectures.ct|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. rNN)r9r:r;r*w12w3)rGr0rrrIs rJr:zSwiGLUFFN.__init__s@ 99RR())AFaK,rKc|j|}|jdd\}}tj||z}|j |S)z.Apply SwiGLU transformation to input features.rNrr)r6rrsilur7)rGrHx12rrhiddens rJrUzSwiGLUFFN.forwardsDhhqk1"%BbwwvrK)rM)r0rWrrWrrWrZrrXr[ras@rJr4r4sJ -rKr4c,eZdZdZdfd ZddZxZS)Residualz7Residual connection wrapper for neural network modules.c$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) r9r:rr;r%zeros_r7r7rD)rGrrIs rJr:zResidual.__init__sS  tvvyy~~& tvvyy''(rKc*||j|zS)z,Apply residual connection to input features.rrns rJrUzResidual.forwards466!9}rK)rrrZrrXr[ras@rJr=r=sA )rKr=c,eZdZdZdfd ZddZxZS)SAVPEzESpatial-Aware Visual Prompt Embedding module for feature enhancement.c 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)rdrrNrN scale_factorNr;rrUpsamplerrrrHrs rJrz!SAVPE.__init__..sa! 1 MMQARQTUY_T_!a%1Pegepeper ! sA)A,c3K|]W\}}tjt|d|dvrtj|dzntjYyw)rrErNrFNrHrJs rJrz!SAVPE.__init__..sP! 1 MM$q"a.QRX["++1q5*I^`^i^i^k l! sAA rVrdr)rwrNN)r9r:r;rrrfrirr<rjrrrrcv6)rGrWrr:rIs ` rJr:zSAVPE.__init__s ==! "" !  ==! !" !   99QVUA.99QVTVVQ:99Q15==a$&&j$&&!!efrKct|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&| dj)|j } | j+dd|j||j||jzdj+ddz} t%j,| j+ddj|| dddScc}}wcc}}w)zJProcess input features and visual prompts to generate enhanced embeddings.rrrrrNri)rrirr?rrfrjrOrCr\rexpandrLr logical_notfinfor8minrrQtorPrk) rGrHvprxirrrrrQscore aggregateds rJrUz SAVPE.forwardsI*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 %R(++AGG4__R,qyyDFFAKQS/T/^/^_ace/ff {{://B7??1bIrUVWW1 8 8s K%K)rWrrrWr:rW)rHrbrTrYrZrYr[ras@rJrBrBsOg8XrKrB)Jr_ __future__rr?torch.nnr;torch.nn.functionalrrultralytics.utils.torch_utilsrr>rrrr r r transformerr __all__Moduler r rrrrrrrrrr!rrrrrrr"r&rrrrryr|r#r$r&r%r'r)r(rr*rr-r.r/r0rr1r,r+r2r3rrr*r4r=rBrrKrJr`s" :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,9XBII9XrK