
    rhQ                     :   d dl Z d dlZd dlmZmZmZ d dlZd dlZd dlm	Z	 d dl
mZ ddlmZ ddl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 ddlmZmZ ddlmZ ddlm Z m!Z! ddl"m#Z#  e!jH                  e%      Z& G d de      Z' G d de      Z( G d de      Z) G d de	jT                        Z+ G d de	jT                        Z, G d de	jT                        Z- G d de	jT                        Z.	 	 	 dBde	jT                  d ej^                  d!ej^                  d"ej^                  d#eej^                     d$ee0   d%e0d&eej^                     fd'Z1 G d( d)e	jT                        Z2 G d* d+e	jT                        Z3 G d, d-e      Z4 G d. d/e	jT                        Z5e  G d0 d1e             Z6	 	 dCd2e7e8e8f   d3e0d4e8d#eejr                     d5e8d6ejt                  fd7Z;e  G d8 d9e6             Z<dZ= e d:;       G d< d=e6             Z> e d>;       G d? d@e6             Z?g dAZ@y)D    N)CallableOptionalUnion)nn)CrossEntropyLoss   )ACT2FN)is_deepspeed_zero3_enabled)is_fsdp_managed_module)FlashAttentionKwargs)GradientCheckpointingLayer)BaseModelOutputCausalLMOutputSequenceClassifierOutput)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)auto_docstringlogging   )	SEWConfigc                   &     e Zd Zd fd	Zd Z xZS )SEWNoLayerNormConvLayerc                 d   t         |           |dkD  r|j                  |dz
     nd| _        |j                  |   | _        t        j                  | j                  | j                  |j                  |   |j                  |   |j                        | _
        t        |j                     | _        y )Nr   r   kernel_sizestridebias)super__init__conv_dimin_conv_dimout_conv_dimr   Conv1dconv_kernelconv_stride	conv_biasconvr	   feat_extract_activation
activationselfconfiglayer_id	__class__s      w/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/models/sew/modeling_sew.pyr    z SEWNoLayerNormConvLayer.__init__/   s    <DqL6??8a<8a"OOH5II**84%%h/!!
	 !!?!?@    c                 J    | j                  |      }| j                  |      }|S N)r(   r*   r,   hidden_statess     r0   forwardzSEWNoLayerNormConvLayer.forward=   s$    		-06r1   r   __name__
__module____qualname__r    r6   __classcell__r/   s   @r0   r   r   .   s    Ar1   r   c                   &     e Zd Zd fd	Zd Z xZS )SEWLayerNormConvLayerc                    t         |           |dkD  r|j                  |dz
     nd| _        |j                  |   | _        t        j                  | j                  | j                  |j                  |   |j                  |   |j                        | _
        t        j                  | j                  d      | _        t        |j                     | _        y )Nr   r   r   T)elementwise_affine)r   r    r!   r"   r#   r   r$   r%   r&   r'   r(   	LayerNorm
layer_normr	   r)   r*   r+   s      r0   r    zSEWLayerNormConvLayer.__init__D   s    <DqL6??8a<8a"OOH5II**84%%h/!!
	 ,,t'8'8TR !?!?@r1   c                     | j                  |      }|j                  dd      }| j                  |      }|j                  dd      }| j                  |      }|S )N)r(   	transposerC   r*   r4   s     r0   r6   zSEWLayerNormConvLayer.forwardS   sV    		-0%//B76%//B76r1   r7   r8   r=   s   @r0   r?   r?   C   s    Ar1   r?   c                   &     e Zd Zd fd	Zd Z xZS )SEWGroupNormConvLayerc                    t         |           |dkD  r|j                  |dz
     nd| _        |j                  |   | _        t        j                  | j                  | j                  |j                  |   |j                  |   |j                        | _
        t        |j                     | _        t        j                  | j                  | j                  d      | _        y )Nr   r   r   T)
