+
    œ°³jXŽ  ã                   ó¼  € R t ^ RIt^ RIt^ RIHt ^ RIHtHtHt ^RIH	t
 ^RIHt ^RIHt ^RIHtHtHtHtHtHtHt ^RIHt ^R	IHtHt ^R
IHt ]P<                  ! ]4      t  ! R R]PB                  4      t" ! R R]PB                  4      t# ! R R]PH                  4      t% ! R R]PB                  4      t& ! R R]PB                  4      t' ! R R]PB                  4      t( ! R R]PB                  4      t) ! R R]PB                  4      t* ! R R]PB                  4      t+ ! R R]PB                  4      t, ! R R ]PB                  4      t- ! R! R"]PB                  4      t.] ! R# R$]4      4       t/] ! R% R&]/4      4       t0] ! R' R(]/4      4       t1]! R)R*7       ! R+ R,]/4      4       t2] ! R- R.]/4      4       t3] ! R/ R0]/4      4       t4] ! R1 R2]/4      4       t5. R3Ot6R# )4zPyTorch SqueezeBert model.N)Únn)ÚBCEWithLogitsLossÚCrossEntropyLossÚMSELoss)Úinitialization)ÚACT2FN)Úcreate_bidirectional_mask)ÚBaseModelOutputÚBaseModelOutputWithPoolingÚMaskedLMOutputÚMultipleChoiceModelOutputÚQuestionAnsweringModelOutputÚSequenceClassifierOutputÚTokenClassifierOutput)ÚPreTrainedModel)Úauto_docstringÚlogging©ÚSqueezeBertConfigc                   ó@   a a€ ] tR t^-t oRtV 3R ltRR ltRtVtV ;t	# )ÚSqueezeBertEmbeddingszGConstruct the embeddings from word, position and token_type embeddings.c                óœ  <€ \         SV `  4        \        P                  ! VP                  VP
                  VP                  R 7      V n        \        P                  ! VP                  VP
                  4      V n	        \        P                  ! VP                  VP
                  4      V n        \        P                  ! VP                  VP                  R7      V n        \        P                  ! VP                   4      V n        \        P$                  ! \&        P(                  ! VP                  4      P+                  R4      RR7      V n        R# ))Úpadding_idx©ÚepsF)Ú
persistentN©é   éÿÿÿÿ)ÚsuperÚ__init__r   Ú	EmbeddingÚ
vocab_sizeÚembedding_sizeÚpad_token_idÚword_embeddingsÚmax_position_embeddingsÚposition_embeddingsÚtype_vocab_sizeÚtoken_type_embeddingsÚ	LayerNormÚhidden_sizeÚlayer_norm_epsÚDropoutÚhidden_dropout_probÚdropoutÚBufferÚtorchÚarangeÚexpandÚposition_ids©ÚselfÚconfigÚ	__class__s   &&€Úu/home/luca/screen-checking/.venv/lib/python3.14/site-packages/transformers/models/squeezebert/modeling_squeezebert.pyr    ÚSqueezeBertEmbeddings.__init__0   sÚ   ø€ Ü‰ÑÔÜ!Ÿ|š|¨F×,=Ñ,=¸v×?TÑ?TÐbh×buÑbuÔvˆÔÜ#%§<¢<°×0NÑ0NÐPV×PeÑPeÓ#fˆÔ Ü%'§\¢\°&×2HÑ2HÈ&×J_ÑJ_Ó%`ˆÔ"äŸš f×&8Ñ&8¸f×>SÑ>SÔTˆŒÜ—z’z &×"<Ñ"<Ó=ˆŒô ŸIšI¤e§l¢l°6×3QÑ3QÓ&R×&YÑ&YÐZaÓ&bÐotÔuˆÖó    c                óì  € Ve   VP                  4       pMVP                  4       R R pV^,          pVf   V P                  RR V13,          pVf<   \        P                  ! V\        P                  V P                  P
                  R7      pVf   V P                  V4      pV P                  V4      pV P                  V4      pWG,           V,           p	V P                  V	4      p	V P                  V	4      p	V	# )NºNNN©ÚdtypeÚdevicer   )Úsizer4   r1   ÚzerosÚlongr@   r%   r'   r)   r*   r/   )
r6   Ú	input_idsÚtoken_type_idsr4   Úinputs_embedsÚinput_shapeÚ
seq_lengthr'   r)   Ú
embeddingss
   &&&&&     r9   ÚforwardÚSqueezeBertEmbeddings.forward<   sà   € ØÒ Ø#Ÿ.™.Ó*‰Kà'×,Ñ,Ó.¨s°Ð3ˆKà  •^ˆ
