
    h                        d dl mZmZmZ d dlZd dlmZ d dlmZm	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 ddlmZ ddlmZ ddl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) ddl*m+Z+m,Z,m-Z-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3m4Z4 ddl5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z;  e.jx                  e=      Z> G d de      Z? G d dej                        ZA G d dej                        ZB G d de2      ZC G d d e3      ZD G d! d"e6      ZE G d# d$e      ZFe, G d% d&e'             ZG G d' d(eG      ZH G d) d*e7      ZI G d+ d,e:      ZJ e,d-.       G d/ d0eGe             ZKg d1ZLy)2    )CallableOptionalUnionN)OutputRecordercheck_model_inputs   )ACT2FN)CacheDynamicCacheEncoderDecoderCache)PretrainedConfig)GenerationMixin)create_causal_mask)_prepare_4d_attention_mask#_prepare_4d_attention_mask_for_sdpa)FlashAttentionKwargs)GradientCheckpointingLayer)BaseModelOutputBaseModelOutputWithPast)BaseModelOutputWithPastAndCrossAttentionsSeq2SeqLMOutputSeq2SeqModelOutput)rope_config_validation)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)TransformersKwargsauto_docstringcan_return_tuplelogging)deprecate_kwarg   )GlmAttentionGlmRotaryEmbeddingapply_rotary_pos_emb)LlamaDecoderLayer