num_groupsnum_channelsaffine)r   r    r!   r"   r#   r   r$   r%   r&   r'   r(   r	   r)   r*   	GroupNormrC   r+   s      r0   r    zSEWGroupNormConvLayer.__init___   s    <DqL6??8a<8a"OOH5II**84%%h/!!
	 !!?!?@,,$2C2CRVRcRclpqr1   c                 l    | j                  |      }| j                  |      }| j                  |      }|S r3   )r(   rC   r*   r4   s     r0   r6   zSEWGroupNormConvLayer.forwardo   s2    		-066r1   r7   r8   r=   s   @r0   rI   rI   ^   s    r r1   rI   c                   $     e Zd Z fdZd Z xZS )SEWPositionalConvEmbeddingc                    t         |           t        j                  |j                  |j                  |j
                  |j
                  dz  |j                  |j                        | _        t        j                  j                  }t        t        j                  j                  d      r$t        j                  j                  j                  }t               r(dd l}|j                  j!                  | j                  j"                  d      5   || j                  dd      | _        d d d        t        | j                  d      rU| j                  j                  j"                  j$                  }| j                  j                  j"                  j&                  }n,| j                  j(                  }| j                  j*                  }|j                  j-                  | |       |j                  j-                  | |       n || j                  dd      | _        t/        |j
                        | _        t2        |j4                     | _        y # 1 sw Y   'xY w)	N   )r   paddinggroupsr   weight_normr   modifier_rankweight)namedimparametrizations)r   r    r   r$   hidden_sizenum_conv_pos_embeddingsnum_conv_pos_embedding_groupssqueeze_factorr(   utilsrV   hasattrr\   r
   	deepspeedzeroGatheredParametersrY   	original0	original1weight_gweight_vregister_external_parameterSEWSamePadLayerrT   r	   r)   r*   )r,   r-   rV   rc   rh   ri   r/   s         r0   r    z#SEWPositionalConvEmbedding.__init__w   s   II6622a777((
	 hh**288,,m<((33??K%'224993C3CST2U I'		aH	Ityy"459955<<FF9955<<FF99--99--NN66tXFNN66tXF#DIIH!DDI&v'E'EF !?!?@I Is   IIc                 l    | j                  |      }| j                  |      }| j                  |      }|S r3   )r(   rT   r*   r4   s     r0   r6   z"SEWPositionalConvEmbedding.forward   s2    		-0]36r1   r8   r=   s   @r0   rQ   rQ   v   s     ADr1   rQ   c                   $     e Zd Z fdZd Z xZS )rk   c                 P    t         |           |dz  dk(  rd| _        y d| _        y )NrS   r   r   )r   r    num_pad_remove)r,   r^   r/   s     r0   r    zSEWSamePadLayer.__init__   s)    #:Q#>!#Car1   c                 V    | j                   dkD  r|d d d d d | j                    f   }|S Nr   )ro   r4   s     r0   r6   zSEWSamePadLayer.forward   s6    ")!Q0F43F3F2F0F*FGMr1   r8   r=   s   @r0   rk   rk      s    Kr1   rk   c                   $     e Zd Z fdZd Z xZS )SEWUpsamplingc                     t         |           t        j                  |j                  |j                  |j
                  z        | _        t        |j                     | _	        |j
                  | _        y r3   )
r   r    r   Linearr]   r`   
projectionr	   r)   r*   r,   r-   r/   s     r0   r    zSEWUpsampling.__init__   sW    ))F$6$68J8JVMbMb8bc !?!?@$33r1   c                 .   | j                  |      }| j                  |      }| j                  dkD  rc|j                         \  }}}|| j                  z  }|| j                  z  }|j	                  ||| j                  |      }|j	                  |||      }|S )Nr   )rv   r*   r`   sizereshape)r,   r5   bszsrc_lensrc_embed_dimtgt_lentgt_embed_dims          r0   r6   zSEWUpsampling.forward   s    66"*7*<*<*>'C- 3 33G)T-@-@@M)11#w@S@SUbcM)11#wNMr1   r8   r=   s   @r0   rs   rs      s    4r1   rs   c                   .     e Zd ZdZ fdZd Zd Z xZS )SEWFeatureEncoderz.Construct the features from raw audio waveformc           	         t         |           |j                  dk(  rDt        |d      gt	        |j
                  dz
        D cg c]  }t        ||dz          c}z   }nV|j                  dk(  r.t	        |j
                        D cg c]  }t        ||       }}nt        d|j                   d      t        j                  |      | _        d| _        d	| _        y c c}w c c}w )
Ngroupr   )r.   r   layerz`config.feat_extract_norm` is z), but has to be one of ['group', 'layer']FT)r   r    feat_extract_normrI   rangenum_feat_extract_layersr   r?   
ValueErrorr   
ModuleListconv_layersgradient_checkpointing_requires_grad)r,   r-   ir   r/   s       r0   r    zSEWFeatureEncoder.__init__   s    ##w.0!DEINvOmOmpqOqIrIDE'Q?I K %%0NSTZTrTrNst0!DtKt01I1I0JJst  ==5&+#"I us   C"	C'c                 J    | j                         D ]	  }d|_         d| _        y NF)
parametersrequires_gradr   r,   params     r0   _freeze_parametersz$SEWFeatureEncoder._freeze_parameters   s(    __& 	(E"'E	(#r1   c                     |d d d f   }| j                   r| j                  rd|_        | j                  D ]
  } ||      } |S )NT)r   trainingr   r   )r,   input_valuesr5   
conv_layers       r0   r6   zSEWFeatureEncoder.forward   sP    $QW- 4==*.M'** 	6J&}5M	6 r1   )r9   r:   r;   __doc__r    r   r6   r<   r=   s   @r0   r   r      s    8#"$

r1   r   modulequerykeyvalueattention_maskscalingdropout	head_maskc                    ||j                  d      dz  }t        j                  ||j                  dd            |z  }	||	|z   }	t        j
                  j                  |	d      }	||	|j                  dddd      z  }	t        j
                  j                  |	|| j                        }	t        j                  |	|      }