àÒØ×,Ñ,¨Q°°°¨^Õ<ˆLàÒ!Ü"Ÿ[š[¨¼E¿J¹JÈt×O`ÑO`×OgÑOgÔhˆNàÒ Ø ×0Ñ0°Ó;ˆMØ"×6Ñ6°|ÓDÐØ $× :Ñ :¸>Ó JÐà"Õ8Ð;PÕPˆ
Ø—^‘^ JÓ/ˆ
Ø—\‘\ *Ó-ˆ
ØÐr;   )r*   r/   r'   r4   r)   r%   )NNNN©
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r    rJ   Ú__static_attributes__Ú__classdictcell__Ú__classcell__©r8   Ú__classdict__s   @@r9   r   r   -   s   ù‡ € ÙQõ
v÷ô r;   r   c                   ó<   a a€ ] tR t^Ut oRtV 3R ltR tRtVtV ;t	# )ÚMatMulWrapperzÇ
Wrapper for torch.matmul(). This makes flop-counting easier to implement. Note that if you directly call
torch.matmul() in your code, the flop counter will typically ignore the flops of the matmul.
c                ó$   <€ \         SV `  4        R # ©N)r   r    )r6   r8   s   &€r9   r    ÚMatMulWrapper.__init__[   s   ø€ Ü‰ÑÖr;   c                ó.   € \         P                  ! W4      # )a  

:param inputs: two torch tensors :return: matmul of these tensors

Here are the typical dimensions found in BERT (the B is optional) mat1.shape: [B, <optional extra dims>, M, K]
mat2.shape: [B, <optional extra dims>, K, N] output shape: [B, <optional extra dims>, M, N]
)r1   Úmatmul)r6   Úmat1Úmat2s   &&&r9   rJ   ÚMatMulWrapper.forward^   s   € ô �|Š|˜DÓ'Ð'r;   © rL   rU   s   @@r9   rX   rX   U   s   ù‡ € ñõ
÷(ò (r;   rX   c                   ó4   a € ] tR t^it o RtRR ltR tRtV tR# )ÚSqueezeBertLayerNormz™
This is a nn.LayerNorm subclass that accepts NCW data layout and performs normalization in the C dimension.

N = batch C = channels W = sequence length
c                óH   € \         P                  P                  WVR 7       R# ))Únormalized_shaper   N)r   r*   r    )r6   r+   r   s   &&&r9   r    ÚSqueezeBertLayerNorm.__init__p   s   € Ü
�‰×Ñ˜dÀcÐÖJr;   c                óŒ   € VP                  ^ ^^4      p\        P                  P                  W4      pVP                  ^ ^^4      # )é    )Úpermuter   r*   rJ   )r6   Úxs   &&r9   rJ   ÚSqueezeBertLayerNorm.forwards   s;   € Ø�I‰I�a˜˜AÓˆÜ�L‰L× Ñ  Ó)ˆØ�y‰y˜˜A˜qÓ!Ð!r;   ra   N)gê-�™—q=)	rM   rN   rO   rP   rQ   r    rJ   rR   rS   )rV   s   @r9   rc   rc   i   s   ø‡ € ñôK÷"ð "r;   rc   c                   ó<   a a€ ] tR t^yt oRtV 3R ltR tRtVtV ;t	# )ÚConvDropoutLayerNormz0
ConvDropoutLayerNorm: Conv, Dropout, LayerNorm
c                ó¶   <€ \         SV `  4        \        P                  ! W^VR7      V n        \        V4      V n        \        P                  ! V4      V n        R# ©r   ©Úin_channelsÚout_channelsÚkernel_sizeÚgroupsN)	r   r    r   ÚConv1dÚconv1drc   Ú	layernormr-   r/   )r6   ÚcinÚcoutrt   Údropout_probr8   s   &&&&&€r9   r    ÚConvDropoutLayerNorm.__init__~   s@   ø€ Ü‰ÑÔä—i’i¨CÐPQÐZ`ÔaˆŒÜ-¨dÓ3ˆŒÜ—z’z ,Ó/ˆŽr;   c                ó|   € V P                  V4      pV P                  V4      pW2,           pV P                  V4      pV# rZ   ©rv   r/   rw   )r6   Úhidden_statesÚinput_tensorrj   s   &&& r9   rJ   ÚConvDropoutLayerNorm.forward…   s8   € Ø�K‰K˜Ó&ˆØ�L‰L˜‹OˆØÕˆØ�N‰N˜1ÓˆØˆr;   r}   rL   rU   s   @@r9   rm   rm   y   s   ù‡ € ñõ0÷ò r;   rm   c                   ó<   a a€ ] tR t^�t oRtV 3R ltR tRtVtV ;t	# )ÚConvActivationz"
ConvActivation: Conv, Activation
c                ó„   <€ \         SV `  4        \        P                  ! W^VR7      V n        \
        V,          V n        R# ro   )r   r    r   ru   rv   r   Úact)r6   rx   ry   rt   r„   r8   s   &&&&&€r9   r    ÚConvActivation.__init__’   s/   ø€ Ü‰ÑÔÜ—i’i¨CÐPQÐZ`ÔaˆŒÜ˜#•;ˆŽr;   c                óF   € V P                  V4      pV P                  V4      # rZ   )rv   r„   )r6   rj   Úoutputs   && r9   rJ   ÚConvActivation.forward—   s   € Ø—‘˜Q“ˆØ�x‰x˜ÓÐr;   )r„   rv   rL   rU   s   @@r9   r‚   r‚   �   s   ù‡ € ñõ÷
 ò  r;   r‚   c                   óN   a a€ ] tR t^œt oRV 3R lltR tR tR tR tRt	Vt
V ;t# )ÚSqueezeBertSelfAttentionc                ó¢  <€ \         SV `  4        W!P                  ,          ^ 8w  d   \        RV RVP                   R24      hVP                  V n        \	        W!P                  ,          4      V n        V P                  V P
                  ,          V n        \        P                  ! W"^VR7      V n	        \        P                  ! W"^VR7      V n
        \        P                  ! W"^VR7      V n        \        P                  ! VP                  4      V n        \        P                  ! RR7      V n        \#        4       V n        \#        4       V n        R# )z¢
config = used for some things; ignored for others (work in progress...) cin = input channels = output channels
groups = number of groups to use in conv1d layers
zcin (z6) is not a multiple of the number of attention heads (Ú)rp   ©ÚdimNr   )r   r    Únum_attention_headsÚ
ValueErrorÚintÚattention_head_sizeÚall_head_sizer   ru   ÚqueryÚkeyÚvaluer-   Úattention_probs_dropout_probr/   ÚSoftmaxÚsoftmaxrX   Ú	matmul_qkÚ
matmul_qkv)r6   r7   rx   Úq_groupsÚk_groupsÚv_groupsr8   s   &&&&&&€r9   r    Ú!SqueezeBertSelfAttention.__init__�   s   ø€ ô
 	‰ÑÔØ×+Ñ+Õ+¨qÔ0ÜØ˜�uÐRÐSY×SmÑSmÐRnÐnoÐpóð ð $*×#=Ñ#=ˆÔ Ü#& s×-GÑ-GÕ'GÓ#HˆÔ Ø!×5Ñ5¸×8PÑ8PÕPˆÔä—Y’Y¨3ÈaÐX`ÔaˆŒ
Ü—9’9¨ÈAÐV^Ô_ˆŒÜ—Y’Y¨3ÈaÐX`ÔaˆŒ
ä—z’z &×"EÑ"EÓFˆŒÜ—z’z bÔ)ˆŒä&›ˆŒÜ'›/ˆŽr;   c                óÒ   € VP                  4       ^ ,          V P                  V P                  VP                  4       R,          3pVP                  ! V!  pVP	                  ^ ^^^4      # )zg
- input: [N, C, W]
- output: [N, C1, W, C2] where C1 is the head index, and C2 is one head's contents
r   )rA   r�   r’   Úviewri   ©r6   rj   Únew_x_shapes   && r9   Útranspose_for_scoresÚ-SqueezeBertSelfAttention.transpose_for_scoresµ   s[   € ð
 —v‘v“x •{ D×$<Ñ$<¸d×>VÑ>VÐXY×X^ÑX^ÓX`ÐacÕXdÐeˆØ�FŠF�KÑ ˆØ�y‰y˜˜A˜q !Ó$Ð$r;   c                ó®   € VP                  4       ^ ,          V P                  V P                  VP                  4       R,          3pVP                  ! V!  pV# )zg
