
    iz              	       t   d Z ddlZddlmZ ddlZddlmZ ddlmZ ddlm	Z	m
Z
 ddlmZ dd	lmZ dd
lmZmZmZmZmZmZ ddlmZ ddlmZ  e       r	ddlmZmZ nd Zd Z ej:                  e      Ze ed       G d de                    Z e ed       G d de                    Z!e ed       G d de                    Z" G d dejF                        Z$ G d dejF                        Z% G d d ejF                        Z&dCd!ejN                  d"e(d#e)d$ejN                  fd%Z* G d& d'ejF                        Z+ G d( d)ejF                        Z, G d* d+ejF                        Z- G d, d-ejF                        Z. G d. d/ejF                        Z/ G d0 d1ejF                        Z0 G d2 d3ejF                        Z1 G d4 d5ejF                        Z2 G d6 d7ejF                        Z3e G d8 d9e             Z4e G d: d;e4             Z5 ed<       G d= d>e4             Z6 ed?       G d@ dAe	e4             Z7g dBZ8y)Dz9PyTorch Dilated Neighborhood Attention Transformer model.    N)	dataclass)nn   )ACT2FN)BackboneMixinfilter_output_hidden_states)BackboneOutput)PreTrainedModel)ModelOutputOptionalDependencyNotAvailableauto_docstringis_natten_availableloggingrequires_backends)can_return_tuple   )DinatConfig)
natten2davnatten2dqkrpbc                      t               Nr   argskwargss     y/var/www/vps2.regionflexible.com/Desarrollo/venv/lib/python3.12/site-packages/transformers/models/dinat/modeling_dinat.pyr   r   *       ,..    c                      t               r   r   r   s     r   r   r   -   r   r   zO
    Dinat encoder's outputs, with potential hidden states and attentions.
    )custom_introc                       e Zd ZU dZdZej                  dz  ed<   dZe	ej                  df   dz  ed<   dZ
e	ej                  df   dz  ed<   dZe	ej                  df   dz  ed<   y)DinatEncoderOutputa  
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    Nlast_hidden_state.hidden_states
attentionsreshaped_hidden_states)__name__
__module____qualname____doc__r#   torchFloatTensor__annotations__r$   tupler%   r&    r   r   r"   r"   7   s}     37u((4/6:>M5**C/047>7;Je'',-4;CGE%"3"3S"89D@Gr   r"   zW
    Dinat model's outputs that also contains a pooling of the last hidden states.
    c                       e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	DinatModelOutputa  
    pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`, *optional*, returned when `add_pooling_layer=True` is passed):
        Average pooling of the last layer hidden-state.
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    Nr#   pooler_output.r$   r%   r&   )r'   r(   r)   r*   r#   r+   r,   r-   r2   r$   r.   r%   r&   r/   r   r   r1   r1   M   s    	 37u((4/6.2M5$$t+2:>M5**C/047>7;Je'',-4;CGE%"3"3S"89D@Gr   r1   z1
    Dinat outputs for image classification.
    c                       e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   dZe
ej                  df   dz  ed<   y)	DinatImageClassifierOutputa7  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Classification (or regression if config.num_labels==1) loss.
    logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
        Classification (or regression if config.num_labels==1) scores (before SoftMax).
    reshaped_hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings + one for the output of each stage) of
        shape `(batch_size, hidden_size, height, width)`.

        Hidden-states of the model at the output of each layer plus the initial embedding outputs reshaped to
        include the spatial dimensions.
    Nlosslogits.r$   r%   r&   )r'   r(   r)   r*   r5   r+   r,   r-   r6   r$   r.   r%   r&   r/   r   r   r4   r4   f   s     &*D%

d
")'+FE$+:>M5**C/047>7;Je'',-4;CGE%"3"3S"89D@Gr   r4   c                   f     e Zd ZdZ fdZdej                  dz  deej                     fdZ	 xZ
S )DinatEmbeddingsz6
    Construct the patch and position embeddings.
    c                     t         |           t        |      | _        t	        j
                  |j                        | _        t	        j                  |j                        | _
        y r   )super__init__DinatPatchEmbeddingspatch_embeddingsr   	LayerNorm	embed_dimnormDropouthidden_dropout_probdropoutselfconfig	__class__s     r   r;   zDinatEmbeddings.__init__   sG     4V <LL!1!12	zz&"<"<=r   pixel_valuesNreturnc                 l    | j                  |      }| j                  |      }| j                  |      }|S r   )r=   r@   rC   )rE   rH   
embeddingss      r   forwardzDinatEmbeddings.forward   s4    **<8
YYz*
\\*-
r   )r'   r(   r)   r*   r;   r+   r,   r.   TensorrL   __classcell__rG   s   @r   r8   r8      s4    >E$5$5$< u||AT r   r8   c                   `     e Zd ZdZ fdZdej                  dz  dej                  fdZ xZ	S )r<   z
    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
    `hidden_states` (patch embeddings) of shape `(batch_size, height, width, hidden_size)` to be consumed by a
    Transformer.
    c           
      P   t         |           |j                  }|j                  |j                  }}|| _        |dk(  rnt        d      t        j                  t        j                  | j                  |dz  ddd      t        j                  |dz  |ddd            | _	        y )N   z2Dinat only supports patch size of 4 at the moment.   r   r   rS   rS   r   r   )kernel_sizestridepadding)