|
j                  dd      j                         }
|
|	fS )NrF         rS   r   r[   r   )pr   )ry   torchmatmulrG   r   
functionalsoftmaxviewr   r   
contiguous)r   r   r   r   r   r   r   r   kwargsattn_weightsattn_outputs              r0   eager_attention_forwardr      s     **R.D(<<s}}Q':;gEL!#n4==((2(>L#innQAq&AA==((6??([L,,|U3K''1-88:K$$r1   c                   H    e Zd ZdZ	 	 	 	 	 ddededededededee   f fd	Z		 	 	 	 dd
e
j                  dee
j                     dee
j                     dee
j                     dee   dee   dee
j                  ee
j                     eee
j                        f   fdZ xZS )SEWAttentionz=Multi-headed attention from 'Attention Is All You Need' paper	embed_dim	num_headsr   
is_decoderr   	is_causalr-   c                 
   t         |           || _        || _        || _        ||z  | _        || _        | j
                  |z  | j                  k7  rt        d| j                   d| d      | j
                  dz  | _        || _	        || _
        t        j                  |||      | _        t        j                  |||      | _        t        j                  |||      | _        t        j                  |||      | _        y )Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).r   )r   )r   r    r   r   r   head_dimr-   r   r   r   r   r   ru   k_projv_projq_projout_proj)	r,   r   r   r   r   r   r   r-   r/   s	           r0   r    zSEWAttention.__init__	  s     	""!Y.MMI%$..8MdnnM]$YKr3  }}d*$"ii	94@ii	94@ii	94@		)YTBr1   r5   key_value_statesr   layer_head_maskoutput_attentionsr   returnc                    |du}|j                   dd \  }}	|r|j                   d   n|	}
||	d| j                  f}||
d| j                  f} | j                  |      j                  | j	                  dd      }|r|n|} | j                  |      j                  | j	                  dd      } | j                  |      j                  | j	                  dd      }t        }| j                  j                  dk7  rt        | j                  j                     } || ||||f| j                  sdn| j                  | j                  ||d|\  }}|j                  ||	d      j                         }| j!                  |      }||dfS )z#Input shape: Batch x Time x ChannelNrF   r   rS   eager        )r   r   r   r   )shaper   r   r   rG   r   r   r   r-   _attn_implementationr   r   r   r   rz   r   r   )r,   r5   r   r   r   r   r   is_cross_attentionr{   r~   r|   q_input_shapekv_input_shapequery_statescurrent_states
key_statesvalue_statesattention_interfacer   r   s                       r0   r6   zSEWAttention.forward(  s    .T9 %**3B/W/A"((+wgr4==9wDMM: 7t{{=166FPPQRTUV-?)]5T[[055~FPPQRTUV
7t{{>277HRRSTVWX(?;;++w6"9$++:Z:Z"[$7%
  $}}C$,,LL/%%
 %
!\ "))#w;FFHmmK0L$..r1   )r   FTFN)NNNF)r9   r:   r;   r   intfloatboolr   r   r    r   Tensorr   r   tupler6   r<   r=   s   @r0   r   r     s   G  &*CC C 	C
 C C C #CD 481526,13/||3/ #5<<03/ !.	3/
 "%,,/3/ $D>3/ -.3/ 
u||Xell3XeELL>Q5RR	S3/r1   r   c                   $     e Zd Z fdZd Z xZS )SEWFeedForwardc                    t         |           t        j                  |j                        | _        t        j                  |j                  |j                        | _	        t        |j                  t              rt        |j                     | _        n|j                  | _        t        j                  |j                  |j                        | _        t        j                  |j                         | _        y r3   )r   r    r   Dropoutactivation_dropoutintermediate_dropoutru   r]   intermediate_sizeintermediate_dense
isinstance
hidden_actstrr	   intermediate_act_fnoutput_densehidden_dropoutoutput_dropoutrw   s     r0   r    zSEWFeedForward.__init___  s    $&JJv/H/H$I!"$))F,>,>@X@X"Yf''-'-f.?.?'@D$'-'8'8D$IIf&>&>@R@RS jj)>)>?r1   c                     | j                  |      }| j                  |      }| j                  |      }| j                  |      }| j	                  |      }|S r3   )r   r   r   r   r   r4   s     r0   r6   zSEWFeedForward.forwardl  sX    //>00?11-@))-8++M:r1   r8   r=   s   @r0   r   r   ^  s    @r1   r   c                   &     e Zd Z fdZddZ xZS )SEWEncoderLayerc                    t         |           t        |j                  |j                  |j
                  d|      | _        t        j                  |j                        | _
        t        j                  |j                  |j                        | _        t        |      | _        t        j                  |j                  |j                        | _        y )NF)r   r   r   r   r-   eps)r   r    r   r]   num_attention_headsattention_dropout	attentionr   r   r   r   rB   layer_norm_epsrC   r   feed_forwardfinal_layer_normrw   s     r0   r    zSEWEncoderLayer.__init__w  s    %((00,,
 zz&"7"78,,v'9'9v?T?TU*62 "V-?-?VEZEZ [r1   c                     |}| j                  |||      \  }}}| j                  |      }||z   }| j                  |      }|| j                  |      z   }| j	                  |      }|f}|r||fz  }|S )Nr   r   )r   r   rC   r   r   )r,   r5   r   r   attn_residualr   _outputss           r0   r6   zSEWEncoderLayer.forward  s    %)-.L] *8 *
&|Q ]3%56%(9(9-(HH--m< "&Gr1   r   r8   r=   s   @r0   r   r   v  s    \r1   r   c                   .     e Zd Z fdZ	 	 	 	 ddZ xZS )
SEWEncoderc                    t         |           || _        t        |      | _        t        j                  |j                  |j                        | _        t        j                  |j                  |j                        | _        t        j                  |j                        | _        t        j                   t#        |j$                        D cg c]  }t'        |       c}      | _        t+        |      | _        d| _        y c c}w )Nr   F)r   r    r-   rQ   pos_conv_embedr   	AvgPool1dr`   poolrB   r]   r   rC   r   r   r   r   r   num_hidden_layersr   layersrs   upsampler   )r,   r-   r   r/   s      r0   r    zSEWEncoder.__init__  s    8@LL!6!68M8MN	,,v'9'9v?T?TUzz&"7"78mmeFLdLdFe$f_V%<$fg%f-&+# %gs   Dc           	      2   |rdnd }|rdnd }||j                  d      j                  dd|j                  d         }| j                  j                  dk(  rd|| <   |d|v r|nd }ngd|| <   |j                         j                  d      }	|	| j                  j                  z  }
|j                  d   | j                  j                  z  }t        j                  d||
j                        j                  dd      j                  |
j                  d   d      }||
j                  dd      k  j                         }d	|d d d d d d f   j                  |j                  
      z
  }|t        j                  |j                        j                   z  }|j                  |j                  d   d|j                  d   |j                  d         }|j                  d   }|j#                  dd      }| j%                  |      }| j'                  |      }t!        |j)                  d      |j)                  d            }|dd |f   |dd |f   z   }|j#                  dd      }| j+                  |      }| j-                  |      }t/               xs t1        |       }| j2                  D ]j  }|r||fz   }t        j4                  g       }| j6                  xr || j                  j8                  k  }|r|r ||||      }|d   }|rd}|sb|d   fz   }l |r||fz   }| j;                  |      }|j                  d   |k  r4t<        j>                  jA                  |ddd||j                  d   z
  f      }|stC        d |||fD              S tE        |||      S )N rF   r   rS   flash_attention_2r   r   device      ?dtype.r   NNc              3   &   K   | ]	  }||  y wr3   r   ).0vs     r0   	<genexpr>z%SEWEncoder.forward.<locals>.<genexpr>  s     mq_`_lms   last_hidden_stater5   
attentions)#	unsqueezerepeatr   r-   r   longsumr`   r   aranger   r   expandtor  finfominrG   r   r   ry   rC   r   r
   r   r   randr   	layerdropr   r   r   padr   r   )r,   r5   r   r   output_hidden_statesreturn_dictall_hidden_statesall_self_attentionsexpand_attention_maskinput_lengthsoutput_lengthsmax_encoder_lengthattention_idsn_input_timestepsposition_embeddingspooled_hidden_states
