Ë
    ÜÓ^juŽ  ã                   óº  — d Z ddlZddlZddlmZ ddlmZmZmZ ddl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mZ dd
lmZ ddlmZmZ ddlmZ  ej<                  e«      Z  G d„ dejB                  «      Z" G d„ dejB                  «      Z# G d„ dejH                  «      Z% G d„ dejB                  «      Z& G d„ dejB                  «      Z' G d„ dejB                  «      Z( G d„ dejB                  «      Z) G d„ dejB                  «      Z* G d„ dejB                  «      Z+ G d „ d!ejB                  «      Z, G d"„ d#ejB                  «      Z- G d$„ d%ejB                  «      Z.e G d&„ d'e«      «       Z/e G d(„ d)e/«      «       Z0e G d*„ d+e/«      «       Z1 ed,¬-«       G d.„ d/e/«      «       Z2e G d0„ d1e/«      «       Z3e G d2„ d3e/«      «       Z4e G d4„ d5e/«      «       Z5g d6¢Z6y)7z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                   ó*   ‡ — e Zd ZdZˆ fd„Zdd„Zˆ xZS )ÚSqueezeBertEmbeddingszGConstruct the embeddings from word, position and token_type embeddings.c                 ó|  •— t         ‰| �  «        t        j                  |j                  |j
                  |j                  ¬«      | _        t        j                  |j                  |j
                  «      | _	        t        j                  |j                  |j
                  «      | _        t        j                  |j                  |j                  ¬«      | _        t        j                  |j                   «      | _        | j%                  dt'        j(                  |j                  «      j+                  d«      d¬«       y )N)Úpadding_idx©ÚepsÚposition_ids©r   éÿÿÿÿF)Ú
persistent)Ú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Úregister_bufferÚtorchÚarangeÚexpand©ÚselfÚconfigÚ	__class__s     €ú/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/models/squeezebert/modeling_squeezebert.pyr"   z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 &×"<Ñ"<Ó=ˆŒð 	×ÑØœEŸL™L¨×)GÑ)GÓH×OÑOÐPWÓXÐejð 	õ 	
ó    c                 óÀ  — |�|j                  «       }n|j                  «       d d }|d   }|€| j                  d d …d |…f   }|€:t        j                  |t        j                  | j                  j
                  ¬«      }|€| j                  |«      }| j                  |«      }| j                  |«      }||z   |z   }	| j                  |	«      }	| j                  |	«      }	|	S )Nr   r   ©ÚdtypeÚdevice)Úsizer   r3   ÚzerosÚlongr?   r'   r)   r+   r,   r1   )
r7   Ú	input_idsÚtoken_type_idsr   Úinputs_embedsÚinput_shapeÚ
seq_lengthr)   r+   Ú
embeddingss
             r:   Úforwardz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Ñ8Ð;PÑPˆ