r:   r;   
patch_sizenum_channelsr?   
ValueErrorr   
SequentialConv2d
projection)rE   rF   rZ   r[   hidden_sizerG   s        r   r;   zDinatPatchEmbeddings.__init__   s    &&
$*$7$79I9Ik(? QRR--IId'')9vV\flmIIkQ&PV`fg
r   rH   NrI   c                     |j                   \  }}}}|| j                  k7  rt        d      | j                  |      }|j	                  dddd      }|S )NzeMake sure that the channel dimension of the pixel values match with the one set in the configuration.r   rS   r   r   )shaper[   r\   r_   permute)rE   rH   _r[   heightwidthrK   s          r   rL   zDinatPatchEmbeddings.forward   s`    )5););&<4,,,w  __\2
''1a3
r   )
r'   r(   r)   r*   r;   r+   r,   rM   rL   rN   rO   s   @r   r<   r<      s/    
"	E$5$5$< 	 	r   r<   c                        e Zd ZdZej
                  fdedej                  ddf fdZde	j                  de	j                  fdZ xZS )	DinatDownsamplerz
    Convolutional Downsampling Layer.

    Args:
        dim (`int`):
            Number of input channels.
        norm_layer (`nn.Module`, *optional*, defaults to `nn.LayerNorm`):
            Normalization layer class.
    dim
norm_layerrI   Nc                     t         |           || _        t        j                  |d|z  dddd      | _         |d|z        | _        y )NrS   rT   rU   rV   F)rW   rX   rY   bias)r:   r;   ri   r   r^   	reductionr@   )rE   ri   rj   rG   s      r   r;   zDinatDownsampler.__init__   sE    3CVF\binoq3w'	r   input_featurec                     | j                  |j                  dddd            j                  dddd      }| j                  |      }|S )Nr   r   r   rS   )rm   rc   r@   )rE   rn   s     r   rL   zDinatDownsampler.forward   sJ    }'<'<Q1a'HIQQRSUVXY[\]		-0r   )r'   r(   r)   r*   r   r>   intModuler;   r+   rM   rL   rN   rO   s   @r   rh   rh      sJ     :< (C (RYY ($ (U\\ ell r   rh   input	drop_probtrainingrI   c                    |dk(  s|s| S d|z
  }| j                   d   fd| j                  dz
  z  z   }|t        j                  || j                  | j
                        z   }|j                          | j                  |      |z  }|S )zc
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

            r   r   )r   )dtypedevice)rb   ndimr+   randrw   rx   floor_div)rr   rs   rt   	keep_probrb   random_tensoroutputs          r   	drop_pathr      s    
 CxII[[^

Q 77E

5ELL YYMYYy!M1FMr   c                   x     e Zd ZdZd	dedz  ddf fdZdej                  dej                  fdZde	fdZ
 xZS )
DinatDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nrs   rI   c                 0    t         |           || _        y r   )r:   r;   rs   )rE   rs   rG   s     r   r;   zDinatDropPath.__init__   s    "r   r$   c                 D    t        || j                  | j                        S r   )r   rs   rt   rE   r$   s     r   rL   zDinatDropPath.forward   s    FFr   c                      d| j                    S )Nzp=)rs   rE   s    r   
extra_reprzDinatDropPath.extra_repr   s    DNN#$$r   r   )r'   r(   r)   r*   floatr;   r+   rM   rL   strr   rN   rO   s   @r   r   r      sG    b#%$, #$ #GU\\ Gell G%C %r   r   c                   j     e Zd Z fdZ	 ddej
                  dedz  deej
                     fdZ xZ	S )NeighborhoodAttentionc                 *   t         |           ||z  dk7  rt        d| d| d      || _        t	        ||z        | _        | j                  | j
                  z  | _        || _        || _        t        j                  t        j                  |d| j                  z  dz
  d| j                  z  dz
              | _        t        j                  | j                  | j                  |j                        | _        t        j                  | j                  | j                  |j                        | _        t        j                  | j                  | j                  |j                        | _        t        j&                  |j(                        | _        y )Nr   zThe hidden size (z6) is not a multiple of the number of attention heads ()rS   r   )rl   )r:   r;   r\   num_attention_headsrp   attention_head_sizeall_head_sizerW   dilationr   	Parameterr+   zerosrpbLinearqkv_biasquerykeyvaluerA   attention_probs_dropout_probrC   rE   rF   ri   	num_headsrW   r   rG   s         r   r;   zNeighborhoodAttention.__init__   sD   ?a#C5(^_h^iijk  $- #&sY#7 !558P8PP&  <<ID<L<L8Lq8PTUX\XhXhThklTl noYYt1143E3EFOO\