min_lengthsynced_gpusr   dropout_probabilityskip_the_layerlayer_outputss                         r0   r6   zSEWEncoder.forward  s    #7BD$5b4%$2$<$<R$@$G$G1mNaNabcNd$e!{{//3FF8;4454B4NSTXfSfmq 9<445!/!4!4!6 ; ;B ?!.$++2L2L!L%2%8%8%;t{{?Y?Y%Y"LL$6~?T?TUT!R[VN003R8 
 #0.2E2Eb!2L"L!R!R!T "%~atQ6F'G'J'JQ^QdQd'J'e!e!/%++m>Q>Q2R2V2V!V!/!6!6"((+Q0D0DR0H.J^J^_aJb" *//2%//15"11-@#yy7,11"57K7P7PQS7TU
,S+:+-=>ATUXZe[eZeUeAff%//156]302R6LT6R[[ 	PE#$58H$H! #(**R.!]]Z/BT[[EZEZ/ZN![ %!.Te! !.a 0 , &9]1=M<O&O#'	P*   1]4D Dm4q!$55MM--maAGX[h[n[nop[qGq=rsMm]4EGZ$[mmm++*
 	
r1   )NFFTr8   r=   s   @r0   r   r     s    	, "W
r1   r   c                       e Zd ZU eed<   dZdZdZdZdZ	dZ
d Zdeej                  ef   fdZd	ed
ej                  fdZy)SEWPreTrainedModelr-   sewr   TFc           
         t        |t              rt        j                  j	                  |j
                  j                  ddt        j                  d|j
                  j                  d   |j
                  j                  z  z        z         t        j                  j                  |j
                  j                  d       nt        |t        j                        r=|j                  j                  j	                  d| j                  j                          nt        |t        j"                  t        j$                  f      rK|j                  j                  j'                          |j                  j                  j)                  d       nHt        |t        j*                        r-t-               rddl}t1        |d      r|t1        |d	      rp|j2                  j5                  |j6                  |j8                  gd
      5  t        j                  j;                  |j                  j                         ddd       n|j2                  j5                  |j                  d
      5  t        j                  j;                  |j                  j                         ddd       n3t        j                  j;                  |j                  j                         t        |t        j                  t        j*                  f      r2|j                  %|j                  j                  j'                          yyy# 1 sw Y   fxY w# 1 sw Y   rxY w)zInitialize the weightsr   rS   r   )meanstdr   r   Nri   rh   rW   )r   rQ   r   initnormal_r(   rY   mathsqrtr   in_channels	constant_r   ru   datar-   initializer_rangerB   rN   zero_fill_r$   r
   rc   rb   rd   re   ri   rh   kaiming_normal_)r,   r   rc   s      r0   _init_weightsz SEWPreTrainedModel._init_weights
  sB   f89GGOO""		!v{{'>'>q'AFKKD[D['["\]]  
 GGfkk..2		* MM&&CT[[5R5R&Sr|| <=KK""$MM$$S)		*)+ 6:.76:3N"::FOOV__;]mn:o D//0B0BCD D #::6==XY:Z D//0B0BCD D ''(:(:;fryy"))45&++:QKK""$ ;R5D DD Ds   4L5(4M5L>M
r  c                     d }t        | j                  j                  | j                  j                        D ]  \  }} ||||      } |S )zH
        Computes the output length of the convolutional layers
        c                 >    t        j                  | |z
  |d      dz   S )Nfloor)rounding_moder   )r   div)input_lengthr   r   s      r0   _conv_out_lengthzMSEWPreTrainedModel._get_feat_extract_output_lengths.<locals>._conv_out_length/  s"     99\K7wWZ[[[r1   )zipr-   r%   r&   )r,   r  r@  r   r   s        r0    _get_feat_extract_output_lengthsz3SEWPreTrainedModel._get_feat_extract_output_lengths*  sQ    
	\
 $'t{{'>'>@W@W#X 	QK,]KPM	Q r1   feature_vector_lengthr   c                    | j                  |j                  d            j                  t        j                        }|j
                  d   }t        j                  ||f|j                  |j                        }d|t        j                  |j
                  d   |j                        |dz
  f<   |j                  dg      j                  d      j                  dg      j                         }|S )NrF   r   )r  r   r   r   )rB  r  r  r   r  r   zerosr  r   r  flipcumsumr   )r,   rC  r   r  
