





import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      FalconForCausalLM,
      FalconForQuestionAnswering,
      FalconForSequenceClassification,
      FalconForTokenClassification,
      FalconModel,
  )







class 	__lowerCAmelCase      :





   def __init__(			self       ,      snake_case       ,      snake_case=3       ,      snake_case=7       ,      snake_case=True       ,      snake_case=True       ,      snake_case=False       ,      snake_case=True       ,      snake_case=99       ,      snake_case=32       ,      snake_case=5       ,      snake_case=4       ,      snake_case=37       ,      snake_case="gelu"       ,      snake_case=0.1       ,      snake_case=0.1       ,      snake_case=512       ,      snake_case=16       ,      snake_case=2       ,      snake_case=0.02       ,      snake_case=3       ,      snake_case=4       ,      snake_case=None       ,      )					->	List[Any]:
      """simple docstring"""





      a__						:    Dict   		=	parent
      a__						:    List[str]   		=	batch_size
      a__						:    Any   		=	seq_length
      a__						:    Optional[int]   		=	is_training
      a__						:    List[Any]   		=	use_input_mask
      a__						:    int   		=	use_token_type_ids
      a__						:    Dict   		=	use_labels
      a__						:    Dict   		=	vocab_size
      a__						:    List[Any]   		=	hidden_size
      a__						:    int   		=	num_hidden_layers
      a__						:    List[Any]   		=	num_attention_heads
      a__						:    Any   		=	intermediate_size
      a__						:    int   		=	hidden_act
      a__						:    str   		=	hidden_dropout_prob
      a__						:    Tuple   		=	attention_probs_dropout_prob
      a__						:    Union[str, Any]   		=	max_position_embeddings
      a__						:    Optional[Any]   		=	type_vocab_size
      a__						:    List[Any]   		=	type_sequence_label_size
      a__						:    Optional[Any]   		=	initializer_range
      a__						:    Tuple   		=	num_labels
      a__						:    Dict   		=	num_choices
      a__						:    Union[str, Any]   		=	scope





   def 						_snake_case			(			self   )					->	Optional[int]:
      """simple docstring"""





      a__						:    Any   		=	ids_tensor([self.batch_size, self.seq_length]       ,      self.vocab_size   )

      a__						:    Optional[int]   		=	None
      if self.use_input_mask:
         a__						:    Union[str, Any]   		=	random_attention_mask([self.batch_size, self.seq_length]   )

      a__						:    Any   		=	None

      a__						:    Union[str, Any]   		=	None
      a__						:    Union[str, Any]   		=	None
      a__						:    int   		=	None
      if self.use_labels:
         a__						:    Optional[Any]   		=	ids_tensor([self.batch_size]       ,      self.type_sequence_label_size   )
         a__						:    Optional[int]   		=	ids_tensor([self.batch_size, self.seq_length]       ,      self.num_labels   )
         a__						:    List[str]   		=	ids_tensor([self.batch_size]       ,      self.num_choices   )

      a__						:    List[str]   		=	self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      return FalconConfig(
          vocab_size=self.vocab_size       ,      hidden_size=self.hidden_size       ,      num_hidden_layers=self.num_hidden_layers       ,      num_attention_heads=self.num_attention_heads       ,      intermediate_size=self.intermediate_size       ,      hidden_act=self.hidden_act       ,      hidden_dropout_prob=self.hidden_dropout_prob       ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,      max_position_embeddings=self.max_position_embeddings       ,      type_vocab_size=self.type_vocab_size       ,      is_decoder=snake_case       ,      initializer_range=self.initializer_range       ,      pad_token_id=1       ,      new_decoder_architecture=snake_case       ,      )





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case   )					->	Dict:
      """simple docstring"""





      a__						:    str   		=	FalconModel(config=snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    Union[str, Any]   		=	model(snake_case       ,      attention_mask=snake_case   )
      a__						:    str   		=	model(snake_case   )
      self.parent.assertEqual(result.last_hidden_state.shape       ,      (self.batch_size, self.seq_length, self.hidden_size)   )





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      )					->	Any:
      """simple docstring"""





      a__						:    Optional[int]   		=	True
      a__						:    int   		=	FalconModel(snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    List[str]   		=	model(
          snake_case       ,      attention_mask=snake_case       ,      encoder_hidden_states=snake_case       ,      encoder_attention_mask=snake_case       ,      )
      a__						:    Tuple   		=	model(
          snake_case       ,      attention_mask=snake_case       ,      encoder_hidden_states=snake_case       ,      )
      a__						:    List[Any]   		=	model(snake_case       ,      attention_mask=snake_case   )
      self.parent.assertEqual(result.last_hidden_state.shape       ,      (self.batch_size, self.seq_length, self.hidden_size)   )





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      )					->	Any:
      """simple docstring"""





      a__						:    List[Any]   		=	FalconForCausalLM(config=snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    List[str]   		=	model(snake_case       ,      attention_mask=snake_case       ,      labels=snake_case   )
      self.parent.assertEqual(result.logits.shape       ,      (self.batch_size, self.seq_length, self.vocab_size)   )





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      )					->	int:
      """simple docstring"""





      a__						:    Any   		=	True
      a__						:    str   		=	True
      a__						:    List[Any]   		=	FalconForCausalLM(config=snake_case   )
      model.to(snake_case   )
      model.eval()

      # first forward pass
      a__						:    List[Any]   		=	model(
          snake_case       ,      attention_mask=snake_case       ,      encoder_hidden_states=snake_case       ,      encoder_attention_mask=snake_case       ,      use_cache=snake_case       ,      )
      a__						:    Optional[int]   		=	outputs.past_key_values

      # create hypothetical multiple next token and extent to next_input_ids
      a__						:    Optional[Any]   		=	ids_tensor((self.batch_size, 3)       ,      config.vocab_size   )
      a__						:    Optional[Any]   		=	ids_tensor((self.batch_size, 3)       ,      vocab_size=2   )

      # append to next input_ids and
      a__						:    int   		=	torch.cat([input_ids, next_tokens]       ,      dim=-1   )
      a__						:    Union[str, Any]   		=	torch.cat([input_mask, next_mask]       ,      dim=-1   )

      a__						:    str   		=	model(
          snake_case       ,      attention_mask=snake_case       ,      encoder_hidden_states=snake_case       ,      encoder_attention_mask=snake_case       ,      output_hidden_states=snake_case       ,      )["hidden_states"][0]
      a__						:    Dict   		=	model(
          snake_case       ,      attention_mask=snake_case       ,      encoder_hidden_states=snake_case       ,      encoder_attention_mask=snake_case       ,      past_key_values=snake_case       ,      output_hidden_states=snake_case       ,      )["hidden_states"][0]

      # select random slice
      a__						:    str   		=	ids_tensor((1,)       ,      output_from_past.shape[-1]   ).item()
      a__						:    Optional[Any]   		=	output_from_no_past[:, -3:, random_slice_idx].detach()
      a__						:    List[str]   		=	output_from_past[:, :, random_slice_idx].detach()

      self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]   )

      # test that outputs are equal for slice
      self.parent.assertTrue(torch.allclose(snake_case       ,      snake_case       ,      atol=1E-3   )   )





   def 						_snake_case			(			self   )					->	Any:
      """simple docstring"""





      a__						:    Optional[Any]   		=	self.prepare_config_and_inputs()
      (
          (
          a__
      )		,  (
          a__
      )		,  (
          a__
      )		,  (
          a__
      )		,  (
          a__
      )		,  (
          a__
      )		,  (
          a__
      )		,  
      )						:    List[Any]   		=	config_and_inputs
      a__						:    str   		=	{"input_ids": input_ids, "attention_mask": input_mask}
      return config, inputs_dict







