
    Phb                     N   d Z ddlZddlmZ ddlmZmZ ddlZddlmZ ddl	m
Z
mZmZmZ ddlmZ dd	lmZmZ d
dlmZ  ej*                  e      Ze ed       G d de                    Z G d dej2                        Z G d dej2                        Z G d dej2                        Z G d dej2                        Z G d dej2                        Z G d dej2                        Z G d dej2                        Z  G d dej2                        Z! G d  d!ej2                        Z" G d" d#ej2                        Z# G d$ d%ej2                        Z$e G d& d'e             Z%e G d( d)e%             Z& ed*       G d+ d,e%             Z' ed-       G d. d/e%             Z(g d0Z)y)1zPyTorch LeViT model.    N)	dataclass)OptionalUnion)nn   )BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttentionModelOutput)PreTrainedModel)auto_docstringlogging   )LevitConfigzD
    Output type of [`LevitForImageClassificationWithTeacher`].
    )custom_introc                       e Zd ZU dZdZeej                     ed<   dZ	eej                     ed<   dZ
eej                     ed<   dZeeej                        ed<   y),LevitForImageClassificationWithTeacherOutputan  
    logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
        Prediction scores as the average of the `cls_logits` and `distillation_logits`.
    cls_logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
        Prediction scores of the classification head (i.e. the linear layer on top of the final hidden state of the
        class token).
    distillation_logits (`torch.FloatTensor` of shape `(batch_size, config.num_labels)`):
        Prediction scores of the distillation head (i.e. the linear layer on top of the final hidden state of the
        distillation token).
    Nlogits
cls_logitsdistillation_logitshidden_states)__name__
__module____qualname____doc__r   r   torchFloatTensor__annotations__r   r   r   tuple     b/var/www/html/saasai/venv/lib/python3.12/site-packages/transformers/models/levit/modeling_levit.pyr   r   &   sc    	 +/FHU&&'..2J**+27;%"3"34;8<M8E%"3"345<r!   r   c                   ,     e Zd ZdZ	 d fd	Zd Z xZS )LevitConvEmbeddingsz[
    LeViT Conv Embeddings with Batch Norm, used in the initial patch embedding layer.
    c	           
          t         	|           t        j                  |||||||d      | _        t        j
                  |      | _        y )NF)dilationgroupsbias)super__init__r   Conv2dconvolutionBatchNorm2d
batch_norm)
selfin_channelsout_channelskernel_sizestridepaddingr&   r'   bn_weight_init	__class__s
            r"   r*   zLevitConvEmbeddings.__init__C   sF     	99{FGh_elq
 ..6r!   c                 J    | j                  |      }| j                  |      }|S N)r,   r.   )r/   
embeddingss     r"   forwardzLevitConvEmbeddings.forwardL   s&    %%j1
__Z0
r!   )r   r   r   r   r   r   r   r*   r:   __classcell__r6   s   @r"   r$   r$   >   s    
 mn7r!   r$   c                   (     e Zd ZdZ fdZd Z xZS )LevitPatchEmbeddingsz
    LeViT patch embeddings, for final embeddings to be passed to transformer blocks. It consists of multiple
    `LevitConvEmbeddings`.
    c                 X   t         |           t        |j                  |j                  d   dz  |j
                  |j                  |j                        | _        t        j                         | _        t        |j                  d   dz  |j                  d   dz  |j
                  |j                  |j                        | _        t        j                         | _        t        |j                  d   dz  |j                  d   dz  |j
                  |j                  |j                        | _        t        j                         | _        t        |j                  d   dz  |j                  d   |j
                  |j                  |j                        | _        |j                  | _        y )Nr            )r)   r*   r$   num_channelshidden_sizesr2   r3   r4   embedding_layer_1r   	Hardswishactivation_layer_1embedding_layer_2activation_layer_2embedding_layer_3activation_layer_3embedding_layer_4r/   configr6   s     r"   r*   zLevitPatchEmbeddings.__init__X   so   !4!4!4Q!71!<f>P>PRXR_R_agaoao"
 #%,,.!4"a')<)<Q)?1)DfFXFXZ`ZgZgioiwiw"
 #%,,.!4"a')<)<Q)?1)DfFXFXZ`ZgZgioiwiw"
 #%,,.!4"a')<)<Q)?ASASU[UbUbdjdrdr"
 #//r!   c                    |j                   d   }|| j                  k7  rt        d      | j                  |      }| j	                  |      }| j                  |      }| j                  |      }| j                  |      }| j                  |      }| j                  |      }|j                  d      j                  dd      S )Nr   zeMake sure that the channel dimension of the pixel values match with the one set in the configuration.rC   )shaperD   