batch_sizes        r0   "_get_feature_vector_attention_maskz5SEWPreTrainedModel._get_feature_vector_attention_mask9  s    >>~?Q?QRT?UVYYZ_ZdZde#))!,
./~7K7KTbTiTi
 uv^%9%9!%<^EZEZ[]kno]opq',,bT299"=BBB4HMMOr1   N)r9   r:   r;   r   __annotations__base_model_prefixmain_input_namesupports_gradient_checkpointing_supports_flash_attn_supports_sdpa_supports_flex_attnr9  r   r   
LongTensorr   rB  rI  r   r1   r0   r)  r)     sg    $O&*#N%@eEDTDTVYDY>Z 
 
]b]m]m 
r1   r)  r   	mask_probmask_length	min_masksr   c                    | \  }dk  rt        d      kD  rt        d d d      t        j                  j                  d      j	                         fd}|-|j                         j                  d      j                         nt        |      D cg c]  } c}}t        j                  |ft        	      }	g }
 |      }|d
k(  r|	S |D ]  } ||      }t        j                  j                  t        j                  |dz
  z
        |d      }t        |      d
k(  rdz
  }n|d
   }t        j                  |t        j                  ||z
  t        j                   	      |z  g      }|
j#                  |        t        j$                  |
      }
t        j&                  |
dddddf   ||f      }
|
j)                  ||z        }
t        j                        ddddf   }t        j&                  |||f      j)                  ||z        }|
|z   }
|
j+                         dz
  kD  rdz
  |
|
dz
  kD  <   t        j,                  |	|