@require_torch
class 	__lowerCAmelCase      (       _UpperCamelCase		,_UpperCamelCase		,_UpperCamelCase		,unittest.TestCase	):
   _UpperCamelCase			:    Union[str, Any]  		=					(
       (
           FalconModel,
           FalconForCausalLM,
           FalconForSequenceClassification,
           FalconForTokenClassification,
           FalconForQuestionAnswering,
       )
       if is_torch_available()
       else ()
   )
   _UpperCamelCase			:    Optional[int]  		=					(FalconForCausalLM,) if is_torch_available() else ()
   _UpperCamelCase			:    int  		=					(
       {
           """feature-extraction""": FalconModel,
           """text-classification""": FalconForSequenceClassification,
           """text-generation""": FalconForCausalLM,
           """question-answering""": FalconForQuestionAnswering,
           """token-classification""": FalconForTokenClassification,
           """zero-shot""": FalconForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   _UpperCamelCase			:    List[Any]  		=					False
   _UpperCamelCase			:    Dict  		=					False





   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      a__						:    Optional[int]   		=	FalconModelTester(self   )
      a__						:    str   		=	ConfigTester(self       ,      config_class=snake_case       ,      hidden_size=37   )





   def 						_snake_case			(			self   )					->	List[str]:
      """simple docstring"""





      self.config_tester.run_common_tests()





   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      a__						:    Union[str, Any]   		=	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case   )





   def 						_snake_case			(			self   )					->	List[Any]:
      """simple docstring"""





      a__		,  *a__						:    Tuple   		=	self.model_tester.prepare_config_and_inputs()
      for alibi in [True, False]:
         a__						:    int   		=	alibi
         self.model_tester.create_and_check_model(snake_case       ,      *snake_case   )





   def 						_snake_case			(			self   )					->	int:
      """simple docstring"""





      a__		,  a__						:    int   		=	self.model_tester.prepare_config_and_inputs_for_common()
      a__						:    Dict   		=	3
      a__						:    List[str]   		=	input_dict["input_ids"]
      a__						:    Tuple   		=	input_ids.ne(1   ).to(snake_case   )
      a__						:    Dict   		=	ids_tensor([self.model_tester.batch_size]       ,      self.model_tester.type_sequence_label_size   )
      a__						:    List[Any]   		=	FalconForSequenceClassification(snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    List[str]   		=	model(snake_case       ,      attention_mask=snake_case       ,      labels=snake_case   )
      self.assertEqual(result.logits.shape       ,      (self.model_tester.batch_size, self.model_tester.num_labels)   )





   def 						_snake_case			(			self   )					->	Optional[int]:
      """simple docstring"""





      a__		,  a__						:    int   		=	self.model_tester.prepare_config_and_inputs_for_common()
      a__						:    Optional[int]   		=	3
      a__						:    Tuple   		=	"single_label_classification"
      a__						:    Optional[int]   		=	input_dict["input_ids"]
      a__						:    Any   		=	input_ids.ne(1   ).to(snake_case   )
      a__						:    Any   		=	ids_tensor([self.model_tester.batch_size]       ,      self.model_tester.type_sequence_label_size   )
      a__						:    int   		=	FalconForSequenceClassification(snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    Dict   		=	model(snake_case       ,      attention_mask=snake_case       ,      labels=snake_case   )
      self.assertEqual(result.logits.shape       ,      (self.model_tester.batch_size, self.model_tester.num_labels)   )





   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      a__		,  a__						:    Optional[int]   		=	self.model_tester.prepare_config_and_inputs_for_common()
      a__						:    Union[str, Any]   		=	input_dict["input_ids"]
      a__						:    Optional[int]   		=	FalconForCausalLM(snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    Tuple   		=	model(snake_case       ,      use_cache=snake_case   )
      a__						:    Dict   		=	input_ids.shape[0]
      a__						:    List[str]   		=	model._convert_to_rw_cache(result.past_key_values   )
      a__						:    Tuple   		=	model._convert_cache_to_standard_format(snake_case       ,      snake_case   )
      for layer in range(len(snake_case   )   ):
         for tensor_idx in range(2   ):
            self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3   )
            self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4   )
            self.assertTrue(
                torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]   )   )





   def 						_snake_case			(			self   )					->	Tuple:
      """simple docstring"""





      a__		,  a__						:    Optional[Any]   		=	self.model_tester.prepare_config_and_inputs_for_common()
      a__						:    List[Any]   		=	3
      a__						:    Any   		=	"multi_label_classification"
      a__						:    Union[str, Any]   		=	input_dict["input_ids"]
      a__						:    List[Any]   		=	input_ids.ne(1   ).to(snake_case   )
      a__						:    int   		=	ids_tensor(
          [self.model_tester.batch_size, config.num_labels]       ,      self.model_tester.type_sequence_label_size   ).to(torch.float   )
      a__						:    int   		=	FalconForSequenceClassification(snake_case   )
      model.to(snake_case   )
      model.eval()
      a__						:    Any   		=	model(snake_case       ,      attention_mask=snake_case       ,      labels=snake_case   )
      self.assertEqual(result.logits.shape       ,      (self.model_tester.batch_size, self.model_tester.num_labels)   )





   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      for model_class in self.all_generative_model_classes:
         a__		,  a__						:    int   		=	self.model_tester.prepare_config_and_inputs_for_common()

         # If it doesn't support cache, pass the test
         if not hasattr(snake_case       ,      "use_cache"   ):
            return

         a__						:    int   		=	model_class(snake_case   ).to(snake_case   )
         if "use_cache" not in inputs:
            a__						:    str   		=	True
         a__						:    List[Any]   		=	model(**snake_case   )

         # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
         if "past_key_values" not in outputs:
            return

         a__						:    int   		=	(
             getattr(snake_case       ,      "decoder_layers"       ,      snake_case   )
             or getattr(snake_case       ,      "num_decoder_layers"       ,      snake_case   )
             or config.num_hidden_layers
         )
         a__						:    int   		=	getattr(snake_case       ,      "num_kv_heads"       ,      config.num_attention_heads   )
         a__						:    Any   		=	getattr(snake_case       ,      "d_model"       ,      config.hidden_size   )
         a__						:    Tuple   		=	embed_dim // num_attention_heads

         a__						:    Union[str, Any]   		=	outputs["past_key_values"]
         self.assertEqual(len(snake_case   )       ,      snake_case   )

         a__		,  a__						:    Optional[int]   		=	inputs["input_ids"].shape
         for i in range(snake_case   ):
            if config.new_decoder_architecture:
               a__						:    Union[str, Any]   		=	config.num_attention_heads
            elif config.multi_query:
               a__						:    str   		=	1
            self.assertEqual(len(past_kv[0]   )       ,      2   )  # K V for the decoder = 2
            self.assertEqual(
                past_kv[i][0].shape       ,      (batch_size, num_attention_heads, seq_length, per_head_embed_dim)   )
            self.assertEqual(
                past_kv[i][1].shape       ,      (batch_size, num_attention_heads, seq_length, per_head_embed_dim)   )