99T//1C1C&//ZYYt1143E3EFOO\
zz&"E"EFr   r$   output_attentionsNrI   c                 p   |j                   d d }g |d| j                  }| j                  |      j                  |      j	                  dd      }| j                  |      j                  |      j	                  dd      }| j                  |      j                  |      j	                  dd      }|t        j                  | j                        z  }t        ||| j                  | j                  | j                        }t        j                  j                  |d      }	| j!                  |	      }	t#        |	|| j                  | j                        }
|
j%                  ddddd      j'                         }
|
j)                         d d | j*                  fz   }|
j                  |      }
|r|
|	f}|S |
f}|S )	Nr   rS   )ri   r   r   rR   )rb   r   r   view	transposer   r   mathsqrtr   r   rW   r   r   
functionalsoftmaxrC   r   rc   
contiguoussizer   )rE   r$   r   input_shapehidden_shapequery_layer	key_layervalue_layerattention_scoresattention_probscontext_layernew_context_layer_shapeoutputss                r   rL   zNeighborhoodAttention.forward  s   
 $))#2.CCbC$*B*BCjj/44\BLLQPQRHH]+00>HHAN	jj/44\BLLQPQR
 "DIId.F.F$GG )i4K[K[]a]j]jk --//0@b/I ,,7"?KAQAQSWS`S`a%--aAq!<GGI"/"4"4"6s";t?Q?Q>S"S%**+BC6G=/2 O\M]r   F
r'   r(   r)   r;   r+   rM   boolr.   rL   rN   rO   s   @r   r   r      s@    G2 */!||!  $;! 
u||		!r   r   c                   n     e Zd Z fdZdej
                  dej
                  dej
                  fdZ xZS )NeighborhoodAttentionOutputc                     t         |           t        j                  ||      | _        t        j
                  |j                        | _        y r   )r:   r;   r   r   denserA   r   rC   rE   rF   ri   rG   s      r   r;   z$NeighborhoodAttentionOutput.__init__-  s6    YYsC(
zz&"E"EFr   r$   input_tensorrI   c                 J    | j                  |      }| j                  |      }|S r   r   rC   )rE   r$   r   s      r   rL   z#NeighborhoodAttentionOutput.forward2  s$    

=1]3r   r'   r(   r)   r;   r+   rM   rL   rN   rO   s   @r   r   r   ,  s2    G
U\\  RWR^R^ r   r   c                   j     e Zd Z fdZ	 ddej
                  dedz  deej
                     fdZ xZ	S )NeighborhoodAttentionModulec                 l    t         |           t        |||||      | _        t	        ||      | _        y r   )r:   r;   r   rE   r   r   r   s         r   r;   z$NeighborhoodAttentionModule.__init__:  s0    )&#y+xX	1&#>r   r$   r   NrI   c                 f    | j                  ||      }| j                  |d   |      }|f|dd  z   }|S Nr   r   )rE   r   )rE   r$   r   self_outputsattention_outputr   s         r   rL   z#NeighborhoodAttentionModule.forward?  sC    
 yy0AB;;|AF#%QR(88r   r   r   rO   s   @r   r   r   9  s?    ? */||  $; 