Ø—^‘^ JÓ/ˆ
Ø—\‘\ *Ó-ˆ
ØÐr;   )NNNN©Ú__name__Ú
__module__Ú__qualname__Ú__doc__r"   rI   Ú__classcell__©r9   s   @r:   r   r   -   s   ø„ ÙQô
÷r;   r   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )Ú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                 ó"   •— t         ‰| �  «        y ©N)r!   r"   )r7   r9   s    €r:   r"   zMatMulWrapper.__init__]   s   ø€ Ü‰ÑÕr;   c                 ó.   — t        j                  ||«      S )a0  

        :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]
        )r3   Úmatmul)r7   Úmat1Úmat2s      r:   rI   zMatMulWrapper.forward`   s   € ô �|‰|˜D $Ó'Ð'r;   rJ   rP   s   @r:   rR   rR   W   s   ø„ ñô
ö(r;   rR   c                   ó   — e Zd ZdZdd„Zd„ Zy)Ú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   — t         j                  j                  | ||¬«       y )N)Únormalized_shaper   )r   r,   r"   )r7   r-   r   s      r:   r"   zSqueezeBertLayerNorm.__init__r   s   € Ü
�‰×Ñ˜d°[ÀcÐÕJr;   c                 óŽ   — |j                  ddd«      }t        j                  j                  | |«      }|j                  ddd«      S )Nr   é   r   )Úpermuter   r,   rI   )r7   Úxs     r:   rI   zSqueezeBertLayerNorm.forwardu   s=   € Ø�I‰I�a˜˜AÓˆÜ�L‰L× Ñ   qÓ)ˆØ�y‰y˜˜A˜qÓ!Ð!r;   N)gê-�™—q=)rK   rL   rM   rN   r"   rI   © r;   r:   rZ   rZ   k   s   „ ñóKó"r;   rZ   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚConvDropoutLayerNormz8
    ConvDropoutLayerNorm: Conv, Dropout, LayerNorm
    c                 ó²   •— t         ‰| �  «        t        j                  ||d|¬«      | _        t        |«      | _        t        j                  |«      | _        y ©Nr   ©Úin_channelsÚout_channelsÚkernel_sizeÚgroups)	r!   r"   r   ÚConv1dÚconv1drZ   Ú	layernormr/   r1   )r7   ÚcinÚcoutrj   Údropout_probr9   s        €r:   r"   zConvDropoutLayerNorm.__init__€   sB   ø€ Ü‰ÑÔä—i‘i¨C¸dÐPQÐZ`ÔaˆŒÜ-¨dÓ3ˆŒÜ—z‘z ,Ó/ˆ�r;   c                 óv   — | j                  |«      }| j                  |«      }||z   }| j                  |«      }|S rT   )rl   r1   rm   )r7   Úhidden_statesÚinput_tensorr`   s       r:   rI   zConvDropoutLayerNorm.forward‡   s:   € Ø�K‰K˜Ó&ˆØ�L‰L˜‹OˆØ�ÑˆØ�N‰N˜1ÓˆØˆr;   rJ   rP   s   @r:   rc   rc   {   s   ø„ ñô0ör;   rc   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚConvActivationz*
    ConvActivation: Conv, Activation
    c                 óz   •— t         ‰| �  «        t        j                  ||d|¬«      | _        t
        |   | _        y re   )r!   r"   r   rk   rl   r	   Úact)r7   rn   ro   rj   rw   r9   s        €r:   r"   zConvActivation.__init__”   s1   ø€ Ü‰ÑÔÜ—i‘i¨C¸dÐPQÐZ`ÔaˆŒÜ˜#‘;ˆ�r;   c                 óF   — | j                  |«      }| j                  |«      S rT   )rl   rw   )r7   r`   Úoutputs      r:   rI   zConvActivation.forward™   s   € Ø—‘˜Q“ˆØ�x‰x˜ÓÐr;   rJ   rP   s   @r:   ru   ru   �   s   ø„ ñôö
 r;   ru   c                   ó8   ‡ — e Zd Zdˆ fd„	Zd„ Zd„ Zd„ Zd„ Zˆ xZS )ÚSqueezeBertSelfAttentionc                 ó„  •— t         ‰| �  «        ||j                  z  dk7  rt        d|› d|j                  › d�«      ‚|j                  | _        t	        ||j                  z  «      | _        | j                  | j
                  z  | _        t        j                  ||d|¬«      | _	        t        j                  ||d|¬«      | _
        t        j                  ||d|¬«      | _        t        j                  |j                  «      | _        t        j                  d¬«      | _        t#        «       | _        t#        «       | _        y	)
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
        r   zcin (z6) is not a multiple of the number of attention heads (ú)r   rf   r   ©ÚdimN)r!   r"   Únum_attention_headsÚ
ValueErrorÚintÚattention_head_sizeÚall_head_sizer   rk   ÚqueryÚkeyÚvaluer/   Úattention_probs_dropout_probr1   ÚSoftmaxÚsoftmaxrR   Ú	matmul_qkÚ
matmul_qkv)r7   r8   rn   Úq_groupsÚk_groupsÚv_groupsr9   s         €r:   r"   z!SqueezeBertSelfAttention.__init__Ÿ   s
  ø€ ô
 	‰ÑÔØ�×+Ñ+Ñ+¨qÒ0ÜØ˜�uÐRÐSY×SmÑSmÐRnÐnoÐpóð ð $*×#=Ñ#=ˆÔ Ü#& s¨V×-GÑ-GÑ'GÓ#HˆÔ Ø!×5Ñ5¸×8PÑ8PÑPˆÔä—Y‘Y¨3¸SÈaÐX`ÔaˆŒ
Ü—9‘9¨¸3ÈAÐV^Ô_ˆŒÜ—Y‘Y¨3¸SÈaÐX`ÔaˆŒ
ä—z‘z &×"EÑ"EÓFˆŒÜ—z‘z bÔ)ˆŒä&›ˆŒÜ'›/ˆ�r;   c                 óÀ   — |j                  «       d   | j                  | j                  |j                  «       d   f} |j                  |Ž }|j	                  dddd«      S )z
        - input: [N, C, W]
        - output: [N, C1, W, C2] where C1 is the head index, and C2 is one head's contents
        r   r   r   r   r^   )r@   r€   rƒ   Úviewr_   ©r7   r`   Únew_x_shapes      r:   Útranspose_for_scoresz-SqueezeBertSelfAttention.transpose_for_scores·   s]   € ð
 —v‘v“x ‘{ D×$<Ñ$<¸d×>VÑ>VÐXY×X^ÑX^ÓX`ÐacÑXdÐeˆØˆA�F‰F�KÐ ˆØ�y‰y˜˜A˜q !Ó$Ð$r;   c                 óœ   — |j                  «       d   | j                  | j                  |j                  «       d   f} |j                  |Ž }|S )z
        - input: [N, C, W]
        - output: [N, C1, C2, W] where C1 is the head index, and C2 is one head's contents
        r   r   )r@   r€   rƒ   r‘   r’   s      r:   Útranspose_key_for_scoresz1SqueezeBertSelfAttention.transpose_key_for_scoresÀ   sM   € ð
 —v‘v“x ‘{ D×$<Ñ$<¸d×>VÑ>VÐXY×X^ÑX^ÓX`ÐacÑXdÐeˆØˆA�F‰F�KÐ ˆàˆr;   c                 óÊ   — |j                  dddd«      j                  «       }|j                  «       d   | j                  |j                  «       d   f} |j                  |Ž }|S )zE
        - input: [N, C1, W, C2]
        - output: [N, C, W]
        r   r   r   r^   )r_   Ú