ValueErrorrF   rH   rI   rJ   rK   rL   rM   flatten	transpose)r/   pixel_valuesrD   r9   s       r"   r:   zLevitPatchEmbeddings.forwardn   s    #))!,4,,,w  ++L9
,,Z8
++J7
,,Z8
++J7
,,Z8
++J7
!!!$..q!44r!   r;   r=   s   @r"   r?   r?   R   s    
0,5r!   r?   c                   &     e Zd Zd fd	Zd Z xZS )MLPLayerWithBNc                     t         |           t        j                  ||d      | _        t        j
                  |      | _        y )NF)in_featuresout_featuresr(   )r)   r*   r   LinearlinearBatchNorm1dr.   )r/   	input_dim
output_dimr5   r6   s       r"   r*   zMLPLayerWithBN.__init__   s3    iiIJUZ[..4r!   c                     | j                  |      }| j                  |j                  dd            j                  |      }|S )Nr   r   )r\   r.   rS   
reshape_asr/   hidden_states     r"   r:   zMLPLayerWithBN.forward   s<    {{<0|';';Aq'ABMMl[r!   )r   r   r   r   r*   r:   r<   r=   s   @r"   rW   rW   ~   s    5
r!   rW   c                   $     e Zd Z fdZd Z xZS )LevitSubsamplec                 >    t         |           || _        || _        y r8   )r)   r*   r3   
resolution)r/   r3   rh   r6   s      r"   r*   zLevitSubsample.__init__   s    $r!   c                     |j                   \  }}}|j                  || j                  | j                  |      d d d d | j                  d d | j                  f   j	                  |d|      }|S )N)rQ   viewrh   r3   reshape)r/   rc   
batch_size_channelss        r"   r:   zLevitSubsample.forward   sk    "."4"4
Ax#((T__dooW_`~$++~~$++~-

'*b(
+ 	 r!   rd   r=   s   @r"   rf   rf      s    %
r!   rf   c                   ^     e Zd Z fdZ ej
                         d fd	       Zd Zd Z xZ	S )LevitAttentionc                 ~   t         |           || _        |dz  | _        || _        || _        ||z  |z  ||z  dz  z   | _        ||z  |z  | _        t        || j                        | _	        t        j                         | _        t        | j                  |d      | _        t        t        j                   t#        |      t#        |                  }t%        |      }i g }	}|D ]W  }
|D ]P  }t'        |
d   |d   z
        t'        |
d   |d   z
        f}||vrt%        |      ||<   |	j)                  ||          R Y i | _        t,        j                  j/                  t-        j0                  |t%        |                  | _        | j5                  dt-        j6                  |	      j9                  ||      d       y )	N      rC   r   )r5   r   attention_bias_idxsF
persistent)r)   r*   num_attention_headsscalekey_dimattention_ratioout_dim_keys_valuesout_dim_projectionrW   queries_keys_valuesr   rG   
activation
projectionlist	itertoolsproductrangelenabsappendattention_bias_cacher   	Parameterzerosattention_biasesregister_buffer
LongTensorrk   )r/   rE   ry   rw   rz   rh   points
len_pointsattention_offsetsindicesp1p2offsetr6   s                r"   r*   zLevitAttention.__init__   s   #6 d]
.#2W#<?R#RU\_rUruvUv#v "1G";>Q"Q#1,@X@X#Y ,,.()@)@,_`ai''j(95;LMN[
%'7Bbebem,c"Q%"Q%-.@A!22034E0F%f-089	   %'! % 2 25;;?RTWXiTj3k l!5#3#3G#<#A#A*j#Yfk 	 	
r!   c                 R    t         |   |       |r| j                  ri | _        y y y r8   r)   trainr   r/   moder6   s     r"   r   zLevitAttention.train   )    dD--(*D% .4r!   c                     | j                   r| j                  d d | j                  f   S t        |      }|| j                  vr*| j                  d d | j                  f   | j                  |<   | j                  |   S r8   trainingr   rt   strr   r/   device
device_keys      r"   get_attention_biasesz#LevitAttention.get_attention_biases   t    ==((D,D,D)DEEVJ!:!::8<8M8MaQUQiQiNi8j))*5,,Z88r!   c                    |j                   \  }}}| j                  |      }|j                  ||| j                  d      j	                  | j
                  | j
                  | j                  | j
                  z  gd      \  }}}|j                  dddd      }|j                  dddd      }|j                  dddd      }||j                  dd      z  | j                  z  | j                  |j                        z   }	|	j                  d      }	|	|z  j                  dd      j                  ||| j                        }| j                  | j!                  |            }|S Nrj   r   dimr   rC   r   )rQ   r}   rk   rw   splitry   rz   permuterT   rx   r   r   softmaxrl   r|   r   r~   )