- input: [N, C, W]
- output: [N, C1, C2, W] where C1 is the head index, and C2 is one head's contents
r   )rA   r�   r’   r¡   r¢   s   && r9   Útranspose_key_for_scoresÚ1SqueezeBertSelfAttention.transpose_key_for_scores¾   sK   € ð
 —v‘v“x •{ D×$<Ñ$<¸d×>VÑ>VÐXY×X^ÑX^ÓX`ÐacÕXdÐeˆØ�FŠF�KÑ ˆàˆr;   c                óÜ   € VP                  ^ ^^^4      P                  4       pVP                  4       ^ ,          V P                  VP                  4       ^,          3pVP                  ! V!  pV# )z-
- input: [N, C1, W, C2]
- output: [N, C, W]
)ri   Ú
contiguousrA   r“   r¡   r¢   s   && r9   Útranspose_outputÚ)SqueezeBertSelfAttention.transpose_outputÈ   sZ   € ð
 �I‰I�a˜˜A˜qÓ!×,Ñ,Ó.ˆØ—v‘v“x •{ D×$6Ñ$6¸¿¹»À½ÐDˆØ�FŠF�KÑ ˆØˆr;   c                ó  € V P                  V4      pV P                  V4      pV P                  V4      pV P                  V4      pV P	                  V4      pV P                  V4      p	V P                  Wx4      p
V
\        P                  ! V P                  4      ,          p
Ve	   W¢,           p
V P                  V
4      pV P                  V4      pV P                  W¹4      pV P                  V4      pRV/pV'       d   W­R&   V# )zƒ
expects hidden_states in [N, C, W] data layout.

The attention_mask data layout is [N, W], and it does not need to be transposed.
Úcontext_layerÚattention_score)r”   r•   r–   r¤   r§   rš   ÚmathÚsqrtr’   r™   r/   r›   r«   )r6   r~   Úattention_maskÚoutput_attentionsÚmixed_query_layerÚmixed_key_layerÚmixed_value_layerÚquery_layerÚ	key_layerÚvalue_layerr¯   Úattention_probsr®   Úresults   &&&&          r9   rJ   Ú SqueezeBertSelfAttention.forwardÒ   sò   € ð !ŸJ™J }Ó5ÐØŸ(™( =Ó1ˆØ ŸJ™J }Ó5Ðà×/Ñ/Ð0AÓBˆØ×1Ñ1°/ÓBˆ	Ø×/Ñ/Ð0AÓBˆð Ÿ.™.¨Ó@ˆØ)¬D¯IªI°d×6NÑ6NÓ,OÕOˆàÒ%Ø-Õ>ˆOð Ÿ,™, Ó7ˆð Ÿ,™, Ó7ˆàŸ™¨ÓEˆØ×-Ñ-¨mÓ<ˆà! =Ð1ˆßØ(7Ð$Ñ%Øˆr;   )
r“   r’   r/   r•   rš   r›   r�   r”   r™   r–   )r   r   r   )rM   rN   rO   rP   r    r¤   r§   r«   rJ   rR   rS   rT   rU   s   @@r9   rŠ   rŠ   œ   s#   ù‡ € ÷*ò0%òò÷"ò "r;   rŠ   c                   ó8   a a€ ] tR t^÷t oV 3R ltR tRtVtV ;t# )ÚSqueezeBertModulec                óÒ  <€ \         SV `  4        VP                  pVP                  pVP                  pVP                  p\	        WVP
                  VP                  VP                  R7      V n        \        W#VP                  VP                  R7      V n        \        W4VP                  VP                  R7      V n        \        WEVP"                  VP                  R7      V n        R# )aP  
- hidden_size = input chans = output chans for Q, K, V (they are all the same ... for now) = output chans for
  the module
- intermediate_size = output chans for intermediate layer
- groups = number of groups for all layers in the BertModule. (eventually we could change the interface to
  allow different groups for different layers)
)r7   rx   rœ   r�   rž   )rx   ry   rt   rz   )rx   ry   rt   r„   N)r   r    r+   Úintermediate_sizerŠ   rœ   r�   rž   Ú	attentionrm   Úpost_attention_groupsr.   Úpost_attentionr‚   Úintermediate_groupsÚ
hidden_actÚintermediateÚoutput_groupsr‡   )r6   r7   Úc0Úc1Úc2Úc3r8   s   &&    €r9   r    ÚSqueezeBertModule.__init__ø   sÁ   ø€ ô 	‰ÑÔà×ÑˆØ×ÑˆØ×%Ñ%ˆØ×Ñˆä1Ø¨F¯O©OÀfÇoÁoÐ`f×`oÑ`oô
ˆŒô 3Ø F×$@Ñ$@Èv×OiÑOiô
ˆÔô +¨rÀ6×C]ÑC]Ðci×ctÑctÔuˆÔÜ*Ø F×$8Ñ$8Àv×GaÑGaô
ˆŽr;   c                óÒ   € V P                  WV4      pVR ,          pV P                  WQ4      pV P                  V4      pV P                  Wv4      pRV/p	V'       d   VR,          V	R&   V	# )r®   Úfeature_mapr¯   )rÁ   rÃ   rÆ   r‡   )
r6   r~   r²   r³   ÚattÚattention_outputÚpost_attention_outputÚintermediate_outputÚlayer_outputÚoutput_dicts
   &&&&      r9   rJ   ÚSqueezeBertModule.forward  su   € Ø�n‰n˜]Ð<MÓNˆØ˜Õ/Ðà $× 3Ñ 3Ð4DÓ TÐØ"×/Ñ/Ð0EÓFÐØ—{‘{Ð#6ÓNˆà$ lÐ3ˆßØ-0Ð1BÕ-CˆKÐ)Ñ*àÐr;   )rÁ   rÆ   r‡   rÃ   ©	rM   rN   rO   rP   r    rJ   rR   rS   rT   rU   s   @@r9   r¾   r¾   ÷   s   ù‡ € õ
÷4ò r;   r¾   c                   ó<   a a€ ] tR tRt oV 3R ltRR ltRtVtV ;t# )ÚSqueezeBertEncoderi!  c                óÚ   <a€ \         SV `  4        SP                  SP                  8X  g   Q R 4       h\        P
                  ! V3R l\        SP                  4       4       4      V n        R# )z™If you want embedding_size != intermediate hidden_size, please insert a Conv1d layer to adjust the number of channels before the first SqueezeBertModule.c              3   ó:   <"  € T F  p\        S4      x € K  	  R # 5irZ   )r¾   )Ú.0Ú_r7   s   & €r9   Ú	<genexpr>Ú.SqueezeBertEncoder.__init__.<locals>.<genexpr>+  s   øé € Ð#gÑGfÀ!Ô$5°f×$=Ð$=ÓGfùs   ƒN)	r   r    r#   r+   r   Ú