dd       |	S c c}w )an  
    Computes random mask spans for a given shape. Used to implement [SpecAugment: A Simple Data Augmentation Method for
    ASR](https://huggingface.co/papers/1904.08779). Note that this method is not optimized to run on TPU and should be run on
    CPU as part of the preprocessing during training.

    Args:
        shape: The shape for which to compute masks. This should be of a tuple of size 2 where
               the first element is the batch size and the second element is the length of the axis to span.
        mask_prob:  The percentage of the whole axis (between 0 and 1) which will be masked. The number of
                    independently generated mask spans of length `mask_length` is computed by
                    `mask_prob*shape[1]/mask_length`. Note that due to overlaps, `mask_prob` is an upper bound and the
                    actual percentage will be smaller.
        mask_length: size of the mask
        min_masks: minimum number of masked spans
        attention_mask: A (right-padded) attention mask which independently shortens the feature axis of
                        each batch dimension.
    r   z&`mask_length` has to be bigger than 0.zO`mask_length` has to be smaller than `sequence_length`, but got `mask_length`: z and `sequence_length`: `c                     t        | z  z  z         }t        |      }|z  kD  rz  }| dz
  z
  |k  rt        | dz
  z
  d      }|S )z;Given input length, compute how many spans should be maskedr   r   )r   max)r?  num_masked_spanepsilonrS  rR  rT  sequence_lengths     r0   compute_num_masked_spanz6_compute_mask_indices.<locals>.compute_num_masked_spanl  so    i,6DwNOoy9 [(?:-<O ;?+o=!,+/"BAFOr1   NrF   r  r   F)replace)r   nprandomr  itemdetachr  tolistr   rE  r   choicer  lenconcatenateonesint32appendarraybroadcast_torz   rX  put_along_axis)r   rR  rS  r   rT  rH  r\  r   r  spec_aug_maskspec_aug_mask_idxsmax_num_masked_spanr?  rY  spec_aug_mask_idxdummy_mask_idxoffsetsrZ  r[  s    `` `            @@r0   _compute_mask_indicesrr  F  s   0 #(JQABB_$]^i]j&&7q:
 	
 iinnQ$$&G $ % 	##B'..0',Z'89!o9  HHj/:$GM1/Ba% 51,? II,,IIlkAo67RW - 
  !Q& -q0N.q1NNN(;o(MUWU]U] ^ao op
 	!!"34/52 "45 1a:&5H+(V ,33J@SVa@ab ii$T4]3Goog
4G'UV^^'+5G ,g5 /A"55GVYZGZ-!0CCD m%7B?w :s   $	I+c                   *    e Zd Zdef fdZ	 	 ddej                  deej                     deej                     fdZ	e
	 	 	 	 	 ddeej                     deej                     deej                     dee   d	ee   d
ee   deeef   fd       Z xZS )SEWModelr-   c                    t         |   |       || _        t        |      | _        t        j                  |j                  d   |j                        | _	        |j                  d   |j                  k7  | _        | j                  r2t        j                  |j                  d   |j                        | _        t        j                  |j                        | _        |j"                  dkD  s|j$                  dkD  rEt        j&                  t)        j*                  |j                        j-                               | _        t1        |      | _        | j5                          y )NrF   r   r   )r   r    r-   r   feature_extractorr   rB   r!   r   rC   r]   project_featuresru   feature_projectionr   feat_proj_dropoutfeature_dropoutmask_time_probmask_feature_prob	Parameterr   r   uniform_masked_spec_embedr   encoder	post_initrw   s     r0   r    zSEWModel.__init__  s     !26!:,,vr':@U@UV & 3v7I7I I  &(ii0CVEWEW&XD#!zz&*B*BC  3&&*B*BS*H%'\\%,,v?Q?Q2R2[2[2]%^D"!&) 	r1   r5   mask_time_indicesr   c                    t        | j                  dd      s|S |j                         \  }}}|)| j                  j	                  |j
                        ||<   n| j                  j                  dkD  r| j                  rt        ||f| j                  j                  | j                  j                  || j                  j                        }t        j                  ||j                  t        j                        }| j                  j	                  |j
                        ||<   | j                  j                  dkD  r| j                  rt        ||f| j                  j                  | j                  j                   | j                  j"                        }t        j                  ||j                  t        j                        }|dddf   j%                  d|d      }d||<   |S )	z
        Masks extracted features along time axis and/or along feature axis according to
        [SpecAugment](https://huggingface.co/papers/1904.08779).
        apply_spec_augmentTNr   )rR  rS  r   rT  )r   r  )rR  rS  rT  rF   )getattrr-   ry   r  r  r  r{  r   rr  mask_time_lengthmask_time_min_masksr   tensorr   r   r|  mask_feature_lengthmask_feature_min_masksr  )r,   r5   r  r   rH  r[  r]   mask_feature_indicess           r0   _mask_hidden_stateszSEWModel._mask_hidden_states  s    t{{$8$?   4A3E3E3G0
O[(/3/E/E/H/HI\I\/]M+,[[''!+ 5_-++44 KK88-++99! !&->}G[G[chcmcm n/3/E/E/H/HI\I\/]M+,;;((1,#8[)++77 KK;;++<<	$  $)<<0D]MaMainisis#t #74#@#G#GO]_#` 23M./r1   r   r   r  r  r   c                 Z   ||n| j                   j                  }||n| j                   j                  }||n| j                   j                  }| j	                  |      }|j                  dd      }| j                  |      }| j                  r| j                  |      }| j                  |      }|| j                  |j                  d   |      }| j                  ||      }| j                  |||||      }	|	d   }|s	|f|	dd z   S t        ||	j                  |	j                         S )a/  
        mask_time_indices (`torch.BoolTensor` of shape `(batch_size, sequence_length)`, *optional*):
            Indices to mask extracted features for contrastive loss. When in training mode, model learns to predict
            masked extracted features in *config.proj_codevector_dim* space.
        Nr   rS   )r  r   r   r  r  r   r  )r-   r   r  use_return_dictrv  rG   rC   rw  rx  rz  rI  r   r  r  r   r5   r
  )
r,   r   r   r  r   r  r  extract_featuresr5   encoder_outputss
             r0   r6   zSEWModel.forward  sU    2C1N-TXT_T_TqTq$8$D $++JjJj 	 &1%<k$++B]B]11,?+55a;??+;<  #667GH,,-=>%!DD]EXEXYZE[]klN00Rc0d,,)/!5# ' 
 (*!#oab&999+)77&11
 	
r1   r  NNNNN)r9   r:   r;   r   r    r   FloatTensorr   rQ  r  r   r   r   r   r   r   r6   r<   r=   s   @r0   rt  rt    s    y . :>59	,((, $E$5$56, !!1!12	,\  269=,0/3&*3
u||,3
 !.3
 $E$5$56	3

 $D>3
 'tn3
 d^3
 
uo%	&3
 3
r1   rt  zk
    SEW Model with a `language modeling` head on top for Connectionist Temporal Classification (CTC).
    )custom_introc                        e Zd Zddee   f fdZd Zd Zd Zd Z	e
	 	 	 	 	 ddeej                     deej                     d	ee   d
ee   dee   deej                     deeef   fd       Z xZS )	SEWForCTCtarget_langc                    t         |   |       t        |      | _        t	        j
                  |j                        | _        || _        |j                  t        d| j                   d      t        |d      r|j                  r|j                  n|j                  }t	        j                   ||j                        | _        | j%                          y)a-  
        target_lang (`str`, *optional*):
            Language id of adapter weights. Adapter weights are stored in the format adapter.<lang>.safetensors or
            adapter.<lang>.bin. Only relevant when using an instance of [`SEWForCTC`] with adapters. Uses 'eng' by
            default.
        NzYou are trying to instantiate z with a configuration that does not define the vocabulary size of the language model head. Please instantiate the model as follows: `SEWForCTC.from_pretrained(..., vocab_size=vocab_size)`. or define `vocab_size` of your model's configuration.add_adapter)r   r    rt  r*  r   r   final_dropoutr   r  