r/   rc   rm   
seq_lengthrn   r}   querykeyvalue	attentions
             r"   r:   zLevitAttention.forward   sN   $0$6$6!
J"66|D/44ZTMeMegijpp\\4<<)=)=)LMST q 
sE aAq)kk!Q1%aAq)CMM"b11DJJ>AZAZ[g[n[nAoo	%%"%-	!E)44Q:BB:z[_[r[rst|'DEr!   T
r   r   r   r*   r   no_gradr   r   r:   r<   r=   s   @r"   rq   rq      s.    
: U]]_+ +
9r!   rq   c                   ^     e Zd Z fdZ ej
                         d fd	       Zd Zd Z xZ	S )LevitAttentionSubsamplec	                 x   t         |           || _        |dz  | _        || _        || _        ||z  |z  ||z  z   | _        ||z  |z  | _        || _        t        || j                        | _
        t        ||      | _        t        |||z        | _        t        j                         | _        t        | j                  |      | _        i | _        t'        t)        j*                  t-        |      t-        |                  }	t'        t)        j*                  t-        |      t-        |                  }
t/        |	      t/        |
      }}i g }}|
D ]q  }|	D ]j  }d}t1        |d   |z  |d   z
  |dz
  dz  z         t1        |d   |z  |d   z
  |dz
  dz  z         f}||vrt/        |      ||<   |j3                  ||          l s t4        j                  j7                  t5        j8                  |t/        |                  | _        | j=                  dt5        j>                  |      jA                  ||      d       y )Nrs   r   r   rC   rt   Fru   )!r)   r*   rw   rx   ry   rz   r{   r|   resolution_outrW   keys_valuesrf   queries_subsamplequeriesr   rG   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rk   )r/   r^   r_   ry   rw   rz   r3   resolution_inr   r   points_r   len_points_r   r   r   r   sizer   r6   s                      r"   r*   z LevitAttentionSubsample.__init__   s'    	#6 d]
.#2W#<?R#RU\_rUr#r "1G";>Q"Q,))T5M5MN!/!F%i;N1NO,,.()@)@*M$&!i''m(<eM>RSTy((~)>n@UVW"%f+s7|K
%'7Bbefnr!u4qA~EFBqETZN]_`a]bLbfjmnfnrsesLsHtu!22034E0F%f-089   !& 2 25;;?RTWXiTj3k l!5#3#3G#<#A#A+z#Zgl 	 	
r!   c                 R    t         |   |       |r| j                  ri | _        y y y r8   r   r   s     r"   r   zLevitAttentionSubsample.train  r   r!   c                     | j                   r| j                  d d | j                  f   S t        |      }|| j                  vr*| j                  d d | j                  f   | j                  |<   | j                  |   S r8   r   r   s      r"   r   z,LevitAttentionSubsample.get_attention_biases
  r   r!   c                 L   |j                   \  }}}| j                  |      j                  ||| j                  d      j	                  | j
                  | j                  | j
                  z  gd      \  }}|j                  dddd      }|j                  dddd      }| j                  | j                  |            }|j                  || j                  dz  | j                  | j
                        j                  dddd      }||j                  dd      z  | j                  z  | j                  |j                        z   }|j                  d      }||z  j                  dd      j!                  |d| j"                        }| j%                  | j'                  |            }|S r   )rQ   r   rk   rw   r   ry   rz   r   r   r   r   rT   rx   r   r   r   rl   r|   r   r~   )	r/   rc   rm   r   rn   r   r   r   r   s	            r"   r:   zLevitAttentionSubsample.forward  s~   $0$6$6!