contiguousr@   r„   r‘   r’   s      r:   Útranspose_outputz)SqueezeBertSelfAttention.transpose_outputÊ   s\   € ð
 �I‰I�a˜˜A˜qÓ!×,Ñ,Ó.ˆØ—v‘v“x ‘{ D×$6Ñ$6¸¿¹»À¹ÐDˆØˆA�F‰F�KÐ ˆØˆr;   c                 óè  — | j                  |«      }| j                  |«      }| j                  |«      }| j                  |«      }| j	                  |«      }| j                  |«      }	| j                  ||«      }
|
t        j                  | j                  «      z  }
|�|
|z   }
| j                  |
«      }| j                  |«      }| j                  ||	«      }| j                  |«      }d|i}|r|
|d<   |S )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Š   r1   rŒ   r™   )r7   rr   Úattention_maskÚoutput_attentionsÚmixed_query_layerÚmixed_key_layerÚmixed_value_layerÚquery_layerÚ	key_layerÚvalue_layerrœ   Úattention_probsr›   Úresults                 r:   rI   z SqueezeBertSelfAttention.forwardÔ   sú   € ð !ŸJ™J }Ó5ÐØŸ(™( =Ó1ˆØ ŸJ™J }Ó5Ðà×/Ñ/Ð0AÓBˆØ×1Ñ1°/ÓBˆ	Ø×/Ñ/Ð0AÓBˆð Ÿ.™.¨°iÓ@ˆØ)¬D¯I©I°d×6NÑ6NÓ,OÑOˆàÐ%Ø-°Ñ>ˆOð Ÿ,™, Ó7ˆð Ÿ,™, Ó7ˆàŸ™¨¸ÓEˆØ×-Ñ-¨mÓ<ˆà! =Ð1ˆÙØ(7ˆFÐ$Ñ%Øˆr;   )r   r   r   )	rK   rL   rM   r"   r”   r–   r™   rI   rO   rP   s   @r:   r{   r{   ž   s   ø„ õ*ò0%òòö"r;   r{   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚSqueezeBertModulec                 óØ  •— t         ‰| �  «        |j                  }|j                  }|j                  }|j                  }t	        |||j
                  |j                  |j                  ¬«      | _        t        |||j                  |j                  ¬«      | _        t        |||j                  |j                  ¬«      | _        t        |||j"                  |j                  ¬«      | _        y)a€  
        - 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)
        )r8   rn   r�   rŽ   r�   )rn   ro   rj   rp   )rn   ro   rj   rw   N)r!   r"   r-   Úintermediate_sizer{   r�   rŽ   r�   Ú	attentionrc   Úpost_attention_groupsr0   Úpost_attentionru   Úintermediate_groupsÚ
hidden_actÚintermediateÚoutput_groupsry   )r7   r8   Úc0Úc1Úc2Úc3r9   s         €r:   r"   zSqueezeBertModule.__init__ú   sÉ   ø€ ô 	‰ÑÔà×ÑˆØ×ÑˆØ×%Ñ%ˆØ×Ñˆä1Ø˜r¨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                 ó¼   — | j                  |||«      }|d   }| j                  ||«      }| j                  |«      }| j                  ||«      }d|i}	|r|d   |	d<   |	S )Nr›   Úfeature_maprœ   )r­   r¯   r²   ry   )
r7   rr   rŸ   r    ÚattÚattention_outputÚpost_attention_outputÚintermediate_outputÚlayer_outputÚoutput_dicts
             r:   rI   zSqueezeBertModule.forward  s|   € Ø�n‰n˜]¨NÐ<MÓNˆØ˜Ñ/Ðà $× 3Ñ 3Ð4DÀmÓ TÐØ"×/Ñ/Ð0EÓFÐØ—{‘{Ð#6Ð8MÓNˆà$ lÐ3ˆÙØ-0Ð1BÑ-CˆKÐ)Ñ*àÐr;   ©rK   rL   rM   r"   rI   rO   rP   s   @r:   rª   rª   ù   s   ø„ ô
ö4r;   rª   c                   ó.   ‡ — e Zd Zˆ fd„Z	 	 	 	 dd„Zˆ xZS )ÚSqueezeBertEncoderc                 óÐ   •‡— t         ‰| �  «        ‰j                  ‰j                  k(  sJ d«       ‚t	        j
                  ˆfd„t        ‰j                  «      D «       «      | _        y )Nz™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   ó4   •K  — | ]  }t        ‰«      –— Œ y ­wrT   )rª   )Ú.0Ú_r8   s     €r:   ú	<genexpr>z.SqueezeBertEncoder.__init__.<locals>.<genexpr>-  s   øè ø€ Ò#gÀ!Ô$5°f×$=Ñ#gùs   ƒ)	r!   r"   r%   r-   r   Ú