vocab_sizer   r/   rb   r  output_hidden_sizer]   ru   lm_headr  )r,   r-   r  r  r/   s       r0   r    zSEWForCTC.__init__A  s     	 F#zz&"6"67&$00@ AH H  *1)GFL^L^F%%djdvdv 	 yy!3V5F5FG 	r1   c                     | j                   }|&t        | j                  dd      t        d| d      |-t        | j                  dd      t        j                  d       y|| j                  |d       yy)a'  
        This method overwrites [`~PreTrainedModel.tie_weights`] so that adapter weights can be correctly loaded when
        passing `target_lang=...` to `from_pretrained(...)`.

        This method is **not** supposed to be called by the user and is prone to be changed in the future.
        Nadapter_attn_dimzCannot pass `target_lang`: z- if `config.adapter_attn_dim` is not defined.z)By default `target_lang` is set to 'eng'.T)
force_load)r  r  r-   r   loggerinfoload_adapter)r,   r  s     r0   tie_weightszSEWForCTC.tie_weights^  s     &&"wt{{<NPT'U']:;-Gtuvv WT[[:Ld%S%_KKCD$kd; %r1   c                 X    t        j                  dt               | j                          y)
        Calling this function will disable the gradient computation for the feature encoder so that its parameter will
        not be updated during training.
        The method `freeze_feature_extractor` is deprecated and will be removed in Transformers v5. Please use the equivalent `freeze_feature_encoder` method instead.NwarningswarnFutureWarningfreeze_feature_encoderr,   s    r0   freeze_feature_extractorz"SEWForCTC.freeze_feature_extractors  '    
 	Q	

 	##%r1   c                 L    | j                   j                  j                          yr  Nr*  rv  r   r  s    r0   r  z SEWForCTC.freeze_feature_encoder      
 	""557r1   c                 P    | j                   j                         D ]	  }d|_         yz
        Calling this function will disable the gradient computation for the base model so that its parameters will not
        be updated during training. Only the classification head will be updated.
        FNr*  r   r   r   s     r0   freeze_base_modelzSEWForCTC.freeze_base_model  (    
 XX((* 	(E"'E	(r1   r   r   r   r  r  labelsr   c           
         ||n| j                   j                  }|I|j                         | j                   j                  k\  r"t	        d| j                   j                         | j                  |||||      }|d   }| j                  |      }| j                  |      }	d}
|b||n$t        j                  |t        j                        }| j                  |j                  d            j                  t        j                        }|dk\  }|j                  d      }|j                  |      }t        j                   j#                  |	dt        j$                        j'                  dd      }t        j(                  j*                  j-                  d	
      5  t        j                   j/                  ||||| j                   j0                  | j                   j2                  | j                   j4                        }
ddd       |s|	f|t6        d z   }|
|
f|z   S |S t9        |
|	|j:                  |j<                        S # 1 sw Y   ExY w)a  
        labels (`torch.LongTensor` of shape `(batch_size, target_length)`, *optional*):
            Labels for connectionist temporal classification. Note that `target_length` has to be smaller or equal to
            the sequence length of the output logits. Indices are selected in `[-100, 0, ..., config.vocab_size - 1]`.
            All labels set to `-100` are ignored (masked), the loss is only computed for labels in `[0, ...,
            config.vocab_size - 1]`.
        Nz$Label values must be <= vocab_size: r  r   r  rF   )r[   r  r   F)enabled)blank	reductionzero_infinitylosslogitsr5   r
  )r-   r  rX  r  r   r*  r   r  r   	ones_liker  rB  r  r  masked_selectr   r   log_softmaxfloat32rG   backendscudnnflagsctc_losspad_token_idctc_loss_reductionctc_zero_infinity_HIDDEN_STATES_START_POSITIONr   r5   r
  )r,   r   r   r   r  r  r  r   r5   r  r  r  labels_masktarget_lengthsflattened_targets	log_probsoutputs                    r0   r6   zSEWForCTC.forward  s'   " &1%<k$++B]B]&**,$++2H2H"HCDKKDZDZC[\]](()/!5#  
  
]3m, #1"<%//R^fkfpfpBq  !AA.BTBTUWBXY\\]b]g]ghM !A+K(__R0N & 4 4[ A 11&b1V``abdefI%%++E+: 	}}--%!"++22"kk<<"&++"?"? . 	 Y)F)G!HHF)-)9TGf$EvEfG4I4IV]VhVh
 	
	 	s   A#IIr3   r  )r9   r:   r;   r   r   r    r  r  r  r  r   r   r   r   r   r   r   r6   r<   r=   s   @r0   r  r  ;  s    HSM :<*
&8(  26,0/3&*)-D
u||,D
 !.D
 $D>	D

 'tnD
 d^D
 &D
 
un$	%D
 D
