


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  :






  """simple docstring"""





  def __init__(  self							:							Union[str, Any]     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Any=3     ,					_lowerCAmelCase							:							Any=7     ,					_lowerCAmelCase							:							Optional[Any]=True     ,					_lowerCAmelCase							:							Dict=True     ,					_lowerCAmelCase							:							Tuple=False     ,					_lowerCAmelCase							:							List[Any]=True     ,					_lowerCAmelCase							:							Dict=9_9     ,					_lowerCAmelCase							:							Optional[int]=3_2     ,					_lowerCAmelCase							:							Optional[Any]=5     ,					_lowerCAmelCase							:							Any=4     ,					_lowerCAmelCase							:							Any=3_7     ,					_lowerCAmelCase							:							Optional[int]="gelu"     ,					_lowerCAmelCase							:							List[str]=0.1     ,					_lowerCAmelCase							:							str=0.1     ,					_lowerCAmelCase							:							List[Any]=5_1_2     ,					_lowerCAmelCase							:							Optional[int]=1_6     ,					_lowerCAmelCase							:							Any=2     ,					_lowerCAmelCase							:							Optional[Any]=0.02     ,					_lowerCAmelCase							:							Optional[int]=3     ,					_lowerCAmelCase							:							List[Any]=4     ,					_lowerCAmelCase							:							Optional[int]=None     ,					) ->			List[str]:




     """simple docstring"""
     snake_case_            =       parent
     snake_case_            =       batch_size
     snake_case_            =       seq_length
     snake_case_            =       is_training
     snake_case_            =       use_input_mask
     snake_case_            =       use_token_type_ids
     snake_case_            =       use_labels
     snake_case_            =       vocab_size
     snake_case_            =       hidden_size
     snake_case_            =       num_hidden_layers
     snake_case_            =       num_attention_heads
     snake_case_            =       intermediate_size
     snake_case_            =       hidden_act
     snake_case_            =       hidden_dropout_prob
     snake_case_            =       attention_probs_dropout_prob
     snake_case_            =       max_position_embeddings
     snake_case_            =       type_vocab_size
     snake_case_            =       type_sequence_label_size
     snake_case_            =       initializer_range
     snake_case_            =       num_labels
     snake_case_            =       num_choices
     snake_case_            =       scope



  def        lowerCAmelCase__	(  self							:							str	) ->			Dict:




     """simple docstring"""
     snake_case_            =       ids_tensor([self.batch_size, self.seq_length]     ,					self.vocab_size	)

     snake_case_            =       None
     if self.use_input_mask:
        snake_case_            =       random_attention_mask([self.batch_size, self.seq_length]	)

     snake_case_            =       None

     snake_case_            =       None
     snake_case_            =       None
     snake_case_            =       None
     if self.use_labels:
        snake_case_            =       ids_tensor([self.batch_size]     ,					self.type_sequence_label_size	)
        snake_case_            =       ids_tensor([self.batch_size, self.seq_length]     ,					self.num_labels	)
        snake_case_            =       ids_tensor([self.batch_size]     ,					self.num_choices	)

     snake_case_            =       self.get_config()

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



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			Optional[int]:




     """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=_lowerCAmelCase     ,					initializer_range=self.initializer_range     ,					pad_token_id=1     ,					new_decoder_architecture=_lowerCAmelCase     ,					)



  def        lowerCAmelCase__	(  self							:							Dict     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							int     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							int	) ->			str:




     """simple docstring"""
     snake_case_            =       FalconModel(config=_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase	)
     snake_case_            =       model(_lowerCAmelCase	)
     self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, self.seq_length, self.hidden_size)	)



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							str     ,					_lowerCAmelCase							:							List[Any]     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							Tuple     ,					) ->			int:




     """simple docstring"""
     snake_case_            =       True
     snake_case_            =       FalconModel(_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(
         _lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					encoder_hidden_states=_lowerCAmelCase     ,					encoder_attention_mask=_lowerCAmelCase     ,					)
     snake_case_            =       model(
         _lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					encoder_hidden_states=_lowerCAmelCase     ,					)
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase	)
     self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, self.seq_length, self.hidden_size)	)



  def        lowerCAmelCase__	(  self							:							Any     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							str     ,					_lowerCAmelCase							:							Optional[int]     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							Optional[Any]     ,					_lowerCAmelCase							:							List[str]     ,					) ->			str:




     """simple docstring"""
     snake_case_            =       FalconForCausalLM(config=_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					labels=_lowerCAmelCase	)
     self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.seq_length, self.vocab_size)	)



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Dict     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							List[str]     ,					_lowerCAmelCase							:							Tuple     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							Dict     ,					) ->			str:




     """simple docstring"""
     snake_case_            =       True
     snake_case_            =       True
     snake_case_            =       FalconForCausalLM(config=_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()

     # first forward pass
     snake_case_            =       model(
         _lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					encoder_hidden_states=_lowerCAmelCase     ,					encoder_attention_mask=_lowerCAmelCase     ,					use_cache=_lowerCAmelCase     ,					)
     snake_case_            =       outputs.past_key_values

     # create hypothetical multiple next token and extent to next_input_ids
     snake_case_            =       ids_tensor((self.batch_size, 3)     ,					config.vocab_size	)
     snake_case_            =       ids_tensor((self.batch_size, 3)     ,					vocab_size=2	)

     # append to next input_ids and
     snake_case_            =       torch.cat([input_ids, next_tokens]     ,					dim=-1	)
     snake_case_            =       torch.cat([input_mask, next_mask]     ,					dim=-1	)

     snake_case_            =       model(
         _lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					encoder_hidden_states=_lowerCAmelCase     ,					encoder_attention_mask=_lowerCAmelCase     ,					output_hidden_states=_lowerCAmelCase     ,					)["hidden_states"][0]
     snake_case_            =       model(
         _lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					encoder_hidden_states=_lowerCAmelCase     ,					encoder_attention_mask=_lowerCAmelCase     ,					past_key_values=_lowerCAmelCase     ,					output_hidden_states=_lowerCAmelCase     ,					)["hidden_states"][0]

     # select random slice
     snake_case_            =       ids_tensor((1,)     ,					output_from_past.shape[-1]	).item()
     snake_case_            =       output_from_no_past[:, -3:, random_slice_idx].detach()
     snake_case_            =       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(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)



  def        lowerCAmelCase__	(  self							:							str	) ->			Any:




     """simple docstring"""
     snake_case_            =       self.prepare_config_and_inputs()
     (
         (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     (
         snake_case_
     )     ,     
     )            =       config_and_inputs
     snake_case_            =       {"input_ids": input_ids, "attention_mask": input_mask}
     return config, inputs_dict






@require_torch
class      __lowerCAmelCase  (			a			,	a			,	a			,	unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							(
      (
          FalconModel,
          FalconForCausalLM,
          FalconForSequenceClassification,
          FalconForTokenClassification,
          FalconForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  _SCREAMING_SNAKE_CASE		     =							(FalconForCausalLM,) if is_torch_available() else ()
  _SCREAMING_SNAKE_CASE		     =							(
      {
          'feature-extraction': FalconModel,
          'text-classification': FalconForSequenceClassification,
          'text-generation': FalconForCausalLM,
          'question-answering': FalconForQuestionAnswering,
          'token-classification': FalconForTokenClassification,
          'zero-shot': FalconForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  _SCREAMING_SNAKE_CASE		     =							False
  _SCREAMING_SNAKE_CASE		     =							False



  def        lowerCAmelCase__	(  self							:							List[str]	) ->			Any:




     """simple docstring"""
     snake_case_            =       FalconModelTester(self	)
     snake_case_            =       ConfigTester(self     ,					config_class=_lowerCAmelCase     ,					hidden_size=3_7	)



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Union[str, Any]:




     """simple docstring"""
     self.config_tester.run_common_tests()



  def        lowerCAmelCase__	(  self							:							int	) ->			List[str]:




     """simple docstring"""
     snake_case_            =       self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Any	) ->			Optional[Any]:




     """simple docstring"""
     snake_case_     ,     *snake_case_            =       self.model_tester.prepare_config_and_inputs()
     for alibi in [True, False]:
        snake_case_            =       alibi
        self.model_tester.create_and_check_model(_lowerCAmelCase     ,					*_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			List[str]:




     """simple docstring"""
     snake_case_     ,     snake_case_            =       self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_            =       3
     snake_case_            =       input_dict["input_ids"]
     snake_case_            =       input_ids.ne(1	).to(_lowerCAmelCase	)
     snake_case_            =       ids_tensor([self.model_tester.batch_size]     ,					self.model_tester.type_sequence_label_size	)
     snake_case_            =       FalconForSequenceClassification(_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					labels=_lowerCAmelCase	)
     self.assertEqual(result.logits.shape     ,					(self.model_tester.batch_size, self.model_tester.num_labels)	)



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Optional[int]:




     """simple docstring"""
     snake_case_     ,     snake_case_            =       self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_            =       3
     snake_case_            =       "single_label_classification"
     snake_case_            =       input_dict["input_ids"]
     snake_case_            =       input_ids.ne(1	).to(_lowerCAmelCase	)
     snake_case_            =       ids_tensor([self.model_tester.batch_size]     ,					self.model_tester.type_sequence_label_size	)
     snake_case_            =       FalconForSequenceClassification(_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					labels=_lowerCAmelCase	)
     self.assertEqual(result.logits.shape     ,					(self.model_tester.batch_size, self.model_tester.num_labels)	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			Optional[Any]:




     """simple docstring"""
     snake_case_     ,     snake_case_            =       self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_            =       input_dict["input_ids"]
     snake_case_            =       FalconForCausalLM(_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					use_cache=_lowerCAmelCase	)
     snake_case_            =       input_ids.shape[0]
     snake_case_            =       model._convert_to_rw_cache(result.past_key_values	)
     snake_case_            =       model._convert_cache_to_standard_format(_lowerCAmelCase     ,					_lowerCAmelCase	)
     for layer in range(len(_lowerCAmelCase	)	):
        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        lowerCAmelCase__	(  self							:							int	) ->			Optional[Any]:




     """simple docstring"""
     snake_case_     ,     snake_case_            =       self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_            =       3
     snake_case_            =       "multi_label_classification"
     snake_case_            =       input_dict["input_ids"]
     snake_case_            =       input_ids.ne(1	).to(_lowerCAmelCase	)
     snake_case_            =       ids_tensor(
         [self.model_tester.batch_size, config.num_labels]     ,					self.model_tester.type_sequence_label_size	).to(torch.float	)
     snake_case_            =       FalconForSequenceClassification(_lowerCAmelCase	)
     model.to(_lowerCAmelCase	)
     model.eval()
     snake_case_            =       model(_lowerCAmelCase     ,					attention_mask=_lowerCAmelCase     ,					labels=_lowerCAmelCase	)
     self.assertEqual(result.logits.shape     ,					(self.model_tester.batch_size, self.model_tester.num_labels)	)



  def        lowerCAmelCase__	(  self							:							Optional[Any]	) ->			Dict:




     """simple docstring"""
     # Falcon can have different numbers of KV-heads than the number of query heads, so we need
     # to override this test to use the right head counts.
     for model_class in self.all_generative_model_classes:
        snake_case_     ,     snake_case_            =       self.model_tester.prepare_config_and_inputs_for_common()

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

        snake_case_            =       model_class(_lowerCAmelCase	).to(_lowerCAmelCase	)
        if "use_cache" not in inputs:
           snake_case_            =       True
        snake_case_            =       model(**_lowerCAmelCase	)

        # 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

        snake_case_            =       (
            getattr(_lowerCAmelCase     ,					"decoder_layers"     ,					_lowerCAmelCase	)
            or getattr(_lowerCAmelCase     ,					"num_decoder_layers"     ,					_lowerCAmelCase	)
            or config.num_hidden_layers
        )
        snake_case_            =       getattr(_lowerCAmelCase     ,					"num_kv_heads"     ,					config.num_attention_heads	)
        snake_case_            =       getattr(_lowerCAmelCase     ,					"d_model"     ,					config.hidden_size	)
        snake_case_            =       embed_dim // num_attention_heads

        snake_case_            =       outputs["past_key_values"]
        self.assertEqual(len(_lowerCAmelCase	)     ,					_lowerCAmelCase	)

        snake_case_     ,     snake_case_            =       inputs["input_ids"].shape
        for i in range(_lowerCAmelCase	):
           if config.new_decoder_architecture:
              snake_case_            =       config.num_attention_heads
           elif config.multi_query:
              snake_case_            =       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       ):






  """simple docstring"""





  @slow
  def        lowerCAmelCase__	(  self							:							Optional[Any]	) ->			int:




     """simple docstring"""
     snake_case_            =       AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"	)
     snake_case_            =       FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"	)
     model.eval()
     model.to(_lowerCAmelCase	)
     snake_case_            =       tokenizer("My favorite food is"     ,					return_tensors="pt"	).to(_lowerCAmelCase	)

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

     snake_case_            =       model.generate(**_lowerCAmelCase     ,					do_sample=_lowerCAmelCase     ,					max_new_tokens=1_9	)
     snake_case_            =       tokenizer.batch_decode(_lowerCAmelCase	)[0]

     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  @slow
  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Optional[int]:




     """simple docstring"""
     # The big models are way too big for the CI, so we use tiny random models that resemble their
     # architectures but with much smaller and fewer layers
     for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
        snake_case_            =       AutoTokenizer.from_pretrained(_lowerCAmelCase	)
        snake_case_            =       FalconForCausalLM.from_pretrained(_lowerCAmelCase	)
        model.eval()
        model.to(_lowerCAmelCase	)
        snake_case_            =       tokenizer("My favorite food is"     ,					return_tensors="pt"	).to(_lowerCAmelCase	)

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



  @slow
  def        lowerCAmelCase__	(  self							:							Any	) ->			int:




     """simple docstring"""
     # The big models are way too big for the CI, so we use tiny random models that resemble their
     # architectures but with much smaller and fewer layers
     with torch.no_grad():
        for repo in [
            "Rocketknight1/falcon-rw-1b",
            "Rocketknight1/tiny-random-falcon-7b",
            "Rocketknight1/tiny-random-falcon-40b",
        ]:
           snake_case_            =       AutoTokenizer.from_pretrained(_lowerCAmelCase	)
           snake_case_            =       FalconForCausalLM.from_pretrained(_lowerCAmelCase	)
           model.eval()
           model.to(device=_lowerCAmelCase	)
           snake_case_            =       tokenizer("My favorite food is"     ,					return_tensors="pt"	).to(_lowerCAmelCase	)

           # Test results are the same with and without cache
           snake_case_            =       model.generate(**_lowerCAmelCase     ,					do_sample=_lowerCAmelCase     ,					max_new_tokens=2_0     ,					use_cache=_lowerCAmelCase	)
           snake_case_            =       model.generate(**_lowerCAmelCase     ,					do_sample=_lowerCAmelCase     ,					max_new_tokens=2_0     ,					use_cache=_lowerCAmelCase	)
           self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0	)








import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
   from transformers import WhisperFeatureExtractor

if is_torch_available():
   import torch

SCREAMING_SNAKE_CASE						:Optional[int]			=  random.Random()



def       _lowerCAmelCase    (				lowerCAmelCase_				:List[str]		,    lowerCAmelCase_				:Tuple=1.0		,    lowerCAmelCase_				:Optional[int]=None		,    lowerCAmelCase_				:List[Any]=None				)->Dict:
   '''simple docstring'''






   if rng is None:
      snake_case_            =       global_rng

   snake_case_            =       []
   for batch_idx in range(shape[0]				):
      values.append([]				)
      for _ in range(shape[1]				):
         values[-1].append(rng.random() * scale				)

   return values


@require_torch
@require_torchaudio
class      __lowerCAmelCase  (			unittest.TestCase       ):






  """simple docstring"""





  def __init__(  self							:							Optional[int]     ,					_lowerCAmelCase							:							Any     ,					_lowerCAmelCase							:							List[str]=7     ,					_lowerCAmelCase							:							List[Any]=4_0_0     ,					_lowerCAmelCase							:							Optional[Any]=2_0_0_0     ,					_lowerCAmelCase							:							Tuple=1_0     ,					_lowerCAmelCase							:							Optional[int]=1_6_0     ,					_lowerCAmelCase							:							List[Any]=8     ,					_lowerCAmelCase							:							List[Any]=0.0     ,					_lowerCAmelCase							:							Dict=4_0_0_0     ,					_lowerCAmelCase							:							str=False     ,					_lowerCAmelCase							:							List[str]=True     ,					) ->			str:




     """simple docstring"""
     snake_case_            =       parent
     snake_case_            =       batch_size
     snake_case_            =       min_seq_length
     snake_case_            =       max_seq_length
     snake_case_            =       (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     snake_case_            =       padding_value
     snake_case_            =       sampling_rate
     snake_case_            =       return_attention_mask
     snake_case_            =       do_normalize
     snake_case_            =       feature_size
     snake_case_            =       chunk_length
     snake_case_            =       hop_length



  def        lowerCAmelCase__	(  self							:							int	) ->			str:




     """simple docstring"""
     return {
         "feature_size": self.feature_size,
         "hop_length": self.hop_length,
         "chunk_length": self.chunk_length,
         "padding_value": self.padding_value,
         "sampling_rate": self.sampling_rate,
         "return_attention_mask": self.return_attention_mask,
         "do_normalize": self.do_normalize,
     }



  def        lowerCAmelCase__	(  self							:							int     ,					_lowerCAmelCase							:							Optional[Any]=False     ,					_lowerCAmelCase							:							List[Any]=False	) ->			int:




     """simple docstring"""
     def _flatten(_lowerCAmelCase							:							Union[str, Any]	):
        return list(itertools.chain(*_lowerCAmelCase	)	)

     if equal_length:
        snake_case_            =       [floats_list((self.max_seq_length, self.feature_size)	) for _ in range(self.batch_size	)]
     else:
        # make sure that inputs increase in size
        snake_case_            =       [
            floats_list((x, self.feature_size)	)
            for x in range(self.min_seq_length     ,					self.max_seq_length     ,					self.seq_length_diff	)
        ]
     if numpify:
        snake_case_            =       [np.asarray(_lowerCAmelCase	) for x in speech_inputs]
     return speech_inputs






@require_torch
@require_torchaudio
class      __lowerCAmelCase  (			a			,	unittest.TestCase       ):






  """simple docstring"""





  _SCREAMING_SNAKE_CASE		     =							WhisperFeatureExtractor if is_speech_available() else None



  def        lowerCAmelCase__	(  self							:							str	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       WhisperFeatureExtractionTester(self	)



  def        lowerCAmelCase__	(  self							:							Tuple	) ->			Union[str, Any]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       feat_extract_first.save_pretrained(_lowerCAmelCase	)[0]
        check_json_file_has_correct_format(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_pretrained(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							List[Any]	) ->			str:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_dict	)

     with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case_            =       os.path.join(_lowerCAmelCase     ,					"feat_extract.json"	)
        feat_extract_first.to_json_file(_lowerCAmelCase	)
        snake_case_            =       self.feature_extraction_class.from_json_file(_lowerCAmelCase	)

     snake_case_            =       feat_extract_first.to_dict()
     snake_case_            =       feat_extract_second.to_dict()
     snake_case_            =       feat_extract_first.mel_filters
     snake_case_            =       feat_extract_second.mel_filters
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase	)	)
     self.assertEqual(_lowerCAmelCase     ,					_lowerCAmelCase	)



  def        lowerCAmelCase__	(  self							:							Any	) ->			Optional[int]:




     """simple docstring"""
     # Tests that all call wrap to encode_plus and batch_encode_plus
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     # create three inputs of length 800, 1000, and 1200
     snake_case_            =       [floats_list((1, x)	)[0] for x in range(8_0_0     ,					1_4_0_0     ,					2_0_0	)]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs]

     # Test feature size
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					padding="max_length"     ,					return_tensors="np"	).input_features
     self.assertTrue(input_features.ndim == 3	)
     self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames	)
     self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size	)

     # Test not batched input
     snake_case_            =       feature_extractor(speech_inputs[0]     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(np_speech_inputs[0]     ,					return_tensors="np"	).input_features
     self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test batched
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test 2-D numpy arrays are batched.
     snake_case_            =       [floats_list((1, x)	)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
     snake_case_            =       np.asarray(_lowerCAmelCase	)
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)

     # Test truncation required
     snake_case_            =       [floats_list((1, x)	)[0] for x in range(2_0_0     ,					(feature_extractor.n_samples + 5_0_0)     ,					2_0_0	)]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs]

     snake_case_            =       [x[: feature_extractor.n_samples] for x in speech_inputs]
     snake_case_            =       [np.asarray(_lowerCAmelCase	) for speech_input in speech_inputs_truncated]

     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="np"	).input_features
     for enc_seq_a, enc_seq_a in zip(_lowerCAmelCase     ,					_lowerCAmelCase	):
        self.assertTrue(np.allclose(_lowerCAmelCase     ,					_lowerCAmelCase     ,					atol=1e-3	)	)



  def        lowerCAmelCase__	(  self							:							Optional[int]	) ->			Tuple:




     """simple docstring"""
     import torch

     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       np.random.rand(1_0_0     ,					3_2	).astype(np.floataa	)
     snake_case_            =       np_speech_inputs.tolist()

     for inputs in [py_speech_inputs, np_speech_inputs]:
        snake_case_            =       feature_extractor.pad([{"input_features": inputs}]     ,					return_tensors="np"	)
        self.assertTrue(np_processed.input_features.dtype == np.floataa	)
        snake_case_            =       feature_extractor.pad([{"input_features": inputs}]     ,					return_tensors="pt"	)
        self.assertTrue(pt_processed.input_features.dtype == torch.floataa	)



  def        lowerCAmelCase__	(  self							:							List[Any]     ,					_lowerCAmelCase							:							Dict	) ->			int:




     """simple docstring"""
     snake_case_            =       load_dataset("hf-internal-testing/librispeech_asr_dummy"     ,					"clean"     ,					split="validation"	)
     # automatic decoding with librispeech
     snake_case_            =       ds.sort("id"	).select(range(_lowerCAmelCase	)	)[:num_samples]["audio"]

     return [x["array"] for x in speech_samples]



  def        lowerCAmelCase__	(  self							:							Optional[Any]	) ->			Optional[Any]:




     """simple docstring"""
     # fmt: off
     snake_case_            =       torch.tensor(
         [
             0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
             0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
             0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
             -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
         ]	)
     # fmt: on

     snake_case_            =       self._load_datasamples(1	)
     snake_case_            =       WhisperFeatureExtractor()
     snake_case_            =       feature_extractor(_lowerCAmelCase     ,					return_tensors="pt"	).input_features
     self.assertEqual(input_features.shape     ,					(1, 8_0, 3_0_0_0)	)
     self.assertTrue(torch.allclose(input_features[0, 0, :3_0]     ,					_lowerCAmelCase     ,					atol=1e-4	)	)



  def        lowerCAmelCase__	(  self							:							Union[str, Any]	) ->			List[str]:




     """simple docstring"""
     snake_case_            =       self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
     snake_case_            =       self._load_datasamples(1	)[0]
     snake_case_            =       ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
     snake_case_            =       feat_extract.zero_mean_unit_var_norm([audio]     ,					attention_mask=_lowerCAmelCase	)[0]

     self.assertTrue(np.all(np.mean(_lowerCAmelCase	) < 1e-3	)	)
     self.assertTrue(np.all(np.abs(np.var(_lowerCAmelCase	) - 1	) < 1e-3	)	)




