a yf_@sddlZddlZddlmZddlmZmZmZmZm Z ddl Z ddl Z ddl mmZddl mZmZddlmZmZmZddlmZmZmZddlmZmZmZmZmZGd d d ej Z!Gd d d ej Z"Gd ddej Z#Gdddej Z$GdddeZ%GdddeZ&GdddeZ'd(e jej ej e jdddZ(Gdddej Z)Gdddej Z*Gdddej Z+Gd d!d!ej Z,Gd"d#d#ej Z-Gd$d%d%ej Z.Gd&d'd'ej Z/dS))N)partial)AnyOptionalTupleTypeUnion)Tensornn)MLP LayerNorm2dMLPBlock) AttentionTwoWayAttentionBlockTwoWayTransformer)add_decomposed_rel_posapply_rotary_enccompute_axial_ciswindow_partitionwindow_unpartitioncs*eZdZdZdfdd ZddZZS) DropPatha Implements stochastic depth regularization for neural networks during training. Attributes: drop_prob (float): Probability of dropping a path during training. scale_by_keep (bool): Whether to scale the output by the keep probability. Methods: forward: Applies stochastic depth to input tensor during training, with optional scaling. Examples: >>> drop_path = DropPath(drop_prob=0.2, scale_by_keep=True) >>> x = torch.randn(32, 64, 224, 224) >>> output = drop_path(x) Tcst||_||_dS)zOInitialize DropPath module for stochastic depth regularization during training.N)super__init__ drop_prob scale_by_keep)selfrr __class__a/var/www/html/django/DPS/env/lib/python3.9/site-packages/ultralytics/models/sam/modules/blocks.pyr$s zDropPath.__init__cCsh|jdks|js|Sd|j}|jdfd|jd}|||}|dkr`|jr`||||S)zPApplies stochastic depth to input tensor during training, with optional scaling.rr r)r )rZtrainingshapendimZ new_emptyZ bernoulli_rZdiv_)rxZ keep_probr!Z random_tensorrrr forward*s  zDropPath.forward)rT__name__ __module__ __qualname____doc__rr$ __classcell__rrrr rsrcs8eZdZdZdddddejffdd Zdd ZZS) MaskDownSamplera A mask downsampling and embedding module for efficient processing of input masks. This class implements a mask downsampler that progressively reduces the spatial dimensions of input masks while expanding their channel dimensions using convolutional layers, layer normalization, and activation functions. Attributes: encoder (nn.Sequential): A sequential container of convolutional layers, layer normalization, and activation functions for downsampling and embedding masks. Methods: forward: Downsamples and encodes input mask to embed_dim channels. Examples: >>> mask_downsampler = MaskDownSampler(embed_dim=256, kernel_size=4, stride=4, padding=0, total_stride=16) >>> input_mask = torch.randn(1, 1, 256, 256) >>> output = mask_downsampler(input_mask) >>> print(output.shape) torch.Size([1, 256, 16, 16]) rc sttt|t|}|||ks2Jt|_d\}} t|D]N} ||d} |j tj || |||d|j t | |j || }qL|j tj | |dddS)zYInitializes a mask downsampler module for progressive downsampling and channel expansion.)r r  kernel_sizestridepaddingr r1N) rrintmathlog2r Z SequentialencoderrangeappendConv2dr ) r embed_dimr1r2r3Z total_stride activation num_layersZ mask_in_chansZmask_out_chans_rrr rMs(     zMaskDownSampler.__init__cCs ||S)zdDownsamples and encodes input mask to embed_dim channels using convolutional layers and LayerNorm2d.)r8rr#rrr r$mszMaskDownSampler.forward) r&r'r(r)r GELUrr$r*rrrr r+6s r+cs*eZdZdZd fdd Zd d ZZS) CXBlocka^ ConvNeXt Block for efficient feature extraction in convolutional neural networks. This block implements a modified version of the ConvNeXt architecture, offering improved performance and flexibility in feature extraction. Attributes: dwconv (nn.Conv2d): Depthwise or standard 2D convolution layer. norm (LayerNorm2d): Layer normalization applied to channels. pwconv1 (nn.Linear): First pointwise convolution implemented as a linear layer. act (nn.GELU): GELU activation function. pwconv2 (nn.Linear): Second pointwise convolution implemented as a linear layer. gamma (nn.Parameter | None): Learnable scale parameter for layer scaling. drop_path (nn.Module): DropPath layer for stochastic depth regularization. Methods: forward: Processes the input tensor through the ConvNeXt block. Examples: >>> import torch >>> x = torch.randn(1, 64, 56, 56) >>> block = CXBlock(dim=64, kernel_size=7, padding=3) >>> output = block(x) >>> print(output.shape) torch.Size([1, 64, 56, 56]) rư>Tcsttj|||||r|ndd|_t|dd|_t|d||_t |_ td|||_ |dkrtj |t |ddnd |_|d krt|nt|_d S) a Initialize a ConvNeXt Block for efficient feature extraction in convolutional neural networks. This block implements a modified version of the ConvNeXt architecture, offering improved performance and flexibility in feature extraction. Args: dim (int): Number of input channels. kernel_size (int): Size of the convolutional kernel. padding (int): Padding size for the convolution. drop_path (float): Stochastic depth rate. layer_scale_init_value (float): Initial value for Layer Scale. use_dwconv (bool): Whether to use depthwise convolution. Examples: >>> block = CXBlock(dim=64, kernel_size=7, padding=3) >>> x = torch.randn(1, 64, 32, 32) >>> output = block(x) >>> print(output.shape) torch.Size([1, 64, 32, 32]) r )r1r3groupsrEepsr-rT)Z requires_gradNr)rrr r;dwconvr normLinearpwconv1rAactpwconv2 ParametertorchonesgammarIdentity drop_path)rdimr1r3rTZlayer_scale_init_valueZ use_dwconvrrr rs"   zCXBlock.__init__cCs||}||}||}|dddd}||}||}||}|jdurZ|j|}|dddd}|||}|S)zbApplies ConvNeXt block operations to input tensor, including convolutions and residual connection.rr/rDr N)rIrJpermuterLrMrNrRrT)rr#inputrrr r$s       zCXBlock.forward)rCrDrrETr%rrrr rBrs1rBcs*eZdZdZdfdd ZddZZS) Fusera A module for fusing features through multiple layers of a neural network. This class applies a series of identical layers to an input tensor, optionally projecting the input first. Attributes: proj (nn.Module): An optional input projection layer. Identity if no projection is needed. layers (nn.ModuleList): A list of identical layers to be applied sequentially. Methods: forward: Applies the fuser to an input tensor. Examples: >>> layer = CXBlock(dim=256) >>> fuser = Fuser(layer, num_layers=3, dim=256, input_projection=True) >>> x = torch.randn(1, 256, 32, 32) >>> output = fuser(x) >>> print(output.shape) torch.Size([1, 256, 32, 32]) NFcsXtt|_tfddt|D|_|rT|dusBJtj||dd|_dS)a Initializes the Fuser module for feature fusion through multiple layers. This module creates a sequence of identical layers and optionally applies an input projection. Args: layer (nn.Module): The layer to be replicated in the fuser. num_layers (int): The number of times to replicate the layer. dim (int | None): The dimension for input projection, if used. input_projection (bool): Whether to use input projection. Examples: >>> layer = nn.Linear(64, 64) >>> fuser = Fuser(layer, num_layers=3, dim=64, input_projection=True) >>> input_tensor = torch.randn(1, 64) >>> output = fuser(input_tensor) csg|]}tqSr)copydeepcopy).0r?layerrr z"Fuser.__init__..Nr r4) rrr rSproj ModuleListr9layersr;)rr]r>rUZinput_projectionrr\r rs    zFuser.__init__cCs"||}|jD] }||}q|S)zOApplies a series of layers to the input tensor, optionally projecting it first.)r`rb)rr#r]rrr r$s   z Fuser.forward)NFr%rrrr rXsrXc sDeZdZdZdejddfeeeeejee ddfdd Z Z S) SAM2TwoWayAttentionBlocka A two-way attention block for performing self-attention and cross-attention in both directions. This block extends the TwoWayAttentionBlock and consists of four main components: self-attention on sparse inputs, cross-attention from sparse to dense inputs, an MLP block on sparse inputs, and cross-attention from dense to sparse inputs. Attributes: self_attn (Attention): Self-attention layer for queries. norm1 (nn.LayerNorm): Layer normalization after the first attention block. cross_attn_token_to_image (Attention): Cross-attention layer from queries to keys. norm2 (nn.LayerNorm): Layer normalization after the second attention block. mlp (MLP): MLP block for transforming query embeddings. norm3 (nn.LayerNorm): Layer normalization after the MLP block. norm4 (nn.LayerNorm): Layer normalization after the third attention block. cross_attn_image_to_token (Attention): Cross-attention layer from keys to queries. skip_first_layer_pe (bool): Flag to skip positional encoding in the first layer. Methods: forward: Processes input through the attention blocks and MLP. Examples: >>> block = SAM2TwoWayAttentionBlock(embedding_dim=256, num_heads=8) >>> sparse_input = torch.randn(1, 100, 256) >>> dense_input = torch.randn(1, 256, 16, 16) >>> sparse_output, dense_output = block(sparse_input, dense_input) ir/FN) embedding_dim num_headsmlp_dimr=attention_downsample_rateskip_first_layer_pereturncs.t||||||t|||d|d|_dS)a Initializes a SAM2TwoWayAttentionBlock for performing self-attention and cross-attention in two directions. This block extends the TwoWayAttentionBlock and consists of four main components: self-attention on sparse inputs, cross-attention from sparse to dense inputs, an MLP block on sparse inputs, and cross-attention from dense to sparse inputs. Args: embedding_dim (int): The channel dimension of the embeddings. num_heads (int): The number of heads in the attention layers. mlp_dim (int): The hidden dimension of the MLP block. activation (Type[nn.Module]): The activation function of the MLP block. attention_downsample_rate (int): The downsample rate for attention computations. skip_first_layer_pe (bool): Whether to skip the positional encoding in the first layer. Examples: >>> block = SAM2TwoWayAttentionBlock(embedding_dim=256, num_heads=8, mlp_dim=2048) >>> sparse_inputs = torch.randn(1, 100, 256) >>> dense_inputs = torch.randn(1, 256, 32, 32) >>> sparse_outputs, dense_outputs = block(sparse_inputs, dense_inputs) r/r>rMN)rrr mlp)rrdrerfr=rgrhrrr r%sz!SAM2TwoWayAttentionBlock.__init__) r&r'r(r)r ReLUr5rModuleboolrr*rrrr rcs rcc s@eZdZdZejdfeeeeeejeddfdd Z Z S)SAM2TwoWayTransformera A Two-Way Transformer module for simultaneous attention to image and query points. This class extends the TwoWayTransformer, implementing a specialized transformer decoder that attends to an input image using queries with supplied positional embeddings. It is particularly useful for tasks like object detection, image segmentation, and point cloud processing. Attributes: depth (int): Number of layers in the transformer. embedding_dim (int): Channel dimension for input embeddings. num_heads (int): Number of heads for multihead attention. mlp_dim (int): Internal channel dimension for the MLP block. layers (nn.ModuleList): List of SAM2TwoWayAttentionBlock layers comprising the transformer. final_attn_token_to_image (Attention): Final attention layer from queries to image. norm_final_attn (nn.LayerNorm): Layer normalization applied to final queries. Methods: forward: Processes input image embeddings and query embeddings through the transformer. Examples: >>> transformer = SAM2TwoWayTransformer(depth=5, embedding_dim=256, num_heads=8, mlp_dim=2048) >>> image_embedding = torch.randn(1, 256, 64, 64) >>> query_embedding = torch.randn(1, 100, 256) >>> output = transformer(image_embedding, query_embedding) >>> print(output[0].shape, output[1].shape) torch.Size([1, 100, 256]) torch.Size([1, 256, 64, 64]) r/N)depthrdrerfr=rgric sRt||||||t|_t|D]$}|jt||||||dkdq(dS)a Initializes a SAM2TwoWayTransformer instance. This transformer decoder attends to an input image using queries with supplied positional embeddings. It is designed for tasks like object detection, image segmentation, and point cloud processing. Args: depth (int): Number of layers in the transformer. embedding_dim (int): Channel dimension for the input embeddings. num_heads (int): Number of heads for multihead attention. Must divide embedding_dim. mlp_dim (int): Channel dimension internal to the MLP block. activation (Type[nn.Module]): Activation function to use in the MLP block. attention_downsample_rate (int): Downsampling rate for attention computations. Examples: >>> transformer = SAM2TwoWayTransformer(depth=5, embedding_dim=256, num_heads=8, mlp_dim=2048) >>> transformer SAM2TwoWayTransformer( (layers): ModuleList( (0-4): 5 x SAM2TwoWayAttentionBlock(...) ) (final_attn_token_to_image): Attention(...) (norm_final_attn): LayerNorm(...) ) r)rdrerfr=rgrhN)rrr rarbr9r:rc)rrprdrerfr=rgirrr rds"  zSAM2TwoWayTransformer.__init__) r&r'r(r)r rlr5rrmrr*rrrr roGs"rocsBeZdZdZddddfdd Zd eeeeed d d ZZS) RoPEAttentiona Implements rotary position encoding for attention mechanisms in transformer architectures. This class extends the base Attention class by incorporating Rotary Position Encoding (RoPE) to enhance the positional awareness of the attention mechanism. Attributes: compute_cis (Callable): Function to compute axial complex numbers for rotary encoding. freqs_cis (Tensor): Precomputed frequency tensor for rotary encoding. rope_k_repeat (bool): Flag to repeat query RoPE to match key length for cross-attention to memories. Methods: forward: Applies rotary position encoding and computes attention between query, key, and value tensors. Examples: >>> rope_attn = RoPEAttention(embedding_dim=256, num_heads=8, rope_theta=10000.0, feat_sizes=(32, 32)) >>> q = torch.randn(1, 1024, 256) >>> k = torch.randn(1, 1024, 256) >>> v = torch.randn(1, 1024, 256) >>> output = rope_attn(q, k, v) >>> print(output.shape) torch.Size([1, 1024, 256]) g@F) rs) rope_theta rope_k_repeat feat_sizescsPtj|i|tt|j|j|d|_|j|d|dd}||_||_dS)zZInitializes RoPEAttention with rotary position encoding for enhanced positional awareness.)rUthetarr Zend_xZend_yN) rrrrZ internal_dimre compute_cis freqs_cisru)rrtrurvargskwargsrzrrr rs zRoPEAttention.__init__r)qkvnum_k_exclude_roperic Csh||}||}||}|||j}|||j}|||j}t|jd}}|j |j |_|jjd|jdkr|j ||d |j |_|jd|jdkr|j sJ| d|}t||ddddd|f|j|j d\}|ddddd|f<|j\}}}} ||dddd} | t| } tj| d d } | |} || } || } | S) z^Applies rotary position encoding and computes attention between query, key, and value tensors.rrxN)rzZrepeat_freqs_kr rDr/rU)Zq_projZk_projZv_projZ_separate_headsrer6sqrtr!rztodeviceryrusizerrVrPsoftmaxZ_recombine_headsZout_proj) rr}r~rrwhZ num_k_roper?Z c_per_headattnoutrrr r$s6       zRoPEAttention.forward)r) r&r'r(r)rrr5r$r*rrrr rrs rr)r#poolrJricCsD|dur |S|dddd}||}|dddd}|r@||}|S)z`Applies pooling and optional normalization to a tensor, handling spatial dimension permutations.NrrDr r/)rV)r#rrJrrr do_poolsrcsDeZdZdZd eeeejdfdd Zej ej dddZ Z S) MultiScaleAttentiona Implements multi-scale self-attention with optional query pooling for efficient feature extraction. This class provides a flexible implementation of multi-scale attention, allowing for optional downsampling of query features through pooling. It's designed to enhance the model's ability to capture multi-scale information in visual tasks. Attributes: dim (int): Input dimension of the feature map. dim_out (int): Output dimension of the attention module. num_heads (int): Number of attention heads. scale (float): Scaling factor for dot-product attention. q_pool (nn.Module | None): Optional pooling module for query features. qkv (nn.Linear): Linear projection for query, key, and value. proj (nn.Linear): Output projection. Methods: forward: Applies multi-scale attention to the input tensor. Examples: >>> import torch >>> from torch import nn >>> x = torch.randn(1, 64, 64, 256) >>> msa = MultiScaleAttention(dim=256, dim_out=256, num_heads=8) >>> output = msa(x) >>> print(output.shape) torch.Size([1, 64, 64, 256]) N)rUdim_outreq_poolcsXt||_||_||_||}|d|_||_t||d|_ t|||_ dS)z_Initializes multi-scale attention with optional query pooling for efficient feature extraction.rDN) rrrUrrescalerr rKqkvr`)rrUrrerhead_dimrrr rs  zMultiScaleAttention.__init__r#ric Cs|j\}}}}|||||d|jd}t|d\}}} |jrt||||d|j}|jdd\}}|||||jd}t | dd| dd| dd}| dd}||||d}| |}|S)zZApplies multi-scale attention with optional query pooling to extract multi-scale features.rDrr/r ) r!rreshapererPunbindrrFZscaled_dot_product_attention transposer`) rr#BHWr?rr}r~rrrr r$*s      zMultiScaleAttention.forward)N) r&r'r(r)r5r rmrrPrr$r*rrrr rs"rc sneZdZdZddddejdfeeeeeeej e fe eefej ed fdd Z e je jd d d ZZS) MultiScaleBlocka A multi-scale attention block with window partitioning and query pooling for efficient vision transformers. This class implements a multi-scale attention mechanism with optional window partitioning and downsampling, designed for use in vision transformer architectures. Attributes: dim (int): Input dimension of the block. dim_out (int): Output dimension of the block. norm1 (nn.Module): First normalization layer. window_size (int): Size of the window for partitioning. pool (nn.Module | None): Pooling layer for query downsampling. q_stride (Tuple[int, int] | None): Stride for query pooling. attn (MultiScaleAttention): Multi-scale attention module. drop_path (nn.Module): Drop path layer for regularization. norm2 (nn.Module): Second normalization layer. mlp (MLP): Multi-layer perceptron module. proj (nn.Linear | None): Projection layer for dimension mismatch. Methods: forward: Processes input tensor through the multi-scale block. Examples: >>> block = MultiScaleBlock(dim=256, dim_out=512, num_heads=8, window_size=7) >>> x = torch.randn(1, 56, 56, 256) >>> output = block(x) >>> print(output.shape) torch.Size([1, 28, 28, 512]) @r LayerNormNr) rUrre mlp_ratiorT norm_layerq_stride act_layer window_sizec stt|tr&ttt|dd}||_||_|||_ | |_ d||_ |_ |j rhtj ||dd|_ t||||j d|_|dkrt|nt|_|||_t|t|||d|d |_||krt|||_dS) z^Initializes a multi-scale attention block with window partitioning and optional query pooling.rErGNF)r1r2Z ceil_mode)rerrr/rj)rr isinstancestrrgetattrr rUrnorm1rrrZ MaxPool2drrrrSrTnorm2r r5rkrKr`) rrUrrerrTrrrrrrr rfs6     zMultiScaleBlock.__init__rc Cs|}||}|j|jkr,t|||j}|j}|dkr^|jd|jd}}t||\}}| |}|j r|j|j d}|jdd\}}||||}||||}||||f}|jdkrt |||||f}|| |}|| | ||}|S)z`Processes input through multi-scale attention and MLP, with optional windowing and downsampling.rr r/rD)rrUrrr`rrr!rrrrrTrkr) rr#shortcutrrrpad_hwZpad_hZpad_wrrr r$s(    zMultiScaleBlock.forward)r&r'r(r)r rAr5floatrrmrrrrPrr$r*rrrr rGs&#  0rcsteZdZdZdeeeedfdd Zdd Z e d d Z e Z e d d Ze e jdddZZS)PositionEmbeddingSinea A module for generating sinusoidal positional embeddings for 2D inputs like images. This class implements sinusoidal position encoding for 2D spatial positions, which can be used in transformer-based models for computer vision tasks. Attributes: num_pos_feats (int): Number of positional features (half of the embedding dimension). temperature (int): Temperature parameter for the sinusoidal functions. normalize (bool): Whether to normalize the positional embeddings. scale (float): Scaling factor for the embeddings when normalize is True. cache (Dict): Cache for storing precomputed embeddings. Methods: _encode_xy: Encodes 2D positions using sine and cosine functions. encode_boxes: Encodes box coordinates and dimensions into positional embeddings. encode_points: Encodes 2D point coordinates with sinusoidal positional embeddings. forward: Generates sinusoidal position embeddings for 2D inputs. Examples: >>> pos_emb = PositionEmbeddingSine(num_pos_feats=128) >>> x = torch.randn(1, 3, 224, 224) >>> embeddings = pos_emb(x) >>> print(embeddings.shape) torch.Size([1, 256, 224, 224]) 'TN) temperature normalizercsjt|ddksJd|d|_||_||_|durH|sHtd|durZdtj}||_i|_ dS)z?Initializes sinusoidal position embeddings for 2D image inputs.r/rzExpecting even model widthNz+normalize should be True if scale is passed) rr num_pos_featsrr ValueErrorr6pircache)rrrrrrrr rs    zPositionEmbeddingSine.__init__cCs(t|t|kr*|j|jkr(dks.nJ||j}||j}tj|jtj|jd}|jd|d|j}|dddf|}|dddf|}tj |dddddf |dddddf fdd d}tj |dddddf |dddddf fdd d}||fS)zWEncodes 2D positions using sine/cosine functions for transformer positional embeddings.r dtyperr/Nrr) lenr"rrParangerfloat32rrstacksincosflatten)rr#yx_embedy_embeddim_tpos_xpos_yrrr _encode_xys.  DDz PositionEmbeddingSine._encode_xycCs>|||\}}tj|||dddf|dddffddS)zPEncodes box coordinates and dimensions into positional embeddings for detection.Nr r)rrPcat)rr#rrrrrrrr encode_boxessz"PositionEmbeddingSine.encode_boxesc Cs|j|j|j\}}\}}\}} ||krB||krB||krB|| ksFJ|||\} } | ||d| ||d} } tj| | |dddddffddS)z@Encodes 2D points with sinusoidal embeddings and appends labels.rNr/r)r!rrrrPr) rr#rlabelsbxnxZbynyblnlrrrrr encode_pointss "$z#PositionEmbeddingSine.encode_points)r#c Csp|jd|jdf}||jvr>|j|d|jddddStjd|jddtj|jdddd|jdd|jd}tjd|jddtj|jdddd|jd|jdd}|jrd}||ddddddf||j }||ddddddf||j }tj|j tj|jd}|j d|d|j }|dddddddf|}|dddddddf|}tj |dddddddddf |dddddddddffd d d }tj |dddddddddf |dddddddddffd d d }tj||fd d dd dd} | d|j|<| S) zCGenerates sinusoidal position embeddings for 2D inputs like images.rrNrr rrEr/r-rrD)r!rrepeatrPrrrviewrrrrrrrrrrV) rr# cache_keyrrrHrrrposrrr r$ s8    ((  \\zPositionEmbeddingSine.forward)rTN)r&r'r(r)r5rnrrrrrPZno_gradrencoderrr$r*rrrr rs"  rcs|eZdZdZdeeeddfdd Zej ej ddd Z e eefej d d d Z ej e eefej d ddZ ZS)PositionEmbeddingRandomaV Positional encoding using random spatial frequencies. This class generates positional embeddings for input coordinates using random spatial frequencies. It is particularly useful for transformer-based models that require position information. Attributes: positional_encoding_gaussian_matrix (torch.Tensor): A buffer containing random values for encoding. Methods: _pe_encoding: Positionally encodes points that are normalized to [0,1]. forward: Generates positional encoding for a grid of the specified size. forward_with_coords: Positionally encodes points that are not normalized to [0,1]. Examples: >>> pe = PositionEmbeddingRandom(num_pos_feats=64) >>> size = (32, 32) >>> encoding = pe(size) >>> print(encoding.shape) torch.Size([128, 32, 32]) @N)rrricsPt|dus|dkrd}|d|td|ftddtjj_dS)zIInitializes random spatial frequency position embedding for transformers.Nrg?#positional_encoding_gaussian_matrixr/F) rrZregister_bufferrPZrandnZuse_deterministic_algorithmsbackendsZcudnnZ deterministic)rrrrrr rDs   z PositionEmbeddingRandom.__init__)coordsricCsBd|d}||j}dtj|}tjt|t|gddS)zFEncodes normalized [0,1] coordinates using random spatial frequencies.r/r rr)rnprrPrrr)rrrrr _pe_encodingOs  z$PositionEmbeddingRandom._pe_encoding)rric Cs||\}}|jj}tj||f|tjd}|jddd}|jddd}||}||}|tj||gdd}|dddS)zJGenerates positional encoding for a grid using random spatial frequencies.)rrrrg?r rr/) rrrPrQrZcumsumrrrV) rrrrrgridrrperrr r$XszPositionEmbeddingRandom.forward) coords_input image_sizericCsz|}|dddddf|d|dddddf<|dddddf|d|dddddf<||tjS)z`Positionally encodes input coordinates, normalizing them to [0,1] based on the given image size.Nrr )clonerrrPr)rrrrrrr forward_with_coordses00z+PositionEmbeddingRandom.forward_with_coords)rN)r&r'r(r)r5rrrrPrrrr$rr*rrrr r-s    rcs|eZdZdZddejejddddfeeee e ej e ej e e ee e eefdd fdd Zejejd d d ZZS) Blocka Transformer block with support for window attention and residual propagation. This class implements a transformer block that can use either global or windowed self-attention, followed by a feed-forward network. It supports relative positional embeddings and is designed for use in vision transformer architectures. Attributes: norm1 (nn.Module): First normalization layer. attn (REAttention): Self-attention layer with optional relative positional encoding. norm2 (nn.Module): Second normalization layer. mlp (MLPBlock): Multi-layer perceptron block. window_size (int): Size of attention window. If 0, global attention is used. Methods: forward: Processes input through the transformer block. Examples: >>> import torch >>> block = Block(dim=256, num_heads=8, window_size=7) >>> x = torch.randn(1, 56, 56, 256) >>> output = block(x) >>> print(output.shape) torch.Size([1, 56, 56, 256]) rTFrN) rUrerqkv_biasrr use_rel_posrel_pos_zero_initr input_sizeric sft|||_t|||||| dkr,| n| | fd|_|||_t|t|||d|_| |_ dS)a Initializes a transformer block with optional window attention and relative positional embeddings. This constructor sets up a transformer block that can use either global or windowed self-attention, followed by a feed-forward network. It supports relative positional embeddings and is designed for use in vision transformer architectures. Args: dim (int): Number of input channels. num_heads (int): Number of attention heads in the self-attention layer. mlp_ratio (float): Ratio of mlp hidden dimension to embedding dimension. qkv_bias (bool): If True, adds a learnable bias to query, key, value projections. norm_layer (Type[nn.Module]): Type of normalization layer to use. act_layer (Type[nn.Module]): Type of activation function to use in the MLP block. use_rel_pos (bool): If True, uses relative positional embeddings in attention. rel_pos_zero_init (bool): If True, initializes relative positional parameters to zero. window_size (int): Size of attention window. If 0, uses global attention. input_size (Optional[Tuple[int, int]]): Input resolution for calculating relative positional parameter size. Examples: >>> block = Block(dim=256, num_heads=8, window_size=7) >>> x = torch.randn(1, 56, 56, 256) >>> output = block(x) >>> print(output.shape) torch.Size([1, 56, 56, 256]) r)rerrrr)rdrfrMN) rrr REAttentionrrr r5rkr) rrUrerrrrrrrrrrr rs'   zBlock.__init__rcCs|}||}|jdkr>|jd|jd}}t||j\}}||}|jdkrft||j|||f}||}||||S)zhProcesses input through transformer block with optional windowed self-attention and residual connection.rr r/)rrr!rrrrkr)rr#rrrrrrr r$s    z Block.forward)r&r'r(r)r rrAr5rrnrrmrrrrPrr$r*rrrr rms.7rc sTeZdZdZd eeeeeeeeefddfdd Ze j e j d d d Z Z S) ra Rotary Embedding Attention module for efficient self-attention in transformer architectures. This class implements a multi-head attention mechanism with rotary positional embeddings, designed for use in vision transformer models. It supports optional query pooling and window partitioning for efficient processing of large inputs. Attributes: compute_cis (Callable): Function to compute axial complex numbers for rotary encoding. freqs_cis (Tensor): Precomputed frequency tensor for rotary encoding. rope_k_repeat (bool): Flag to repeat query RoPE to match key length for cross-attention to memories. q_proj (nn.Linear): Linear projection for query. k_proj (nn.Linear): Linear projection for key. v_proj (nn.Linear): Linear projection for value. out_proj (nn.Linear): Output projection. num_heads (int): Number of attention heads. internal_dim (int): Internal dimension for attention computation. Methods: forward: Applies rotary position encoding and computes attention between query, key, and value tensors. Examples: >>> rope_attn = REAttention(embedding_dim=256, num_heads=8, rope_theta=10000.0, feat_sizes=(32, 32)) >>> q = torch.randn(1, 1024, 256) >>> k = torch.randn(1, 1024, 256) >>> v = torch.randn(1, 1024, 256) >>> output = rope_attn(q, k, v) >>> print(output.shape) torch.Size([1, 1024, 256]) TFN)rUrerrrrricst||_||}|d|_tj||d|d|_t|||_||_|jr|dusbJdt t d|dd||_ t t d|dd||_ dS) a Initializes a Relative Position Attention module for transformer-based architectures. This module implements multi-head attention with optional relative positional encodings, designed specifically for vision tasks in transformer models. Args: dim (int): Number of input channels. num_heads (int): Number of attention heads. Default is 8. qkv_bias (bool): If True, adds a learnable bias to query, key, value projections. Default is True. use_rel_pos (bool): If True, uses relative positional encodings. Default is False. rel_pos_zero_init (bool): If True, initializes relative positional parameters to zero. Default is True. input_size (Tuple[int, int] | None): Input resolution for calculating relative positional parameter size. Required if use_rel_pos is True. Default is None. Examples: >>> attention = REAttention(dim=256, num_heads=8, input_size=(32, 32)) >>> x = torch.randn(1, 32, 32, 256) >>> output = attention(x) >>> print(output.shape) torch.Size([1, 32, 32, 256]) rrD)ZbiasNzBInput size must be provided if using relative positional encoding.r/rr )rrrerr rKrr`rrOrPZzeros rel_pos_h rel_pos_w)rrUrerrrrrrrr rs   zREAttention.__init__rc Cs|j\}}}}|||||d|jdddddd}|d||j||dd\}}} ||j|dd} |jrt | ||j |j ||f||f} | j dd} | |  ||j||dddddd|||d}||S) zXApplies multi-head attention with optional relative positional encoding to input tensor.rDrr/rr r-rr)r!rrrerVrrrrrrrrrr`) rr#rrrr?rr}r~rrrrr r$s,& 2zREAttention.forward)rTFTN) r&r'r(r)r5rnrrrrPrr$r*rrrr rs ".rcs^eZdZdZd eeefeeefeeefeeddfdd Zejejd d d Z Z S) PatchEmbeda  Image to Patch Embedding module for vision transformer architectures. This module converts an input image into a sequence of patch embeddings using a convolutional layer. It is commonly used as the first layer in vision transformer architectures to transform image data into a suitable format for subsequent transformer blocks. Attributes: proj (nn.Conv2d): Convolutional layer for projecting image patches to embeddings. Methods: forward: Applies patch embedding to the input tensor. Examples: >>> patch_embed = PatchEmbed(kernel_size=(16, 16), stride=(16, 16), in_chans=3, embed_dim=768) >>> x = torch.randn(1, 3, 224, 224) >>> output = patch_embed(x) >>> print(output.shape) torch.Size([1, 768, 14, 14]) r.r.rrrDN)r1r2r3in_chansr<rics$ttj|||||d|_dS)a Initializes the PatchEmbed module for converting image patches to embeddings. This module is typically used as the first layer in vision transformer architectures to transform image data into a suitable format for subsequent transformer blocks. Args: kernel_size (Tuple[int, int]): Size of the convolutional kernel for patch extraction. stride (Tuple[int, int]): Stride of the convolutional operation. padding (Tuple[int, int]): Padding applied to the input before convolution. in_chans (int): Number of input image channels. embed_dim (int): Dimensionality of the output patch embeddings. Examples: >>> patch_embed = PatchEmbed(kernel_size=(16, 16), stride=(16, 16), in_chans=3, embed_dim=768) >>> x = torch.randn(1, 3, 224, 224) >>> output = patch_embed(x) >>> print(output.shape) torch.Size([1, 768, 14, 14]) r0N)rrr r;r`)rr1r2r3rr<rrr rGs zPatchEmbed.__init__rcCs||ddddS)zRComputes patch embedding by applying convolution and transposing resulting tensor.rr/rDr )r`rVr@rrr r$gszPatchEmbed.forward)rrrrDr) r&r'r(r)rr5rrPrr$r*rrrr r1s    r)N)0rYr6 functoolsrtypingrrrrrnumpyrrPZtorch.nn.functionalr Z functionalrrZultralytics.nn.modulesr r r Z transformerrrrutilsrrrrrrmrr+rBrXrcrorrrrrrrrrrrrrr s2 #<^8?NSPss@d`