ModuleListÚrangeÚnum_hidden_layersÚlayersr5   s   &f€r9   r    ÚSqueezeBertEncoder.__init__"  sW   ù€ Ü‰ÑÔà×$Ñ$¨×(:Ñ(:Ô:ð 	
ð2ó	
Ð:ô —m’mÔ#gÄuÈV×MeÑMeÔGfÓ#gÓgˆŽr;   c                ó(  € VP                  ^ ^^4      pV'       d   RMRpV'       d   RMRpV P                   Fo  pV'       d0   VP                  ^ ^^4      pWa3,          pVP                  ^ ^^4      pVP                  WV4      p	V	R,          pV'       g   K_  WyR,          3,          pKq  	  VP                  ^ ^^4      pV'       d
   Wa3,          pV'       g1   \        ;QJ d    . R WV3 4       F  NK  	  5# ! R WV3 4       4      # \	        WVR7      # )rh   NrÎ   r¯   c              3   ó0   "  € T F  qf   K  Vx € K  	  R # 5irZ   ra   )rÛ   Úvs   & r9   rÝ   Ú-SqueezeBertEncoder.forward.<locals>.<genexpr>O  s   é € ÐhÑ$V˜qŸšÓ$Vùs   ‚Œ
)Úlast_hidden_stater~   Ú
attentionsra   )ri   râ   rJ   Útupler	   )
r6   r~   r²   r³   Úoutput_hidden_statesÚreturn_dictÚall_hidden_statesÚall_attentionsÚlayerrÓ   s
   &&&&&&    r9   rJ   ÚSqueezeBertEncoder.forward-  s	  € ð &×-Ñ-¨a°°AÓ6ˆç"6™B¸DÐß0™°dˆà—[”[ˆEß#Ø -× 5Ñ 5°a¸¸AÓ >�Ø!Ð%5Õ5Ð!Ø -× 5Ñ 5°a¸¸AÓ >�à Ÿ=™=¨ÐHYÓZˆLà(¨Õ7ˆMç Ñ ØÐ0AÕ#BÐ"DÕD’ñ !ð &×-Ñ-¨a°°AÓ6ˆçØÐ!1Õ1Ðçß”5Ñh ]À~Ñ$VÓh—5Ðh�5Ñh ]À~Ñ$VÓhÓhÐhÜØ+ÐYgô
ð 	
r;   )râ   )NFFTrÖ   rU   s   @@r9   rØ   rØ   !  s   ù‡ € õ	h÷%
ô %
r;   rØ   c                   ó8   a a€ ] tR tRt oV 3R ltR tRtVtV ;t# )ÚSqueezeBertPooleriU  c                ó¸   <€ \         SV `  4        \        P                  ! VP                  VP                  4      V n        \        P                  ! 4       V n        R # rZ   )r   r    r   ÚLinearr+   ÚdenseÚTanhÚ
activationr5   s   &&€r9   r    ÚSqueezeBertPooler.__init__V  s9   ø€ Ü‰ÑÔÜ—Y’Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
ÜŸ'š'›)ˆŽr;   c                ó\   € VR,          pV P                  V4      pV P                  V4      pV# )r=   )r=   rh   )rõ   r÷   )r6   r~   Úfirst_token_tensorÚpooled_outputs   &&  r9   rJ   ÚSqueezeBertPooler.forward[  s2   € ð +¨4Õ0ÐØŸ
™
Ð#5Ó6ˆØŸ™¨Ó6ˆØÐr;   )r÷   rõ   rÖ   rU   s   @@r9   rò   rò   U  s   ù‡ € õ$÷
ò r;   rò   c                   ó8   a a€ ] tR tRt oV 3R ltR tRtVtV ;t# )Ú"SqueezeBertPredictionHeadTransformid  c                ó‚  <€ \         SV `  4        \        P                  ! VP                  VP                  4      V n        \        VP                  \        4      '       d   \        VP                  ,          V n
        MVP                  V n
        \        P                  ! VP                  VP                  R 7      V n        R# )r   N)r   r    r   rô   r+   rõ   Ú
isinstancerÅ   Ústrr   Útransform_act_fnr*   r,   r5   s   &&€r9   r    Ú+SqueezeBertPredictionHeadTransform.__init__e  s~   ø€ Ü‰ÑÔÜ—Y’Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
Ü�f×'Ñ'¬×-Ò-Ü$*¨6×+<Ñ+<Õ$=ˆDÕ!à$*×$5Ñ$5ˆDÔ!ÜŸš f×&8Ñ&8¸f×>SÑ>SÔTˆŽr;   c                ól   € V P                  V4      pV P                  V4      pV P                  V4      pV# rZ   )rõ   r  r*   ©r6   r~   s   &&r9   rJ   Ú*SqueezeBertPredictionHeadTransform.forwardn  s4   € ØŸ
™
 =Ó1ˆØ×-Ñ-¨mÓ<ˆØŸ™ }Ó5ˆØÐr;   )r*   rõ   r  rÖ   rU   s   @@r9   rþ   rþ   d  s   ù‡ € õU÷ò r;   rþ   c                   ó8   a a€ ] tR tRt oV 3R ltR tRtVtV ;t# )ÚSqueezeBertLMPredictionHeadiu  c                ó  <€ \         SV `  4        \        V4      V n        \        P
                  ! VP                  VP                  R R7      V n        \        P                  ! \        P                  ! VP                  4      4      V n        R# )T)ÚbiasN)r   r    rþ   Ú	transformr   rô   r+   r"   ÚdecoderÚ	Parameterr1   rB   r
  r5   s   &&€r9   r    Ú$SqueezeBertLMPredictionHead.__init__v  s[   ø€ Ü‰ÑÔÜ;¸FÓCˆŒô —y’y ×!3Ñ!3°V×5FÑ5FÈTÔRˆŒä—L’L¤§¢¨V×->Ñ->Ó!?Ó@ˆŽ	r;   c                óJ   € V P                  V4      pV P                  V4      pV# rZ   )r  r  r  s   &&r9   rJ   Ú#SqueezeBertLMPredictionHead.forward‚  s$   € ØŸ™ }Ó5ˆØŸ™ ]Ó3ˆØÐr;   )r
  r  r  rÖ   rU   s   @@r9   r  r  u  s   ù‡ € õA÷ò r;   r  c                   ó8   a a€ ] tR tRt oV 3R ltR tRtVtV ;t# )ÚSqueezeBertOnlyMLMHeadiˆ  c                óD   <€ \         SV `  4        \        V4      V n        R # rZ   )r   r    r  Úpredictionsr5   s   &&€r9   r    ÚSqueezeBertOnlyMLMHead.__init__‰  s   ø€ Ü‰ÑÔÜ6°vÓ>ˆÖr;   c                ó(   € V P                  V4      pV# rZ   ©r  )r6   Úsequence_outputÚprediction_scoress   && r9   rJ   ÚSqueezeBertOnlyMLMHead.forward�  s   € Ø ×,Ñ,¨_Ó=ÐØ Ð r;   r  rÖ   rU   s   @@r9   r  r  ˆ  s   ù‡ € õ?÷!ò !r;   r  c                   ój   a a€ ] tR tRt oRt]P                  ! 4       V 3R l4       tV3R ltRt	Vt