LlamaModeleager_attention_forward)WhisperModelshift_tokens_rightc                   j     e Zd ZdZdZdgZddddZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d	 fd	Z xZS )
MoonshineConfiga"  
    This is the configuration class to store the configuration of a [`MoonshineModel`]. It is used to instantiate a Moonshine
    model according to the specified arguments, defining the model architecture. Instantiating a configuration with the
    defaults will yield a similar configuration to that of the Moonshine
    [UsefulSensors/moonshine-tiny](https://huggingface.co/UsefulSensors/moonshine-tiny).

    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
    documentation from [`PretrainedConfig`] for more information.

    Args:
        vocab_size (`int`, *optional*, defaults to 32768):
            Vocabulary size of the Moonshine model. Defines the number of different tokens that can be represented by the
            `inputs_ids` passed when calling [`MoonshineModel`].
        hidden_size (`int`, *optional*, defaults to 288):
            Dimension of the hidden representations.
        intermediate_size (`int`, *optional*, defaults to 1152):
            Dimension of the MLP representations.
        encoder_num_hidden_layers (`int`, *optional*, defaults to 6):
            Number of hidden layers in the Transformer encoder.
        decoder_num_hidden_layers (`int`, *optional*, defaults to 6):
            Number of hidden layers in the Transformer decoder.
        encoder_num_attention_heads (`int`, *optional*, defaults to 8):
            Number of attention heads for each attention layer in the Transformer encoder.
        decoder_num_attention_heads (`int`, *optional*, defaults to 8):
            Number of attention heads for each attention layer in the Transformer decoder.
        encoder_num_key_value_heads (`int`, *optional*):
            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
            `encoder_num_key_value_heads=encoder_num_attention_heads`, the model will use Multi Head Attention (MHA), if
            `encoder_num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When
            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
            by meanpooling all the original heads within that group. For more details, check out [this
            paper](https://huggingface.co/papers/2305.13245). If it is not specified, will default to
            `num_attention_heads`.
        decoder_num_key_value_heads (`int`, *optional*):
            This is the number of key_value heads that should be used to implement Grouped Query Attention. If
            `decoder_num_key_value_heads=decoder_num_attention_heads`, the model will use Multi Head Attention (MHA), if
            `decoder_num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When
            converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed
            by meanpooling all the original heads within that group. For more details, check out [this
            paper](https://huggingface.co/papers/2305.13245). If it is not specified, will default to
            `decoder_num_attention_heads`.
        pad_head_dim_to_multiple_of (`int`, *optional*):
            Pad head dimension in encoder and decoder to the next multiple of this value. Necessary for using certain
            optimized attention implementations.
        encoder_hidden_act (`str` or `function`, *optional*, defaults to `"gelu"`):
            The non-linear activation function (function or string) in the encoder.
        decoder_hidden_act (`str` or `function`, *optional*, defaults to `"silu"`):
            The non-linear activation function (function or string) in the decoder.
        max_position_embeddings (`int`, *optional*, defaults to 512):
            The maximum sequence length that this model might ever be used with.
        initializer_range (`float`, *optional*, defaults to 0.02):
            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
        decoder_start_token_id (`int`, *optional*, defaults to 1):
            Corresponds to the "<|startoftranscript|>" token, which is automatically used when no `decoder_input_ids`
            are provided to the `generate` function. It is used to guide the model`s generation process depending on
            the task.
        use_cache (`bool`, *optional*, defaults to `True`):
            Whether or not the model should return the last key/values attentions (not used by all models).
        rope_theta (`float`, *optional*, defaults to 10000.0):
            The base period of the RoPE embeddings.
        rope_scaling (`Dict`, *optional*):
            Dictionary containing the scaling configuration for the RoPE embeddings. NOTE: if you apply new rope type
            and you expect the model to work on longer `max_position_embeddings`, we recommend you to update this value
            accordingly.
            Expected contents:
                `rope_type` (`str`):
                    The sub-variant of RoPE to use. Can be one of ['default', 'linear', 'dynamic', 'yarn', 'longrope',
                    'llama3'], with 'default' being the original RoPE implementation.
                `factor` (`float`, *optional*):
                    Used with all rope types except 'default'. The scaling factor to apply to the RoPE embeddings. In
                    most scaling types, a `factor` of x will enable the model to handle sequences of length x *
                    original maximum pre-trained length.
                `original_max_position_embeddings` (`int`, *optional*):
                    Used with 'dynamic', 'longrope' and 'llama3'. The original max position embeddings used during
                    pretraining.
                `attention_factor` (`float`, *optional*):
                    Used with 'yarn' and 'longrope'. The scaling factor to be applied on the attention
                    computation. If unspecified, it defaults to value recommended by the implementation, using the
                    `factor` field to infer the suggested value.
                `beta_fast` (`float`, *optional*):
                    Only used with 'yarn'. Parameter to set the boundary for extrapolation (only) in the linear
                    ramp function. If unspecified, it defaults to 32.
                `beta_slow` (`float`, *optional*):
                    Only used with 'yarn'. Parameter to set the boundary for interpolation (only) in the linear
                    ramp function. If unspecified, it defaults to 1.
                `short_factor` (`list[float]`, *optional*):
                    Only used with 'longrope'. The scaling factor to be applied to short contexts (<
                    `original_max_position_embeddings`). Must be a list of numbers with the same length as the hidden
                    size divided by the number of attention heads divided by 2
                `long_factor` (`list[float]`, *optional*):
                    Only used with 'longrope'. The scaling factor to be applied to long contexts (<
                    `original_max_position_embeddings`). Must be a list of numbers with the same length as the hidden
                    size divided by the number of attention heads divided by 2
                `low_freq_factor` (`float`, *optional*):
                    Only used with 'llama3'. Scaling factor applied to low frequency components of the RoPE
                `high_freq_factor` (`float`, *optional*):
                    Only used with 'llama3'. Scaling factor applied to high frequency components of the RoPE
        partial_rotary_factor (`float`, *optional*, defaults to 0.9):
            Percentage of the query and keys which will have rotary embedding.
        is_encoder_decoder (`bool`, *optional*, defaults to `True`):
            Whether the model is used as an encoder/decoder or not.
        attention_bias (`bool`, *optional*, defaults to `False`):
            Whether to use a bias in the query, key, value and output projection layers during self-attention.
        attention_dropout (`float`, *optional*, defaults to 0.0):
            The dropout ratio for the attention probabilities.
        bos_token_id (`int`, *optional*, defaults to 1):
            Denotes beginning of sequences token id.
        eos_token_id (`int`, *optional*, defaults to 2):
            Denotes end of sequences token id.

    Example:

    ```python
    >>> from transformers import MoonshineModel, MoonshineConfig

    >>> # Initializing a Moonshine style configuration
    >>> configuration = MoonshineConfig().from_pretrained("UsefulSensors/moonshine-tiny")

    >>> # Initializing a model from the configuration
    >>> model = MoonshineModel(configuration)

    >>> # Accessing the model configuration
    >>> configuration = model.config
    ```	moonshinepast_key_valuesencoder_num_key_value_headsencoder_num_attention_headsencoder_num_hidden_layers)num_key_value_headsnum_attention_headsnum_hidden_layersc                    || _         || _        || _        || _        || _        || _        || _        ||}|| _        |	|}	|	| _        |
| _	        || _
        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        || _        t-        |        t/        | `  d||||d| y )N)bos_token_ideos_token_idis_encoder_decoderdecoder_start_token_id )