u||		r   r   c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )DinatIntermediatec                    t         |           t        j                  |t	        |j
                  |z              | _        t        |j                  t              rt        |j                     | _        y |j                  | _        y r   )r:   r;   r   r   rp   	mlp_ratior   
isinstance
hidden_actr   r   intermediate_act_fnr   s      r   r;   zDinatIntermediate.__init__K  sa    YYsC(8(83(>$?@
f''-'-f.?.?'@D$'-'8'8D$r   r$   rI   c                 J    | j                  |      }| j                  |      }|S r   )r   r   r   s     r   rL   zDinatIntermediate.forwardS  s&    

=100?r   r   rO   s   @r   r   r   J  s#    9U\\ ell r   r   c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )DinatOutputc                     t         |           t        j                  t	        |j
                  |z        |      | _        t        j                  |j                        | _	        y r   )
r:   r;   r   r   rp   r   r   rA   rB   rC   r   s      r   r;   zDinatOutput.__init__Z  sF    YYs6#3#3c#9:C@
zz&"<"<=r   r$   rI   c                 J    | j                  |      }| j                  |      }|S r   r   r   s     r   rL   zDinatOutput.forward_  s$    

=1]3r   r   rO   s   @r   r   r   Y  s#    >
U\\ ell r   r   c            	            e Zd Zd fd	Zd Z	 d	dej                  dedz  deej                  ej                  f   fdZ	 xZ
S )

DinatLayerc                    t         |           |j                  | _        |j                  | _        || _        | j                  | j                  z  | _        t        j                  ||j                        | _	        t        |||| j                  | j                        | _        |dkD  rt        |      nt        j                         | _        t        j                  ||j                        | _        t!        ||      | _        t%        ||      | _        |j(                  dkD  r?t        j*                  |j(                  t-        j.                  d|f      z  d      | _        y d | _        y )Neps)rW   r   rv   r   rS   T)requires_grad)r:   r;   chunk_size_feed_forwardrW   r   window_sizer   r>   layer_norm_epslayernorm_beforer   	attentionr   Identityr   layernorm_afterr   intermediater   r   layer_scale_init_valuer   r+   oneslayer_scale_parameters)rE   rF   ri   r   r   drop_path_raterG   s         r   r;   zDinatLayer.__init__f  s(   '-'E'E$!-- ++dmm; "Sf6K6K L4C0@0@4==
 ;I3:N~6TVT_T_Ta!||CV5J5JK-fc:!&#. ,,q0 LL66QH9MM]ab 	#  	#r   c                     | j                   }d}||k  s||k  rJdx}}t        d||z
        }t        d||z
        }	dd||||	f}t        j                  j	                  ||      }||fS )N)r   r   r   r   r   r   r   )r   maxr   r   pad)
rE   r$   re   rf   r   
pad_valuespad_lpad_tpad_rpad_bs
             r   	maybe_padzDinatLayer.maybe_padz  s    &&'
K5;#6EE;./E;/0EQueU;JMM--mZHMj((r   r$   r   NrI   c                    |j                         \  }}}}|}| j                  |      }| j                  |||      \  }}|j                  \  }	}
}}	| j	                  ||      }|d   }|d   dkD  xs |d   dkD  }|r|d d d |d |d d f   j                         }| j                  | j                  d   |z  }|| j                  |      z   }| j                  |      }| j                  | j                  |            }| j                  | j                  d   |z  }|| j                  |      z   }|r	||d   f}|S |f}|S )N)r   r   r      r   )r   r   r   rb   r   r   r   r   r   r   r   )rE   r$   r   
batch_sizere   rf   channelsshortcutr   rd   
height_pad	width_padattention_outputsr   
was_paddedlayer_outputlayer_outputss                    r   rL   zDinatLayer.forward  s|   
 /<.@.@.B+
FE8 --m<$(NN=&%$P!z&3&9&9#:y! NN=L]N^,Q/]Q&;*Q-!*;
/7F7FUFA0EFQQS&&2#::1=@PP 4>>2B#CC++M:{{4#4#4\#BC&&266q9LHL$t~~l'CC@Q'8';< YeWfr   )rv   r   )r'   r(   r)   r;   r   r+   rM   r   r.   rL   rN   rO   s   @r   r   r   e  sM    
(	) */$||$  $;$ 
u||U\\)	*	$r   r   c                   j     e Zd Z fdZ	 ddej
                  dedz  deej
                     fdZ xZ	S )