V ;t# )ÚSqueezeBertPreTrainedModeli’  Útransformerc                ó„  <€ \         SV `  V4       \        V\        4      '       d#   \        P
                  ! VP                  4       R# \        V\        4      '       db   \        P                  ! VP                  \        P                  ! VP                  P                  R,          4      P                  R4      4       R# R# )zInitialize the weightsNr   r   )r   Ú_init_weightsr   r  ÚinitÚzeros_r
  r   Úcopy_r4   r1   r2   Úshaper3   )r6   Úmoduler8   s   &&€r9   r  Ú(SqueezeBertPreTrainedModel._init_weights—  s~   ø€ ô 	‰Ñ˜fÔ%Ü�fÔ9×:Ò:Ü�KŠK˜Ÿ™Ö$Ü˜Ô 5×6Ò6Ü�JŠJ�v×*Ñ*¬E¯LªL¸×9LÑ9L×9RÑ9RÐSUÕ9VÓ,W×,^Ñ,^Ð_fÓ,gÖhñ 7r;   c                ó&   <€ V ^8„  d   Qh/ S[ ;R&   # )é   r7   r   )ÚformatrV   s   "€r9   Ú__annotate__Ú'SqueezeBertPreTrainedModel.__annotate__’  s   ø‡ ‚ áÑò r;   ra   )rM   rN   rO   rP   Úbase_model_prefixr1   Úno_gradr  Ú__annotate_func__rR   rS   rT   rU   s   @@r9   r  r  ’  s.   ù‡ € ð &Ðà
‡]‚]ƒ_ôió ði÷ … r;   r  c                   ó^   a a€ ] tR tRt oV 3R ltR tR t]RV3R lR ll4       tRt	Vt
V ;t# )	ÚSqueezeBertModeli¡  c                ó¦   <€ \         SV `  V4       \        V4      V n        \	        V4      V n        \        V4      V n        V P                  4        R # rZ   )	r   r    r   rI   rØ   Úencoderrò   ÚpoolerÚ	post_initr5   s   &&€r9   r    ÚSqueezeBertModel.__init__£  s@   ø€ Ü‰Ñ˜Ô ä/°Ó7ˆŒÜ)¨&Ó1ˆŒÜ'¨Ó/ˆŒð 	�‰Ör;   c                ó.   € V P                   P                  # rZ   ©rI   r%   ©r6   s   &r9   Úget_input_embeddingsÚ%SqueezeBertModel.get_input_embeddings­  s   € Ø�‰×.Ñ.Ð.r;   c                ó&   € WP                   n        R # rZ   r6  ©r6   Únew_embeddingss   &&r9   Úset_input_embeddingsÚ%SqueezeBertModel.set_input_embeddings°  s   € Ø*8�‰Ö'r;   c                ó4  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[R,          RS[R,          R	S[R,          R
S[S[,          /	# )r'  rD   Nr²   rE   r4   rF   r³   rë   rì   Úreturn)r1   ÚTensorÚFloatTensorÚboolrê   r
   )r(  rV   s   "€r9   r)  ÚSqueezeBertModel.__annotate__´  s¦   ø€ ÷ ?
ñ ?
á—<‘< $Õ&ð?
ñ Ÿ™ tÕ+ð?
ñ Ÿ™ tÕ+ð	?
ñ
 —l‘l TÕ)ð?
ñ ×(Ñ(¨4Õ/ð?
ñ   $�;ð?
ñ # T�kð?
ñ ˜D•[ð?
ñ 
Ñ+Õ	+ñ?
r;   c	                óT  € Ve   TMV P                   P                  pVe   TMV P                   P                  pVe   TMV P                   P                  pVe   Ve   \	        R4      hVe#   V P                  W4       VP                  4       p
M#Ve   VP                  4       R R
 p
M\	        R4      hVe   VP                  MVP                  pVf   \        P                  ! W«R7      pVf(   \        P                  ! V
\        P                  VR7      pV P                  WW5R7      p\        V P                   VVR7      pV P                  VVVVVR7      pV^ ,          pV P                  V4      pV'       g   Wï3VR,          ,           # \!        VVVP"                  VP$                  R	7      # )NzDYou cannot specify both input_ids and inputs_embeds at the same timez5You have to specify either input_ids or inputs_embeds)r@   r>   )rD   r4   rE   rF   )r7   rF   r²   )r~   r²   r³   rë   rì   :r   NN)rè   Úpooler_outputr~   ré   r   )r7   r³   rë   rì   r�   Ú%warn_if_padding_and_no_attention_maskrA   r@   r1   ÚonesrB   rC   rI   r   r1  r2  r
   r~   ré   )r6   rD   r²   rE   r4   rF   r³   rë   rì   ÚkwargsrG   r@   Úembedding_outputÚencoder_outputsr  rû   s   &&&&&&&&&,      r9   rJ   ÚSqueezeBertModel.forward³  s£  € ð 2CÒ1NÑ-ÐTX×T_ÑT_×TqÑTqÐà$8Ò$DÑ È$Ï+É+×JjÑJjð 	ð &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆàÒ  ]Ò%>ÜÐcÓdÐdØÒ"Ø×6Ñ6°yÔQØ#Ÿ.™.Ó*‰KØÒ&Ø'×,Ñ,Ó.¨s°Ð3‰KäÐTÓUÐUà%.Ò%:�×!Ò!À×@TÑ@TˆàÒ!Ü"ŸZšZ¨ÔCˆNØÒ!Ü"Ÿ[š[¨¼E¿J¹JÈvÔVˆNàŸ?™?ØÈ>ð +ó 
Ðô 3Ø—;‘;Ø*Ø)ô
ˆð Ÿ,™,Ø*Ø)Ø/Ø!5Ø#ð 'ó 
ˆð *¨!Õ,ˆØŸ™ OÓ4ˆçØ#Ð3°oÀbÕ6IÕIÐIä)Ø-Ø'Ø)×7Ñ7Ø&×1Ñ1ô	
ð 	
r;   )rI   r1  r2  )NNNNNNNN)rM   rN   rO   rP   r    r8  r=  r   rJ   rR   rS   rT   rU   s   @@r9   r/  r/  ¡  s2   ù‡ € õò/ò9ð ÷?
ñ ?
ó ÷?
ð ?
r;   r/  c                   ój   a a€ ] tR tRt oRRRR/tV 3R ltR tR t]RV3R	 lR
 ll4       t	Rt
VtV ;t# )ÚSqueezeBertForMaskedLMiö  zcls.predictions.decoder.biaszcls.predictions.biaszcls.predictions.decoder.weightz-transformer.embeddings.word_embeddings.weightc                ó†   <€ \         SV `  V4       \        V4      V n        \	        V4      V n        V P                  4        R # rZ   )r   r    r/  r  r  Úclsr3  r5   s   &&€r9   r    ÚSqueezeBertForMaskedLM.__init__ý  s5   ø€ Ü‰Ñ˜Ô ä+¨FÓ3ˆÔÜ)¨&Ó1ˆŒð 	�‰Ör;   c                óB   € V P                   P                  P                  # rZ   )rP  r  r  r7  s   &r9   Úget_output_embeddingsÚ,SqueezeBertForMaskedLM.get_output_embeddings  s   € Ø�x‰x×#Ñ#×+Ñ+Ð+r;   c                ó„   € WP                   P                  n        VP                  V P                   P                  n        R # rZ   )rP  r  r  r
  r;  s   &&r9   Úset_output_embeddingsÚ,SqueezeBertForMaskedLM.set_output_embeddings	  s*   € Ø'5�‰×ÑÔ$Ø$2×$7Ñ$7ˆ�‰×ÑÖ!r;   c                ó\  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[R,          R	S[R,          R