vocab_sizehidden_sizeintermediate_sizer1   decoder_num_hidden_layersr0   decoder_num_attention_headsr/   decoder_num_key_value_headspad_head_dim_to_multiple_ofencoder_hidden_actdecoder_hidden_actmax_position_embeddingsinitializer_ranger9   	use_cache
rope_thetarope_scalingpartial_rotary_factorr8   attention_biasattention_dropoutr   super__init__)selfr;   r<   r=   r1   r>   r0   r?   r/   r@   rA   rB   rC   rD   rE   r9   rF   rG   rH   rI   r8   rJ   rK   r6   r7   kwargs	__class__s                             m/var/www/html/eduruby.in/venv/lib/python3.12/site-packages/transformers/models/moonshine/modular_moonshine.pyrM   zMoonshineConfig.__init__   s    8 %&!2)B&)B&+F(+F(&.*E'+F(&.*E'+F(+F("4"4'>$!2&<#"$(%:""4,!2 	t$ 	
%%1#9		

 	
    )i   i   i     rS      rT   NNNgelusilui   g{Gz?   Tg     @Ng?TF        rW   r"   )	__name__
__module____qualname____doc__
model_typekeys_to_ignore_at_inferenceattribute_maprM   __classcell__rP   s   @rQ   r,   r,   2   s    {z J#4"5<<8M "#"#$%$%$($($(!! # !3D
 D
rR   r,   c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )MoonshineEncoderMLPc                    t         |           || _        t        |   | _        t        j                  |j                  |j                        | _	        t        j                  |j                  |j                        | _
        y NrL   rM   configr	   activation_fnnnLinearr<   r=   fc1fc2rN   rg   
hidden_actrP   s      rQ   rM   zMoonshineEncoderMLP.__init__   s^    #J/99V//1I1IJ99V55v7I7IJrR   hidden_statesreturnc                 l    | j                  |      }| j                  |      }| j                  |      }|S re   )rk   rh   rl   )rN   ro   s     rQ   forwardzMoonshineEncoderMLP.forward  s4    /**=9/rR   rY   rZ   r[   rM   torchTensorrr   r`   ra   s   @rQ   rc   rc      s$    KU\\ ell rR   rc   c                   V     e Zd Z fdZdej
                  dej
                  fdZ xZS )MoonshineDecoderMLPc                    t         |           || _        t        |   | _        t        j                  |j                  |j                  dz        | _	        t        j                  |j                  |j                        | _
        y )Nr"   rf   rm   s      rQ   rM   zMoonshineDecoderMLP.__init__  sc    #J/99V//1I1IA1MN99V55v7I7IJrR   ro   rp   c                     | j                  |      }|j                  dd      \  }}| j                  |      |z  }| j                  |      }|S )Nr"   )dim)rk   chunkrh   rl   )rN   ro   gates      rQ   rr   zMoonshineDecoderMLP.forward  sS    /+11!1<t**40=@/rR   rs   ra   s   @rQ   rw   rw     s$    KU\\ ell rR   rw   c                       e Zd Zdededededef
 fdZ eddd	
      	 	 	 	 	 ddej                  de
eej                  ej                  f      de
ej                     de
e   de
ej                     de
ej                     dee   deej                  e
ej                     e
eej                        f   fd       Z xZS )MoonshineAttentionrg   	layer_idx	is_causalr3   r2   c                 n   |j                  ||d       t        | 	  ||       || _        t	        |d|j
                  |j                  z        | _        | j                  j                  C| j                  j                  }|| j                  |z   dz
  |z  z  }|| j                  z
  | _
        y d| _
        y )N)r3   r2   head_dimrW   r   )updaterL   rM   r   getattrr<   r3   r   rg   rA   head_dim_padding)	rN   rg   r   r   r3   r2   target_multipletarget_head_dimrP   s	           rQ   rM   zMoonshineAttention.__init__  s     	.AZmno+"
F4F4F&JdJd4de ;;22>"kkEEO-$--/2QTU2UZi1ijO$3dmm$CD!$%D!rR   past_key_valuer.   4.58new_nameversionro   position_embeddingsattention_maskcache_positionkey_value_statesrO   rp   c                 j   |j                   d d \  }}	| j                  |      j                  ||	| j                  j                  | j
                        j                  dd      }
|d u}|Y|j                  j                  | j                        }|r&d|j                  | j                  <   |j                  }n|j                  }||n|}|rK|rIrG|j                  | j                     j                  }|j                  | j                     j                  }n| j                  |      j                  |d| j                  j                  | j
                        j                  dd      }| j!                  |      j                  |d| j                  j                  | j
                        j                  dd      }|r%|#|j#                  ||| j                  d|i      \  }}|s?|\  }}t%        |