DinatStagec                 <   t         	|           || _        || _        t	        j
                  t        |      D cg c]  }t        |||||   ||          c}      | _        |% ||t        j                        | _
        d| _        y d | _
        d| _        y c c}w )N)rF   ri   r   r   r   )ri   rj   F)r:   r;   rF   ri   r   
ModuleListranger   layersr>   
downsamplepointing)
rE   rF   ri   depthr   	dilationsr   r   irG   s
            r   r;   zDinatStage.__init__  s    mm u	  !'&q\#1!#4	
 !(SR\\JDO  #DO%	s   Br$   r   NrI   c                     |j                         \  }}}}t        | j                        D ]  \  }} |||      }|d   } |}	| j                  | j                  |	      }||	f}
|r|
dd  z  }
|
S r   )r   	enumerater   r   )rE   r$   r   rd   re   rf   r  layer_moduler   !hidden_states_before_downsamplingstage_outputss              r   rL   zDinatStage.forward  s    
 ,00265!(5 	-OA|(8IJM)!,M	- -:)??& OO,MNM&(IJ]12..Mr   r   r   rO   s   @r   r   r     s?    8 */||  $; 
u||		r   r   c                   z     e Zd Z fdZ	 	 	 	 d
dej
                  dedz  dedz  dedz  dedz  deez  fd	Z	 xZ
S )DinatEncoderc                    t         |           t        |j                        | _        || _        t        j                  d|j                  t        |j                        d      D cg c]  }|j                          }}t        j                  t        | j                        D cg c]  }t        |t        |j                   d|z  z        |j                  |   |j"                  |   |j$                  |   |t        |j                  d |       t        |j                  d |dz           || j                  dz
  k  rt&        nd        c}      | _        y c c}w c c}w )Nr   cpu)rx   rS   r   )rF   ri   r  r   r  r   r   )r:   r;   lendepths
num_levelsrF   r+   linspacer   sumitemr   r   r   r   rp   r?   r   r  rh   levels)rE   rF   xdpri_layerrG   s        r   r;   zDinatEncoder.__init__  s,   fmm,!&63H3H#fmmJ\ej!klAqvvxllmm  %T__5  !F,,q'z9: --0$..w7$..w7#&s6=='+B'Cc&--XeZadeZeJfFg#h4;dooPQ>Q4Q/X\
 ms   )E(B#Er$   r   Noutput_hidden_states(output_hidden_states_before_downsamplingreturn_dictrI   c                    |rdnd }|rdnd }|rdnd }|r |j                  dddd      }	||fz  }||	fz  }t        | j                        D ]l  \  }
} |||      }|d   }|d   }|r#|r!|j                  dddd      }	||fz  }||	fz  }n$|r"|s |j                  dddd      }	||fz  }||	fz  }|se||dd  z  }n |st        d |||fD              S t	        ||||      S )Nr/   r   r   r   rS   c              3   &   K   | ]	  }||  y wr   r/   ).0vs     r   	<genexpr>z'DinatEncoder.forward.<locals>.<genexpr>  s     mq_`_lms   )r#   r$   r%   r&   )rc   r  r  r.   r"   )rE   r$   r   r  r  r  all_hidden_statesall_reshaped_hidden_statesall_self_attentionsreshaped_hidden_stater  r  r   r  s                 r   rL   zDinatEncoder.forward  s]    #7BD+?RT"$5b4$1$9$9!Q1$E!-!11&+@*BB&(5 	9OA|(8IJM)!,M0=a0@-#(P(I(Q(QRSUVXY[\(]%!&G%II!*/D.FF*%.V(5(=(=aAq(I%!m%55!*/D.FF* #}QR'88#%	9( m]4EGZ$[mmm!++*#=	
 	
r   )FFFT)r'   r(   r)   r;   r+   rM   r   r.   r"   rL   rN   rO   s   @r   r
  r
    so    