S[R,          RS[S[,          /
# ©r'  rD   Nr²   rE   r4   rF   Úlabelsr³   rë   rì   r@  )r1   rA  rC  rê   r   )r(  rV   s   "€r9   r)  Ú#SqueezeBertForMaskedLM.__annotate__  s¶   ø€ ÷ 1
ñ 1
á—<‘< $Õ&ð1
ñ Ÿ™ tÕ+ð1
ñ Ÿ™ tÕ+ð	1
ñ
 —l‘l TÕ)ð1
ñ —|‘| dÕ*ð1
ñ —‘˜tÕ#ð1
ñ   $�;ð1
ñ # T�kð1
ñ ˜D•[ð1
ñ 
‘Õ	ñ1
r;   c
                óÐ  € V	e   T	MV P                   P                  p	V P                  VVVVVVVV	R7      pV^ ,          pV P                  V4      pRpVeG   \	        4       pV! VP                  RV P                   P                  4      VP                  R4      4      pV	'       g"   V3VR,          ,           pVe   V3V,           # T# \        VVVP                  VP                  R7      # )az  
labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
    Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
    config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
    loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
N©r²   rE   r4   rF   r³   rë   rì   ºr'  NN©ÚlossÚlogitsr~   ré   r   )
r7   rì   r  rP  r   r¡   r"   r   r~   ré   )r6   rD   r²   rE   r4   rF   rZ  r³   rë   rì   rI  Úoutputsr  r  Úmasked_lm_lossÚloss_fctr‡   s   &&&&&&&&&&,      r9   rJ   ÚSqueezeBertForMaskedLM.forward  s÷   € ð( &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆà×"Ñ"ØØ)Ø)Ø%Ø'Ø/Ø!5Ø#ð #ó 	
ˆð " !�*ˆØ ŸH™H _Ó5ÐàˆØÒÜ'Ó)ˆHÙ%Ð&7×&<Ñ&<¸RÀÇÁ×AWÑAWÓ&XÐZ`×ZeÑZeÐfhÓZiÓjˆNçØ'Ð)¨G°B­KÕ7ˆFØ3AÒ3M�^Ð%¨Õ.ÐYÐSYÐYäØØ$Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   )rP  r  ©	NNNNNNNNN)rM   rN   rO   rP   Ú_tied_weights_keysr    rS  rV  r   rJ   rR   rS   rT   rU   s   @@r9   rN  rN  ö  sH   ù‡ € ð 	'Ð(>Ø(Ð*YðÐõ
ò,ò8ð ÷1
ñ 1
ó ÷1
ð 1
r;   rN  z£
    SqueezeBERT Model transformer with a sequence classification/regression head on top (a linear layer on top of the
    pooled output) e.g. for GLUE tasks.
    )Úcustom_introc                   óR   a a€ ] tR tRt oV 3R lt]RV3R lR ll4       tRtVtV ;t	# )Ú$SqueezeBertForSequenceClassificationiB  c                óR  <€ \         SV `  V4       VP                  V n        Wn        \	        V4      V n        \        P                  ! VP                  4      V n	        \        P                  ! VP                  V P                  P                  4      V n        V P                  4        R # rZ   )r   r    Ú
num_labelsr7   r/  r  r   r-   r.   r/   rô   r+   Ú
classifierr3  r5   s   &&€r9   r    Ú-SqueezeBertForSequenceClassification.__init__I  ss   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒØŒä+¨FÓ3ˆÔÜ—z’z &×"<Ñ"<Ó=ˆŒÜŸ)š) F×$6Ñ$6¸¿¹×8NÑ8NÓOˆŒð 	�‰Ör;   c                ó\  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[R,          R	S[R,          R
S[R,          RS[S[,          /
# rY  )r1   rA  rC  rê   r   )r(  rV   s   "€r9   r)  Ú1SqueezeBertForSequenceClassification.__annotate__V  sÃ   ø€ ÷ E
ñ E
á—<‘< $Õ&ðE
ñ Ÿ™ tÕ+ðE
ñ Ÿ™ tÕ+ð	E
ñ
 —l‘l TÕ)ðE
ñ —|‘| dÕ*ðE
ñ —‘˜tÕ#ðE
ñ   $�;ðE
ñ # T�kðE
ñ ˜D•[ðE
ñ 
Ñ)Õ	)ñE
r;   c
                ó–  € V	e   T	MV P                   P                  p	V P                  VVVVVVVV	R7      pV^,          pV P                  V4      pV P	                  V4      pRpVEe˜   V P                   P
                  f–   V P                  ^8X  d   RV P                   n        MrV P                  ^8”  dQ   VP                  \        P                  8X  g    VP                  \        P                  8X  d   RV P                   n        MRV P                   n        V P                   P
                  R8X  dK   \        4       pV P                  ^8X  d'   V! VP                  4       VP                  4       4      pMŽV! WÖ4      pM…V P                   P
                  R8X  d>   \        4       pV! VP                  RV P                  4      VP                  R4      4      pM-V P                   P
                  R8X  d   \        4       pV! WÖ4      pV	'       g"   V3VR,          ,           pVe   V3V,           # T# \!        VVVP"                  VP$                  R7      # )	ae  
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
    Labels for computing the sequence 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]  Ú
regressionÚsingle_label_classificationÚmulti_label_classificationr^  r_  r   )r7   rì   r  r/   rm  Úproblem_typerl  r?   r1   rC   r‘   r   Úsqueezer   r¡   r   r   r~   ré   )r6   rD   r²   rE   r4   rF   rZ  r³   rë   rì   rI  rb  rû   ra  r`  rd  r‡   s   &&&&&&&&&&,      r9   rJ   Ú,SqueezeBertForSequenceClassification.forwardU  sá  € ð( &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆà×"Ñ"ØØ)Ø)Ø%Ø'Ø/Ø!5Ø#ð #ó 	
ˆð   �
ˆàŸ™ ]Ó3ˆØ—‘ Ó/ˆàˆØÓØ�{‰{×'Ñ'Ò/Ø—?‘? aÔ'Ø/;�D—K‘KÕ,Ø—_‘_ qÔ(¨f¯l©l¼e¿j¹jÔ.HÈFÏLÉLÔ\a×\eÑ\eÔLeØ/L�D—K‘KÕ,à/K�D—K‘KÔ,à�{‰{×'Ñ'¨<Ô7Ü"›9�Ø—?‘? aÔ'Ù# F§N¡NÓ$4°f·n±nÓ6FÓG‘Dá# FÓ3‘DØ—‘×)Ñ)Ð-JÔJÜ+Ó-�Ù §¡¨B°·±Ó @À&Ç+Á+ÈbÃ/ÓR‘Ø—‘×)Ñ)Ð-IÔIÜ,Ó.�Ù Ó/�çØ�Y ¨¥Õ,ˆFØ)-Ò)9�T�G˜fÕ$ÐE¸vÐEä'ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   )rm  r7   r/   rl  r  rf  ©
rM   rN   rO   rP   r    r   rJ   rR   rS   rT   rU   s   @@r9   rj  rj  B  s,   ù‡ € õ
ð ÷E
ñ E
ó ÷E
ð E
r;   rj  c                   óR   a a€ ] tR tRt oV 3R lt]RV3R lR ll4       tRtVtV ;t	# )ÚSqueezeBertForMultipleChoiceiž  c                óü   <€ \         SV `  V4       \        V4      V n        \        P
                  ! VP                  4      V n        \        P                  ! VP                  ^4      V n
        V P                  4        R# )r   N)r   r    r/  r  r   r-   r.   r/   rô   r+   rm  r3  r5   s   &&€r9   r    Ú%SqueezeBertForMultipleChoice.__init__   sW   ø€ Ü‰Ñ˜Ô ä+¨FÓ3ˆÔÜ—z’z &×"<Ñ"<Ó=ˆŒÜŸ)š) F×$6Ñ$6¸Ó:ˆŒð 	�‰Ör;   c                ó\  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[R,          R	S[R,          R