|||      \  }
}|'|||d}|j#                  ||| j                  |      \  }}t&        }| j                  j(                  dk7  rt*        | j                  j(                     }| j,                  xr |d u xr |	dkD  }| j.                  dkD  rt0        j2                  j4                  j7                  |
d| j.                  f      }
t0        j2                  j4                  j7                  |d| j.                  f      }t0        j2                  j4                  j7                  |d| j.                  f      } || |
|||f| j8                  sd	n| j:                  | j<                  |d
|\  }}| j.                  dkD  r|dd | j.                   f   }|j?                  ||	d      jA                         }| jC                  |      }||fS )Nrz   rW   r"   Tr   )sincosr   eagerr   rX   )dropoutscalingr   .)"shapeq_projviewrg   r2   r   	transpose
is_updatedgetr   cross_attention_cacheself_attention_cachelayerskeysvaluesk_projv_projr   r%   r(   _attn_implementationr   r   r   rt   ri   
functionalpadtrainingrK   r   reshape
contiguouso_proj)rN   ro   r   r   r.   r   r   rO   bszq_lenquery_statesis_cross_attentionr   current_states
key_statesvalue_statesr   r   cache_kwargsattention_interfacer   attn_outputattn_weightss                          rQ   rr   zMoonshineAttention.forward4  s    #(("-
U KK&++C8W8WY]YfYfgqqrsuvw 	 .T9&(3377GJ!=A**4>>:"1"G"G"1"F"F .>-I)}/j(//?DDJ*11$..AHHL N+c2t{{>>N1a  N+c2t{{>>N1a 
 "o&A+:+A+Adnn?OQ_>`,(
L "*HC';L*VY[^'_$L**'*3.Y+:+A+Adnnl,(
L )@;;++w6"9$++:Z:Z"[NNK~'=K%!)	  1$ 88..22<!TEZEZA[\L,,00aAVAV=WXJ 88..22<!TEZEZA[\L$7
%
  $}}C$2H2HLL
%
 
%
!\   1$%c+Cd.C.C-C+C&CDK!))#ub9DDFkk+.L((rR   )NNNNN)rY   rZ   r[   r,   intboolrM   r!   rt   ru   r   tupler
   
LongTensorr   r   rr   r`   ra   s   @rQ   r   r     s,   && & 	&
 !& !&* %0A6R LP15+/5937U)||U) &eELL%,,,F&GHU) !.	U)
 "%U) !!1!12U) #5<<0U) -.U) 
u||Xell3XeELL>Q5RR	SU) SU)rR   r   c                       e Zd Zy)MoonshineRotaryEmbeddingN)rY   rZ   r[   r:   rR   rQ   r   r     s    rR   r   c                   (     e Zd Zdedef fdZ xZS )MoonshineEncoderLayerrg   r   c                 F   t         |   ||       t        ||d|j                  |j                        | _        t        ||j                        | _        t        j                  |j                  d      | _        t        j                  |j                  d      | _        y )NFrg   r   r   r3   r2   bias)rL   rM   r   r0   r/   	self_attnrc   rB   mlpri   	LayerNormr<   input_layernormpost_attention_layernormrN   rg   r   rP   s      rQ   rM   zMoonshineEncoderLayer.__init__  s    ++ & B B & B B
 'vv/H/HI!||F,>,>UK(*V5G5Ge(T%rR   )rY   rZ   r[   r,   r   rM   r`   ra   s   @rQ   r   r     s    U U3 U UrR   r   c            !       &    e Zd Zddedee   f fdZ eddd      	 	 	 	 	 	 	 	 	 	 ddej                  d	eej                     d
eej                     deej                     deej                     deej                     dee   dee   deej                     deeej                  ej                  f      deeej                  ej                  f      dee   deej                   eeej                   ej                   f      f   fd       Z xZS )MoonshineDecoderLayerrg   r   c                    t         |           |j                  | _        t        ||d|j                  |j
                        | _        t        ||d|j                  |j
                        | _        t        ||j                        | _
        t        j                  |j                  d      | _        t        j                  |j                  d      | _        t        j                  |j                  d      | _        y )NTr   Fr   )rL   rM   r<   r   r?   r@   r   encoder_attnrw   rC   r   ri   r   r   r   final_layernormr   s      rQ   rM   zMoonshineDecoderLayer.__init__  s    !--+ & B B & B B
 / & B B & B B
 'vv/H/HI!||F,>,>UK(*V5G5Ge(T%!||F,>,>UKrR   r   r.   r   r   ro   r   encoder_hidden_statesencoder_attention_maskposition_idsencoder_position_idsrF   r   r   encoder_position_embeddingsrO   rp   c                 (   |}| j                  |      } | j                  d||||||	|