@require_torch
class 	__lowerCAmelCase      (       unittest.TestCase	):





   @slow
   def 						_snake_case			(			self   )					->	Dict:
      """simple docstring"""





      a__						:    List[Any]   		=	AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"   )
      a__						:    Any   		=	FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"   )
      model.eval()
      model.to(snake_case   )
      a__						:    Dict   		=	tokenizer("My favorite food is"       ,      return_tensors="pt"   ).to(snake_case   )

      a__						:    Tuple   		=	(
          "My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."
      )

      a__						:    List[Any]   		=	model.generate(**snake_case       ,      do_sample=snake_case       ,      max_new_tokens=19   )
      a__						:    List[Any]   		=	tokenizer.batch_decode(snake_case   )[0]

      self.assertEqual(snake_case       ,      snake_case   )





   @slow
   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
         a__						:    int   		=	AutoTokenizer.from_pretrained(snake_case   )
         a__						:    Dict   		=	FalconForCausalLM.from_pretrained(snake_case   )
         model.eval()
         model.to(snake_case   )
         a__						:    Optional[int]   		=	tokenizer("My favorite food is"       ,      return_tensors="pt"   ).to(snake_case   )

         # We just test that these run without errors - the models are randomly initialized
         # and so the actual text outputs will be garbage
         model.generate(**snake_case       ,      do_sample=snake_case       ,      max_new_tokens=4   )
         model.generate(**snake_case       ,      do_sample=snake_case       ,      max_new_tokens=4   )
         model.generate(**snake_case       ,      num_beams=2       ,      max_new_tokens=4   )





   @slow
   def 						_snake_case			(			self   )					->	Union[str, Any]:
      """simple docstring"""





      with torch.no_grad():
         for repo in [
             "Rocketknight1/falcon-rw-1b",
             "Rocketknight1/tiny-random-falcon-7b",
             "Rocketknight1/tiny-random-falcon-40b",
         ]:
            a__						:    Tuple   		=	AutoTokenizer.from_pretrained(snake_case   )
            a__						:    Optional[int]   		=	FalconForCausalLM.from_pretrained(snake_case   )
            model.eval()
            model.to(device=snake_case   )
            a__						:    int   		=	tokenizer("My favorite food is"       ,      return_tensors="pt"   ).to(snake_case   )

            # Test results are the same with and without cache
            a__						:    Optional[Any]   		=	model.generate(**snake_case       ,      do_sample=snake_case       ,      max_new_tokens=20       ,      use_cache=snake_case   )
            a__						:    Optional[Any]   		=	model.generate(**snake_case       ,      do_sample=snake_case       ,      max_new_tokens=20       ,      use_cache=snake_case   )
            self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0   )