r1   r  z
    SEW Model with a sequence classification head on top (a linear layer over the pooled output) for tasks like
    SUPERB Keyword Spotting.
    c                        e Zd Z fdZd Zd Zd Ze	 	 	 	 	 ddee	j                     dee	j                     dee   dee   d	ee   d
ee	j                     deeef   fd       Z xZS )SEWForSequenceClassificationc                    t         |   |       t        |d      r|j                  rt	        d      t        |      | _        |j                  dz   }|j                  r0t        j                  t        j                  |      |z        | _        t        j                  |j                  |j                         | _        t        j                  |j                   |j$                        | _        | j)                          y )Nr  zZSequence classification does not support the use of SEW adapters (config.add_adapter=True)r   )r   r    rb   r  r   rt  r*  r   use_weighted_layer_sumr   r}  r   rf  layer_weightsru   r]   classifier_proj_size	projector
num_labels
classifierr  )r,   r-   
num_layersr/   s      r0   r    z%SEWForSequenceClassification.__init__  s     6=)f.@.@l  F#--1
((!#ejj.Dz.Q!RD6#5#5v7R7RS))F$?$?ARARS 	r1   c                 X    t        j                  dt               | j                          y)z
        Calling this function will disable the gradient computation for the feature encoder so that its parameters will
        not be updated during training.
        r  Nr  r  s    r0   r  z5SEWForSequenceClassification.freeze_feature_extractor  r  r1   c                 L    | j                   j                  j                          yr  r  r  s    r0   r  z3SEWForSequenceClassification.freeze_feature_encoder  r  r1   c                 P    | j                   j                         D ]	  }d|_         yr  r  r   s     r0   r  z.SEWForSequenceClassification.freeze_base_model  r  r1   r   r   r   r  r  r  r   c                 <   ||n| j                   j                  }| j                   j                  rdn|}| j                  |||||      }| j                   j                  rr|t           }t        j                  |d      }t        j                  j                  | j                  d      }	||	j                  ddd      z  j                  d      }n|d   }| j                  |      }||j                  d      }
n| j                  |j                   d   |      }|j#                  d      j%                  dd|j                   d         }d	|| <   |j                  d      |j                  d      j                  dd      z  }
| j'                  |
      }d}|Ft)               } ||j                  d| j                   j*                        |j                  d            }|s|f|t        d z   }||f|z   S |S t-        |||j.                  |j0                  
      S )a  
        input_values (`torch.FloatTensor` of shape `(batch_size, sequence_length)`):
            Float values of input raw speech waveform. Values can be obtained by loading a `.flac` or `.wav` audio file
            into an array of type `list[float]`, a `numpy.ndarray` or a `torch.Tensor`, *e.g.* via the torchcodec library
            (`pip install torchcodec`) or the soundfile library (`pip install soundfile`).
            To prepare the array into `input_values`, the [`AutoProcessor`] should be used for padding and conversion
            into a tensor of type `torch.FloatTensor`. See [`SEWProcessor.__call__`] for details.
        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).
        NTr  r   r   rF   r   rS   r   r  )r-   r  r  r*  r  r   stackr   r   r   r  r   r  r  r,  rI  r   r  r  r  r   r  r   r5   r
  )r,   r   r   r   r  r  r  r   r5   norm_weightspooled_outputpadding_maskexpand_padding_maskr  r  loss_fctr  s                    r0   r6   z$SEWForSequenceClassification.forward	  s   . &1%<k$++B]B]'+{{'I'ItOc(()/!5#  
 ;;--#$ABM!KK1=M==001C1C0LL*\->->r1a-HHMMRSMTM#AJM}5!)..1.5MBB=CVCVWXCY[ijL"."8"8"<"C"CAq-J]J]^_J`"a25M../)--!-4|7G7GA7G7N7S7STVXY7ZZM/')HFKKDKK,B,BCV[[QS_UDY)F)G!HHF)-)9TGf$EvE'!//))	
 	
r1   r  )r9   r:   r;   r    r  r  r  r   r   r   r   r   r   r   r   r6   r<   r=   s   @r0   r  r    s    "
&8(  26,0/3&*)-B
u||,B
 !.B
 $D>	B

 'tnB
 d^B
 &B
 
u..	/B
 B
r1   r  )r  r  rt  r)  )Nr   Nrq   )Ar0  r  typingr   r   r   numpyr^  r   r   torch.nnr   activationsr	   integrations.deepspeedr
   integrations.fsdpr   modeling_flash_attention_utilsr   modeling_layersr   modeling_outputsr   r   r   modeling_utilsr   r   processing_utilsr   ra   r   r   configuration_sewr   
get_loggerr9   r  r   r?   rI   ModulerQ   rk   rs   r   r   r   r   r   r   r   r   r)  r   r   rQ  ndarrayrr  rt  r  r  r  __all__r   r1   r0   <module>r     s  ,   , ,    % ! @ 7 B 9 Y Y F & , ( 
		H	%8 *6 66 0( (Vbii BII ,#		 #X  $(,%II%<<% 
% <<	%
 U\\*% e_% % %%<U/299 U/pRYY 0!0 !Hc
 c
L B B BR 26tc?tt t U--.	t
 t ZZtn w
! w
 w
t !"  
S
" S

S
l p
#5 p
p
f Zr1   