d|\  }}||z   }|1|}| j                  |      }| j                  |||||      \  }}||z   }|}| j	                  |      }| j                  |      }||z   }|S )N)ro   r   r   r.   rF   r   r   )ro   r   r   r.   rF   r:   )r   r   r   r   r   r   )rN   ro   r   r   r   r   r   r.   rF   r   r   r   rO   residual_s                  rQ   rr   zMoonshineDecoderLayer.forward  s      !,,];)4>> 	
')%+) 3	
 	
q !=0 ,$H 99-HM#00+!65 /#  1  M1 %}4M ,,];/ =0rR   re   )
NNNNNNFNNN)rY   rZ   r[   r,   r   r   rM   r!   rt   ru   r   r
   r   r   r   r   FloatTensorrr   r`   ra   s   @rQ   r   r     s   L L8C= L0 %0A6R 268<9=37;?+/$)59KOSW.||. !..  (5	.
 !) 6. u//0. 'u'7'78. "%. D>. !!1!12. &eELL%,,,F&GH. &.eELL%,,4N.O%P. +,. 
u  (51B1BEDUDU1U+V"WW	X. S.rR   r   c                   X    e Zd ZU eed<   dZdZdZddgZdZ	dZ
dZdej                  fdZy	)
MoonshinePreTrainedModelrg   modelinput_valuesTr   r   input_lengthsc                 ~    t        |dz
  dz  dz         }t        |dz
  dz  dz         }t        |dz
  dz  dz         }|S )zH
        Computes the output length of the convolutional layers
           @   rW      r   r"   )r   )rN   r   output_conv1_lengthoutput_conv2_lengthoutput_conv3_lengths        rQ    _get_feat_extract_output_lengthsz9MoonshinePreTrainedModel._get_feat_extract_output_lengths  sZ     "=3#6""<q"@A!#6#:a"?!"CD!#6#:a"?!"CD""rR   N)rY   rZ   r[   r,   __annotations__base_model_prefixmain_input_namesupports_gradient_checkpointing_no_split_modules_supports_flash_attn_supports_sdpa_can_compile_fullgraphrt   r   r   r:   rR   rQ   r   r     sH    $O&*#02IJN!#e>N>N #rR   r   c            
            e Zd ZdZdZeedZdef fdZ	de
j                  fdZde
j                  fd	Ze	 ddej                   d
eej$                     dee   defd       Z xZS )MoonshineEncoderz
    Transformer encoder consisting of *config.num_hidden_layers* layers. Each layer is a [`MoonshineEncoderLayer`]

    Args:
        config: MoonshineConfig
    r   )
attentionsro   rg   c           	      b   t         |   |       || _        |j                  }t	        j
                  d|ddd      | _        t	        j
                  |d|z  dd	      | _        t	        j
                  d|z  |dd	      | _        t	        j                  d|d
      | _
        t        |      | _        t	        j                  t        |j                        D cg c]  }t!        ||       c}      | _        t	        j$                  |d      | _        d| _        | j+                          y c c}w )NrW   r   r   F)kernel_sizestrider   r"   r   r   )r   r   gh㈵>)
num_groupsnum_channelsepsrg   r   )rL   rM   rg   r<   ri   Conv1dconv1conv2conv3	GroupNorm	groupnormr   
rotary_emb
ModuleListranger1   r   r   r   
layer_normgradient_checkpointing	post_init)rN   rg   	embed_dimidxrP   s       rQ   rM   zMoonshineEncoder.__init__  s     &&	YYq)ReT
YYy!i-QqQ
YYq9}iQqQ
PTU2&Amm;@AaAa;bcC"63/c
 ,,yu=&+#	 ds   D,rp   c                     | j                   S re   r   rN   s    rQ   get_input_embeddingsz%MoonshineEncoder.get_input_embeddings%  s    zzrR   valuec                     || _         y re   r  )rN   r  s     rQ   set_input_embeddingsz%MoonshineEncoder.set_input_embeddings(  s	    
rR   r   rO   c                    |j                  d      }t        j                  j                  | j	                  |            }| j                  |      }t        j                  j                  | j                  |            }t        j                  j                  | j                  |            }|j                  ddd      }|| j                  |j                  d         }d}|ddd|f   dd|f   }| j                  j                  dk(  r|d	k(  j                         r|nd}nF| j                  j                  d
k(  rt        ||j                         }nt#        ||j                         }t%        j&                  d|j                  d   |j(                        j                  d      }| j+                  ||      }| j,                  D ]  }	 |	|f|||d|} | j/                  |      }t1        |      S )a.  
        Args:
            input_values (`torch.FloatTensor` of shape `(batch_size, audio_length)`):
                Float values of the raw speech waveform. Raw speech waveform 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 [`AutoFeatureExtractor`] should be used for padding
                and conversion into a tensor of type `torch.FloatTensor`.
            attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
                Mask to avoid performing attention on padding indices in `input_values`. Mask values selected in `[0, 1]`:
                - 1 for tokens that are **not masked**,
                - 0 for tokens that are **masked**.
                [What are attention masks?](../glossary#attention-mask)
        rW   r   r"   Nrz     .flash_attention_2rX   sdpadevice)r   r   r   )last_hidden_state)	unsqueezeri   r   tanhr   r   rU   r   r   permuter   r   rg   r   anyr   dtyper   rt   aranger  r   r   r   r   )
rN   r   r   rO   ro   mask_lendownsample_strider   r   encoder_layers
             rQ   rr   zMoonshineEncoder.forward+  s   , $--a0**4::l+CD}5**4::m+DE**4::m+DE%--aA6 %<<^=Q=QRT=UVH *+C1D3D1D,DEc9H9nUN{{//3FF4Bc4I3N3N3PVZ11V;!D^UbUhUh!i!;NML_L_!`||A}':':1'=mFZFZ[eefgh"oom\J![[ 	M)-)$7	
 M	 6&+
 	