. */,1@E#'.
||.
  $;.
 #Tk	.

 37+.
 D[.
 
#	#.
r   r
  c                   $    e Zd ZU eed<   dZdZdZy)DinatPreTrainedModelrF   dinatrH   )imageN)r'   r(   r)   r   r-   base_model_prefixmain_input_nameinput_modalitiesr/   r   r   r$  r$  !  s    $O!r   r$  c                        e Zd Zd
 fd	Zd Ze	 	 	 	 ddej                  dz  dedz  dedz  dedz  de	e
z  f
d	       Z xZS )
DinatModelc                    t         |   |       t        | dg       || _        t	        |j
                        | _        t        |j                  d| j                  dz
  z  z        | _	        t        |      | _        t        |      | _        t        j                  | j                  |j                         | _        |rt        j$                  d      nd| _        | j)                          y)zv
        add_pooling_layer (bool, *optional*, defaults to `True`):
            Whether to add a pooling layer
        nattenrS   r   r   N)r:   r;   r   rF   r  r  r  rp   r?   num_featuresr8   rK   r
  encoderr   r>   r   	layernormAdaptiveAvgPool1dpooler	post_init)rE   rF   add_pooling_layerrG   s      r   r;   zDinatModel.__init__+  s    
 	 $
+fmm, 0 0119L3M MN)&1#F+d&7&7V=R=RS1Bb**1- 	r   c                 .    | j                   j                  S r   rK   r=   r   s    r   get_input_embeddingszDinatModel.get_input_embeddingsA      ///r   NrH   r   r  r  rI   c                 R   ||n| j                   j                  }||n| j                   j                  }||n| j                   j                  }|t	        d      | j                  |      }| j                  ||||      }|d   }| j                  |      }d }	| j                  G| j                  |j                  dd      j                  dd            }	t        j                  |	d      }	|s||	f|dd  z   }
|
S t        ||	|j                  |j                  |j                        S )Nz You have to specify pixel_valuesr   r  r  r   r   rS   )r#   r2   r$   r%   r&   )rF   r   r  r  r\   rK   r/  r0  r2  flattenr   r+   r1   r$   r%   r&   )rE   rH   r   r  r  r   embedding_outputencoder_outputssequence_outputpooled_outputr   s              r   rL   zDinatModel.forwardD  sA    2C1N-TXT_T_TqTq$8$D $++JjJj 	 &1%<k$++BYBY?@@??<8,,/!5#	 ' 
 *!,..9;;" KK(?(?1(E(O(OPQST(UVM!MM-;M%}58KKFM-')77&11#2#I#I
 	
r   )T)NNNN)r'   r(   r)   r;   r7  r   r+   r,   r   r.   r1   rL   rN   rO   s   @r   r+  r+  )  s|    ,0  26)-,0#'-
''$.-
  $;-
 #Tk	-

 D[-
 
!	!-
 -
r   r+  z
    Dinat Model transformer with an image classification head on top (a linear layer on top of the final hidden state
    of the [CLS] token) e.g. for ImageNet.
    c                        e Zd Z fdZe	 	 	 	 	 d
dej                  dz  dej                  dz  dedz  dedz  dedz  de	e
z  fd	       Z xZS )DinatForImageClassificationc                 X   t         |   |       t        | dg       |j                  | _        t	        |      | _        |j                  dkD  r4t        j                  | j
                  j                  |j                        nt        j                         | _
        | j                          y )Nr-  r   )r:   r;   r   
num_labelsr+  r%  r   r   r.  r   
classifierr3  rD   s     r   r;   z$DinatForImageClassification.__init__|  s     $
+ ++'
 FLEVEVYZEZBIIdjj--v/@/@A`b`k`k`m 	
 	r   NrH   labelsr   r  r  rI   c                 T   ||n| j                   j                  }| j                  ||||      }|d   }| j                  |      }	d}
|| j	                  ||	| j                         }
|s|	f|dd z   }|
|
f|z   S |S t        |
|	|j                  |j                  |j                        S )a  
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
        Nr:  r   rS   )r5   r6   r$   r%   r&   )	rF   r  r%  rD  loss_functionr4   r$   r%   r&   )rE   rH   rE  r   r  r  r   r   r?  r6   r5   r   s               r   rL   z#DinatForImageClassification.forward  s      &1%<k$++BYBY**/!5#	  
  
/%%ffdkkBDY,F)-)9TGf$EvE)!//))#*#A#A
 	