ModuleListÚrangeÚnum_hidden_layersÚlayersr6   s    `€r:   r"   zSqueezeBertEncoder.__init__$  sW   ù€ Ü‰ÑÔà×$Ñ$¨×(:Ñ(:Ò:ð 	
ð2ó	
Ð:ô —m‘mÓ#gÄuÈV×MeÑMeÓGfÔ#gÓgˆ�r;   c                 ó†  — |j                  ddd«      }|rdnd }|rdnd }| j                  D ]T  }|r,|j                  ddd«      }||fz  }|j                  ddd«      }|j                  |||«      }	|	d   }|sŒL||	d   fz  }ŒV |j                  ddd«      }|r||fz  }|st        d„ |||fD «       «      S t	        |||¬«      S )	Nr   r^   r   ra   r¹   rœ   c              3   ó&   K  — | ]	  }|€Œ|–— Œ y ­wrT   ra   )rÅ   Úvs     r:   rÇ   z-SqueezeBertEncoder.forward.<locals>.<genexpr>Q  s   è ø€ Òh˜qÐZ[ÑZgœÑhùs   ‚Š)Úlast_hidden_staterr   Ú
attentions)r_   rË   rI   Útupler   )
r7   rr   rŸ   r    Úoutput_hidden_statesÚreturn_dictÚall_hidden_statesÚall_attentionsÚlayerr¾   s
             r:   rI   zSqueezeBertEncoder.forward/  s  € ð &×-Ñ-¨a°°AÓ6ˆá"6™B¸DÐÙ0™°dˆà—[‘[ò 	EˆEÙ#Ø -× 5Ñ 5°a¸¸AÓ >�Ø! mÐ%5Ñ5Ð!Ø -× 5Ñ 5°a¸¸AÓ >�à Ÿ=™=¨¸ÐHYÓZˆLà(¨Ñ7ˆMâ Ø <Ð0AÑ#BÐ"DÑD‘ð	Eð &×-Ñ-¨a°°AÓ6ˆáØ -Ð!1Ñ1ÐáÜÑh ]Ð4EÀ~Ð$VÔhÓhÐhÜØ+Ð;LÐYgô
ð 	
r;   )NFFTrÀ   rP   s   @r:   rÂ   rÂ   #  s   ø„ ô	hð ØØ"Ø÷%
r;   rÂ   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚSqueezeBertPoolerc                 ó²   •— t         ‰| �  «        t        j                  |j                  |j                  «      | _        t        j                  «       | _        y rT   )r!   r"   r   ÚLinearr-   ÚdenseÚTanhÚ
activationr6   s     €r:   r"   zSqueezeBertPooler.__init__X  s9   ø€ Ü‰ÑÔÜ—Y‘Y˜v×1Ñ1°6×3EÑ3EÓFˆŒ
ÜŸ'™'›)ˆ�r;   c                 ó\   — |d d …df   }| j                  |«      }| j                  |«      }|S )Nr   )rÛ   rÝ   )r7   rr   Úfirst_token_tensorÚpooled_outputs       r:   rI   zSqueezeBertPooler.forward]  s6   € ð +ª1¨a¨4Ñ0ÐØŸ
™
Ð#5Ó6ˆØŸ™¨Ó6ˆØÐr;   rÀ   rP   s   @r:   rØ   rØ   W  s   ø„ ô$ö
r;   rØ   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )Ú"SqueezeBertPredictionHeadTransformc                 óh  •— t         ‰| �  «        t        j                  |j                  |j                  «      | _        t        |j                  t        «      rt        |j                     | _
        n|j                  | _
        t        j                  |j                  |j                  ¬«      | _        y )Nr   )r!   r"   r   rÚ   r-   rÛ   Ú
isinstancer±   Ústrr	   Útransform_act_fnr,   r.   r6   s     €r:   r"   z+SqueezeBertPredictionHeadTransform.__init__g  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   — | j                  |«      }| j                  |«      }| j                  |«      }|S rT   )rÛ   ræ   r,   ©r7   rr   s     r:   rI   z*SqueezeBertPredictionHeadTransform.forwardp  s4   € ØŸ
™
 =Ó1ˆØ×-Ñ-¨mÓ<ˆØŸ™ }Ó5ˆØÐr;   rÀ   rP   s   @r:   râ   râ   f  s   ø„ ôUör;   râ   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚSqueezeBertLMPredictionHeadc                 ó  •— t         ‰| �  «        t        |«      | _        t	        j
                  |j                  |j                  d¬«      | _        t	        j                  t        j                  |j                  «      «      | _        y )NT)Úbias)r!   r"   râ   Ú	transformr   rÚ   r-   r$   ÚdecoderÚ	Parameterr3   rA   rì   r6   s     €r:   r"   z$SqueezeBertLMPredictionHead.__init__x  s[   ø€ Ü‰ÑÔÜ;¸FÓCˆŒô —y‘y ×!3Ñ!3°V×5FÑ5FÈTÔRˆŒä—L‘L¤§¡¨V×->Ñ->Ó!?Ó@ˆ�	r;   c                 óJ   — | j                  |«      }| j                  |«      }|S rT   )rí   rî   rè   s     r:   rI   z#SqueezeBertLMPredictionHead.forward„  s$   € ØŸ™ }Ó5ˆØŸ™ ]Ó3ˆØÐr;   rÀ   rP   s   @r:   rê   rê   w  s   ø„ ôAör;   rê   c                   ó$   ‡ — e Zd Zˆ fd„Zd„ Zˆ xZS )ÚSqueezeBertOnlyMLMHeadc                 óB   •— t         ‰| �  «        t        |«      | _        y rT   )r!   r"   rê   Úpredictionsr6   s     €r:   r"   zSqueezeBertOnlyMLMHead.__init__‹  s   ø€ Ü‰ÑÔÜ6°vÓ>ˆÕr;   c                 ó(   — | j                  |«      }|S rT   )rô   )r7   Úsequence_outputÚprediction_scoress      r:   rI   zSqueezeBertOnlyMLMHead.forward�  s   € Ø ×,Ñ,¨_Ó=ÐØ Ð r;   rÀ   rP   s   @r:   rò   rò   Š  s   ø„ ô?ö!r;   rò   c                   óV   ‡ — e Zd ZU eed<   dZ ej                  «       ˆ fd„«       Zˆ xZ	S )ÚSqueezeBertPreTrainedModelr8   Útransformerc                 óX  •— t         ‰| �  |«       t        |t        «      r t	        j
                  |j                  «       yt        |t        «      rZt	        j                  |j                  t        j                  |j                  j                  d   «      j                  d«      «       yy)zInitialize the weightsr   r   N)r!   Ú_init_weightsrä   rê   ÚinitÚzeros_rì   r   Úcopy_r   r3   r4   Úshaper5   )r7   Úmoduler9   s     €r:   rü   z(SqueezeBertPreTrainedModel._init_weights™  sx   ø€ ô 	‰Ñ˜fÔ%Ü�fÔ9Ô:Ü�K‰K˜Ÿ™Õ$Ü˜Ô 5Ô6Ü�J‰J�v×*Ñ*¬E¯L©L¸×9LÑ9L×9RÑ9RÐSUÑ9VÓ,W×,^Ñ,^Ð_fÓ,gÕhð 7r;   )
rK   rL   rM   r   Ú__annotations__Úbase_model_prefixr3   Úno_gradrü   rO   rP   s   @r:   rù   rù   ”  s+   ø… àÓØ%Ðà€U‡]�]ƒ_óió ôir;   rù   c                   ó  ‡ — e Zd Zˆ fd„Zd„ Zd„ Ze	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  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 )ÚSqueezeBertModelc                 ó¤   •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        t        |«      | _        | j                  «        y rT   )	r!   r"   r   rH   rÂ   ÚencoderrØ   ÚpoolerÚ	post_initr6   s     €r:   r"   zSqueezeBertModel.__init__¥  s@   ø€ Ü‰Ñ˜Ô ä/°Ó7ˆŒÜ)¨&Ó1ˆŒÜ'¨Ó/ˆŒð 	�‰Õr;   c                 ó.   — | j                   j                  S rT   ©rH   r'   ©r7   s    r:   Úget_input_embeddingsz%SqueezeBertModel.get_input_embeddings¯  s   € Ø�‰×.Ñ.Ð.r;   c                 ó&   — || j                   _        y rT   r  ©r7   Únew_embeddingss     r:   Úset_input_embeddingsz%SqueezeBertModel.set_input_embeddings²  s   € Ø*8ˆ�‰Õ'r;   NrC   rŸ   rD   r   rE   r    rÒ   rÓ   Úreturnc	                 ó  — |�|n| j                   j                  }|�|n| j                   j                  }|�|n| j                   j                  }|�|�t	        d«      ‚|�#| j                  ||«       |j                  «       }
n!|�|j                  «       d d }
nt	        d«      ‚|�|j                  n|j                  }|€t        j                  |
|¬«      }|€&t        j                  |
t        j                  |¬«      }| j                  ||||¬«      }t        | j                   ||¬«      }| j                  |||||¬«      }|d	   }| j                  |«      }|s
||f|d
d  z   S t!        |||j"                  |j$                  ¬«      S )NzDYou cannot specify both input_ids and inputs_embeds at the same timer   z5You have to specify either input_ids or inputs_embeds)r?   r=   )rC   r   rD   rE   )r8   rE   rŸ   )rr   rŸ   r    rÒ   rÓ   r   r   )rÏ   Úpooler_outputrr   rÐ   )r8   r    rÒ   rÓ   r�   Ú%warn_if_padding_and_no_attention_maskr@   r?   r3   ÚonesrA   rB   rH   r
   r  r	  r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   r    rÒ   rÓ   ÚkwargsrF   r?   Úembedding_outputÚencoder_outputsrö   rà   s                   r:   rI   z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¨¸FÔCˆNØÐ!Ü"Ÿ[™[¨¼E¿J¹JÈvÔVˆNàŸ?™?Ø¨lÈ>Ðivð +ó 
Ðô 3Ø—;‘;Ø*Ø)ô
ˆð Ÿ,™,Ø*Ø)Ø/Ø!5Ø#ð 'ó 
ˆð *¨!Ñ,ˆØŸ™ OÓ4ˆáØ# ]Ð3°oÀaÀbÐ6IÑIÐIä)Ø-Ø'Ø)×7Ñ7Ø&×1Ñ1ô	
ð 	
r;   )NNNNNNNN)rK   rL   rM   r"   r  r  r   r3   ÚTensorÚFloatTensorÚboolrÑ   r   rI   rO   rP   s   @r:   r  r  £  sÙ   ø„ ôò/ò9ð ð *.Ø.2Ø.2Ø,0Ø26Ø)-Ø,0Ø#'ñ?
à—<‘< $Ñ&ð?
ð Ÿ™ tÑ+ð?
ð Ÿ™ tÑ+ð	?
ð
 —l‘l TÑ)ð?
ð ×(Ñ(¨4Ñ/ð?
ð   $™;ð?
ð # T™kð?
ð ˜D‘[ð?
ð 
Ð+Ñ	+ò?
ó ô?
r;   r  c                   ó6  ‡ — e Zd ZdddœZˆ fd„Zd„ Zd„ Ze	 	 	 	 	 	 	 	 	 ddej                  dz  d	ej                  dz  d
ej                  dz  dej                  dz  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 )ÚSqueezeBertForMaskedLMzcls.predictions.biasz-transformer.embeddings.word_embeddings.weight)zcls.predictions.decoder.biaszcls.predictions.decoder.weightc                 ó„   •— t         ‰| �  |«       t        |«      | _        t	        |«      | _        | j                  «        y rT   )r!   r"   r  rú   rò   Úclsr
  r6   s     €r:   r"   zSqueezeBertForMaskedLM.__init__ÿ  s5   ø€ Ü‰Ñ˜Ô ä+¨FÓ3ˆÔÜ)¨&Ó1ˆŒð 	�‰Õr;   c                 óB   — | j                   j                  j                  S rT   )r!  rô   rî   r  s    r:   Úget_output_embeddingsz,SqueezeBertForMaskedLM.get_output_embeddings  s   € Ø�x‰x×#Ñ#×+Ñ+Ð+r;   c                 ó„   — || j                   j                  _        |j                  | j                   j                  _        y rT   )r!  rô   rî   rì   r  s     r:   Úset_output_embeddingsz,SqueezeBertForMaskedLM.set_output_embeddings  s,   € Ø'5ˆ�‰×ÑÔ$Ø$2×$7Ñ$7ˆ�‰×ÑÕ!r;   NrC   rŸ   rD   r   rE   Úlabelsr    rÒ   rÓ   r  c
           
      ó˜  — |	�|	n| j                   j                  }	| j                  ||||||||	¬«      }|d   }| j                  |«      }d}|�Ft	        «       } ||j                  d| j                   j                  «      |j                  d«      «      }|	s|f|dd z   }|�|f|z   S |S t        |||j                  |j                  ¬«      S )a¢  
        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Ÿ   rD   r   rE   r    rÒ   rÓ   r   r   r^   ©ÚlossÚlogitsrr   rÐ   )
r8   rÓ   rú   r!  r   r‘   r$   r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  Úoutputsrö   r÷   Úmasked_lm_lossÚloss_fctry   s                    r:   rI   z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°A°B¨KÑ7ˆFØ3AÐ3M�^Ð%¨Ñ.ÐYÐSYÐYäØØ$Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   ©	NNNNNNNNN)rK   rL   rM   Ú_tied_weights_keysr"   r#  r%  r   r3   r  r  rÑ   r   rI   rO   rP   s   @r:   r  r  ø  sü   ø„ ð )?Ø*YñÐô
ò,ò8ð ð *.Ø.2Ø.2Ø,0Ø-1Ø&*Ø)-Ø,0Ø#'ñ1
à—<‘< $Ñ&ð1
ð Ÿ™ tÑ+ð1
ð Ÿ™ tÑ+ð	1
ð
 —l‘l TÑ)ð1
ð —|‘| dÑ*ð1
ð —‘˜tÑ#ð1
ð   $™;ð1
ð # T™kð1
ð ˜D‘[ð1
ð 
�Ñ	ò1
ó ô1
r;   r  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                   ó   ‡ — e Zd Zˆ fd„Ze	 	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  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 )Ú$SqueezeBertForSequenceClassificationc                 óN  •— t         ‰| �  |«       |j                  | _        || _        t	        |«      | _        t        j                  |j                  «      | _	        t        j                  |j                  | j                  j                  «      | _        | j                  «        y rT   )r!   r"   Ú
num_labelsr8   r  rú   r   r/   r0   r1   rÚ   r-   Ú
classifierr
  r6   s     €r:   r"   z-SqueezeBertForSequenceClassification.__init__K  su   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒØˆŒä+¨FÓ3ˆÔÜ—z‘z &×"<Ñ"<Ó=ˆŒÜŸ)™) F×$6Ñ$6¸¿¹×8NÑ8NÓOˆŒð 	�‰Õr;   NrC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  c
           
      ó>  — |	�|	n| j                   j                  }	| j                  ||||||||	¬«      }|d   }| j                  |«      }| j	                  |«      }d}|��‡| j                   j
                  €�| j                  dk(  rd| j                   _        nl| j                  dkD  rL|j                  t        j                  k(  s|j                  t        j                  k(  rd| j                   _        nd| j                   _        | j                   j
                  dk(  rIt        «       }| j                  dk(  r& ||j                  «       |j                  «       «      }nŒ |||«      }n‚| j                   j
                  dk(  r=t        «       } ||j                  d| j                  «      |j                  d«      «      }n,| j                   j
                  dk(  rt        «       } |||«      }|	s|f|dd z   }|�|f|z   S |S t!        |||j"                  |j$                  ¬	«      S )
a�  
        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(  r   Ú
regressionÚsingle_label_classificationÚmulti_label_classificationr   r^   r)  )r8   rÓ   rú   r1   r6  Úproblem_typer5  r>   r3   rB   r‚   r   Úsqueezer   r‘   r   r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  r,  rà   r+  r*  r.  ry   s                    r:   rI   z,SqueezeBertForSequenceClassification.forwardW  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¨FÓ3‘DØ—‘×)Ñ)Ð-JÒJÜ+Ó-�Ù §¡¨B°·±Ó @À&Ç+Á+ÈbÃ/ÓR‘Ø—‘×)Ñ)Ð-IÒIÜ,Ó.�Ù ¨Ó/�áØ�Y ¨¨ Ñ,ˆFØ)-Ð)9�T�G˜fÑ$ÐE¸vÐEä'ØØØ!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   r/  )rK   rL   rM   r"   r   r3   r  r  rÑ   r   rI   rO   rP   s   @r:   r3  r3  D  sï   ø„ ô
ð ð *.Ø.2Ø.2Ø,0Ø-1Ø&*Ø)-Ø,0Ø#'ñE
à—<‘< $Ñ&ðE
ð Ÿ™ tÑ+ðE
ð Ÿ™ tÑ+ð	E
ð
 —l‘l TÑ)ðE
ð —|‘| dÑ*ðE
ð —‘˜tÑ#ðE
ð   $™;ðE
ð # T™kðE
ð ˜D‘[ðE
ð 
Ð)Ñ	)òE
ó ôE
r;   r3  c                   ó   ‡ — e Zd Zˆ fd„Ze	 	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  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 )ÚSqueezeBertForMultipleChoicec                 óö   •— t         ‰| �  |«       t        |«      | _        t	        j
                  |j                  «      | _        t	        j                  |j                  d«      | _
        | j                  «        y )Nr   )r!   r"   r  rú   r   r/   r0   r1   rÚ   r-   r6  r
  r6   s     €r:   r"   z%SqueezeBertForMultipleChoice.__init__¢  sW   ø€ Ü‰Ñ˜Ô ä+¨FÓ3ˆÔÜ—z‘z &×"<Ñ"<Ó=ˆŒÜŸ)™) F×$6Ñ$6¸Ó:ˆŒð 	�‰Õr;   NrC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  c
           
      óJ  — |	�|	n| j                   j                  }	|�|j                  d   n|j                  d   }|�!|j                  d|j	                  d«      «      nd}|�!|j                  d|j	                  d«      «      nd}|�!|j                  d|j	                  d«      «      nd}|�!|j                  d|j	                  d«      «      nd}|�1|j                  d|j	                  d«      |j	                  d«      «      nd}| j                  ||||||||	¬«      }|d   }| j                  |«      }| j                  |«      }|j                  d|«      }d}|�t        «       } |||«      }|	s|f|dd z   }|�|f|z   S |S t        |||j                  |j                  ¬«      S )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^   r)  )r8   rÓ   r   r‘   r@   rú   r1   r6  r   r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  Únum_choicesr,  rà   r+  Úreshaped_logitsr*  r.  ry   s                      r:   rI   z$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¨VÓ4ˆDáØ%Ð'¨'°!°"¨+Ñ5ˆFØ)-Ð)9�T�G˜fÑ$ÐE¸vÐEä(ØØ"Ø!×/Ñ/Ø×)Ñ)ô	
ð 	
r;   r/  )rK   rL   rM   r"   r   r3   r  r  rÑ   r   rI   rO   rP   s   @r:   r>  r>     sï   ø„ ôð ð *.Ø.2Ø.2Ø,0Ø-1Ø&*Ø)-Ø,0Ø#'ñW
à—<‘< $Ñ&ðW
ð Ÿ™ tÑ+ðW
ð Ÿ™ tÑ+ð	W
ð
 —l‘l TÑ)ðW
ð —|‘| dÑ*ðW
ð —‘˜tÑ#ðW
ð   $™;ðW
ð # T™kðW
ð ˜D‘[ðW
ð 
Ð*Ñ	*òW
ó ôW
r;   r>  c                   ó   ‡ — e Zd Zˆ fd„Ze	 	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  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 )Ú!SqueezeBertForTokenClassificationc                 ó,  •— t         ‰| �  |«       |j                  | _        t        |«      | _        t        j                  |j                  «      | _        t        j                  |j                  |j                  «      | _        | j                  «        y rT   )r!   r"   r5  r  rú   r   r/   r0   r1   rÚ   r-   r6  r
  r6   s     €r:   r"   z*SqueezeBertForTokenClassification.__init__	  sj   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä+¨FÓ3ˆÔÜ—z‘z &×"<Ñ"<Ó=ˆŒÜŸ)™) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Õr;   NrC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  c
           
      ó¦  — |	�|	n| j                   j                  }	| j                  ||||||||	¬«      }|d   }| j                  |«      }| j	                  |«      }d}|�<t        «       } ||j                  d| j                  «      |j                  d«      «      }|	s|f|dd z   }|�|f|z   S |S t        |||j                  |j                  ¬«      S )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^   r)  )r8   rÓ   rú   r1   r6  r   r‘   r5  r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   r&  r    rÒ   rÓ   r  r,  rö   r+  r*  r.  ry   s                    r:   rI   z)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;   r/  )rK   rL   rM   r"   r   r3   r  r  rÑ   r   rI   rO   rP   s   @r:   rE  rE    sã   ø„ ô	ð ð *.Ø.2Ø.2Ø,0Ø-1Ø&*Ø)-Ø,0Ø#'ñ1
à—<‘< $Ñ&ð1
ð Ÿ™ tÑ+ð1
ð Ÿ™ tÑ+ð	1
ð
 —l‘l TÑ)ð1
ð —|‘| dÑ*ð1
ð —‘˜tÑ#ð1
ð   $™;ð1
ð # T™kð1
ð ˜D‘[ð1
ð 
Ð&Ñ	&ò1
ó ô1
r;   rE  c                   ó@  ‡ — e Zd Zˆ fd„Ze	 	 	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  dej                  dz  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 )ÚSqueezeBertForQuestionAnsweringc                 óä   •— t         ‰| �  |«       |j                  | _        t        |«      | _        t        j                  |j                  |j                  «      | _        | j                  «        y rT   )
r!   r"   r5  r  rú   r   rÚ   r-   Ú
qa_outputsr
  r6   s     €r:   r"   z(SqueezeBertForQuestionAnswering.__init__K  sT   ø€ Ü‰Ñ˜Ô Ø ×+Ñ+ˆŒä+¨FÓ3ˆÔÜŸ)™) F×$6Ñ$6¸×8IÑ8IÓJˆŒð 	�‰Õr;   NrC   rŸ   rD   r   rE   Ústart_positionsÚend_positionsr    rÒ   rÓ   r  c           
      ó&  — |
�|
n| j                   j                  }
| j                  |||||||	|
¬«      }|d   }| j                  |«      }|j	                  dd¬«      \  }}|j                  d«      j                  «       }|j                  d«      j                  «       }d }|�·|�µt        |j                  «       «      dkD  r|j                  d«      }t        |j                  «       «      dkD  r|j                  d«      }|j                  d«      }|j                  d|«      }|j                  d|«      }t        |¬«      } |||«      } |||«      }||z   dz  }|
s||f|dd  z   }|�|f|z   S |S t        ||||j                  |j                  ¬«      S )	Nr(  r   r   r   r~   )Úignore_indexr^   )r*  Ústart_logitsÚ
end_logitsrr   rÐ   )r8   rÓ   rú   rK  Úsplitr<  r˜   Úlenr@   Úclampr   r   rr   rÐ   )r7   rC   rŸ   rD   r   rE   rL  rM  r    rÒ   rÓ   r  r,  rö   r+  rP  rQ  Ú
total_lossÚignored_indexr.  Ú
start_lossÚend_lossry   s                          r:   rI   z'SqueezeBertForQuestionAnswering.forwardU  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;   )
NNNNNNNNNN)rK   rL   rM   r"   r   r3   r  r  rÑ   r   rI   rO   rP   s   @r:   rI  rI  I  sù   ø„ ôð ð *.Ø.2Ø.2Ø,0Ø-1Ø/3Ø-1Ø)-Ø,0Ø#'ñ=
à—<‘< $Ñ&ð=
ð Ÿ™ tÑ+ð=
ð Ÿ™ tÑ+ð	=
ð
 —l‘l TÑ)ð=
ð —|‘| dÑ*ð=
ð Ÿ™¨Ñ,ð=
ð —|‘| dÑ*ð=
ð   $™;ð=
ð # T™kð=
ð ˜D‘[ð=
ð 
Ð-Ñ	-ò=
ó ô=
r;   rI  )r  r>  rI  r3  rE  r  rª   rù   )7rN   r�   r3   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_loggerrK   ÚloggerÚModuler   rR   r,   rZ   rc   ru   r{   rª   rÂ   rØ   râ   rê   rò   rù   r  r  r3  r>  rE  rI  Ú__all__ra   r;   r:   ú<module>re     s  ðñ !ã ã Ý ß AÑ Aå &Ý !Ý 6÷÷ ñ õ .÷õ 9ð 
ˆ×	Ñ	˜HÓ	%€ô'˜BŸI™Iô 'ôT(�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;   