rR   re   )rY   rZ   r[   r\   r   r   r   _can_record_outputsr,   rM   ri   Moduler  r
  r   rt   r   r   ru   r   r   r   rr   r`   ra   s   @rQ   r   r     s     %O(.
 $bii "))   268
''8
 !.8
 +,	8

 
!8
 8
rR   r   c                   |    e Zd ZdZ eedd      e eedd      dZdef fdZ	e
	 	 	 	 	 	 	 	 	 ddeej                     d	eej                     d
eej                     dee   deej                      dee   deej                     deej                      deej                     dee   deeef   fd       Z xZS )MoonshineDecoder	input_idsrW   r   )index
layer_namer   )r   ro   cross_attentionsrg   c           	         t         |   |       t        j                  |j                  d      | _        t        j                  t        |j                        D cg c]  }t        ||       c}      | _
        y c c}w NFr   )rL   rM   ri   r   r<   normr   r   r>   r   r   )rN   rg   r  rP   s      rQ   rM   zMoonshineDecoder.__init__o  s\     LL!3!3%@	mm;@AaAa;bcC"63/c
cs   A=r   r   r.   inputs_embedsrF   r   r   r   rO   rp   c
                    |du |duz  rt        d      || j                  |      }|r6|4t        t        | j                        t        | j                              }|F||j                         nd}t        j                  |||j                  d   z   |j                        }||j                  d      }t        | j                  |||||      }|}| j                  ||      }|	|j                  d   }d	}|	d
dd|f   d
d|f   }	| j                  j                  dk(  r|	dk(  j                         r|	nd}	nb| j                  j                  dk(  r%t        |	|j                   |j                  d         }	n$t#        |	|j                   |j                  d         }	| j$                  D ]  } ||||f|	|||||d|
} | j'                  |      }t)        ||r|      S d      S )a  
        encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*):
            Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
            of the decoder.
        encoder_attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):
            Mask to avoid performing attention on padding indices in `encoder_hidden_states`. Mask values selected in `[0, 1]`:
            - 1 for tokens that are **not masked**,
            - 0 for tokens that are **masked**.
            [What are attention masks?](../glossary#attention-mask)
        Nz:You must specify exactly one of input_ids or inputs_embedsr   r   rW   r  )rg   input_embedsr   r   r.   r   r  .r  rX   r  )r   r   r.   rF   r   r   )r  r.   )
ValueErrorembed_tokensr   r   rg   get_seq_lengthrt   r  r   r  r  r   r   r   r  r   r  r   r   r%  r   )rN   r  r   r   r.   r&  rF   r   r   r   rO   past_seen_tokenscausal_maskro   r   r  r  decoder_layers                     rQ   rr   zMoonshineDecoder.forwardv  sI   0 -t";<YZZ  --i8M01,dkk2RT`hlhshsTtuO!CRC^==?de"\\ "2]5H5H5K"KTaThThN )33A6L(;;&))+%
 &"oom\J!-,2226H *%;CATCTAT<T%UVY[d\d[dVd%e"{{//3FFDZ^aDaCfCfCh)?nr&11V;)L*M,?,?ATATUWAX*& *D*M,?,?ATATUWAX*& "[[ 	M)% (>) /#-$7 M	 		-08+/8O
 	
>B
 	
rR   )	NNNNNNNNN)rY   rZ   r[   r   r   r   r   r  r,   rM   r   r   rt   r   ru   r
   r   r   r   r   r   r   r   rr   r`   ra   s   @rQ   r  r  g  sF   !O$%7q[Y.*+=QSab
 
  151537+/59$(59=A9=W
E,,-W
 !.W
 u//0	W

 "%W
   1 12W
 D>W
 !!1!12W
  ((9(9:W
 !) 6W
 +,W
 
u--	.W
 W
rR   r  c                      e Zd Zee	 	 	 	 	 	 	 	 	 	 ddeej                     deej                     deej                     deej                     dee	e	ej                           dee
ee	ej                     f      dee	ej                        d	ee	ej                        d
ee   deej                     dee   defd              Zy)MoonshineModelNr   r   decoder_input_idsdecoder_attention_maskencoder_outputsr.   decoder_inputs_embedsdecoder_position_idsrF   r   rO   rp   c                 B   | | j                   |fd|i|} | j                  d||||j                  ||||	|
d	|}t        |j                  |j                  |j
                  |j                  |j                  |j                  |j
                  |j                        S )a
  
        input_values (`torch.FloatTensor` of shape `(batch_size, audio_length)`):
            Float values of the raw speech waveform. Raw speech waveform 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 [`AutoFeatureExtractor`] should be used for padding
            and conversion into a tensor of type `torch.FloatTensor`.
        decoder_position_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`):
            Indices of positions of each input sequence tokens in the position embeddings.
            Used to calculate the position embeddings up to `config.decoder_config.max_position_embeddings`

        Example:

        ```python
        >>> import torch
        >>> from transformers import AutoFeatureExtractor, MoonshineModel
        >>> from datasets import load_dataset

        >>> model = MoonshineModel.from_pretrained("UsefulSensors/moonshine-tiny")
        >>> feature_extractor = AutoFeatureExtractor.from_pretrained("UsefulSensors/moonshine-tiny")
        >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
        >>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
        >>> input_values = inputs.input_values
        >>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
        >>> last_hidden_state = model(input_values, decoder_input_ids=decoder_input_ids).last_hidden_state
        >>> list(last_hidden_state.shape)
        [1, 2, 288]
        ```
        r   )	r  r   r   r   r.   r&  r   rF   r   )r  r.   decoder_hidden_statesdecoder_attentionsr"  encoder_last_hidden_stater   encoder_attentionsr:   )encoderdecoderr  r   r.   ro   r   r"  )rN   r   r   r2  r3  r4  r.   r5  r6  rF   r   rO   decoder_outputss                rQ   rr   zMoonshineModel.forward  s    \ "/;t||L/rYg/rkq/rOEQT\\ F