S[R,          RS[S[,          /
# rY  )r1   rA  rC  rê   r   )r(  rV   s   "€r9   r)  Ú)SqueezeBertForMultipleChoice.__annotate__«  sÃ   ø€ ÷ W
ñ W
á—<‘< $Õ&ðW
ñ Ÿ™ tÕ+ðW
ñ Ÿ™ tÕ+ð	W
ñ
 —l‘l TÕ)ðW
ñ —|‘| dÕ*ðW
ñ —‘˜tÕ#ðW
ñ   $�;ðW
ñ # T�kðW
ñ ˜D•[ðW
ñ 
Ñ*Õ	*ñW
r;   c
                ó¨  € V	e   T	MV P                   P                  p	Ve   VP                  ^,          MVP                  ^,          pVe"   VP                  RVP	                  R4      4      MRpVe"   VP                  RVP	                  R4      4      MRpVe"   VP                  RVP	                  R4      4      MRpVe"   VP                  RVP	                  R4      4      MRpVe2   VP                  RVP	                  R4      VP	                  R4      4      MRpV P                  VVVVVVVV	R7      pV^,          pV P                  V4      pV P                  V4      pVP                  RV4      pRpVe   \        4       pV! Wö4      pV	'       g"   V3VR,          ,           pVe   V3V,           # T# \        VVVP                  VP                  R7      # )a›  
input_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`):
    Indices of input sequence tokens in the vocabulary.

    Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
    [`PreTrainedTokenizer.__call__`] for details.

    [What are input IDs?](../glossary#input-ids)
token_type_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`, *optional*):
    Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0,
    1]`:

    - 0 corresponds to a *sentence A* token,
    - 1 corresponds to a *sentence B* token.

    [What are token type IDs?](../glossary#token-type-ids)
position_ids (`torch.LongTensor` of shape `(batch_size, num_choices, sequence_length)`, *optional*):
    Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
    config.max_position_embeddings - 1]`.

    [What are position IDs?](../glossary#position-ids)
inputs_embeds (`torch.FloatTensor` of shape `(batch_size, num_choices, sequence_length, hidden_size)`, *optional*):
    Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
    is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
    model's internal embedding lookup matrix.
labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
    Labels for computing the multiple choice classification loss. Indices should be in `[0, ...,
    num_choices-1]` where *num_choices* is the size of the second dimension of the input tensors. (see
    *input_ids* above)
Nr]  r^  r_  r   éþÿÿÿ)r7   rì   r#  r¡   rA   r  r/   rm  r   r   r~   ré   )r6   rD   r²   rE   r4   rF   rZ  r³   rë   rì   rI  Únum_choicesrb  rû   ra  Úreshaped_logitsr`  rd  r‡   s   &&&&&&&&&&,        r9   rJ   Ú$SqueezeBertForMultipleChoice.forwardª  sÙ  € ðX &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆØ,5Ò,A�i—o‘o aÖ(À}×GZÑGZÐ[\ÕG]ˆà>GÒ>S�I—N‘N 2 y§~¡~°bÓ'9Ô:ÐY]ˆ	ØM[ÒMg˜×,Ñ,¨R°×1DÑ1DÀRÓ1HÔIÐmqˆØM[ÒMg˜×,Ñ,¨R°×1DÑ1DÀRÓ1HÔIÐmqˆØGSÒG_�|×(Ñ(¨¨\×->Ñ->¸rÓ-BÔCÐeiˆð Ò(ð ×Ñ˜r =×#5Ñ#5°bÓ#9¸=×;MÑ;MÈbÓ;QÔRàð 	ð ×"Ñ"ØØ)Ø)Ø%Ø'Ø/Ø!5Ø#ð #ó 	
ˆð   �
ˆàŸ™ ]Ó3ˆØ—‘ Ó/ˆØ Ÿ+™+ b¨+Ó6ˆàˆØÒÜ'Ó)ˆHÙ˜OÓ4ˆDçØ%Ð'¨'°"­+Õ5ˆFØ)-Ò)9�T�G˜fÕ$ÐE¸vÐEä(ØØ"Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   )rm  r/   r  rf  rx  rU   s   @@r9   rz  rz  ž  s,   ù‡ € õð ÷W
ñ W
ó ÷W
ð W
r;   rz  c                   óR   a a€ ] tR tRt oV 3R lt]RV3R lR ll4       tRtVtV ;t	# )Ú!SqueezeBertForTokenClassificationi  c                ó2  <€ \         SV `  V4       VP                  V n        \        V4      V n        \
        P                  ! VP                  4      V n        \
        P                  ! VP                  VP                  4      V n        V P                  4        R # rZ   )r   r    rl  r/  r  r   r-   r.   r/   rô   r+   rm  r3  r5   s   &&€r9   r    Ú*SqueezeBertForTokenClassification.__init__  sj   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä+¨FÓ3ˆÔÜ—z’z &×"<Ñ"<Ó=ˆŒÜŸ)š) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Ör;   c                ó\  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[R,          R	S[R,          R