J\*T*j$*B*BBGUDLL$"6"6"EFAUN 	U
 kk!Q1%aAq)T33LAB

:t':':A'=t?W?WY]YeYefnnq!Q
 CMM"b11DJJ>AZAZ[g[n[nAoo	%%"%-	!E)44Q:BB:rSWSjSjkt|'DEr!   r   r   r=   s   @r"   r   r      s/    +
Z U]]_+ +
9r!   r   c                   (     e Zd ZdZ fdZd Z xZS )LevitMLPLayerzE
    MLP Layer with `2X` expansion in contrast to ViT with `4X`.
    c                     t         |           t        ||      | _        t	        j
                         | _        t        ||      | _        y r8   )r)   r*   rW   	linear_upr   rG   r~   linear_down)r/   r^   
hidden_dimr6   s      r"   r*   zLevitMLPLayer.__init__.  s8    '	:>,,.)*i@r!   c                 l    | j                  |      }| j                  |      }| j                  |      }|S r8   )r   r~   r   rb   s     r"   r:   zLevitMLPLayer.forward4  s4    ~~l3|4''5r!   r;   r=   s   @r"   r   r   )  s    Ar!   r   c                   (     e Zd ZdZ fdZd Z xZS )LevitResidualLayerz"
    Residual Block for LeViT
    c                 >    t         |           || _        || _        y r8   )r)   r*   module	drop_rate)r/   r   r   r6   s      r"   r*   zLevitResidualLayer.__init__@  s    "r!   c                    | j                   r| j                  dkD  rt        j                  |j	                  d      dd|j
                        }|j                  | j                        j                  d| j                  z
        j                         }|| j                  |      |z  z   }|S || j                  |      z   }|S )Nr   r   )r   )
r   r   r   randr   r   ge_divdetachr   )r/   rc   rnds      r"   r:   zLevitResidualLayer.forwardE  s    ==T^^a/**\..q11a@S@STC''$..)--a$...@AHHJC'$++l*Cc*IIL'$++l*CCLr!   r;   r=   s   @r"   r   r   ;  s    #
 r!   r   c                   .     e Zd ZdZ fdZd Zd Z xZS )
LevitStagezP
    LeViT Stage consisting of `LevitMLPLayer` and `LevitAttention` layers.
    c                 
   t         |           g | _        || _        |
| _        t        |      D ]  }| j                  j                  t        t        |||||
      | j                  j                               |dkD  sO||z  }| j                  j                  t        t        ||      | j                  j                                |	d   dk(  r| j                  dz
  |	d   z  dz   | _        | j                  j                  t        | j                  j                  ||dz    |	d   |	d   |	d   |	d   |
| j                  d       | j                  | _        |	d   dkD  r| j                  j                  |dz      |	d   z  }| j                  j                  t        t        | j                  j                  |dz      |      | j                  j                               t        j                  | j                        | _        y )	Nr   	Subsampler      rC   r   )ry   rw   rz   r3   r   r   rB   )r)   r*   layersrO   r   r   r   r   rq   drop_path_rater   r   r   rE   r   
ModuleList)r/   rO   idxrE   ry   depthsrw   rz   	mlp_ratiodown_opsr   rn   r   r6   s                r"   r*   zLevitStage.__init__U  s    	*vAKK""<:M`mnKK.. 1})I5
""&}\:'NPTP[P[PjPjk  A;+%#'#5#5#9hqk"IA"MDKK'[[--cC!G<$QK(0$,QK#A;"/#'#6#6
 "&!4!4D{Q![[55cAg>!L