import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


SCREAMING_SNAKE_CASE__							:      Optional[int]         =    logging.get_logger(__name__)







class 	__lowerCAmelCase      (       _UpperCamelCase	):
   _UpperCamelCase			:    Tuple  		=					["""input_values""", """attention_mask"""]





   def __init__(			self       ,      snake_case = 1       ,      snake_case = 16_000       ,      snake_case = 0.0       ,      snake_case = False       ,      snake_case = 80       ,      snake_case = 16       ,      snake_case = 64       ,      snake_case = "hann_window"       ,      snake_case = 1.0       ,      snake_case = 80       ,      snake_case = 7_600       ,      snake_case = 1E-10       ,      snake_case = 2       ,      snake_case = True       ,      **snake_case       ,      )					->	Dict:
      """simple docstring"""





      super().__init__(feature_size=snake_case       ,      sampling_rate=snake_case       ,      padding_value=snake_case       ,      **snake_case   )
      a__						:    Any   		=	do_normalize
      a__						:    List[str]   		=	return_attention_mask

      a__						:    List[Any]   		=	num_mel_bins
      a__						:    List[str]   		=	hop_length
      a__						:    int   		=	win_length
      a__						:    List[Any]   		=	win_function
      a__						:    List[str]   		=	frame_signal_scale
      a__						:    List[Any]   		=	fmin
      a__						:    Optional[Any]   		=	fmax
      a__						:    Union[str, Any]   		=	mel_floor
      a__						:    Union[str, Any]   		=	reduction_factor

      a__						:    List[str]   		=	win_length * sampling_rate // 1_000
      a__						:    List[Any]   		=	hop_length * sampling_rate // 1_000
      a__						:    List[Any]   		=	optimal_fft_length(self.sample_size   )
      a__						:    Dict   		=	(self.n_fft // 2) + 1

      a__						:    str   		=	window_function(window_length=self.sample_size       ,      name=self.win_function       ,      periodic=snake_case   )

      a__						:    Tuple   		=	mel_filter_bank(
          num_frequency_bins=self.n_freqs       ,      num_mel_filters=self.num_mel_bins       ,      min_frequency=self.fmin       ,      max_frequency=self.fmax       ,      sampling_rate=self.sampling_rate       ,      norm="slaney"       ,      mel_scale="slaney"       ,      )

      if frame_signal_scale != 1.0:
         warnings.warn(
             "The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers"       ,      snake_case       ,      )
      if reduction_factor != 2.0:
         warnings.warn(
             "The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"       ,      snake_case       ,      )





   @staticmethod
   # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
   def 						_snake_case			(			snake_case       ,      snake_case       ,      snake_case = 0.0   )					->	List[np.ndarray]:
      """simple docstring"""





      if attention_mask is not None:
         a__						:    Tuple   		=	np.array(snake_case       ,      np.intaa   )
         a__						:    List[str]   		=	[]

         for vector, length in zip(snake_case       ,      attention_mask.sum(-1   )   ):
            a__						:    List[Any]   		=	(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7   )
            if length < normed_slice.shape[0]:
               a__						:    List[str]   		=	padding_value

            normed_input_values.append(snake_case   )
      else:
         a__						:    Any   		=	[(x - x.mean()) / np.sqrt(x.var() + 1E-7   ) for x in input_values]

      return normed_input_values





   def 						_snake_case			(			self       ,      snake_case       ,      )					->	np.ndarray:
      """simple docstring"""





      a__						:    str   		=	spectrogram(
          snake_case       ,      window=self.window       ,      frame_length=self.sample_size       ,      hop_length=self.sample_stride       ,      fft_length=self.n_fft       ,      mel_filters=self.mel_filters       ,      mel_floor=self.mel_floor       ,      log_mel="log10"       ,      )
      return log_mel_spec.T





   def __call__(			self       ,      snake_case = None       ,      snake_case = None       ,      snake_case = False       ,      snake_case = None       ,      snake_case = False       ,      snake_case = None       ,      snake_case = None       ,      snake_case = None       ,      snake_case = None       ,      **snake_case       ,      )					->	BatchFeature:
      """simple docstring"""





      if audio is None and audio_target is None:
         raise ValueError("You must provide either `audio` or `audio_target` values."   )

      if sampling_rate is not None:
         if sampling_rate != self.sampling_rate:
            raise ValueError(
                F"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
                F""" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"""
                F""" {self.sampling_rate} and not {sampling_rate}."""   )
      else:
         logger.warning(
             "It is strongly recommended to pass the ``sampling_rate`` argument to this function. "
             "Failing to do so can result in silent errors that might be hard to debug."   )

      if audio is not None:
         a__						:    Dict   		=	self._process_audio(
             snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      **snake_case       ,      )
      else:
         a__						:    Optional[int]   		=	None

      if audio_target is not None:
         a__						:    List[Any]   		=	self._process_audio(
             snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      snake_case       ,      **snake_case       ,      )

         if inputs is None:
            return inputs_target
         else:
            a__						:    Tuple   		=	inputs_target["input_values"]
            a__						:    Tuple   		=	inputs_target.get("attention_mask"   )
            if decoder_attention_mask is not None:
               a__						:    Tuple   		=	decoder_attention_mask

      return inputs





   def 						_snake_case			(			self       ,      snake_case       ,      snake_case = False       ,      snake_case = False       ,      snake_case = None       ,      snake_case = False       ,      snake_case = None       ,      snake_case = None       ,      snake_case = None       ,      **snake_case       ,      )					->	BatchFeature:
      """simple docstring"""





      a__						:    Optional[int]   		=	isinstance(snake_case       ,      np.ndarray   ) and len(speech.shape   ) > 1
      if is_batched_numpy and len(speech.shape   ) > 2:
         raise ValueError(F"""Only mono-channel audio is supported for input to {self}"""   )
      a__						:    List[Any]   		=	is_batched_numpy or (
          isinstance(snake_case       ,      (list, tuple)   ) and (isinstance(speech[0]       ,      (np.ndarray, tuple, list)   ))
      )

      if is_batched:
         a__						:    int   		=	[np.asarray(snake_case       ,      dtype=np.floataa   ) for speech in speech]
      elif not is_batched and not isinstance(snake_case       ,      np.ndarray   ):
         a__						:    Any   		=	np.asarray(snake_case       ,      dtype=np.floataa   )
      elif isinstance(snake_case       ,      np.ndarray   ) and speech.dtype is np.dtype(np.floataa   ):
         a__						:    List[Any]   		=	speech.astype(np.floataa   )

      # always return batch
      if not is_batched:
         a__						:    Union[str, Any]   		=	[speech]

      # needed to make pad() work on spectrogram inputs
      a__						:    Optional[Any]   		=	self.feature_size

      # convert into correct format for padding
      if is_target:
         a__						:    List[str]   		=	[self._extract_mel_features(snake_case   ) for waveform in speech]
         a__						:    Optional[Any]   		=	BatchFeature({"input_values": features}   )
         a__						:    str   		=	self.num_mel_bins
      else:
         a__						:    int   		=	BatchFeature({"input_values": speech}   )

      a__						:    int   		=	self.pad(
          snake_case       ,      padding=snake_case       ,      max_length=snake_case       ,      truncation=snake_case       ,      pad_to_multiple_of=snake_case       ,      return_attention_mask=snake_case       ,      **snake_case       ,      )

      a__						:    Any   		=	feature_size_hack

      # convert input values to correct format
      a__						:    Tuple   		=	padded_inputs["input_values"]
      if not isinstance(input_values[0]       ,      np.ndarray   ):
         a__						:    int   		=	[np.asarray(snake_case       ,      dtype=np.floataa   ) for array in input_values]
      elif (
          not isinstance(snake_case       ,      np.ndarray   )
          and isinstance(input_values[0]       ,      np.ndarray   )
          and input_values[0].dtype is np.dtype(np.floataa   )
      ):
         a__						:    Union[str, Any]   		=	[array.astype(np.floataa   ) for array in input_values]
      elif isinstance(snake_case       ,      np.ndarray   ) and input_values.dtype is np.dtype(np.floataa   ):
         a__						:    Optional[int]   		=	input_values.astype(np.floataa   )

      # convert attention_mask to correct format
      a__						:    Optional[int]   		=	padded_inputs.get("attention_mask"   )
      if attention_mask is not None:
         a__						:    Tuple   		=	[np.asarray(snake_case       ,      dtype=np.intaa   ) for array in attention_mask]

      # zero-mean and unit-variance normalization
      if not is_target and self.do_normalize:
         a__						:    Any   		=	(
             attention_mask
             if self._get_padding_strategies(snake_case       ,      max_length=snake_case   ) is not PaddingStrategy.DO_NOT_PAD
             else None
         )
         a__						:    Optional[Any]   		=	self.zero_mean_unit_var_norm(
             padded_inputs["input_values"]       ,      attention_mask=snake_case       ,      padding_value=self.padding_value   )

      if return_tensors is not None:
         a__						:    int   		=	padded_inputs.convert_to_tensors(snake_case   )

      return padded_inputs





   def 						_snake_case			(			self   )					->	Dict[str, Any]:
      """simple docstring"""





      a__						:    int   		=	super().to_dict()

      # Don't serialize these as they are derived from the other properties.
      a__						:    str   		=	["window", "mel_filters", "sample_size", "sample_stride", "n_fft", "n_freqs"]
      for name in names:
         if name in output:
            del output[name]

      return output