S[R,          RS[S[,          /
# rY  )r1   rA  rC  rê   r   )r(  rV   s   "€r9   r)  Ú.SqueezeBertForTokenClassification.__annotate__  s·   ø€ ÷ 1
ñ 1
á—<‘< $Õ&ð1
ñ Ÿ™ tÕ+ð1
ñ Ÿ™ tÕ+ð	1
ñ
 —l‘l TÕ)ð1
ñ —|‘| dÕ*ð1
ñ —‘˜tÕ#ð1
ñ   $�;ð1
ñ # T�kð1
ñ ˜D•[ð1
ñ 
Ñ&Õ	&ñ1
r;   c
                óÞ  € V	e   T	MV P                   P                  p	V P                  VVVVVVVV	R7      pV^ ,          pV P                  V4      pV P	                  V4      pRpVe=   \        4       pV! VP                  RV P                  4      VP                  R4      4      pV	'       g"   V3VR,          ,           pVe   V3V,           # T# \        VVVP                  VP                  R7      # )zÃ
labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
    Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
Nr]  r^  r_  r   )r7   rì   r  r/   rm  r   r¡   rl  r   r~   ré   )r6   rD   r²   rE   r4   rF   rZ  r³   rë   rì   rI  rb  r  ra  r`  rd  r‡   s   &&&&&&&&&&,      r9   rJ   Ú)SqueezeBertForTokenClassification.forward  só   € ð$ &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆà×"Ñ"ØØ)Ø)Ø%Ø'Ø/Ø!5Ø#ð #ó 	
ˆð " !�*ˆàŸ,™, Ó7ˆØ—‘ Ó1ˆàˆØÒÜ'Ó)ˆHÙ˜FŸK™K¨¨D¯O©OÓ<¸f¿k¹kÈ"»oÓNˆDçØ�Y ¨¥Õ,ˆFØ)-Ò)9�T�G˜fÕ$ÐE¸vÐEä$ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   )rm  r/   rl  r  rf  rx  rU   s   @@r9   r…  r…    s(   ù‡ € õ	ð ÷1
ñ 1
ó ÷1
ð 1
r;   r…  c                   óR   a a€ ] tR tRt oV 3R lt]RV3R lR ll4       tRtVtV ;t	# )ÚSqueezeBertForQuestionAnsweringiG  c                óè   <€ \         SV `  V4       VP                  V n        \        V4      V n        \
        P                  ! VP                  VP                  4      V n        V P                  4        R # rZ   )
r   r    rl  r/  r  r   rô   r+   Ú
qa_outputsr3  r5   s   &&€r9   r    Ú(SqueezeBertForQuestionAnswering.__init__I  sT   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä+¨FÓ3ˆÔÜŸ)š) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Ör;   c                ó„  <€ V ^8„  d   QhRS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          RS[ P                  R,          R	S[R,          R
S[R,          RS[R,          RS[S[,          /# )r'  rD   Nr²   rE   r4   rF   Ústart_positionsÚend_positionsr³   rë   rì   r@  )r1   rA  rC  rê   r   )r(  rV   s   "€r9   r)  Ú,SqueezeBertForQuestionAnswering.__annotate__T  sÊ   ø€ ÷ =
ñ =
á—<‘< $Õ&ð=
ñ Ÿ™ tÕ+ð=
ñ Ÿ™ tÕ+ð	=
ñ
 —l‘l TÕ)ð=
ñ —|‘| dÕ*ð=
ñ Ÿ™¨Õ,ð=
ñ —|‘| dÕ*ð=
ñ   $�;ð=
ñ # T�kð=
ñ ˜D•[ð=
ñ 
Ñ-Õ	-ñ=
r;   c                óx  € V
e   T
MV P                   P                  p
V P                  VVVVVVV	V
R7      pV^ ,          pV P                  V4      pVP	                  ^RR7      w  ppVP                  R4      P                  4       pVP                  R4      P                  4       pR pVeÅ   VeÁ   \        VP                  4       4      ^8”  d   VP                  R4      p\        VP                  4       4      ^8”  d   VP                  R4      pVP                  ^4      pVP                  ^ V4      pVP                  ^ V4      p\        VR7      pV! Wö4      pV! VV4      pVV,           ^,          pV
'       g#   VV3VR,          ,           pVe   V3V,           # T# \        VVVVP                  VP                  R7      # )Nr]  r�   )Úignore_indexr^  )r`  Ústart_logitsÚ
end_logitsr~   ré   r   )r7   rì   r  r�  Úsplitrv  rª   ÚlenrA   Úclampr   r   r~   ré   )r6   rD   r²   rE   r4   rF   r’  r“  r³   rë   rì   rI  rb  r  ra  r—  r˜  Ú
total_lossÚignored_indexrd  Ú
start_lossÚend_lossr‡   s   &&&&&&&&&&&,           r9   rJ   Ú'SqueezeBertForQuestionAnswering.forwardS  s½  € ð &1Ò%<‘kÀ$Ç+Á+×BYÑBYˆà×"Ñ"ØØ)Ø)Ø%Ø'Ø/Ø!5Ø#ð #ó 	
ˆð " !�*ˆà—‘ Ó1ˆØ#)§<¡<°°r <Ó#:Ñ ˆ�jØ#×+Ñ+¨BÓ/×:Ñ:Ó<ˆØ×'Ñ'¨Ó+×6Ñ6Ó8ˆ
àˆ
ØÒ&¨=Ò+Dä�?×'Ñ'Ó)Ó*¨QÔ.Ø"1×"9Ñ"9¸"Ó"=�Ü�=×%Ñ%Ó'Ó(¨1Ô,Ø -× 5Ñ 5°bÓ 9�à(×-Ñ-¨aÓ0ˆMØ-×3Ñ3°A°}ÓEˆOØ)×/Ñ/°°=ÓAˆMä'°]ÔCˆHÙ! ,Ó@ˆJÙ 
¨MÓ:ˆHØ$ xÕ/°1Õ4ˆJçØ" JÐ/°'¸"µ+Õ=ˆFØ/9Ò/E�Z�M FÕ*ÐQÈ6ÐQä+ØØ%Ø!Ø!×/Ñ/Ø×)Ñ)ô
ð 	
r;   )rl  r�  r  )
NNNNNNNNNNrx  rU   s   @@r9   r�  r�  G  s(   ù‡ € õð ÷=
ñ =
ó ÷=
ð =
r;   r�  )rN  rz  r�  rj  r…  r/  r¾   r  )7rQ   r°   r1   r   Útorch.nnr   r   r   Ú r   r   Úactivationsr   Úmasking_utilsr   Úmodeling_outputsr	   r
   r   r   r   r   r   Úmodeling_utilsr   Úutilsr   r   Úconfiguration_squeezebertr   Ú
get_loggerrM   ÚloggerÚModuler   rX   r*   rc   rm   r‚   rŠ   r¾   rØ   rò   rþ   r  r  r  r/  rN  rj  rz  r…  r�  Ú__all__ra   r;   r9   Ú<module>r­     s  ðñ !ã ã Ý ß AÑ Aå &Ý !Ý 6÷÷ ñ õ .÷õ 9ð 
×	Ò	˜HÓ	%€ô%˜BŸI™Iô %ôP(�B—I‘Iô (ô("˜2Ÿ<™<ô "ô ˜2Ÿ9™9ô ô( �R—Y‘Yô  ôX˜rŸy™yô Xôv'˜Ÿ	™	ô 'ôT1
˜Ÿ™ô 1
ôh˜Ÿ	™	ô ô¨¯©ô ô" "§)¡)ô ô&!˜RŸY™Yô !ð ôi ó ió ðið ôQ
Ð1ó Q
ó ðQ
ðh ôH
Ð7ó H
ó ðH
ñV ðôôS
Ð+Eó S
óðS
ðl ôc
Ð#=ó c
ó ðc
ðL ô>
Ð(Bó >
ó ð>
ðB ôI
Ð&@ó I
ó ðI
òX	‚r;   