""&%dkk&>&>sQw&GTVZVaVaVpVp mmDKK0r!   c                     | j                   S r8   )r   )r/   s    r"   get_resolutionzLevitStage.get_resolution  s    !!!r!   c                 8    | j                   D ]
  } ||      } |S r8   )r   )r/   rc   layers      r"   r:   zLevitStage.forward  s     [[E .L !r!   )r   r   r   r   r*   r   r:   r<   r=   s   @r"   r   r   P  s    51n"r!   r   c                   *     e Zd ZdZ fdZddZ xZS )LevitEncoderzC
    LeViT Encoder consisting of multiple `LevitStage` stages.
    c                    t         |           || _        | j                  j                  | j                  j                  z  }g | _        | j                  j                  j                  dg       t        t        |j                              D ]  }t        |||j                  |   |j                  |   |j                  |   |j                  |   |j                  |   |j                   |   |j                  |   |
      }|j#                         }| j
                  j                  |        t%        j&                  | j
                        | _        y )N )r)   r*   rO   
image_size
patch_sizestagesr   r   r   r   r   r   rE   ry   rw   rz   r   r   r   r   )r/   rO   rh   	stage_idxstager6   s        r"   r*   zLevitEncoder.__init__  s   [[++t{{/E/EE
##RD)s6==12I##I.y)i(**95&&y1  +	*E --/JKKu% 3  mmDKK0r!   c                     |rdnd }| j                   D ]  }|r||fz   } ||      } |r||fz   }|st        d ||fD              S t        ||      S )Nr    c              3   &   K   | ]	  }||  y wr8   r    ).0vs     r"   	<genexpr>z'LevitEncoder.forward.<locals>.<genexpr>  s     W$Eq$Es   )last_hidden_stater   )r   r   r   )r/   rc   output_hidden_statesreturn_dictall_hidden_statesr   s         r"   r:   zLevitEncoder.forward  sn    "6BD[[E#$5$G! .L !
   1\O CW\3D$EWWW-\mnnr!   )FTr;   r=   s   @r"   r   r     s    12or!   r   c                   (     e Zd ZdZ fdZd Z xZS )LevitClassificationLayerz$
    LeViT Classification Layer
    c                     t         |           t        j                  |      | _        t        j
                  ||      | _        y r8   )r)   r*   r   r]   r.   r[   r\   )r/   r^   r_   r6   s      r"   r*   z!LevitClassificationLayer.__init__  s0    ..3ii	:6r!   c                 J    | j                  |      }| j                  |      }|S r8   )r.   r\   )r/   rc   r   s      r"   r:   z LevitClassificationLayer.forward  s#    |4\*r!   r;   r=   s   @r"   r   r     s    7
r!   r   c                   ,    e Zd ZU eed<   dZdZdgZd Zy)LevitPreTrainedModelrO   levitrU   r   c                    t        |t        j                  t        j                  f      rm|j                  j
                  j                  d| j                  j                         |j                  %|j                  j
                  j                          yyt        |t        j                  t        j                  f      rJ|j                  j
                  j                          |j                  j
                  j                  d       yy)zInitialize the weightsg        )meanstdNg      ?)
isinstancer   r[   r+   weightdatanormal_rO   initializer_ranger(   zero_r]   r-   fill_)r/   r   s     r"   _init_weightsz"LevitPreTrainedModel._init_weights  s    fryy"))45 MM&&CT[[5R5R&S{{&  &&( ' @AKK""$MM$$S) Br!   N)	r   r   r   r   r   base_model_prefixmain_input_name_no_split_modulesr  r    r!   r"   r   r     s!    $O-.
*r!   r   c                   x     e Zd Z fdZe	 	 	 ddeej                     dee   dee   de	e
ef   fd       Z xZS )
LevitModelc                     t         |   |       || _        t        |      | _        t        |      | _        | j                          y r8   )r)   r*   rO   r?   patch_embeddingsr   encoder	post_initrN   s     r"   r*   zLevitModel.__init__  s:      4V <#F+r!   rU   r   r   returnc                 D   ||n| j                   j                  }||n| j                   j                  }|t        d      | j	                  |      }| j                  |||      }|d   }|j                  d      }|s
||f|dd  z   S t        |||j                        S )Nz You have to specify pixel_valuesr   r   r   r   r   )r   pooler_outputr   )	rO   r   use_return_dictrR   r  r  r   r	   r   )r/   rU   r   r   r9   encoder_outputsr   pooled_outputs           r"   r:   zLevitModel.forward  s     %9$D $++JjJj 	 &1%<k$++B]B]?@@**<8
,,!5# ' 
 ,A. *..1.5%}58KKK7/')77
 	