'1#1"1"C"C+/-)F
 F
 "-??+;;"1"?"?.99,==&5&G&G"1"?"?.99	
 		
rR   )
NNNNNNNNNN)rY   rZ   r[   r   r   r   rt   r   r   r   r   r   r   r   r   r   rr   r:   rR   rQ   r1  r1    sQ    59598<=AEIZ^DHBF$(59E
u001E
 !!1!12E
 $E$4$45	E

 !))9)9 :E
 "%e.?.?(@"ABE
 "%(;U5CTCT=U(U"VWE
  (e.?.?(@AE
 'uU-=-='>?E
 D>E
 !!1!12E
 +,E
 
E
  E
rR   r1  zj
    The Moonshine Model with a language modeling head. Can be used for automatic speech recognition.
    )custom_introc                       e Zd ZdgZdef fdZd Zd Zd Zd Z	de
j                  fd	Zee	 	 	 	 	 	 	 	 	 	 	 dd
eej"                     deej$                     deej$                     deej$                     deeeej"                           deeeeej"                     f      deeej"                        deeej$                        dee   deej$                     deej$                     dee   defd              Z xZS )!MoonshineForConditionalGenerationzproj_out.weightrg   c                     t         |   |       t        |      | _        t	        j
                  |j                  |j                  d      | _        | j                          y r$  )
