hzSrSSKJr SSKrSSKrSSKJr SSKJs Jr SSK J r J r SSK Jr SSKJr SSKJrJrJr S r"S S \R,5r"S S \5r"SS\R,5r"SS\R,5r"SS\R,5r"SS\R,5r"SS\R,5r"SS\R,5r"SS\R,5r"SS\R,5r g)zTransformer modules.) annotationsN) constant_xavier_uniform_) TORCH_1_11)Conv) _get_clonesinverse_sigmoid#multi_scale_deformable_attn_pytorch) TransformerEncoderLayerTransformerLayerTransformerBlockMLPBlock LayerNorm2dAIFIDeformableTransformerDecoder!DeformableTransformerDecoderLayer MSDeformAttnMLPc^\rSrSrSrSSS\R "5S4S U4Sjjjr\SSSjj5r SSS jjr SSS jjr SSS jjr S r U=r$)r a A single layer of the transformer encoder. This class implements a standard transformer encoder layer with multi-head attention and feedforward network, supporting both pre-normalization and post-normalization configurations. Attributes: ma (nn.MultiheadAttention): Multi-head attention module. fc1 (nn.Linear): First linear layer in the feedforward network. fc2 (nn.Linear): Second linear layer in the feedforward network. norm1 (nn.LayerNorm): Layer normalization after attention. norm2 (nn.LayerNorm): Layer normalization after feedforward network. dropout (nn.Dropout): Dropout layer for the feedforward network. dropout1 (nn.Dropout): Dropout layer after attention. dropout2 (nn.Dropout): Dropout layer after feedforward network. act (nn.Module): Activation function. normalize_before (bool): Whether to apply normalization before attention and feedforward. Fc>[TU]5 SSKJn U(d [ S5e[ R "XUSS9Ul[ R"X5Ul [ R"X!5Ul [ R"U5Ul [ R"U5Ul [ R"U5Ul[ R"U5Ul[ R"U5UlXPlX`lg)a Initialize the TransformerEncoderLayer with specified parameters. Args: c1 (int): Input dimension. cm (int): Hidden dimension in the feedforward network. num_heads (int): Number of attention heads. dropout (float): Dropout probability. act (nn.Module): Activation function. normalize_before (bool): Whether to apply normalization before attention and feedforward. ) TORCH_1_9z]TransformerEncoderLayer() requires torch>=1.9 to use nn.MultiheadAttention(batch_first=True).T)dropout batch_firstN)super__init__utils.torch_utilsrModuleNotFoundErrornnMultiheadAttentionmaLinearfc1fc2 LayerNormnorm1norm2Dropoutrdropout1dropout2actnormalize_before) selfc1cm num_headsrr0r1r __class__s \/home/james-whalen/.local/lib/python3.13/site-packages/ultralytics/nn/modules/transformer.pyr! TransformerEncoderLayer.__init__4s( 2%o ''wTXY99R$99R$\\"% \\"% zz'*  7+  7+  0cUcU$X-$)z2Add position embeddings to the tensor if provided.tensorposs r7with_pos_embed&TransformerEncoderLayer.with_pos_embed]v6&,6r9c ZURX5=pVURXVXUS9SnXRU5-nURU5nUR UR UR URU5555nXRU5-nURU5$)av Perform forward pass with post-normalization. Args: src (torch.Tensor): Input tensor. src_mask (torch.Tensor, optional): Mask for the src sequence. src_key_padding_mask (torch.Tensor, optional): Mask for the src keys per batch. pos (torch.Tensor, optional): Positional encoding. Returns: (torch.Tensor): Output tensor after attention and feedforward. value attn_maskkey_padding_maskr) r?r&r.r+r)rr0r(r/r,)r2srcsrc_masksrc_key_padding_maskr>qksrc2s r7 forward_post$TransformerEncoderLayer.forward_postbs&##C--wwq3MawbcdeMM$''jjoxx TXXdhhsm%<=>MM$''zz#r9c ZURU5nURXT5=pgURXgXRUS9SnXRU5-nUR U5nUR UR URURU5555nXRU5-$)au Perform forward pass with pre-normalization. Args: src (torch.Tensor): Input tensor. src_mask (torch.Tensor, optional): Mask for the src sequence. src_key_padding_mask (torch.Tensor, optional): Mask for the src keys per batch. pos (torch.Tensor, optional): Positional encoding. Returns: (torch.Tensor): Output tensor after attention and feedforward. rCr) r+r?r&r.r,r)rr0r(r/)r2rGrHrIr>rLrJrKs r7 forward_pre#TransformerEncoderLayer.forward_pre}s&zz###D..wwq4NbwcdefMM$''zz#xx TXXdhhtn%=>?]]4(((r9clUR(aURXX45$URXX45$)a Forward propagate the input through the encoder module. Args: src (torch.Tensor): Input tensor. src_mask (torch.Tensor, optional): Mask for the src sequence. src_key_padding_mask (torch.Tensor, optional): Mask for the src keys per batch. pos (torch.Tensor, optional): Positional encoding. Returns: (torch.Tensor): Output tensor after transformer encoder layer. )r1rPrM)r2rGrHrIr>s r7forwardTransformerEncoderLayer.forwards5&  ##C3GM M  0DJJr9) r0rr.r/r(r)r&r+r,r1 r3intr4rVr5rVrfloatr0 nn.Moduler1boolNr= torch.Tensorr>torch.Tensor | Nonereturnr\NNN) rGr\rHr]rIr]r>r]r^r\)__name__ __module__ __qualname____firstlineno____doc__r$GELUr! staticmethodr?rMrPrS__static_attributes__ __classcell__r6s@r7r r sD,!&'1 '1 '1 '1  '1  '1'1'1R77)-48#'  &2  !   <)-48#' ) )&)2 ) ! )  )<)-48#' K K&K2 K ! K  KKr9r c^\rSrSrSrSSS\R "5S4S U4SjjjrS U4Sjjr\ S SS jj5r S r U=r $)rz AIFI transformer layer for 2D data with positional embeddings. This class extends TransformerEncoderLayer to work with 2D feature maps by adding 2D sine-cosine positional embeddings and handling the spatial dimensions appropriately. rrrFc(>[TU]XX4XV5 g)a| Initialize the AIFI instance with specified parameters. Args: c1 (int): Input dimension. cm (int): Hidden dimension in the feedforward network. num_heads (int): Number of attention heads. dropout (float): Dropout probability. act (nn.Module): Activation function. normalize_before (bool): Whether to apply normalization before attention and feedforward. N)r r!)r2r3r4r5rr0r1r6s r7r! AIFI.__init__s( SKr9cR>URSSup#nURXCU5n[TU] UR S5R SSS5UR URURS9S9nUR SSS5RSX#U/5R5$)z Forward pass for the AIFI transformer layer. Args: x (torch.Tensor): Input tensor with shape [B, C, H, W]. Returns: (torch.Tensor): Output tensor with shape [B, C, H, W]. rNr)devicedtype)r>) shape"build_2d_sincos_position_embeddingr rSflattenpermutetorprqview contiguous)r2xchw pos_embedr6s r7rS AIFI.forwards''!"+a;;A!D GOAIIaL00Aq9y||STS[S[cdcjcj|?kO lyyAq!&&A!}5@@BBr9cUS-S:XdS5e[R"U[RS9n[R"U[RS9n[(a[R"XESS9O[R"XE5upEUS-n[R"U[RS9U- nSX7-- nUR 5SUS -nUR 5SUS -n [R "[R"U5[R"U5[R"U 5[R"U 5/S 5S $) a? Build 2D sine-cosine position embedding. Args: w (int): Width of the feature map. h (int): Height of the feature map. embed_dim (int): Embedding dimension. temperature (float): Temperature for the sine/cosine functions. Returns: (torch.Tensor): Position embedding with shape [1, embed_dim, h*w]. rzHEmbed dimension must be divisible by 4 for 2D sin-cos position embeddingrqij)indexingg?.NNr) torcharangefloat32rmeshgridrucatsincos) r}r| embed_dim temperaturegrid_wgrid_hpos_dimomegaout_wout_hs r7rt'AIFI.build_2d_sincos_position_embeddings 1}!m#mm!au}}5au}}5JT*FZ_ZhZhioZxq. WEMM:WD{)* +eDk9 +eDk9yy%))E*EIIe,NPUPYPYZ_P`acdefjkkr9r;rUrzr\r^r\)g@) r}rVr|rVrrVrrWr^r\) r`rarbrcrdr$rer!rSrfrtrgrhris@r7rrs!&L L L L  L  LLL,C CJl ll#&l;@l llr9rc:^\rSrSrSrSU4SjjrSSjrSrU=r$)r zeTransformer layer https://arxiv.org/abs/2010.11929 (LayerNorm layers removed for better performance).cX>[TU]5 [R"XSS9Ul[R"XSS9Ul[R"XSS9Ul[R"XS9Ul[R"XSS9Ul [R"XSS9Ul g)z Initialize a self-attention mechanism using linear transformations and multi-head attention. Args: c (int): Input and output channel dimension. num_heads (int): Number of attention heads. F)bias)rr5N) r r!r$r'rJrKvr%r&r(r))r2r{r5r6s r7r!TransformerLayer.__init__s| 1e,1e,1e,''!I99Q.99Q.r9cURURU5URU5URU55SU-nUR UR U55U-$)z Apply a transformer block to the input x and return the output. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after transformer layer. r)r&rJrKrr)r(r2rzs r7rSTransformerLayer.forwardsT GGDFF1Itvvay$&&) 4Q 7! ;xx $q((r9)r(r)rKr&rJr)r{rVr5rVr r`rarbrcrdr!rSrgrhris@r7r r so/ ) )r9r c:^\rSrSrSrSU4SjjrSSjrSrU=r$)ria Vision Transformer block based on https://arxiv.org/abs/2010.11929. This class implements a complete transformer block with optional convolution layer for channel adjustment, learnable position embedding, and multiple transformer layers. Attributes: conv (Conv, optional): Convolution layer if input and output channels differ. linear (nn.Linear): Learnable position embedding. tr (nn.Sequential): Sequential container of transformer layers. c2 (int): Output channel dimension. c>^^[TU]5 SUlUT:wa[UT5Ul[R "TT5Ul[R"UU4Sj[U556Ul TUl g)a Initialize a Transformer module with position embedding and specified number of heads and layers. Args: c1 (int): Input channel dimension. c2 (int): Output channel dimension. num_heads (int): Number of attention heads. num_layers (int): Number of transformer layers. Nc3<># UHn[TT5v M g7frZ)r ).0_c2r5s r7 ,TransformerBlock.__init__..:s!]K\a"22y"A"AK\s) r r!convrr$r'linear Sequentialrangetrr)r2r3rr5 num_layersr6s `` r7r!TransformerBlock.__init__+s`  8R DIiiB' --!]5Q[K\!]^r9c:URbURU5nURup#pEURS5RSSS5nUR X`R U5-5RSSS5R X RXE5$)z Forward propagate the input through the transformer block. Args: x (torch.Tensor): Input tensor with shape [b, c1, w, h]. Returns: (torch.Tensor): Output tensor with shape [b, c2, w, h]. rorr)rrsrurvrrreshaper)r2rzbrr}r|ps r7rSTransformerBlock.forward=s 99  ! AWW a IIaL Aq )wwq;;q>)*221a;CCAwwPQUUr9)rrrr)r3rVrrVr5rVrrVrrris@r7rrs $VVr9rcT^\rSrSrSr\R 4SU4SjjjrSSjrSr U=r $)riNz+A single block of a multi-layer perceptron.c>[TU]5 [R"X5Ul[R"X!5UlU"5Ulg)z Initialize the MLPBlock with specified embedding dimension, MLP dimension, and activation function. Args: embedding_dim (int): Input and output dimension. mlp_dim (int): Hidden dimension. act (nn.Module): Activation function. N)r r!r$r'lin1lin2r0)r2 embedding_dimmlp_dimr0r6s r7r!MLPBlock.__init__Qs9 IIm5 IIg5 5r9c`URURURU555$)z Forward pass for the MLPBlock. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after MLP block. )rr0rrs r7rSMLPBlock.forward_s$yy$))A,/00r9)r0rr)rrVrrVr) r`rarbrcrdr$rer!rSrgrhris@r7rrNs!5=?WW   1 1r9rch^\rSrSrSr\R S4SU4SjjjrSSjrSr U=r $) rila A simple multi-layer perceptron (also called FFN). This class implements a configurable MLP with multiple linear layers, activation functions, and optional sigmoid output activation. Attributes: num_layers (int): Number of layers in the MLP. layers (nn.ModuleList): List of linear layers. sigmoid (bool): Whether to apply sigmoid to the output. act (nn.Module): Activation function. Fc>[TU]5 X@lU/US- -n[R"S[ U/U-Xs/-555UlX`lU"5Ulg)ae Initialize the MLP with specified input, hidden, output dimensions and number of layers. Args: input_dim (int): Input dimension. hidden_dim (int): Hidden dimension. output_dim (int): Output dimension. num_layers (int): Number of layers. act (nn.Module): Activation function. sigmoid (bool): Whether to apply sigmoid to the output. rc3R# UHup[R"X5v M g7frZ)r$r')rnrKs r7rMLP.__init__..s#g@fBIIaOO@fs%'N) r r!rr$ ModuleListziplayerssigmoidr0) r2 input_dim hidden_dim output_dimrr0rr|r6s r7r! MLP.__init__zs^ $ LJN +mm#gYKRSOUVYeUe@f#gg  5r9c[UR5HKup#X RS- :a,[US[R "55"U"U55OU"U5nMM [USS5(aUR 5$U$)z Forward pass for the entire MLP. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after MLP. rr0rF) enumeraterrgetattrr$ReLUr)r2rzilayers r7rS MLP.forwardsm"$++.HA=>STAT=TeRWWY/a9Z_`aZbA/%dIu==qyy{D1Dr9)r0rrr) rrVrrVrrVrrVrrYr) r`rarbrcrdr$rr!rSrgrhris@r7rrlsV VXU\U\ns*-;>LOgk* E Er9rc>^\rSrSrSrSSU4SjjjrSSjrSrU=r$) riaI 2D Layer Normalization module inspired by Detectron2 and ConvNeXt implementations. This class implements layer normalization for 2D feature maps, normalizing across the channel dimension while preserving spatial dimensions. Attributes: weight (nn.Parameter): Learnable scale parameter. bias (nn.Parameter): Learnable bias parameter. eps (float): Small constant for numerical stability. References: https://github.com/facebookresearch/detectron2/blob/main/detectron2/layers/batch_norm.py https://github.com/facebookresearch/ConvNeXt/blob/main/models/convnext.py c>[TU]5 [R"[R "U55Ul[R"[R"U55UlX l g)z Initialize LayerNorm2d with the given parameters. Args: num_channels (int): Number of channels in the input. eps (float): Small constant for numerical stability. N) r r!r$ Parameterronesweightzerosreps)r2 num_channelsrr6s r7r!LayerNorm2d.__init__sG ll5::l#;< LL\!:; r9c URSSS9nX- RS5RSSS9nX- [R"X0R-5- nUR SS2SS4U-UR SS2SS4-$)z Perform forward pass for 2D layer normalization. Args: x (torch.Tensor): Input tensor. Returns: (torch.Tensor): Normalized output tensor. rTkeepdimroN)meanpowrsqrtrrr)r2rzuss r7rSLayerNorm2d.forwards~ FF1dF # UKKN  4  0 UejjXX. .{{1dD=)A- !T4-0HHHr9)rrr)gư>)rrVrrWrrris@r7rrs   I Ir9rc`^\rSrSrSrSSU4SjjjrSrS S SjjrSrU=r $) ria Multiscale Deformable Attention Module based on Deformable-DETR and PaddleDetection implementations. This module implements multiscale deformable attention that can attend to features at multiple scales with learnable sampling locations and attention weights. Attributes: im2col_step (int): Step size for im2col operations. d_model (int): Model dimension. n_levels (int): Number of feature levels. n_heads (int): Number of attention heads. n_points (int): Number of sampling points per attention head per feature level. sampling_offsets (nn.Linear): Linear layer for generating sampling offsets. attention_weights (nn.Linear): Linear layer for generating attention weights. value_proj (nn.Linear): Linear layer for projecting values. output_proj (nn.Linear): Linear layer for projecting output. References: https://github.com/fundamentalvision/Deformable-DETR/blob/main/models/ops/modules/ms_deform_attn.py c>[TU]5 X-S:wa[SUSU35eX-nXS-U:XdS5eSUlXlX lX0lX@l[R"XU-U-S-5Ul [R"XU-U-5Ul [R"X5Ul [R"X5Ul UR5 g)a Initialize MSDeformAttn with the given parameters. Args: d_model (int): Model dimension. n_levels (int): Number of feature levels. n_heads (int): Number of attention heads. n_points (int): Number of sampling points per attention head per feature level. rz.d_model must be divisible by n_heads, but got z and z(`d_model` must be divisible by `n_heads`@roN)r r! ValueError im2col_stepd_modeln_levelsn_headsn_pointsr$r'sampling_offsetsattention_weights value_proj output_proj_reset_parameters)r2rrrr _d_per_headr6s r7r!MSDeformAttn.__init__s    !MgYV[\c[def f( $/[1[[/    " 'X3E3PST3T U!#7h4F4Q!R))G599W6  r9cP[URRRS5 [R "UR [RS9S[R-UR - -n[R"UR5UR5/S5nX"R5RSSS9S- RUR SSS 5R!SUR"UR$S5n['UR$5HnUS S 2S S 2US S 24==US--ss'M [R("5 [*R,"URS55URlS S S 5 [UR0RRS5 [UR0R.RS5 [3UR4RR5 [UR4R.RS5 [3UR6RR5 [UR6R.RS5 g !,(df  GN =f) zReset module parameters.rrg@rrTrrrroN)rrrdatarrrrmathpistackrrabsmaxrxrepeatrrrno_gradr$rrrrrr)r2thetas grid_initrs r7rMSDeformAttn._reset_parameterss$''..33S9dll%--@C$''MTXT`T`D`aKKvzz| qA A T$,,1a ( VAt}}dmmQ 7  t}}%A aAqj !QU * !& ]]_)+innR6H)ID ! ! &$((//44c:$((--22C8..334$//&&++S1((//445$""'',,c2_s 5J J%c URSSupgURSn[SU55U:XdeURU5nUbURUS[ S55nUR XhUR URUR -5nURU5R XgUR URURS5n URU5R XgUR URUR-5n [R"U S5R XgUR URUR5n URSn U S:Xa`[R"XAR UR"S9R%S5n XSSSSS2SSS24- n USS2SS2SSS2SSS24U -nOQU S :Xa<XR- USS2SS2SSS2SSS24-S -n USS2SS2SSS2SSS24U -nO['S U S 35e[)X4X5nUR+U5$) ad Perform forward pass for multiscale deformable attention. Args: query (torch.Tensor): Query tensor with shape [bs, query_length, C]. refer_bbox (torch.Tensor): Reference bounding boxes with shape [bs, query_length, n_levels, 2], range in [0, 1], top-left (0,0), bottom-right (1, 1), including padding area. value (torch.Tensor): Value tensor with shape [bs, value_length, C]. value_shapes (list): List with shape [n_levels, 2], [(H_0, W_0), (H_1, W_1), ..., (H_{L-1}, W_{L-1})]. value_mask (torch.Tensor, optional): Mask tensor with shape [bs, value_length], True for non-padding elements, False for padding elements. Returns: (torch.Tensor): Output tensor with shape [bs, Length_{query}, C]. References: https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/transformers/deformable_transformer.py Nrorc36# UHoSUS-v M g7f)rrNr;)rrs r7r'MSDeformAttn.forward..2s5 1Q4!A$; srrrr)rqrprg?z5Last dim of reference_points must be 2 or 4, but got .)rssumr masked_fillrWrxrrrrrrFsoftmaxr as_tensorrqrpfliprr r)r2query refer_bboxrD value_shapes value_maskbslen_qlen_vrr num_pointsoffset_normalizeraddsampling_locationsoutputs r7rSMSDeformAttn.forwards24KKO  A5 55>>>&  !%%j&;U1XFE 2dllDLLDLL4PQ007<>r$,,X\XeXehlhuhuXuvII&7<AA"T\\[_[h[hjnjwjwx%%b) ? % KKX]XdXd e j jkm n "tT4DRS7S%TTC!+Aq$4,B!Cc!I  1_"]]2Z1dAtUVUW@W5XX[^^C!+Aq$4!,C!Ds!J TU_T``abc c4UJ\p''r9) rrrrrrrrr)rrrr)rrVrrVrrVrrVrZ) r r\r r\rDr\r listrr]r^r\) r`rarbrcrdr!rrSrgrhris@r7rrs`*!!>36+/ 1(1(!1( 1(  1( ( 1( 1(1(r9rc^\rSrSrSrSSSS\R "5SS4S U4Sjjjr\SS j5r SS jr SSS jjr S r U=r $)riJa Deformable Transformer Decoder Layer inspired by PaddleDetection and Deformable-DETR implementations. This class implements a single decoder layer with self-attention, cross-attention using multiscale deformable attention, and a feedforward network. Attributes: self_attn (nn.MultiheadAttention): Self-attention module. dropout1 (nn.Dropout): Dropout after self-attention. norm1 (nn.LayerNorm): Layer normalization after self-attention. cross_attn (MSDeformAttn): Cross-attention module. dropout2 (nn.Dropout): Dropout after cross-attention. norm2 (nn.LayerNorm): Layer normalization after cross-attention. linear1 (nn.Linear): First linear layer in the feedforward network. act (nn.Module): Activation function. dropout3 (nn.Dropout): Dropout in the feedforward network. linear2 (nn.Linear): Second linear layer in the feedforward network. dropout4 (nn.Dropout): Dropout after the feedforward network. norm3 (nn.LayerNorm): Layer normalization after the feedforward network. References: https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/transformers/deformable_transformer.py https://github.com/fundamentalvision/Deformable-DETR/blob/main/models/deformable_transformer.py rrirrcj>[TU]5 [R"XUS9Ul[R "U5Ul[R"U5Ul[XX'5Ul [R "U5Ul [R"U5Ul [R"X5UlXPl[R "U5Ul[R"X15Ul[R "U5Ul[R"U5Ulg)a Initialize the DeformableTransformerDecoderLayer with the given parameters. Args: d_model (int): Model dimension. n_heads (int): Number of attention heads. d_ffn (int): Dimension of the feedforward network. dropout (float): Dropout probability. act (nn.Module): Activation function. n_levels (int): Number of feature levels. n_points (int): Number of sampling points. )rN)r r!r$r% self_attnr-r.r*r+r cross_attnr/r,r'linear1r0dropout3linear2dropout4norm3) r2rrd_ffnrr0rrr6s r7r!*DeformableTransformerDecoderLayer.__init__ds, ..wQ 7+ \\'* 'w'L 7+ \\'* yy0  7+ yy0  7+ \\'* r9cUcU$X-$)z;Add positional embeddings to the input tensor, if provided.r;r<s r7r?0DeformableTransformerDecoderLayer.with_pos_embedrAr9c URURURURU5555nXR U5-nUR U5$)z Perform forward pass through the Feed-Forward Network part of the layer. Args: tgt (torch.Tensor): Input tensor. Returns: (torch.Tensor): Output tensor after FFN. )rrr0rr r!)r2tgttgt2s r7 forward_ffn-DeformableTransformerDecoderLayer.forward_ffnsL||DMM$((4<<3D*EFGMM$''zz#r9cURX5=pURURSS5U RSS5URSS5US9SRSS5n XRU 5-nUR U5nUR URX5UR S5X4U5n XRU 5-nURU5nURU5$)a Perform the forward pass through the entire decoder layer. Args: embed (torch.Tensor): Input embeddings. refer_bbox (torch.Tensor): Reference bounding boxes. feats (torch.Tensor): Feature maps. shapes (list): Feature shapes. padding_mask (torch.Tensor, optional): Padding mask. attn_mask (torch.Tensor, optional): Attention mask. query_pos (torch.Tensor, optional): Query position embeddings. Returns: (torch.Tensor): Output tensor after decoder layer. rr)rEro) r?r transposer.r+r unsqueezer/r,r)) r2embedr featsshapes padding_maskrE query_posrJrKr's r7rS)DeformableTransformerDecoderLayer.forwards4##E55nnQ[[A. Aq0A5??STVWCXdmnn  )Aq/  c** 5!oo    1:3G3G3JE[g  c** 5!&&r9) r0rr.r/rr rrr+r,r!r)rrVrrVr"rVrrWr0rXrrVrrVr[)r'r\r^r\r_)r.r\r r\r/r\r0rr1r]rEr]r2r]r^r\)r`rarbrcrdr$rr!rfr?r)rSrgrhris@r7rrJs6(+(+(+ (+  (+  (+(+(+(+T77 (-1)-)-)')'!)' )'  )' * )'')'')' )')'r9rch^\rSrSrSrSSU4SjjjrSS SjjrSrU=r$) riaJ Deformable Transformer Decoder based on PaddleDetection implementation. This class implements a complete deformable transformer decoder with multiple decoder layers and prediction heads for bounding box regression and classification. Attributes: layers (nn.ModuleList): List of decoder layers. num_layers (int): Number of decoder layers. hidden_dim (int): Hidden dimension. eval_idx (int): Index of the layer to use during evaluation. References: https://github.com/PaddlePaddle/PaddleDetection/blob/develop/ppdet/modeling/transformers/deformable_transformer.py c>[TU]5 [X#5UlX0lXlUS:aX@lgX4-Ulg)a Initialize the DeformableTransformerDecoder with the given parameters. Args: hidden_dim (int): Hidden dimension. decoder_layer (nn.Module): Decoder layer module. num_layers (int): Number of decoder layers. eval_idx (int): Index of the layer to use during evaluation. rN)r r!r rrreval_idx)r2r decoder_layerrr6r6s r7r!%DeformableTransformerDecoder.__init__s: !-< $$$,M z7L r9c Un /n /n Sn UR5n[UR5GHupU"XX4XU"U55n X^"U 5n[R"U[ U5-5nUR (acU R Xn"U 55 US:XaU R U5 OmU R [R"U[ U 5-55 O;XR:Xa,U R Xn"U 55 U R U5 O*Un UR (aUR5OUnGM [R"U 5[R"U 54$)aq Perform the forward pass through the entire decoder. Args: embed (torch.Tensor): Decoder embeddings. refer_bbox (torch.Tensor): Reference bounding boxes. feats (torch.Tensor): Image features. shapes (list): Feature shapes. bbox_head (nn.Module): Bounding box prediction head. score_head (nn.Module): Score prediction head. pos_mlp (nn.Module): Position MLP. attn_mask (torch.Tensor, optional): Attention mask. padding_mask (torch.Tensor, optional): Padding mask. Returns: dec_bboxes (torch.Tensor): Decoded bounding boxes. dec_cls (torch.Tensor): Decoded classification scores. Nr) rrrrr trainingappendr6detachr)r2r.r r/r0 bbox_head score_headpos_mlprEr1r dec_bboxesdec_clslast_refined_bboxrrbbox refined_bboxs r7rS$DeformableTransformerDecoder.forwards1<  '') !$++.HA6ulW^_iWjkF<'D == 0K)KLL}}z}V456%%l3%%emmD?K\;]4]&^_mm#z}V45!!,/ , 26--,,.\J%/({{:& G(<<rXr?rXrEr]r1r]rris@r7rrs~ MM2*.,07=7=!7= 7=  7=  7=7=7='7=*7=7=r9r)!rd __future__rrrtorch.nnr$torch.nn.functional functionalr torch.nn.initrrultralytics.utils.torch_utilsrrrutilsr r r __all__Moduler rr rrrrrrrr;r9r7rOs" 44TT MKbiiMK`Il "IlX)ryy)B.Vryy.Vb1ryy1