r!   NNN)r   r   r   r*   r   r   r   r   boolr   r   r	   r:   r<   r=   s   @r"   r  r    sk      59/3&*	!
u001!
 'tn!
 d^	!

 
u>>	?!
 !
r!   r  z
    Levit Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    c                        e Zd Z fdZe	 	 	 	 ddeej                     deej                     dee	   dee	   de
eef   f
d       Z xZS )	LevitForImageClassificationc                 >   t         |   |       || _        |j                  | _        t	        |      | _        |j                  dkD  r#t        |j                  d   |j                        nt        j                  j                         | _        | j                          y Nr   rj   )r)   r*   rO   
num_labelsr  r   r   rE   r   r   Identity
classifierr  rN   s     r"   r*   z$LevitForImageClassification.__init__  s      ++'

   1$ %V%8%8%<f>O>OP""$ 	 	r!   rU   labelsr   r   r  c                 H   ||n| j                   j                  }| j                  |||      }|d   }|j                  d      }| j	                  |      }d}|| j                  ||| j                         }|s|f|dd z   }	||f|	z   S |	S t        |||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   r   rC   )lossr   r   )rO   r  r   r   r  loss_functionr
   r   )
r/   rU   r   r   r   outputssequence_outputr   r"  outputs
             r"   r:   z#LevitForImageClassification.forward-  s     &1%<k$++B]B]**\@Tbm*n!!*)..q11%%ffdkkBDY,F)-)9TGf$EvE3!//
 	
r!   )NNNN)r   r   r   r*   r   r   r   r   r   r  r   r   r
   r:   r<   r=   s   @r"   r  r    s       59-1/3&*!
u001!
 ))*!
 'tn	!

 d^!
 
u::	;!
 !
r!   r  ap  
    LeViT Model transformer with image classification heads on top (a linear layer on top of the final hidden state and
    a linear layer on top of the final hidden state of the distillation token) e.g. for ImageNet. .. warning::
           This model supports inference-only. Fine-tuning with distillation (i.e. with a teacher) is not yet
           supported.
    c                   x     e Zd Z fdZe	 	 	 ddeej                     dee   dee   de	e
ef   fd       Z xZS )&LevitForImageClassificationWithTeacherc                    t         |   |       || _        |j                  | _        t	        |      | _        |j                  dkD  r#t        |j                  d   |j                        nt        j                  j                         | _        |j                  dkD  r#t        |j                  d   |j                        nt        j                  j                         | _        | j                          y r  )r)   r*   rO   r  r  r   r   rE   r   r   r  r  classifier_distillr  rN   s     r"   r*   z/LevitForImageClassificationWithTeacher.__init__[  s      ++'

   1$ %V%8%8%<f>O>OP""$ 	   1$ %V%8%8%<f>O>OP""$ 	 	r!   rU   r   r   r  c                 .   ||n| j                   j                  }| j                  |||      }|d   }|j                  d      }| j	                  |      | j                  |      }}||z   dz  }|s|||f|dd  z   }	|	S t        ||||j                        S )Nr  r   r   rC   )r   r   r   r   )rO   r  r   r   r  r*  r   r   )
r/   rU   r   r   r$  r%  r   distill_logitsr   r&  s
             r"   r:   z.LevitForImageClassificationWithTeacher.forwardp  s     &1%<k$++B]B]**\@Tbm*n!!*)..q1%)___%EtG^G^_nGoN
~-2j.9GABKGFM;! .!//	
 	
r!   r  )r   r   r   r*   r   r   r   r   r  r   r   r   r:   r<   r=   s   @r"   r(  r(  R  sk    *  59/3&*	
u001
 'tn
 d^	

 
uBB	C
 
r!   r(  )r  r(  r  r   )*r   r   dataclassesr   typingr   r   r   r   modeling_outputsr   r	   r
   r   modeling_utilsr   utilsr   r   configuration_levitr   
get_loggerr   loggerr   Moduler$   r?   rW   rf   rq   r   r   r   r   r   r   r   r  r  r(  __all__r    r!   r"   <module>r7     s     ! "    . , , 
		H	% 
=; = =$")) ()5299 )5X	RYY 	RYY ;RYY ;|Pbii PfBII $   *B BJ+o299 +o\ryy   *? * *& +
% +
 +
\ 3
"6 3
3
l /
-A /
/
dr!   