o W hk@sdZddlZddlmZddlmmZddlmZddl m Z m Z m Z m Z mZmZddlmZdZGdd d ejZGd d d ejZGd d d ejZGdddejZGdddejZGdddejZGdddejZGdddejZGdddejZGdddejZGdddeZGdddejZGd d!d!eZ Gd"d#d#eZ!Gd$d%d%ejZ"Gd&d'd'ejZ#Gd(d)d)ejZ$Gd*d+d+ejZ%Gd,d-d-ejZ&Gd.d/d/ejZ'Gd0d1d1ejZ(Gd2d3d3ejZ)Gd4d5d5ejZ*Gd6d7d7ejZ+Gd8d9d9e#Z,Gd:d;d;eZ-Gdd?d?e.Z/Gd@dAdAejZ0GdBdCdCejZ1GdDdEdEejZ2GdFdGdGejZ3GdHdIdIejZ4GdJdKdKejZ5GdLdMdMeZ6GdNdOdOeZ7GdPdQdQejjZ8GdRdSdSejZ9GdTdUdUeZ:GdVdWdWejZ;GdXdYdYejZGd^d_d_eZ?Gd`dadaejZ@GdbdcdcejZAGdddedeejZBGdfdgdgejZCGdhdidiejZDGdjdkdkejZEGdldmdmejZFGdndodoejZGdS)pzBlock modules.N)fuse_conv_and_bn)ConvDWConv GhostConv LightConvRepConvautopad)TransformerBlock)'DFLHGBlockHGStemSPPSPPFC1C2C3C2fC2fAttnImagePoolingAttnContrastiveHeadBNContrastiveHeadC3xC3TRC3GhostGhostBottleneck Bottleneck BottleneckCSPProtoRepC3 ResNetLayer RepNCSPELAN4ELAN1ADownAConvSPPELANCBFuseCBLinearC3k2C2fPSAC2PSARepVGGDWCIBC2fCIB AttentionPSASCDown TorchVisionc*eZdZdZdfdd ZddZZS)r z Integral module of Distribution Focal Loss (DFL). Proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391 csbttj|ddddd|_tj|tjd}t | d|dd|jj j dd<||_ dS)zGInitialize a convolutional layer with a given number of input channels.rFbias)dtypeN)super__init__nnConv2drequires_grad_convtorcharangefloat Parameterviewweightdatac1)selfrDx __class__P/var/www/vscode/kcb/lib/python3.10/site-packages/ultralytics/nn/modules/block.pyr8?s $ z DFL.__init__cCs<|j\}}}|||d|j|ddd|d|S)zCApply the DFL module to input tensor and return transformed output.r)shaper<rArD transposesoftmax)rErFb_arIrIrJforwardGs 0z DFL.forward)r3__name__ __module__ __qualname____doc__r8rS __classcell__rIrIrGrJr 8sr c*eZdZdZdfdd ZddZZS) rz1YOLOv8 mask Proto module for segmentation models. csRtt||dd|_tj||ddddd|_t||dd|_t|||_dS)a Initialize the YOLOv8 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). krLrTr4N) r7r8rcv1r9ConvTranspose2dupsamplecv2cv3)rErDc_c2rGrIrJr8Qs zProto.__init__c Cs|||||S)zEPerform a forward pass through layers using an upsampled input image.)rdrcrbr`rErFrIrIrJrS`sz Proto.forward)r[r\rTrIrIrGrJrNrc(eZdZdZfddZddZZS)r z StemBlock of PPHGNetV2 with 5 convolutions and one maxpool2d. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py cstt||ddtd|_t||ddddtd|_t|d|dddtd|_t|d|ddtd|_t||ddtd|_ tj ddddd|_ dS) z Initialize the StemBlock of PPHGNetV2. Args: c1 (int): Input channels. cm (int): Middle channels. c2 (int): Output channels. r]rLactrrT) kernel_sizestridepadding ceil_modeN) r7r8rr9ReLUstem1stem2astem2bstem3stem4 MaxPool2dpool)rErDcmrfrGrIrJr8ls zHGStem.__init__cCsr||}t|gd}||}t|gd}||}||}tj||gdd}||}| |}|S)+Forward pass of a PPHGNetV2 backbone layer.)rrrrrdim) rqFpadrrrsrwr=catrtru)rErFx2x1rIrIrJrS}s      zHGStem.forwardrTrIrIrGrJr es r cs8eZdZdZddddeffdd ZddZZS) r z HG_Block of PPHGNetV2 with 2 convolutions and LightConv. https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/backbones/hgnet_v2.py r]Fc st|r tnttfddt|D|_t||dddd|_t|d|ddd|_ |o?|k|_ dS)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. c3s,|]}|dkr ndVqdS)rr_rkNrI).0irkblockrDrxr_rIrJ s*z#HGBlock.__init__..rLrrjN) r7r8rrr9 ModuleListrangemscecadd) rErDrxrfr_n lightconvshortcutrkrGrrJr8s  & zHGBlock.__init__csJ|gfdd|jD||td|jr#|SS)ryc3|] }|dVqdSNrIrryrIrJrz"HGBlock.forward..r)extendrrrr=r~rrgrIrrJrSszHGBlock.forward) rUrVrWrXr9rpr8rSrYrIrIrGrJr sr cr2)rzDSpatial Pyramid Pooling (SPP) layer https://arxiv.org/abs/1406.4729. csXt|d}t||dd|_t|t|d|dd|_tdd|D|_dS)z Initialize the SPP layer with input/output channels and pooling kernel sizes. Args: c1 (int): Input channels. c2 (int): Output channels. k (Tuple[int, int, int]): Kernel sizes for max pooling. rLrcSs g|] }tj|d|ddqS)rrLrlrmrn)r9rv)rrFrIrIrJ  z SPP.__init__..N) r7r8rr`lenrcr9rrrErDrfr_rerGrIrJr8s z SPP.__init__cs2||tgfdd|jDdS)zBForward pass of the SPP layer, performing spatial pyramid pooling.csg|]}|qSrIrIrrFrIrJrszSPP.forward..r)r`rcr=r~rrgrIrrJrSs (z SPP.forward)rrTrIrIrGrJrrhrcr2)rzGSpatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher.rcsPt|d}t||dd|_t|d|dd|_tj|d|dd|_dS)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)). rLrrKrN)r7r8rr`rcr9rvrrrGrIrJr8s z SPPF.__init__cs<|gfddtdDtdS)zRApply sequential pooling operations to input and return concatenated feature maps.c3s|] }dVqdSrrrrQrErrIrJrszSPPF.forward..r]r)r`rrrcr=r~rgrIrrJrSs z SPPF.forwardrrTrIrIrGrJrrcr2)rz"CSP Bottleneck with 1 convolution.rcs<tt|dd|_tjfddt|D|_dS)z Initialize the CSP Bottleneck with 1 convolution. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of convolutions. rc3s|] }tdVqdS)r]N)rrrfrIrJrrzC1.__init__..N)r7r8rr`r9 Sequentialrr)rErDrfrrGrrJr8s "z C1.__init__cCs||}|||S)z:Apply convolution and residual connection to input tensor.)r`r)rErFrrIrIrJrSs z C1.forwardrrTrIrIrGrJrs rc*eZdZdZd fdd ZddZZS) rz#CSP Bottleneck with 2 convolutions.rT?cshtt||_t|djdd_tdj|d_tjfddt |D_ dS)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. rLrc 3(|]}tjjdddVqdS)r]r]r?r_eNrcrgrErrIrJr &zC2.__init__..N r7r8intrrr`rcr9rrrrErDrfrrrrrGrrJr8s &z C2.__init__cCs2||dd\}}|t|||fdS)z.N) r7r8rrrr`rcr9rrrrrGrrJr8s &z C2f.__init__csBt||ddfdd|jD|tdS)zForward pass through C2f layer.rLrc3rrrIrrrIrJr-rzC2f.forward..)listr`rrrrcr=r~rgrIrrJrS*sz C2f.forwardcsV|||j|jfdddgfdd|jD|tdS).Forward pass using split() instead of chunk().rrc3rrrIrrrIrJr4rz$C2f.forward_split..)r`splitrrrrcr=r~rgrIrrJ forward_split0szC2f.forward_splitrFrrrUrVrWrXr8rSrrYrIrIrGrJr rcr) rz#CSP Bottleneck with 3 convolutions.rTrcsntt||t|dd|_t|dd|_td|d|_tjfddt |D|_ dS)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. rrLc 3$|] }tdddVqdS)))rrrrrNrrrerrrIrJrL"zC3.__init__..N) r7r8rrr`rcrdr9rrrrrGrrJr8;s &z C3.__init__c Cs(|t|||||fdS)z.N)r7r8rrer9rrrrrGrrJr8Vs &z C3x.__init__rrUrVrWrXr8rYrIrIrGrJrSrcrZ) rzRep C3.r]rcs~tt||t|dd|_t|dd|_tjfddt|D|_ |kr8t|dd|_ dSt |_ dS)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. rcsg|]}tqSrI)rrrerIrJrxsz"RepC3.__init__..N) r7r8rrr`rcr9rrrIdentityrdrErDrfrrrGrrJr8js *zRepC3.__init__cCs ||||||S)zForward pass of RepC3 module.)rdrr`rcrgrIrIrJrS{s z RepC3.forward)r]rrTrIrIrGrJrgrcr)rz"C3 module with TransformerBlock().rTrcs6t||||||t||}t||d||_dS)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. rKN)r7r8rr r)rErDrfrrrrrerGrIrJr8s z C3TR.__init__rrrIrIrGrJrrrcr)rz!C3 module with GhostBottleneck().rTrcsDt||||||t||tjfddt|D|_dS)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. c3s|]}tVqdS)N)rrrrIrJrsz#C3Ghost.__init__..Nr7r8rr9rrrrrGrrJr8s "zC3Ghost.__init__rrrIrIrGrJrrrcrZ) rzGGhost Bottleneck https://github.com/huawei-noah/Efficient-AI-Backbones.r]rc st|d}tt||dd|dkrt||||ddntt||dddd|_|dkrGtt||||ddt||dddd|_ dSt|_ dS)z Initialize Ghost Bottleneck module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rLrFrjN) r7r8r9rrrrr<rr)rErDrfr_srerGrIrJr8s   .zGhostBottleneck.__init__cCs||||S)z8Apply skip connection and concatenation to input tensor.)r<rrgrIrIrJrSszGhostBottleneck.forwardrrTrIrIrGrJrrc*eZdZdZd fdd Zdd ZZS) rzStandard bottleneck.TrrrcsTtt||}t|||dd|_t|||dd|d|_|o&||k|_dS)am 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[int, int]): Kernel sizes for convolutions. e (float): Expansion ratio. rrrN)r7r8rrr`rcrrErDrfrrr_rrerGrIrJr8s zBottleneck.__init__cCs*|jr ||||S|||S)z3Apply bottleneck with optional shortcut connection.)rrcr`rgrIrIrJrSs*zBottleneck.forwardTrrrrTrIrIrGrJrrrcr) rzGCSP Bottleneck https://github.com/WongKinYiu/CrossStagePartialNetworks.rTrcstt||t|dd|_tj|dddd|_tjdddd|_td|dd|_ t d|_ t |_ tjfddt|D|_dS)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. rFr4rLc3"|] }tddVqdSrrNrrrrIrJr z)BottleneckCSP.__init__..N)r7r8rrr`r9r:rcrdcv4 BatchNorm2dbnSiLUrkrrrrrGrrJr8s  &zBottleneckCSP.__init__c CsB||||}||}|||t||fdS)z)Apply CSP bottleneck with 3 convolutions.r) rdrr`rcrrkrr=r~)rErFy1y2rIrIrJrSs "zBottleneckCSP.forwardrrTrIrIrGrJrsrcrZ) ResNetBlockz.ResNet block with standard convolution layers.rrKc st||}t||dddd|_t||d|ddd|_t||ddd|_|dks/||kr>tt||d|dd|_ dSt|_ dS) z Initialize ResNet block. Args: c1 (int): Input channels. c2 (int): Output channels. s (int): Stride. e (int): Expansion ratio. rTr_rrkr]r_rprkFrN) r7r8rr`rcrdr9rrr)rErDrfrrc3rGrIrJr8s <zResNetBlock.__init__c Cs&t||||||S)z&Forward pass through the ResNet block.)r|relurdrcr`rrgrIrIrJrSs&zResNetBlock.forward)rrKrTrIrIrGrJrrrcr) r z)ResNet layer with multiple ResNet blocks.rFrKc st||_|jr"tt|dddddtjdddd|_d St||dg}| fd d t |dDtj||_d S) 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. rLr]Trrrrcs g|] }tddqS)rr)rrrfrrIrJr0rz(ResNetLayer.__init__..N) r7r8is_firstr9rrrvlayerrrr)rErDrfrrrrblocksrGrrJr8s   "zResNetLayer.__init__cCs ||S)z&Forward pass through the ResNet layer.)rrgrIrIrJrS3s zResNetLayer.forward)rFrrKrTrIrIrGrJr sr cr) MaxSigmoidAttnBlockzMax Sigmoid attention block.rFcst||_|||_||krt||dddnd|_t|||_t t ||_ t||dddd|_ |rFt t d|dd|_dSd|_dS)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. rFrNr]rr)r7r8nhhcrrr9Linearglr@r=zerosr5 proj_convonesscale)rErDrfrrgcrrGrIrJr8;s  *zMaxSigmoidAttnBlock.__init__c Cs|j\}}}}||}|||jd|j|j}|jdur#||n|}|||j|j||}td||}|jddd}||jd}||j dddddf}| |j }| |}|||jd||}|| d}||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->bmhwnrrzrrrL)rMrrArrrr=einsummaxr5sigmoidrr unsqueeze) rErFguidebsrQhwembedawrIrIrJrSPs  zMaxSigmoidAttnBlock.forward)rrrFrTrIrIrGrJr8rrcs2eZdZdZd fdd Zd d Zd d ZZS)rz*C2f module with an additional attn module.rrrFrc stt|| _t|djdd_td|j|d_tfddt |D_ t jj|||d_ dS)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. rLrr]c 3rrrrrrIrJrrz#C2fAttn.__init__..)rrrN) r7r8rrrr`rcr9rrrrattn) rErDrfrrrrrrrrGrrJr8qs "zC2fAttn.__init__csXt||ddfdd|jD|d||t dS)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. rLrc3rrrIrrrIrJrrz"C2fAttn.forward..r) rr`rrrappendrrcr=r~rErFrrIrrJrSs zC2fAttn.forwardcs`t|||j|jfdfdd|jD|d||t dS)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. rc3rrrIrrrIrJrrz(C2fAttn.forward_split..r) rr`rrrrrrrcr=r~rrIrrJrs zC2fAttn.forward_split)rrrrFrrrrIrIrGrJrns rcs*eZdZdZd fdd Zd d ZZS) rzKImagePoolingAttn: Enhance the text embeddings with image-aware information.r[rIrr]Fcstt|}tt|t||_ttt|_ttt|_ t||_ |rGtj t dgddnd|_tfdd|D|_tfddt|D|_|_||_||_||_|_dS) 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_gradrcsg|] }tj|ddqS)r)rl)r9r:)r in_channels)rrIrJrsz-ImagePoolingAttn.__init__..csg|] }tfqSrI)r9AdaptiveMaxPool2drr^rIrJrsN)r7r8rr9r LayerNormrquerykeyvalueprojr@r=tensorrr projectionsrim_poolsrrnfrr_)rErchctrr_rrrG)rr_rJr8s    zImagePoolingAttn.__init__cs|djdt||jksJ|jdfddt||j|jD}tj|dd dd}| |}| |}| |}| d|j|j}| d|j|j}| d|j|j}td||}||jd }tj|dd}td ||}|| d|j}||j|S) 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. rrLcs(g|]\}}}|||dqS)r)rA)rrFrrwr num_patchesrIrJrs(z,ImagePoolingAttn.forward..rrzrzbnmc,bkmc->bmnkrzbmnk,bkmc->bnmc)rMrrr_ziprrr=r~rNrrrreshaperrrr|rOrrr)rErFtextqr_vrrIrrJrSs"      zImagePoolingAttn.forward)r[rIrrr]FrTrIrIrGrJrsrcri)rzZImplements contrastive learning head for region-text similarity in vision-language models.csBtttdg|_ttgtd|_ dS)zBInitialize ContrastiveHead with region-text similarity parameters.$g$I$I,@N) r7r8r9r@r=rr5rlog logit_scalerErGrIrJr8s $zContrastiveHead.__init__cCsBtj|ddd}tj|ddd}td||}||j|jS)z Forward function of contrastive learning. Args: x (torch.Tensor): Image features. w (torch.Tensor): Text features. Returns: (torch.Tensor): Similarity scores. rrLr{rrbchw,bkc->bkhw)r| normalizer=rr!expr5rErFrrIrIrJrSs zContrastiveHead.forwardrTrIrIrGrJrs rcs>eZdZdZdeffdd ZddZddZd d ZZ S) rz Batch Norm Contrastive Head using batch norm instead of l2-normalization. Args: embed_dims (int): Embed dimensions of text and image features. embed_dimscsDtt||_ttdg|_tdt g|_ dS)z Initialize BNContrastiveHead. Args: embed_dims (int): Embedding dimensions for features. rgN) r7r8r9rnormr@r=rr5rr!)rEr(rGrIrJr8 s  zBNContrastiveHead.__init__cCs|`|`|`|j|_dS)zCFuse the batch normalization layer in the BNContrastiveHead module.N)r)r5r! forward_fuserSr"rIrIrJfuses zBNContrastiveHead.fusecCs|S)zN Passes input out unchanged. TODO: Update or remove? rIr'rIrIrJr*!szBNContrastiveHead.forward_fusecCs<||}tj|ddd}td||}||j|jS)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. rrLr#r$)r)r|r%r=rr!r&r5r'rIrIrJrS)s zBNContrastiveHead.forward) rUrVrWrXrr8r+r*rSrYrIrIrGrJrs rc"eZdZdZdfdd ZZS) RepBottleneckzRep bottleneck.Trrrcs:t||||||t||}t|||dd|_dS)a^ 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[int, int]): Kernel sizes for convolutions. e (float): Expansion ratio. rrN)r7r8rrr`rrGrIrJr8>s zRepBottleneck.__init__rrrIrIrGrJr-;rr-cr)RepCSPzXRepeatable Cross Stage Partial Network (RepCSP) module for efficient feature extraction.rTrcsHt||||t||tjfddt|D|_dS)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. c3rr)r-rrrIrJr`rz"RepCSP.__init__..NrrrGrrJr8Rs &zRepCSP.__init__rrrIrIrGrJr.Orr.cs2eZdZdZd fdd ZddZddZZS) r!z CSP-ELAN.rcst|d|_t||dd|_tt|d||t||dd|_tt|||t||dd|_ t|d||dd|_ dS)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. rLrr]N) r7r8rrr`r9rr.rcrdr)rErDrfrc4rrGrIrJr8fs $ zRepNCSPELAN4.__init__csHt||ddfdd|j|jfD|tdS)z(Forward pass through RepNCSPELAN4 layer.rLrc3rrrIrrrIrJr{rz'RepNCSPELAN4.forward..) rr`rrrcrdrr=r~rgrIrrJrSxs zRepNCSPELAN4.forwardcsPt|||j|jfdfdd|j|jfD|t dS)rrc3rrrIrrrIrJrrz-RepNCSPELAN4.forward_split..) rr`rrrrcrdrr=r~rgrIrrJr~s zRepNCSPELAN4.forward_splitrrrIrIrGrJr!crr!cs eZdZdZfddZZS)r"z!ELAN1 module with 4 convolutions.cslt|||||d|_t||dd|_t|d|dd|_t||dd|_t|d||dd|_dS)z Initialize ELAN1 layer. Args: c1 (int): Input channels. c2 (int): Output channels. c3 (int): Intermediate channels. c4 (int): Intermediate channels for convolutions. rLrr]N)r7r8rrr`rcrdr)rErDrfrr/rGrIrJr8s  zELAN1.__init__rrIrIrGrJr"sr"cri)r$zAConv.cs tt||ddd|_dS)z Initialize AConv module. Args: c1 (int): Input channels. c2 (int): Output channels. r]rLrN)r7r8rr`rErDrfrGrIrJr8s zAConv.__init__cCs"tjj|ddddd}||S)z!Forward pass through AConv layer.rLrrFT)r=r9 functional avg_pool2dr`rgrIrIrJrSs z AConv.forwardrTrIrIrGrJr$s  r$cri)r#zADown.csHt|d|_t|d|jddd|_t|d|jddd|_dS)z Initialize ADown module. Args: c1 (int): Input channels. c2 (int): Output channels. rLr]rrN)r7r8rrr`rcr0rGrIrJr8s  zADown.__init__cCs`tjj|ddddd}|dd\}}||}tjj|ddd}||}t||fdS)z!Forward pass through ADown layer.rLrrFTr]) r=r9r1r2rr` max_pool2drcr~)rErFrrrIrIrJrSs   z ADown.forwardrTrIrIrGrJr#s  r#cr2)r%z SPP-ELAN.rcszt||_t||dd|_tj|d|dd|_tj|d|dd|_tj|d|dd|_ td||dd|_ dS)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. rrLrrKN) r7r8rrr`r9rvrcrdrcv5)rErDrfrr_rGrIrJr8s zSPPELAN.__init__csB||gfdd|j|j|jfD|tdS)z#Forward pass through SPPELAN layer.c3rrrIrrrIrJrrz"SPPELAN.forward..r)r`rrcrdrr4r=r~rgrIrrJrSs $zSPPELAN.forwardrrTrIrIrGrJr%rr%crZ) r'z CBLinear.rNc s8t||_tj|t|||t|||dd|_dS)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)groupsr5N)r7r8c2sr9r:sumr r<)rErDr6r_rrrrGrIrJr8s (zCBLinear.__init__cCs||j|jddS)z$Forward pass through CBLinear layer.rrz)r<rr6rgrIrIrJrSszCBLinear.forward)rrNrrTrIrIrGrJr'sr'cri)r&zCBFuse.cst||_dS)zv Initialize CBFuse module. Args: idx (List[int]): Indices for feature selection. N)r7r8idx)rEr8rGrIrJr8s  zCBFuse.__init__csR|djddfddt|ddD}tjt||ddddS)z Forward pass through CBFuse layer. Args: xs (List[torch.Tensor]): List of input tensors. Returns: (torch.Tensor): Fused output tensor. rrLNcs*g|]\}}tj|j|ddqS)nearest)sizemode)r| interpolater8rrrFrE target_sizerIrJrs*z"CBFuse.forward..rrz)rM enumerater=r7stack)rExsresrIr>rJrS s  zCBFuse.forwardrTrIrIrGrJr&s  r&cr) C3frrFrcsrtt||t|dd|_t|dd|_td||d|_tfddt |D|_ dS)an Initialize CSP bottleneck layer with two 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. rrLc 3rrrrrrIrJr,rzC3f.__init__..N) r7r8rrr`rcrdr9rrrrrGrrJr8s &z C3f.__init__cs@||||gfdd|jD|tdS)zForward pass through C3f layer.c3rrrIrrrIrJr1rzC3f.forward..r)rcr`rrrdr=r~rgrIrrJrS.sz C3f.forwardrrTrIrIrGrJrDrrDcr,) r(rrFrTcs>t||||tfddt|D_dS)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. c3s:|]}rtjjdntjjVqdS)rLN)C3krrrc3krrErrIrJrFs* z C3k2.__init__..Nr7r8r9rrr)rErDrfrrGrrrrGrFrJr88s z C3k2.__init__)rFrrTrrIrIrGrJr(5rr(cr,) rEzhC3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks.rTrr]csJt||||t||tjfddt|D|_dS)ap Initialize C3k module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of Bottleneck blocks. shortcut (bool): Whether to use shortcut connections. g (int): Groups for convolutions. e (float): Expansion ratio. k (int): Kernel size. c 3s(|]}tfddVqdS)rrNrrrerr_rrIrJr^rzC3k.__init__..Nr)rErDrfrrrrr_rGrIrJr8Ns (z C3k.__init__)rTrrr]rrIrIrGrJrEKrrEcsBeZdZdZd fdd ZddZdd Zed d Z Z S) r+zfRepVGGDW is a class that represents a depth wise separable convolutional block in RepVGG architecture.returnNc sNtt||ddd|dd|_t||ddd|dd|_||_t|_dS)zm Initialize RepVGGDW module. Args: ed (int): Input and output channels. rrr]FrrkN) r7r8rr<conv1r{r9rrk)rEedrGrIrJr8ds zRepVGGDW.__init__cCs|||||S)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. )rkr<rLrgrIrIrJrSqs zRepVGGDW.forwardcC|||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. )rkr<rgrIrIrJr*} zRepVGGDW.forward_fusec Cst|jj|jj}t|jj|jj}|j}|j}|j}|j}tjj |gd}||}||}|jj ||jj |||_|`dS)z Fuse the convolutional layers in the RepVGGDW block. This method fuses the convolutional layers and updates the weights and biases accordingly. )rLrLrLrLN) rr<rrLrBr5r=r9r1r}rCcopy_) rEr<rLconv_wconv_bconv1_wconv1_b final_conv_w final_conv_brIrIrJr+sz RepVGGDW.fuserJN) rUrVrWrXr8rSr*r=no_gradr+rYrIrIrGrJr+as   r+cr) 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. TrFc stt||}tt||d|dt|d|d|r#td|n td|d|dd|dtd||dt||d|d|_|oF||k|_dS)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. r]rrLrN) r7r8rr9rrr+r`r)rErDrfrrlkrerGrIrJr8s *z CIB.__init__cCs|jr |||S||S)z Forward pass of the CIB module. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor. )rr`rgrIrIrJrSs z CIB.forward)TrFrTrIrIrGrJr,s r,cr)r-aQ C2fCIB class represents a convolutional block with C2f and CIB modules. Args: c1 (int): Number of input channels. c2 (int): Number of output channels. n (int, optional): Number of CIB modules to stack. Defaults to 1. shortcut (bool, optional): Whether to use shortcut connection. Defaults to False. lk (bool, optional): Whether to use local key connection. Defaults to False. g (int, optional): Number of groups for grouped convolution. Defaults to 1. e (float, optional): Expansion ratio for CIB modules. Defaults to 0.5. rFrcs<t|||||tfddt|D_dS)a Initialize C2fCIB module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of CIB modules. shortcut (bool): Whether to use shortcut connection. lk (bool): Whether to use local key connection. g (int): Groups for convolutions. e (float): Expansion ratio. c3s&|]}tjjddVqdS)r)rrYN)r,rrrYrErrIrJr$z"C2fCIB.__init__..NrH)rErDrfrrrYrrrGrZrJr8s &zC2fCIB.__init__)rFFrrrrIrIrGrJr-s r-crZ) r.a 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. rrcst||_|||_t|j||_|jd|_|j|}||d}t||ddd|_t||ddd|_ t||dd|dd|_ dS) 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. rLrFrjr]rKN) r7r8 num_headshead_dimrkey_dimrrqkvrpe)rEr{r] attn_rationh_kdrrGrIrJr8s     zAttention.__init__c Cs|j\}}}}||}||}|||j|jd|j|j|j|j|jgdd\}} } |dd| |j} | j dd} | | dd||||| | ||||}| |}|S)z Forward pass of the Attention module. Args: x (torch.Tensor): The input tensor. Returns: (torch.Tensor): The output tensor after self-attention. rLrzr) rMr`rAr]r_r^rrNrrOrarr) rErFBCHWNr`rr_rrrIrIrJrSs    2 zAttention.forward)rrrTrIrIrGrJr.sr.cs,eZdZdZd d fdd Zd d ZZS) PSABlockaK PSABlock class implementing a Position-Sensitive Attention block for neural networks. This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers with optional shortcut connections. Attributes: attn (Attention): Multi-head attention module. ffn (nn.Sequential): Feed-forward neural network module. add (bool): Flag indicating whether to add shortcut connections. Methods: forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers. Examples: Create a PSABlock and perform a forward pass >>> 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) rrKTrJNc sNtt|||d|_tt||ddt|d|ddd|_||_dS)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. rbr]rLrFrjN) r7r8r.rr9rrffnr)rErrbr]rrGrIrJr8Hs * zPSABlock.__init__cCsD|jr |||n||}|jr|||}|S||}|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. )rrrlrgrIrIrJrSXs   zPSABlock.forward)rrKTrWrTrIrIrGrJrj2srjcr2)r/a 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) rc st||ks Jt|||_t|d|jdd|_td|j|d|_t|jd|jdd|_t t|j|jddt|jd|jddd|_ dS) z Initialize PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. e (float): Expansion ratio. rLrr@rkFrjN) r7r8rrrr`rcr.rr9rrl)rErDrfrrGrIrJr8s 6z PSA.__init__cCsR||j|j|jfdd\}}|||}|||}|t||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. rrz)r`rrrrlrcr=r~rrIrIrJrSs z PSA.forward)rrTrIrIrGrJr/gsr/crZ) 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) rrcspt||ks Jt||_t|djdd_tdj|d_tjfddt |D_ dS)z Initialize C2PSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. rLrc3&|]}tjdjddVqdSrrmrkNrjrrr"rIrJrr[z!C2PSA.__init__..NrrrGr"rJr8s "zC2PSA.__init__cCs@||j|j|jfdd\}}||}|t||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. rrz)r`rrrrcr=r~rrIrIrJrSs z C2PSA.forwardrrrTrIrIrGrJr*sr*cs"eZdZdZdfdd ZZS)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) rrcsB||ksJtj||||dtfddt|D_dS)z Initialize C2fPSA module. Args: c1 (int): Input channels. c2 (int): Output channels. n (int): Number of PSABlock modules. e (float): Expansion ratio. )rrc3rnrorprr"rIrJrr[z"C2fPSA.__init__..NrHrrGr"rJr8s "zC2fPSA.__init__rqrrIrIrGrJr)sr)cri)r0a< 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]) cs4tt||dd|_t|||||dd|_dS)z Initialize SCDown module. Args: c1 (int): Input channels. c2 (int): Output channels. k (int): Kernel size. s (int): Stride. rF)r_rrrkN)r7r8rr`rc)rErDrfr_rrGrIrJr8s zSCDown.__init__cCrN)z Apply convolution and downsampling to the input tensor. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Downsampled output tensor. )rcr`rgrIrIrJrS)rOzSCDown.forwardrTrIrIrGrJr0s r0cr) r1aZ 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. DEFAULTTrLFcsddl}tt|jdr|jj||d|_n |jj|t|d|_|rZt |j }t |dt j rFgt |d |dd}t j |rQ|d| n||_||_dSd|_t |j_|j_dS)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) torchvisionr7r8hasattrmodelsrsr__dict__boolrchildren isinstancer9rrrheadheads)rEmodelrtunwraptruncaterrvlayersrGrIrJr8Gs    zTorchVision.__init__cs8|jr|gfdd|jDS||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. c3rrrIrrrIrJrorz&TorchVision.forward..)rrrrgrIrrJrScs   zTorchVision.forward)rrTrLFrTrIrIrGrJr16sr1cr2)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]) rc srt||_||_|||_}||j}t||dddd|_t||ddd|_t||ddd|dd|_dS)a5 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, default is 1. r]rFrjrrKN) r7r8arear]r^rr`rra)rEr{r]rr^ all_head_dimrGrIrJr8s  zAAttn.__init__c Cs|j\}}}}||}||ddd}|jdkr1|||j||j|d}|j\}}}||||j|jd ddddj |j|j|jgdd\} } } | dd| |jd} | j dd} | | dd}| dddd}| dddd} |jdkr|||j||j|}| ||j||j|} |j\}}}||||| dddd }| |||| dddd } || | }||S) z Process the input tensor through the area-attention. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention. rLrr]rrzrdrr\)rMr`flattenrNrrrAr]r^permuterrO contiguousrar) rErFrerfrgrhrir`rQrr_rrrIrIrJrSs0          z AAttn.forwardrrTrIrIrGrJrusrcs2eZdZdZd fdd ZddZdd ZZS) 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]) 333333?rc sXtt|||d|_t||}tt||dt||ddd|_| |j dS)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. )r]rrFrjN) r7r8rrrr9rrmlpapply _init_weights)rEr{r] mlp_ratiormlp_hidden_dimrGrIrJr8s  "zABlock.__init__cCsDt|tjrtjj|jdd|jdur tj|jddSdSdS)z Initialize weights using a truncated normal distribution. Args: m (nn.Module): Module to initialize. g{Gz?)stdNr)r|r9r:init trunc_normal_rBr5 constant_rErrIrIrJrs  zABlock._init_weightscCs|||}|||S)z Forward pass through ABlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after area-attention and feed-forward processing. )rrrgrIrIrJrSs zABlock.forward)rr)rUrVrWrXr8rrSrYrIrIrGrJrs  rcs*eZdZdZd fdd Zd d ZZS) 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]) rTF@rc stt||ddksJdt|dd|_td||d|_r8|r8tjdt |ddnd|_ t fd d t |D|_ dS) 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. r\rz(Dimension of ABlock be a multiple of 32.rg{Gz?Tr Nc3sD|]}rtjfddtdDntdVqdS)c3s"|] }tdVqdS)r\N)rr)rrerrIrJr@rz+A2C2f.__init__...rLN)r9rrrEra2rrerrrrIrJr?s" z!A2C2f.__init__..)r7r8rrr`rcr9r@r=rgammarrr) rErDrfrrrresidualrrrrrGrrJr8's  &zA2C2f.__init__csf||gfdd|jD|td|jdur1||jdt|jddSS)z Forward pass through A2C2f layer. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after processing. c3rrrIrrrIrJrQrz A2C2f.forward..rNr) r`rrrcr=r~rrArrgrIrrJrSFs   z A2C2f.forward)rTrFrrrTrTrIrIrGrJrsrcs,eZdZdZd d fdd ZddZZS) SwiGLUFFNz@SwiGLU Feed-Forward Network for transformer-based architectures.rKrJNcs6tt||||_t||d||_dS)zSInitialize SwiGLU FFN with input dimension, output dimension, and expansion factor.rLN)r7r8r9rw12w3)rErrrrGrIrJr8[s zSwiGLUFFN.__init__cCs4||}|jddd\}}t||}||S)z.Apply SwiGLU transformation to input features.rLrrz)rrr|silur)rErFx12rrhiddenrIrIrJrSas  zSwiGLUFFN.forward)rKrWrTrIrIrGrJrXsrcs*eZdZdZdfdd ZddZZS) Residualz7Residual connection wrapper for neural network modules.rJNcs8t||_tj|jjjtj|jjjdS)z3Initialize residual module with the wrapped module.N) r7r8rr9rzeros_rr5rBrrGrIrJr8ls zResidual.__init__cCs|||S)z,Apply residual connection to input features.rrgrIrIrJrSuszResidual.forwardrWrTrIrIrGrJris rcri)SAVPEzESpatial-Aware Visual Prompt Embedding module for feature enhancement.c sttfddt|D|_tfddt|D|_d|_td|d|_ tjd|jddd|_ tjd|jddd|_ t t d|j|jdtj|j|jddd|_d S) zVInitialize SAVPE module with channels, intermediate channels, and embedding dimension.c3sN|]"\}}tt|dtd|dvrtj|ddntVqdS)r]rrLrL scale_factorNr9rrUpsamplerr=rrIrJrs2 z!SAVPE.__init__..c3sD|]\}}tt|d|dvrtj|ddntVqdS)rrrLrNrr=rrIrJrs . r3r]r)rnrLN)r7r8r9rr@r`rcrr:rdrr4rrcv6)rErrrrGrrJr8}s   4zSAVPE.__init__c sfddt|D}tj|dd}fddt|D}tj|dd}|j\}}}}|jd}|||d}||dj|| d|ddd||j||}|||d||||d||} tj| |fdd}|||jd}|||dd}||t |t |jj} tj| dtjd| j} | dd ||j|jddd} tj| dd ||ddd d S) zJProcess input features and visual prompts to generate enhanced embeddings.cg|] \}}j||qSrI)rcrrxir"rIrJrz!SAVPE.forward..rrzcrrI)r`rr"rIrJrrr)r{r6rdrLr#)r@rr=r~rdrMrArrexpandrr4 logical_notfinfor6minr|rOr?torNr%) rErFvprrerfrgrhQscore aggregatedrIr"rJrSs  4" ,"z SAVPE.forwardrTrIrIrGrJrzs r)HrXr=torch.nnr9torch.nn.functionalr1r|ultralytics.utils.torch_utilsrr<rrrrrr transformerr __all__Moduler rr r rrrrrrrrrrrrrrr rrrrrr-r.r!r"r$r#r%r'r&rDr(rEr+r,r-r.rjr/r*r)r0r1rrrrrrrIrIrIrJsx    +&$#  6:A7"C0?5::(3?VDI