rL   rM   r1  r   ri   rj   r<   r;   proj_outr  )rN   rg   rP   s     rQ   rM   z*MoonshineForConditionalGeneration.__init__$  sH     #F+
		&"4"4f6G6GeT 	rR   c                 6    | j                   j                         S re   )r   get_encoderr  s    rQ   rE  z-MoonshineForConditionalGeneration.get_encoder,      zz%%''rR   c                 6    | j                   j                         S re   )r   get_decoderr  s    rQ   rH  z-MoonshineForConditionalGeneration.get_decoder/  rF  rR   c                     | j                   S re   rC  r  s    rQ   get_output_embeddingsz7MoonshineForConditionalGeneration.get_output_embeddings2  s    }}rR   c                     || _         y re   rJ  )rN   new_embeddingss     rQ   set_output_embeddingsz7MoonshineForConditionalGeneration.set_output_embeddings5  s	    &rR   rp   c                 6    | j                   j                         S re   )r   r  r  s    rQ   r  z6MoonshineForConditionalGeneration.get_input_embeddings8  s    zz..00rR   r   r   r2  r3  r4  r.   r5  r6  rF   r   labelsrO   c                    |9|7|5t        || j                  j                  | j                  j                        } | j                  |f||||||||	|
d	|}| j                  |j                        }d}|(| j                  ||| j                  j                        }t        |||j                  |j                  |j                  |j                  |j                  |j                  |j                   	      S )a0  
        input_values (`torch.FloatTensor` of shape `(batch_size, audio_length)`):
            Float values of the raw speech waveform. Raw speech waveform 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 [`AutoFeatureExtractor`] should be used for padding
            and conversion into a tensor of type `torch.FloatTensor`.
        decoder_position_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`):
            Indices of positions of each input sequence tokens in the position embeddings.
            Used to calculate the position embeddings up to `config.decoder_config.max_position_embeddings`

        Example:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, MoonshineForConditionalGeneration
        >>> from datasets import load_dataset

        >>> processor = AutoProcessor.from_pretrained("UsefulSensors/moonshine-tiny")
        >>> model = MoonshineForConditionalGeneration.from_pretrained("UsefulSensors/moonshine-tiny")

        >>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

        >>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
        >>> input_values = inputs.input_values

        >>> generated_ids = model.generate(input_values, max_new_tokens=100)

        >>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
        >>> transcription
        'Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'
        ```N)	r   r2  r4  r3  r.   r5  r6  rF   r   )logitsrP  r;   )	lossrR  r.   r8  r9  r"  r:  r   r;  )r*   rg   pad_token_idr9   r   rC  r  loss_functionr;   r   r.   r8  r9  r"  r:  r   r;  )rN   r   r   r2  r3  r4  r.   r5  r6  rF   r   rP  rO   outputsrR  rS  s                   rQ   rr   z)MoonshineForConditionalGeneration.forward;  s   f  (-B-J$6DKK44dkk6X6X%! '1djj'
)/+#9+"7!5)'
 '
 w889%%VFt{{OeOe%fD#33")"?"?&99$55&-&G&G")"?"?&99

 
	
rR   )NNNNNNNNNNN)rY   rZ   r[   _tied_weights_keysr,   rM   rE  rH  rK  rN  ri   r  r  r   r   r   rt   r   r   r   r   r   r   r   r   r   rr   r`   ra   s   @rQ   rA  rA    s    ,, (('1bii 1  59598<=AEIZ^DHBF$(59-1T
u001T
 !!1!12T
 $E$4$45	T

 !))9)9 :T
 "%e.?.?(@"ABT
 "%(;U5CTCT=U(U"VWT
  (e.?.?(@AT
 'uU-=-='>?T
 D>T
 !!1!12T
 ))*T
 +,T
 
T
  T
rR   rA  )r,   r1  r   rA  )Mtypingr   r   r   rt   torch.nnri   transformers.utils.genericr   r   activationsr	   cache_utilsr
   r   r   configuration_utilsr   
generationr   masking_utilsr   modeling_attn_mask_utilsr   r   modeling_flash_attention_utilsr   modeling_layersr   modeling_outputsr   r   r   r   r   modeling_rope_utilsr   modeling_utilsr   r   processing_utilsr   utilsr   r   r   r    utils.deprecationr!   glm.modeling_glmr#   r$   r%   llama.modeling_llamar&   r'   r(   whisper.modeling_whisperr)   r*   
get_loggerrY   loggerr,   r  rc   rw   r   r   r   r   r   r   r  r1  rA  __all__r:   rR   rQ   <module>ro     sY   - ,   I ! C C 3 ) / g B 9  : F & R R 0 U U Y Y G 
		H	%J
& J
Z")) "))  l) l)^	1 	U- U"H6 HV # # #._
/ _
Dg
z g
TH
\ H
V 
p
(@/ p

p
frR   