r   )NNNNN)r'   r(   r)   r;   r   r+   r,   
LongTensorr   r.   r4   rL   rN   rO   s   @r   rA  rA  u  s       26*.)-,0#'*
''$.*
   4'*
  $;	*

 #Tk*
 D[*
 
+	+*
 *
r   rA  zL
    NAT backbone, to be used with frameworks like DETR and MaskFormer.
    c                        e Zd Z fdZd Zeee	 	 	 d
dej                  de
dz  de
dz  de
dz  def
d	                     Z xZS )DinatBackbonec           	         t         |   |       t        | dg       t        |      | _        t        |      | _        |j                  gt        t        |j                              D cg c]  }t        |j                  d|z  z         c}z   | _        i }t        | j                  | j                        D ]  \  }}t!        j"                  |      ||<    t!        j$                  |      | _        | j)                          y c c}w )Nr-  rS   )r:   r;   r   r8   rK   r
  r/  r?   r   r  r  rp   r.  zipout_featuresr   r   r>   
ModuleDicthidden_states_normsr3  )rE   rF   r  rO  stager[   rG   s         r   r;   zDinatBackbone.__init__  s     $
+)&1#F+#--.X]^abhbobo^pXq1rST#f6F6FA6M2N1rr !#&t'8'8$--#H 	DE<)+l)C&	D#%==1D#E  	 2ss   *"Dc                 .    | j                   j                  S r   r6  r   s    r   r7  z"DinatBackbone.get_input_embeddings  r8  r   NrH   r  r   r  rI   c                    ||n| j                   j                  }||n| j                   j                  }||n| j                   j                  }| j	                  |      }| j                  ||ddd      }|j                  }d}	t        | j                  |      D ]  \  }
}|
| j                  v s|j                  \  }}}}|j                  dddd      j                         }|j                  |||z  |      } | j                  |
   |      }|j                  ||||      }|j                  dddd      j                         }|	|fz  }	 |s|	f}|r||j                  fz  }|S t!        |	|r|j                  nd|j"                  	      S )
a  
        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, AutoBackbone
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> processor = AutoImageProcessor.from_pretrained("shi-labs/nat-mini-in1k-224")
        >>> model = AutoBackbone.from_pretrained(
        ...     "shi-labs/nat-mini-in1k-224", out_features=["stage1", "stage2", "stage3", "stage4"]
        ... )

        >>> inputs = processor(image, return_tensors="pt")

        >>> outputs = model(**inputs)

        >>> feature_maps = outputs.feature_maps
        >>> list(feature_maps[-1].shape)
        [1, 512, 7, 7]
        ```NT)r   r  r  r  r/   r   rS   r   r   )feature_mapsr$   r%   )rF   r  r  r   rK   r/  r&   rL  stage_namesrM  rb   rc   r   r   rO  r$   r	   r%   )rE   rH   r  r   r  r   r<  r   r$   rS  rP  hidden_stater   r[   re   rf   r   s                    r   rL   zDinatBackbone.forward  s   L &1%<k$++BYBY$8$D $++JjJj 	 2C1N-TXT_T_TqTq??<8,,/!%59  
  66#&t'7'7#G 	0E<))):F:L:L7
L&%+33Aq!Q?JJL+00Ve^\Z>t77>|L+00VULY+33Aq!Q?JJL/	0 "_F#70022M%3G'//T))
 	
r   )NNN)r'   r(   r)   r;   r7  r   r   r   r+   rM   r   r	   rL   rN   rO   s   @r   rJ  rJ    s    $0   -1)-#'J
llJ
 #TkJ
  $;	J

 D[J
 
J
  ! J
r   rJ  )rA  r+  r$  rJ  )rv   F)9r*   r   dataclassesr   r+   r   activationsr   backbone_utilsr   r   modeling_outputsr	   modeling_utilsr
   utilsr   r   r   r   r   r   utils.genericr   configuration_dinatr   natten.functionalr   r   
get_loggerr'   loggerr"   r1   r4   rq   r8   r<   rh   rM   r   r   r   r   r   r   r   r   r   r   r   r
  r$  r+  rA  rJ  __all__r/   r   r   <module>rb     s|   @  !   ! H . -  . , ;;// 
		H	% 
H H H  
H{ H H& 
H H H*bii ,!299 !Hryy 0U\\ e T V[VbVb  %BII %8BII 8v
")) 
")) "		 	")) 	D DN, ,^C
299 C
L "? " " H
% H
 H
V <
"6 <
<
~ 
c
M#7 c

c
L ar   