Fi$dZddlmZddlZddlmZddlmcmZddl 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*ZIGdqdreZJGdsdtej*ZKy)uzBlock modules.) annotationsN)fuse_conv_and_bn)ConvDWConv GhostConv LightConvRepConvautopad)TransformerBlock)'C1C2C2PSAC3C3TRCIBDFLELAN1PSASPPSPPELANSPPFAConvADown AttentionBNContrastiveHead Bottleneck BottleneckCSPC2fC2fAttnC2fCIBC2fPSAC3GhostC3k2C3xCBFuseCBLinearContrastiveHeadGhostBottleneckHGBlockHGStemImagePoolingAttnProtoRepC3 RepNCSPELAN4RepVGGDW ResNetLayerSCDown TorchVisionc.eZdZdZddfd ZddZxZS)rzIntegral 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)zInitialize a convolutional layer with a given number of input channels. Args: c1 (int): Number of input channels. rFbiasdtypeN)super__init__nnConv2drequires_grad_convtorcharangefloat Parameterviewweightdatac1)selfrGx __class__s ^/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/ultralytics/nn/modules/block.pyr;z DFL.__init__@s~ 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?rDrG transposesoftmax)rHrIb_as rKforwardz DFL.forwardLs]''1ayy1dggq1;;AqAII!LMRRSTVWYZ[[rL))rGintrI torch.TensorreturnrZ__name__ __module__ __qualname____doc__r;rV __classcell__rJs@rKrr:s \rLrc.eZdZdZddfd ZddZxZS)r-zBUltralytics YOLO models mask Proto module for segmentation models.ct|t||d|_t j ||dddd|_t||d|_t|||_y)aInitialize 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). krOrTr6N) r:r;rcv1r<ConvTranspose2dupsamplecv2cv3)rHrGc_c2rJs rKr;zProto.__init__VsY B!$**2r1aF B!$B<rLc ~|j|j|j|j|S)zEPerform a forward pass through layers using an upsampled input image.)rlrkrjrhrHrIs rKrVz Proto.forwardds+xxtxx{!;<==rL) )rGrXrmrXrnrXrYr\rbs@rKr-r-SsL  >rLr-c,eZdZdZdfd ZddZxZS)r+zStemBlock 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) zInitialize the StemBlock of PPHGNetV2. Args: c1 (int): Input channels. cm (int): Middle channels. c2 (int): Output channels. rerOactrrT) kernel_sizestridepadding ceil_modeN) r:r;rr<ReLUstem1stem2astem2bstem3stem4 MaxPool2dpool)rHrGcmrnrJs rKr;zHGStem.__init__os "b!QBGGI6 2rQw1aRWWY? 27B1aRWWY? "q&"a : "b!QBGGI6 LLQq!tT rLcd|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~rr@catrr)rHrIx2x1s rKrVzHGStem.forwards JJqM EE!\ " [[^ UU2| $ [[_ YYq\ IIr2hA & JJqM JJqMrL)rGrXrrXrnrXrYr\rbs@rKr+r+is U rLr+cteZdZdZddddej f dfd ZddZxZS) r*zHG_Block of PPHGNetV2 with 2 convolutions and LightConv. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py reFc 0 t ||rtnt t j  fdt |D|_t|zz|dzdd|_t|dz|dd|_ |xr|k(|_ y)aInitialize 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)rrgrvN).0irvblockrGrrgs rK z#HGBlock.__init__..s(_QRu16Rr2LL_ rOrruN) r:r;r rr< ModuleListrangemscecadd) rHrGrrnrgn lightconvshortcutrvrrJs `` ` `@rKr;zHGBlock.__init__s~. & D_V[\]V^__rAF{B!GQs;rQwAqc2(brLc|gjfd|jD|j|jt j d|j r|zSS)rc34K|]}|dywNrrrys rKrz"HGBlock.forward..*a1R5*r)extendrrrr@rrrHrIrs @rKrVzHGBlock.forwardsV C *466** GGDGGEIIaO, -q1u'a'rL)rGrXrrXrnrXrgrXrrXrboolrrrv nn.ModulerY) r]r^r_r`r<r{r;rVrarbs@rKr*r*sy ) ) )  )  )  ))))<(rLr*c.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)zInitialize 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. rOrrwrxryN) r:r;rrhlenrkr<rrr)rHrGrnrgrmrIrJs rKr;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)rhrkr@rr)rHrIrs rKrVz SPP.forwardsF HHQKxx 1#tvv(>!1(>">BCC(>sA)) )rGrXrnrXrgtuple[int, ...]rYr\rbs@rKrrsN cDrLrc.eZdZdZddfd ZddZxZS)rzGSpatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher.ct||dz}t||ddd|_t||dzz|dd|_t j |d|dz|_||_|xr||k(|_ y)aInitialize the SPPF layer with given input/output channels and kernel size. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. n (int): Number of pooling iterations. shortcut (bool): Whether to use shortcut connection. Notes: This module is equivalent to SPP(k=(5, 9, 13)). rOrFrurN) r:r;rrhrkr<rrrr)rHrGrnrgrrrmrJs rKr;z SPPF.__init__sv  1WB1%0a!e b!Q/!AqAvF(brLc j|gjfdttddDj t j dtddr|zSS)zRApply sequential pooling operations to input and return concatenated feature maps.c3FK|]}jdywrr)rrTrHrs rKrzSPPF.forward..sE1"Es!rrerrF)rhrrgetattrrkr@rrs` @rKrVz SPPF.forwardsd XXa[M EgdC.C(DEE HHUYYq!_ %eU3q1u::rL)rreF) rGrXrnrXrgrXrrXrrrYr\rbs@rKrrsQ)*;rLrc.eZdZdZddfd ZddZxZS)r z"CSP Bottleneck with 1 convolution.ct|t|dd|_t j fdt |D|_y)zInitialize the CSP Bottleneck with 1 convolution. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of convolutions. rc38K|]}tdyw)reNr)rrTrns rKrzC1.__init__..s CQb"a CsN)r:r;rrhr< Sequentialrr)rHrGrnrrJs ` rKr;z C1.__init__s< B1% C%( CDrLcL|j|}|j||zS)z:Apply convolution and residual connection to input tensor.)rhrrs rKrVz C1.forwards! HHQKvvay1}rLr)rGrXrnrXrrXrYr\rbs@rKr r s, ErLr c.eZdZdZddfd ZddZxZS)rz#CSP Bottleneck with 2 convolutions.c"tt||z_t |djzdd_t djz|d_tjfdt|D_ y)a_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. rOrc 3hK|])}tjjdd+yw)rerer?rgeNrcrrTgrHrs rKrzC2.__init__..s. vhiDFFDFFHaK[_b!c!c v/2N r:r;rXrrrhrkr<rrrrHrGrnrrrrrJs` `` rKr;z C2.__init__sn R!VAJ1-DFF B* vmrstmu vwrLc|j|jdd\}}|jtj|j ||fdS)z.2.tfgz$&&$&&(AIY]`aatrN) r:r;rXrrrhrkr<rrrrs` `` rKr;z C2f.__init__#ss R!VAJ1-Q$&&("a0tkpqrksttrLct|j|jddjfd|jD|j t jdS)zForward pass through C2f layer.rOrc34K|]}|dywrrrs rKrzC2f.forward..7rr)listrhrrrrkr@rrs @rKrVz C2f.forward4sQ !""1a( ) *466**xx !Q((rLc|j|j|j|jfdddgjfd|jD|j t jdS).Forward pass using split() instead of chunk().rrc34K|]}|dywrrrs rKrz$C2f.forward_split..>rr)rhsplitrrrrkr@rrs @rK forward_splitzC2f.forward_split:sj HHQK  tvvtvv. 2 qT1Q4L *466**xx !Q((rLrFrrrrYr]r^r_r`r;rVrrarbs@rKrr sFu") )rLrc.eZdZdZddfd ZddZxZS)rz#CSP Bottleneck with 3 convolutions.ct|t||zt|dd|_t|dd|_tdz|d|_tjfdt|D|_ y)aaInitialize 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. rrOc 3@K|]}tddyw)))rrrrrNrrrTrmrrs rKrzC3.__init__..Us& n`aBHaCSWZ![![ nN) r:r;rXrrhrkrlr<rrr rHrGrnrrrrrmrJs `` @rKr;z C3.__init__Esr  a[B1%B1%BA& nejklem norLc |jtj|j|j ||j |fdS)z.ls. vhiDGGTWWhM]ab!c!c vrN)r:r;rXrmr<rrrrs` `` rKr;z C3x.__init___sH RHa3b1f+ vmrstmu vwrLrrr]r^r_r`r;rarbs@rKr%r%\s, x xrLr%c.eZdZdZddfd ZddZxZS)r.zRep C3.c ht|t||z}t||dd|_t||dd|_t jt|Dcgc]}t||c}|_ ||k7rt||dd|_ yt j|_ ycc}w)zInitialize RepC3 module with RepConv blocks. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of RepConv blocks. e (float): Expansion ratio. rN) r:r;rXrrhrkr<rrr rIdentityrl)rHrGrnrrrmrTrJs rKr;zRepC3.__init__rs  a[B1%B1%%( CQR CD)+r4B1%r{{}!Ds B/c|j|j|j||j|zS)zForward pass of RepC3 module.)rlrrhrkrps rKrVz RepC3.forwards/xxtxx{+dhhqk9::rL)rerrGrXrnrXrrXrrBrYr\rbs@rKr.r.osE ;rLr.c&eZdZdZddfd ZxZS)rz"C3 module with TransformerBlock().cpt|||||||t||z}t||d||_y)a[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. rNN)r:r;rXr rrs rKr;z C3TR.__init__s; RHa3 a[!"b!Q/rLrrrrbs@rKrrs, 0 0rLrc&eZdZdZddfd ZxZS)r#z!C3 module with GhostBottleneck().ct|||||||t||ztjfdt |D|_y)a_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))rrTrms rKrz#C3Ghost.__init__..s KQR!8 KsNr:r;rXr<rrrrs @rKr;zC3Ghost.__init__sC RHa3 a[ K%( KLrLrrrrbs@rKr#r#s+ M MrLr#c.eZdZdZddfd ZddZxZS)r)zGGhost 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)zInitialize Ghost Bottleneck module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rOrFruN) r:r;r<rrrrr?rr)rHrGrnrgsrmrJs rKr;zGhostBottleneck.__init__s  1WMM b"a #/0AvF2r1aU +2;;= b"a .  ^_bc]cBMM&RA594B1RW;X Y ikititiv rLcH|j||j|zS)z3Apply skip connection and addition to input tensor.)r?rrps rKrVzGhostBottleneck.forwardsyy|dmmA...rLrrGrXrnrXrgrXrrXrYr\rbs@rKr)r)sQ (/rLr)cFeZdZdZ d dfd ZddZxZS)rzStandard bottleneck.ct|t||z}t|||dd|_t|||dd||_|xr||k(|_y)aZInitialize 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;rXrrhrkr rHrGrnrrrgrrmrJs rKr;zBottleneck.__init__s[  a[B!a(B!a1-(brLc|jr#||j|j|zS|j|j|S)z3Apply bottleneck with optional shortcut connection.)rrkrhrps rKrVzBottleneck.forwards:,0HHq488DHHQK((O$((488A;:OOrLTrrr rGrXrnrXrrrrXrgztuple[int, int]rrBrYr\rbs@rKrrsHlo)))*.):=)FU)ch)&PrLrc.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)aIInitialize 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. rFr6rOc3>K|]}tdywrrNrrs rKrz)BottleneckCSP.__init__..s! ZABHa3!G!G ZN)r:r;rXrrhr<r=rkrlcv4 BatchNorm2dbnSiLUrvrrrrs `` @rKr;zBottleneckCSP.__init__s  a[B1%99RQ699RQ6BAq)..R(779 ZQVWXQY Z[rLc  |j|j|j|}|j|}|j |j |j tj||fdS)z)Apply CSP bottleneck with 4 convolutions.r) rlrrhrkrrvrr@r)rHrIy1y2s rKrVzBottleneckCSP.forwards^ XXdffTXXa[) * XXa[xxB8Q)?!@ABBrLrrrYr\rbs@rKrrsQ\*CrLrc.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) zInitialize ResNet block. Args: c1 (int): Input channels. c2 (int): Output channels. s (int): Stride. e (int): Expansion ratio. rTrgrrvrergrprvFrN) r:r;rrhrkrlr<rrr)rHrGrnrrc3rJs rKr;zResNetBlock.__init__s  VB!qd3B!qA48B!/LMQRFVX\^V^ d2rQ!&GH dfdododq rLc tj|j|j|j ||j |zS)z&Forward pass through the ResNet block.)rrelurlrkrhrrps rKrVzResNetBlock.forwards9vvdhhtxx 45 a8HHIIrL)rrN)rGrXrnrXrrXrrXrYr\rbs@rKrrs8r JrLrc.eZdZdZddfd ZddZxZS)r1z)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) a,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. rOreTrrrrN) r:r;is_firstr<rrrlayerrrr) rHrGrnrr$rrblocksrTrJs rKr;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%rps rKrVzResNetLayer.forward5szz!}rL)rFrrN) rGrXrnrXrrXr$rrrXrrXrYr\rbs@rKr1r1s30.rLr1c.eZdZdZddfd ZddZxZS)MaxSigmoidAttnBlockzMax Sigmoid attention block.ct|||_||z|_||k7rt ||ddnd|_t j|||_t jtj||_ t ||ddd|_ |r1t jtjd|dd|_yd|_y)a?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. rFrNrerr)r:r;nhhcrrr<LinearglrCr@zerosr7 proj_convonesscale)rHrGrnr+rgcr2rJs rKr;zMaxSigmoidAttnBlock.__init__=s (24($r2.))B#LLR1 b"QE:>CR\\%**QAq"9:  rLc|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) zForward pass of MaxSigmoidAttnBlock. Args: x (torch.Tensor): Input tensor. guide (torch.Tensor): Guide tensor. Returns: (torch.Tensor): Output tensor after attention. rNzbmchw,bnmc->bmhwnrrrrrO)rPr.rDr+r,rr@einsummaxr7sigmoidr2r0 unsqueeze) rHrIguidebsrThwembedaws rKrVzMaxSigmoidAttnBlock.forwardQs4gg Aq! 2u{{1~tww@"gg1 q 2twwA6 \\-ue < VVV^A  477C<  $))D!T4/0 0 ZZ\DJJ & NN1  FF2twwAq )  Q vvb"a##rL)rF) rGrXrnrXr+rXrrXr3rXr2rrIrZr9rZr[rZr\rbs@rKr)r):s&M($rLr)cfeZdZdZ d dfd ZddZddZxZS)r z*C2f module with an additional attn module.c t t|| z_t |djzdd_t d|zjz|d_tjfdt|D_ tjj|||_ y)aInitialize 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. rOrrec 3hK|])}tjjdd+ywrrrs rKrz#C2fAttn.__init__..rr)r3rr+N) r:r;rXrrrhrkr<rrrr)attn) rHrGrnrrr+r3rrrrJs ` `` rKr;zC2fAttn.__init__qs2 R!VAJ1-Q$&&("a0tkpqrkstt'2"L rLc2t|j|jddjfd|jDj |j d||jtjdS)zForward 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. rOrc34K|]}|dywrrrs rKrz"C2fAttn.forward..rrr) rrhrrrappendrErkr@rrHrIr9rs @rKrVzC2fAttn.forwardsn !""1a( ) *466** 1R5%()xx !Q((rLc^t|j|j|j|jfdj fd|j Dj |jd||jtjdS)zForward 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 rKrz(C2fAttn.forward_split..rrr) rrhrrrrrHrErkr@rrIs @rKrzC2fAttn.forward_splits{ !""DFFDFF#3Q7 8 *466** 1R5%()xx !Q((rL)rr?rr@Frr)rGrXrnrXrrXrrXr+rXr3rXrrrrXrrBrArrbs@rKr r ns4 M M M  M  M  M MM M M@ ) )rLr cFeZdZdZ d dfd ZddZxZS)r,zKImagePoolingAttn: 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)aInitialize 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-querykeyvalueprojrCr@tensorr2rr= projectionsrAdaptiveMaxPool2dim_poolsrr+nfr,rg) rHrchctr+rgr2rY in_channelsrTrJs rKr;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) zForward pass of ImagePoolingAttn. Args: x (list[torch.Tensor]): List of input feature maps. text (torch.Tensor): Text embeddings. Returns: (torch.Tensor): Enhanced text embeddings. rrOrrrzbnmc,bkmc->bmnkrzbmnk,bkmc->bnmc)rPrrYrgziprVrXrDr@rrQrQrRrSreshaper+r,r5rrRrTrr2) rHrItextr: num_patchesrTrqrgvr>s rKrVzImagePoolingAttn.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)rqrr@reF) rrXrZrr[rXr+rXrgrXr2r)rIlist[torch.Tensor]r`rZr[rZr\rbs@rKr,r,sGUns!0;>JMVYfj:%rLr,c*eZdZdZfdZddZxZS)r(zZImplements 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<rCr@rUr7r1log logit_scale)rHrJs rKr;zContrastiveHead.__init__sY LLug!67 << 2h9O9S9S9U(UVrLctj|dd}tj|dd}tjd||}||jj z|j zS)zForward function of contrastive learning. Args: x (torch.Tensor): Image features. w (torch.Tensor): Text features. Returns: (torch.Tensor): Similarity scores. rrOrrrbchw,bkc->bkhw)r normalizer@r5rjexpr7rHrIr<s rKrVzContrastiveHead.forwards^ KKqA & KKrQ ' LL)1a 04##''))DII55rLrIrZr<rZr[rZr\rbs@rKr(r(sdW 6rLr(cDeZdZdZdfd ZdZeddZddZxZ S)rzBatch 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)zvInitialize BNContrastiveHead. Args: embed_dims (int): Embedding dimensions for features. rhgN) r:r;r<rnormrCr@rUr7r1rj)rH embed_dimsrJs rKr;zBNContrastiveHead.__init__sY NN:. LLug!67 <<uzz"~(=>rLc2|`|`|`|j|_y)zCFuse the batch normalization layer in the BNContrastiveHead module.N)rtr7rj forward_fuserVrHs rKfusezBNContrastiveHead.fuses I I  (( rLc|S)z5Passes image features through unchanged after fusing.r)rIr<s rKrwzBNContrastiveHead.forward_fuse&s rLc|j|}tj|dd}tjd||}||j j z|jzS)zForward function of contrastive learning with batch normalization. Args: x (torch.Tensor): Image features. w (torch.Tensor): Text features. Returns: (torch.Tensor): Similarity scores. rrOrlrm)rtrrnr@r5rjror7rps rKrVzBNContrastiveHead.forward+sY IIaL KKrQ ' LL)1a 04##''))DII55rL)rurXrq) r]r^r_r`r;ry staticmethodrwrVrarbs@rKrr s+ ?)6rLrc>eZdZdZ d dfd ZxZS) RepBottleneckzRep bottleneck.cvt|||||||t||z}t|||dd|_y)aKInitialize 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;rXr rhrs rKr;zRepBottleneck.__init__?s? R1a3 a[2r1Q4+rLr r rrbs@rKr~r~<sGlo,,,*.,:=,FU,ch,,rLr~c&eZdZdZddfd ZxZS)RepCSPzXRepeatable Cross Stage Partial Network (RepCSP) module for efficient feature extraction.ct|||||t||ztjfdt |D|_y)aJInitialize 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)r~rs rKrz"RepCSP.__init__..as! ]qr2xc!J!J ]rNrrs `` @rKr;zRepCSP.__init__TsF RHa3 a[ ]TYZ[T\ ]^rLrrrrbs@rKrrQsb _ _rLrc6eZdZdZddfd 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)aInitialize 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. rOrreN) r:r;rrrhr<rrrkrlr)rHrGrnrc4rrJs rKr;zRepNCSPELAN4.__init__gs qB1%==aQ!7b"a9KL==B!2DRA4FGa"f r1a0rLct|j|jddjfd|j|j fD|j tjdS)z(Forward pass through RepNCSPELAN4 layer.rOrc34K|]}|dywrrrs rKrz'RepNCSPELAN4.forward..{s:!AbE(:r) rrhrrrkrlrr@rrs @rKrVzRepNCSPELAN4.forwardxsZ !""1a( ) :dhh%9::xx !Q((rLc.t|j|j|j|jfdj fd|j |j fD|jtjdS)rrc34K|]}|dywrrrs rKrz-RepNCSPELAN4.forward_split..s8a1R58r) rrhrrrrkrlrr@rrs @rKrzRepNCSPELAN4.forward_split~sg !""DFFDFF#3Q7 8 8DHHdhh#788xx !Q((rLr) rGrXrnrXrrXrrXrrXrYrrbs@rKr/r/ds1") )rLr/c$eZdZdZdfd ZxZS)rz!ELAN1 module with 4 convolutions.ct||||||dz|_t||dd|_t|dz|dd|_t||dd|_t|d|zz|dd|_y)zInitialize ELAN1 layer. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. c4 (int): Intermediate channels for convolutions. rOrreN)r:r;rrrhrkrlr)rHrGrnrrrJs rKr;zELAN1.__init__sw RR(qB1%aQ*B1%a"f r1a0rL)rGrXrnrXrrXrrXrrbs@rKrrs+11rLrc,eZdZdZdfd ZddZxZS)rzAConv.cJt|t||ddd|_y)z}Initialize AConv module. Args: c1 (int): Input channels. c2 (int): Output channels. rerOrN)r:r;rrhrHrGrnrJs rKr;zAConv.__init__s$ B1a(rLctjjj|ddddd}|j |S)z!Forward pass through AConv layer.rOrrFT)r@r< functional avg_pool2drhrps rKrVz AConv.forwards4 HH   * *1aAud Cxx{rLrGrXrnrXrYr\rbs@rKrrs)rLrc,eZdZdZdfd ZddZxZS)rzADown.ct||dz|_t|dz|jddd|_t|dz|jddd|_y)z}Initialize ADown module. Args: c1 (int): Input channels. c2 (int): Output channels. rOrerrN)r:r;rrrhrkrs rKr;zADown.__init__sS qaAq1aAq1rLcTtjjj|ddddd}|j dd\}}|j |}tjjj |ddd}|j|}tj||fdS)z!Forward pass through ADown layer.rOrrFTre) r@r<rrrrh max_pool2drkr)rHrIrrs rKrVz ADown.forwards HH   * *1aAud CAB XXb\ XX + +B1a 8 XXb\yy"b1%%rLrrYr\rbs@rKrrs 2&rLrc.eZdZdZddfd ZddZxZS)rz SPP-ELAN.cBt|||_t||dd|_t j |d|dz|_t j |d|dz|_t j |d|dz|_ td|z|dd|_ y)zInitialize SPP-ELAN block. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. k (int): Kernel size for max pooling. rrOrrNN) r:r;rrrhr<rrkrlrcv5)rHrGrnrrgrJs rKr;zSPPELAN.__init__s B1%<.sBa1R5Brr)rhrrkrlrrr@rrs @rKrVzSPPELAN.forwardsP XXa[M BDHHdhh#ABBxx !Q((rL)r)rGrXrnrXrrXrgrXrYr\rbs@rKrrs*")rLrc.eZdZdZddfd ZddZxZS)r'z CBLinear.c t|||_tj|t |||t |||d|_y)aInitialize 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)r:r;c2sr<r=sumr r?)rHrGrrgrrrrJs rKr;zCBLinear.__init__s> IIb#c(Aq'!Q-PTU rLcZ|j|j|jdS)z$Forward pass through CBLinear layer.rr)r?rrrps rKrVzCBLinear.forwards$yy|!!$((!22rL)rrNr) rGrXr list[int]rgrXrrXrz int | NonerrX)rIrZr[rer\rbs@rKr'r's V3rLr'c,eZdZdZdfd ZddZxZS)r&zCBFuse.c0t|||_y)zmInitialize CBFuse module. Args: idx (list[int]): Indices for feature selection. N)r:r;idx)rHrrJs rKr;zCBFuse.__init__s rLc |djdd}t|ddDcgc]-\}}tj||j||d/}}}t j t j||ddzdScc}}w)zForward pass through CBFuse layer. Args: xs (list[torch.Tensor]): List of input tensors. Returns: (torch.Tensor): Fused output tensor. rrONnearestsizemoderr)rP enumerater interpolaterr@rstack)rHxs target_sizerrIress rKrVzCBFuse.forwardsfll12& [deghkikel[mnSWSTVWq}}Qtxx{^+INnnyyS2bc7]3;;os2B )rr)rrer[rZr\rbs@rKr&r&s .$s&l^_z"b(AAQUXYYlrN) r:r;rXrrhrkrlr<rrrrs `` @rKr;z C3f.__init__sv  a[B1%B1%Q" b!,lchijckllrLc|j||j|gjfd|jD|j t j dS)zForward pass through C3f layer.c34K|]}|dywrrrs rKrzC3f.forward..)rrr)rkrhrrrlr@rrs @rKrVz C3f.forward&sL XXa[$((1+ & *466**xx !Q((rLrrrYr\rbs@rKrrsFm$)rLrcPeZdZdZ d dfd ZxZS)r$rc t ||||tjfdt |D_y)aInitialize 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. attn (bool): Whether to use attention blocks. g (int): Groups for convolutions. shortcut (bool): Whether to use shortcut connections. c 3vK|]}rctjtjjt jdt jdzdnFr#t jjdn!tjjyw)r@r attn_ratio num_headsrON)r<rrrPSABlockr6C3k)rrTrEc3krrHrs rKrz C3k2.__init__..Hs    MM4664668Q7C3tvv|Q;OP  TVVTVVQ!4DFFDFFHa8 9  sB6B9Nr:r;r<rrr) rHrGrnrrrrErrrJs ` ` ```rKr;z C3k2.__init__0s?. RHa3  1X   rL)rFrFrT)rGrXrnrXrrXrrrrBrErrrXrrrrbs@rKr$r$-srF " "  "   "  "  " "  " " " rLr$c&eZdZdZddfd ZxZS)rzhC3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks.ct |||||t||ztjfdt |D|_y)agInitialize 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)rrTrmrrgrs rKrzC3k.__init__..gs( dVWBHaAq6S!Q!Q drNr) rHrGrnrrrrrgrmrJs `` `@rKr;z C3k.__init__XsF RHa3 a[ d[`ab[c derL)rTrrre)rGrXrnrXrrXrrrrXrrBrgrXrrbs@rKrrUsrffrLrcbeZdZdZdfd ZddZddZejdZ xZ S)r0z\RepVGGDW is a class that represents a depth-wise convolutional block in RepVGG architecture.c t|t||ddd|d|_t||ddd|d|_||_t j|_y)zdInitialize RepVGGDW module. Args: ed (int): Input and output channels. r#rreFrrvN) r:r;rr?conv1rr<rrv)rHedrJs rKr;zRepVGGDW.__init__msT RAqBE: "b!QRU; 779rLcf|j|j||j|zS)zPerform a forward pass of the RepVGGDW block. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after applying the depth-wise convolution. )rvr?rrps rKrVzRepVGGDW.forwardys(xx ! tzz!}455rLcB|j|j|S)zPerform a forward pass of the fused RepVGGDW block. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after applying the depth-wise convolution. )rvr?rps rKrwzRepVGGDW.forward_fusesxx ! %%rLc`t|dsyt|jj|jj}t|jj|jj}|j }|j }|j }|j }tjjj|gd}||z}||z}|j jj||j jj|||_|`y)zFuse the convolutional layers in the RepVGGDW block. This method fuses the convolutional layers and updates the weights and biases accordingly. rN)rOrOrOrO) hasattrrr?rrrEr7r@r<rrrFcopy_) rHr?rconv_wconv_bconv1_wconv1_b final_conv_w final_conv_bs rKryz RepVGGDW.fuses tW%   = $**--@,,**((%%))'<@' '  |, \* JrL)rrXr[NonerY) r]r^r_r`r;rVrwr@no_gradryrarbs@rKr0r0js1f  6 &U]]_rLr0c.eZdZdZddfd ZddZxZS)raCompact Inverted 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)aInitialize 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. rerrOrN) r:r;rXr<rrr0rhr)rHrGrnrrlkrmrJs rKr;z CIB.__init__s  a[== Rb ! QVQ  "HQV QVQVQ!b&(I RQ  Rb !  (brLcd|jr||j|zS|j|S)zForward pass of the CIB module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )rrhrps rKrVz CIB.forwards)#'((q488A;; ;rL)TrF) rGrXrnrXrrrrBrrrYr\rbs@rKrrs), .s)]qs4664668srJJ]s.1Nr) rHrGrnrrrrrrJs ` `` rKr;zC2fCIB.__init__s9 RHa3]TYZ[T\]]rL)rFFrr)rGrXrnrXrrXrrrrrrXrrBrrbs@rKr!r!sZ nq^^^#&^6:^HL^Y\^ej^^rLr!c.eZdZdZddfd ZddZxZS)raAttention 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) zInitialize multi-head attention module. Args: dim (int): Input dimension. num_heads (int): Number of attention heads. attn_ratio (float): Attention ratio for key dimension. rOrFrurerN) r:r;rhead_dimrXkey_dimr2rqkvrTpe)rHrrrnh_kdr;rJs rKr;zAttention.__init__ s "y( 4==:56 \\4'  y( %!)OQu-c1%0 sCA%8rLc P|j\}}}}||z}|j|}|j||j|jdz|j z|j |j|j|j gd\}} } |jdd| z|jz} | jd} | | jddzj|||||j| j||||z}|j|}|S)zForward pass of the Attention module. Args: x (torch.Tensor): The input tensor. Returns: (torch.Tensor): The output tensor after self-attention. rOrr) rPrrDrrrrrQr2rRrr_rT) rHrIBCHWNrrbrgrcrEs rKrVzAttention.forwards 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)aInitialize 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. rrOrFruN) r:r;rrEr<rrffnr)rHrrrrrJs rKr;zPSABlock.__init__HsU aJ)L ==aQ!2DQ1%4PQrLc|jr||j|zn|j|}|jr||j|z}|S|j|}|S)zExecute a forward pass through PSABlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after attention and feed-forward processing. )rrErrps rKrVzPSABlock.forwardWsV!%A ! diil#xxA O.2XXa[rL)rrNT) rrXrrBrrXrrr[rrYr\rbs@rKrr3s(  rLrc.eZdZdZddfd ZddZxZS)raPSA 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 c1. 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|jdt|jdzd|_ tjt |j|jdzdt |jdz|jdd|_ y) zInitialize PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. e (float): Expansion ratio. rOrrrrFruN) r:r;rXrrrhrkrr6rEr<rr)rHrGrnrrJs rKr;z PSA.__init__|s RxxR!VAJ1-DFF B*dffDFFbLRS@TU ==dffdffqj!!derLc|j|j|j|jfd\}}||j|z}||j |z}|j t j||fdS)zExecute forward pass in PSA module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after attention and feed-forward processing. rr)rhrrrErrkr@rrs rKrVz PSA.forwardssxx{  $&&$&&!1q 91  !   Oxx 1a&!,--rL)r)rGrXrnrXrrBrYr\rbs@rKrres,f" .rLrc.eZdZdZddfd ZddZxZS)raHC2PSA 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 c1. 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. 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) Notes: This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules. c(t||k(sJt||z_t |djzdd_t djz|d_tjfdt|D_ y)zInitialize C2PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. rOrc3hK|])}tjdjdz+yw)rrrN)rrrrTrHs rKrz!C2PSA.__init__..s+ l^_$&&SDFFVXL!Y!Y lrNrrHrGrnrrrJs` rKr;zC2PSA.__init__sy RxxR!VAJ1-DFF B* lchijck lmrLc|j|j|j|jfd\}}|j|}|j t j ||fdS)zProcess the input tensor through a series of PSA blocks. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. rr)rhrrrrkr@rrs rKrVz C2PSA.forwards]xx{  $&&$&&!1q 91 FF1Ixx 1a&!,--rLrrrrYr\rbs@rKrrs.n" .rLrc&eZdZdZddfd ZxZS)r"aC2fPSA 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 c2. m (nn.ModuleList): List of PSABlock modules 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.nn.modules.block 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)zInitialize C2fPSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. )rrc 3|K|]3}tjdtjdzd5yw)rrrrN)rrr6rs rKrz"C2fPSA.__init__..s3rdex3#dffXZl\]J^__rs9<Nrrs` rKr;zC2fPSA.__init__sCRxx R1*rinopiqrrrLrrrrbs@rKr"r"s0 s srLr"c,eZdZdZdfd ZddZxZS)r2aHSCDown 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.nn.modules.block 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)zInitialize SCDown module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rF)rgrrrvN)r:r;rrhrk)rHrGrnrgrrJs rKr;zSCDown.__init__s8 B1%B!qBE:rLcB|j|j|S)zApply convolution and downsampling to the input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Downsampled output tensor. )rkrhrps rKrVzSCDown.forwardsxx $$rLrrYr\rbs@rKr2r2s, ; %rLr2cBeZdZdZ d dfd ZddZxZS)r3a?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. Args: model (str): Name of the torchvision model to load. weights (str, optional): Pre-trained weights to load. Default is "DEFAULT". unwrap (bool, optional): Unwraps the model to a sequential containing all but the last `truncate` layers. 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. Attributes: m (nn.Module): The loaded torchvision model, possibly truncated and unwrapped. 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)aeLoad 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) torchvisionr:r;rmodelsrr__dict__rrchildren isinstancer<rrrheadheads) rHmodelrunwraptruncaterrlayersrJs rKr;zTorchVision.__init__;s   ;%%{ 3 ''11%1IDF7[''0074=QDF $&&//+,F&)R]]3C4q 2 2 45Cqr C]]8VJhY%7QDFDJDJ)+ 6DFFK$&&,rLc|jr)|gjfd|jDS|j|S)zForward pass through the model. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor | list[torch.Tensor]): Output tensor or list of tensors. c34K|]}|dywrrrs rKrz&TorchVision.forward..cs.!QquX.r)rrrrs @rKrVzTorchVision.forwardXsD ::A HH.tvv. .q ArL)DEFAULTTrOF) rstrrrrrrrXrrrYr\rbs@rKr3r3*sA"kp77#&7<@7SV7cg7:rLr3c8eZdZdZddfd ZfdZddZxZS)AAttnaArea-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 into. 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|_}||jzx|_}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 into. rerFrur#rN) r:r;arearr all_head_dimrrrTr)rHrrrrrrJs rKr;zAAttn.__init__s  "#&)#33 +3dnn+DDL\A-qe<sA59 |\1alPUVrLczt||t|ds|j|jz|_yy)z6Add missing all_head_dim attribute to old checkpoints.rN)r: __setstate__rrrr)rHstaterJs rKrzAAttn.__setstate__s4 U#t^, $  >D -rLcj|j\}}}}||z}|j|jdjdd}|jdkDrJ|j ||jz||jz|j dz}|j\}}}|j|||j|jdzjddddj|j|j|jgd\}} } |jdd| z|jdzz} | jd} | | jddz}|jdddd}| jdddd} |jdkDr~|j ||jz||jz|j }| j ||jz||jz|j } |j\}}}|j ||||j jddddj}| j ||||j jddddj} ||j| z}|j|S) zProcess the input tensor through the area-attention. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention. rOrrerrrrr)rPrflattenrQrr_rrDrrpermuterrR contiguousrrT) rHrIrrTrrrrrbrgrcrEs rKrVz AAttn.forwardsIWW 1a Ehhqk!!!$..q!4 99q=++a$))mQ$))^T=N=NQR=RSCiiGAq! HHQ4>>4==1+< = WQ1a UDMM4==$--@aU H 1a  B#a'DMM4,?@|||# r2& & IIaAq ! IIaAq ! 99q= !tyy.!dii-9J9JKA !tyy.!dii-9J9JKAggGAq! IIaAt00 1 9 9!Q1 E P P R IIaAt00 1 9 9!Q1 E P P R  Nyy|rLr)rrXrrXrrXrY)r]r^r_r`r;rrVrarbs@rKrris0W&? $rLrc@eZdZdZddfd ZeddZddZxZS) ABlockaArea-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)aaInitialize 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 into. )rrrFruN) r:r;rrErXr<rrmlpapply _init_weights)rHrr mlp_ratiormlp_hidden_dimrJs rKr;zABlock.__init__si #> S9_-==c>1!=tNTWYZ`e?fg 4%%&rLct|tjrctjj |j d|j +tjj|j dyyy)zInitialize weights using a truncated normal distribution. Args: m (nn.Module): Module to initialize. g{Gz?)stdNr)r r<r=init trunc_normal_rEr7 constant_rs rKr'zABlock._init_weightssY a # GG ! !!(( ! 5vv!!!!&&!," $rLcR||j|z}||j|zS)zForward pass through ABlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention and feed-forward processing. )rEr%rps rKrVzABlock.forwards(  ! 488A;rL)g333333?r)rrXrrXr(rBrrX)rrrY) r]r^r_r`r;r|r'rVrarbs@rKr#r#s&,'" - - rLr#cdeZdZdZ d dfd ZddZxZS)A2C2faArea-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) aInitialize 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 into. 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. rrrz-Dimension of ABlock must be a multiple of 32.r{Gz?TrNNc3K|];}r&tjfdtdDntd=yw)c3@K|]}tdzyw)rrN)r#)rrTrrmr(s rKrz+A2C2f.__init__...>s TaF2rRxDATrrON)r<rrr)rrTa2rrmrr(rs rKrz!A2C2f.__init__..=sI  MMT5QR8T URQ!, - sAA)r:r;rXrrhrkr<rCr@r1gammarrr) rHrGrnrr6rresidualr(rrrrmrJs `` ` ``@rKr;zA2C2f.__init__s6  a[Bw!|LLL|B1%Q" b!,PRW_R\\$B"7tLei   1X   rLcL|j|gjfd|jD|jt j d|j ;||j jd|j jdddzzSS)zForward pass through A2C2f layer. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. c34K|]}|dywrrrs rKrz A2C2f.forward..Nrrrrr) rhrrrkr@rr7rDrPrs @rKrVz A2C2f.forwardDsXXa[M *466** HHUYYq!_ % :: !tzzr4::+;+;A+>1EII IrL)rTrFg@rrT)rGrXrnrXrrXr6rrrXr8rr(rBrrBrrXrrrYr\rbs@rKr1r1s4( (  (   (  (  ( ( (  (  ( ( TrLr1c.eZdZdZddfd ZddZxZS) SwiGLUFFNz@SwiGLU Feed-Forward Network for transformer-based architectures.ct|tj|||z|_tj||zdz||_y)zInitialize SwiGLU FFN with input dimension, output dimension, and expansion factor. Args: gc (int): Guide channels. ec (int): Embedding channels. e (int): Expansion factor. rON)r:r;r<r-w12w3)rHr3rrrJs rKr;zSwiGLUFFN.__init__Xs@ 99RR())AFaK,rLc|j|}|jdd\}}tj||z}|j |S)z.Apply SwiGLU transformation to input features.rOrr)r>rrsilur?)rHrIx12rrhiddens rKrVzSwiGLUFFN.forwarddsDhhqk1"%BbwwvrL)rN)r3rXrrXrrXr[rrYr\rbs@rKr<r<UsJ -rLr<c,eZdZdZdfd ZddZxZS)Residualz7Residual connection wrapper for neural network modules.c$t|||_tjj |jj jtjj |jj jy)zInitialize residual module with the wrapped module. Args: m (nn.Module): Module to wrap with residual connection. N) r:r;rr<r,zeros_r?r7rE)rHrrJs rKr;zResidual.__init__osS  tvvyy~~& tvvyy''(rLc*||j|zS)z,Apply residual connection to input features.rrps rKrVzResidual.forward|s466!9}rL)rrr[rrYr\rbs@rKrErElsA )rLrEc,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) aInitialize 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)rerrOrO scale_factorNr<rrUpsamplerrrrIrs rKrz!SAVPE.__init__..sa! 1 MMQARQTUY_T_!a%1Pegepeper ! sA)A,c3K|]W\}}tjt|d|dvrtj|dzntjYyw)rrMrOrNNrPrRs rKrz!SAVPE.__init__..sP! 1 MM$q"a.QRX["++1q5*I^`^i^i^k l! sAA rWrer)ryrON)r:r;r<rrrhrkrr=rlrrrrcv6)rHrZrr=rJs ` rKr;zSAVPE.__init__s ==! "" !  ==! !" !   99QVUA.99QVTVVQ:99Q15==a$&&j$&&!!efrLct|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.rrrrrOrl)rrkrr@rrhrlrPrDr_rexpandrTr logical_notfinfor9minrrRtorQrn) rHrIvprxirrrrrQscore aggregateds rKrVz 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)rZrrrXr=rX)rIrer\rZr[rZr\rbs@rKrJrJsOg6XrLrJc:eZdZdZddfd Zddfd ZdZxZS) Proto26zDUltralytics YOLO26 models mask Proto module for segmentation models.c :t||||tjfdddD|_t d|d|_tjt d|dt ||dtj||d|_ y)apInitialize the Ultralytics YOLO models mask Proto module with specified number of protos and masks. Args: ch (tuple): Tuple of channel sizes from backbone feature maps. c_ (int): Intermediate channels. c2 (int): Output channels (number of protos). nc (int): Number of classes for semantic segmentation. c3@K|]}t|ddyw)rrrfNr)rrIrZs rKrz#Proto26.__init__..s!(MaA!)<)<(MrrNrrerf) r:r;r<r feat_refiner feat_fuserr=semseg)rHrZrmrnncrJs ` rKr;zProto26.__init__s R$==(Mbf(MMbeR1-mmDAa$8$r2:KRYYWY[]_`Mab rLc>|d}t|jD]=\}}|||dz}tj||jddd}||z}?t ||j|}|jr|r|j|}||fS|S)zUPerform a forward pass by fusing multi-scale feature maps and generating proto masks.rrrONrr) rrerrrPr:rVrftrainingrg) rHrI return_semsegfeatrfup_featrrgrJs rKrVzProto26.forwardstd../ "DAq!a%kGmmG$**QR.yQG'>D " GODNN40 1 ==][[&Fv; rLcd|_y)zHFuse the model for inference by removing the semantic segmentation head.N)rgrxs rKryz Proto26.fuses  rL)rrqrrP)rZtuplermrXrnrXrhrX)T)rIrZrkrr[rZ)r]r^r_r`r;rVryrarbs@rKrbrbsN c rLrbcdeZdZdZedZedZedZfdZ dZ dZ dZ xZ S) RealNVPzRealNVP: a flow-based generative model. References: https://arxiv.org/abs/1605.08803 https://github.com/open-mmlab/mmpose/blob/main/mmpose/models/utils/realnvp.py c tjtjddtjtjddtjtjddtjS)z3Get the scale model in a single invertible mapping.rOr)r<rr-rTanhrrLrKnetsz RealNVP.netssY}}RYYq"-rwwy"))B:KRWWYXZXaXabdfgXhjljqjqjsttrLc tjtjddtjtjddtjtjddS)z9Get the translation model in a single invertible mapping.rOr)r<rr-rrrLrKnettz RealNVP.nettsM}}RYYq"-rwwy"))B:KRWWYXZXaXabdfgXhiirLcjtjj|j|jS)zThe prior distribution.)r@ distributionsMultivariateNormalloccovrxs rKpriorz RealNVP.priors%""55dhhIIrLct||jdtjd|jdtj d|jdtj ddgddggdztjtjjtt|jDcgc]}|jc}|_tjjtt|jDcgc]}|jc}|_|j#ycc}wcc}w) Nr|rOr}maskrrrer8)r:r;register_bufferr@r/eyerUfloat32r<rrrrrvrrxt init_weights)rHrTrJs rKr;zRealNVP.__init__s  UEKKN3 UEIIaL1 VU\\Aq6Aq62BQ2Femm%\]$$5TYY;P%Qadiik%QR$$5TYY;P%Qadiik%QR &R%Qs E!-E&c|jD]H}t|tjstjj |j dJy)zInitialize model weights.r3)gainN)modulesr r<r-r,xavier_uniform_rE)rHrs rKrzRealNVP.init_weightss@ =A!RYY'''t'< =rLc|j|jd|}}ttt |j D]}|j ||z}|j||d|j |z z}|j ||d|j |z z}d|j |z ||z ztj| z|z}||jdz}||fS)zApply mapping from the data space to the latent space and calculate the log determinant of the Jacobian matrix. rrr) new_zerosrPreversedrrrrrr@ror)rHrI log_det_jacobzrz_rrs rK backward_pzRealNVP.backward_ps;;qwwqz2Aq %DFF ,- *A1!Bq " TYYq\!12Aq " TYYq\!12ATYYq\!a!e,uyy!}rs" :FF)( V\"))\2>BII>,!RYY!H)(bii)(XD"))D.;299;@*666)")))DJJ4x"x&;BII;0020&MbM&/bii/8PP6CBIIC>J"))J0"))>1$"))1$h?)bii?)D>%ryy>%B6bii64.6 .6b,J,*_R_&)299)B1L1(BII&&BII&2)bii)63ryy3.uxx>B*<"))*9 9x/ryy/d4."))4.n4.BII4.n$sS$sN-%RYY-%`<"))<~VBIIVr>RYY>BOBIIOd .ryy*8XBII8Xv e F:0bii:0rL