





'''simple docstring'''
from collections import OrderedDict

from ...utils import logging
from .auto_factory import _BaseAutoModelClass, _LazyAutoMapping, auto_class_update
from .configuration_auto import CONFIG_MAPPING_NAMES


lowerCamelCase			:				Tuple 			=					logging.get_logger(__name__)


lowerCamelCase			:				Optional[Any] 			=					OrderedDict(
    [
        # Base model mapping
        ("albert", "FlaxAlbertModel"),
        ("bart", "FlaxBartModel"),
        ("beit", "FlaxBeitModel"),
        ("bert", "FlaxBertModel"),
        ("big_bird", "FlaxBigBirdModel"),
        ("blenderbot", "FlaxBlenderbotModel"),
        ("blenderbot-small", "FlaxBlenderbotSmallModel"),
        ("clip", "FlaxCLIPModel"),
        ("distilbert", "FlaxDistilBertModel"),
        ("electra", "FlaxElectraModel"),
        ("gpt-sw3", "FlaxGPT2Model"),
        ("gpt2", "FlaxGPT2Model"),
        ("gpt_neo", "FlaxGPTNeoModel"),
        ("gptj", "FlaxGPTJModel"),
        ("longt5", "FlaxLongT5Model"),
        ("marian", "FlaxMarianModel"),
        ("mbart", "FlaxMBartModel"),
        ("mt5", "FlaxMT5Model"),
        ("opt", "FlaxOPTModel"),
        ("pegasus", "FlaxPegasusModel"),
        ("regnet", "FlaxRegNetModel"),
        ("resnet", "FlaxResNetModel"),
        ("roberta", "FlaxRobertaModel"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormModel"),
        ("roformer", "FlaxRoFormerModel"),
        ("t5", "FlaxT5Model"),
        ("vision-text-dual-encoder", "FlaxVisionTextDualEncoderModel"),
        ("vit", "FlaxViTModel"),
        ("wav2vec2", "FlaxWav2Vec2Model"),
        ("whisper", "FlaxWhisperModel"),
        ("xglm", "FlaxXGLMModel"),
        ("xlm-roberta", "FlaxXLMRobertaModel"),
    ]
)

lowerCamelCase			:				int 			=					OrderedDict(
    [
        # Model for pre-training mapping
        ("albert", "FlaxAlbertForPreTraining"),
        ("bart", "FlaxBartForConditionalGeneration"),
        ("bert", "FlaxBertForPreTraining"),
        ("big_bird", "FlaxBigBirdForPreTraining"),
        ("electra", "FlaxElectraForPreTraining"),
        ("longt5", "FlaxLongT5ForConditionalGeneration"),
        ("mbart", "FlaxMBartForConditionalGeneration"),
        ("mt5", "FlaxMT5ForConditionalGeneration"),
        ("roberta", "FlaxRobertaForMaskedLM"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForMaskedLM"),
        ("roformer", "FlaxRoFormerForMaskedLM"),
        ("t5", "FlaxT5ForConditionalGeneration"),
        ("wav2vec2", "FlaxWav2Vec2ForPreTraining"),
        ("whisper", "FlaxWhisperForConditionalGeneration"),
        ("xlm-roberta", "FlaxXLMRobertaForMaskedLM"),
    ]
)

lowerCamelCase			:				int 			=					OrderedDict(
    [
        # Model for Masked LM mapping
        ("albert", "FlaxAlbertForMaskedLM"),
        ("bart", "FlaxBartForConditionalGeneration"),
        ("bert", "FlaxBertForMaskedLM"),
        ("big_bird", "FlaxBigBirdForMaskedLM"),
        ("distilbert", "FlaxDistilBertForMaskedLM"),
        ("electra", "FlaxElectraForMaskedLM"),
        ("mbart", "FlaxMBartForConditionalGeneration"),
        ("roberta", "FlaxRobertaForMaskedLM"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForMaskedLM"),
        ("roformer", "FlaxRoFormerForMaskedLM"),
        ("xlm-roberta", "FlaxXLMRobertaForMaskedLM"),
    ]
)

lowerCamelCase			:				List[Any] 			=					OrderedDict(
    [
        # Model for Seq2Seq Causal LM mapping
        ("bart", "FlaxBartForConditionalGeneration"),
        ("blenderbot", "FlaxBlenderbotForConditionalGeneration"),
        ("blenderbot-small", "FlaxBlenderbotSmallForConditionalGeneration"),
        ("encoder-decoder", "FlaxEncoderDecoderModel"),
        ("longt5", "FlaxLongT5ForConditionalGeneration"),
        ("marian", "FlaxMarianMTModel"),
        ("mbart", "FlaxMBartForConditionalGeneration"),
        ("mt5", "FlaxMT5ForConditionalGeneration"),
        ("pegasus", "FlaxPegasusForConditionalGeneration"),
        ("t5", "FlaxT5ForConditionalGeneration"),
    ]
)

lowerCamelCase			:				List[str] 			=					OrderedDict(
    [
        # Model for Image-classsification
        ("beit", "FlaxBeitForImageClassification"),
        ("regnet", "FlaxRegNetForImageClassification"),
        ("resnet", "FlaxResNetForImageClassification"),
        ("vit", "FlaxViTForImageClassification"),
    ]
)

lowerCamelCase			:				Tuple 			=					OrderedDict(
    [
        ("vision-encoder-decoder", "FlaxVisionEncoderDecoderModel"),
    ]
)

lowerCamelCase			:				Optional[Any] 			=					OrderedDict(
    [
        # Model for Causal LM mapping
        ("bart", "FlaxBartForCausalLM"),
        ("bert", "FlaxBertForCausalLM"),
        ("big_bird", "FlaxBigBirdForCausalLM"),
        ("electra", "FlaxElectraForCausalLM"),
        ("gpt-sw3", "FlaxGPT2LMHeadModel"),
        ("gpt2", "FlaxGPT2LMHeadModel"),
        ("gpt_neo", "FlaxGPTNeoForCausalLM"),
        ("gptj", "FlaxGPTJForCausalLM"),
        ("opt", "FlaxOPTForCausalLM"),
        ("roberta", "FlaxRobertaForCausalLM"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForCausalLM"),
        ("xglm", "FlaxXGLMForCausalLM"),
        ("xlm-roberta", "FlaxXLMRobertaForCausalLM"),
    ]
)

lowerCamelCase			:				Tuple 			=					OrderedDict(
    [
        # Model for Sequence Classification mapping
        ("albert", "FlaxAlbertForSequenceClassification"),
        ("bart", "FlaxBartForSequenceClassification"),
        ("bert", "FlaxBertForSequenceClassification"),
        ("big_bird", "FlaxBigBirdForSequenceClassification"),
        ("distilbert", "FlaxDistilBertForSequenceClassification"),
        ("electra", "FlaxElectraForSequenceClassification"),
        ("mbart", "FlaxMBartForSequenceClassification"),
        ("roberta", "FlaxRobertaForSequenceClassification"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForSequenceClassification"),
        ("roformer", "FlaxRoFormerForSequenceClassification"),
        ("xlm-roberta", "FlaxXLMRobertaForSequenceClassification"),
    ]
)

lowerCamelCase			:				Optional[int] 			=					OrderedDict(
    [
        # Model for Question Answering mapping
        ("albert", "FlaxAlbertForQuestionAnswering"),
        ("bart", "FlaxBartForQuestionAnswering"),
        ("bert", "FlaxBertForQuestionAnswering"),
        ("big_bird", "FlaxBigBirdForQuestionAnswering"),
        ("distilbert", "FlaxDistilBertForQuestionAnswering"),
        ("electra", "FlaxElectraForQuestionAnswering"),
        ("mbart", "FlaxMBartForQuestionAnswering"),
        ("roberta", "FlaxRobertaForQuestionAnswering"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForQuestionAnswering"),
        ("roformer", "FlaxRoFormerForQuestionAnswering"),
        ("xlm-roberta", "FlaxXLMRobertaForQuestionAnswering"),
    ]
)

lowerCamelCase			:				Tuple 			=					OrderedDict(
    [
        # Model for Token Classification mapping
        ("albert", "FlaxAlbertForTokenClassification"),
        ("bert", "FlaxBertForTokenClassification"),
        ("big_bird", "FlaxBigBirdForTokenClassification"),
        ("distilbert", "FlaxDistilBertForTokenClassification"),
        ("electra", "FlaxElectraForTokenClassification"),
        ("roberta", "FlaxRobertaForTokenClassification"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForTokenClassification"),
        ("roformer", "FlaxRoFormerForTokenClassification"),
        ("xlm-roberta", "FlaxXLMRobertaForTokenClassification"),
    ]
)

lowerCamelCase			:				Dict 			=					OrderedDict(
    [
        # Model for Multiple Choice mapping
        ("albert", "FlaxAlbertForMultipleChoice"),
        ("bert", "FlaxBertForMultipleChoice"),
        ("big_bird", "FlaxBigBirdForMultipleChoice"),
        ("distilbert", "FlaxDistilBertForMultipleChoice"),
        ("electra", "FlaxElectraForMultipleChoice"),
        ("roberta", "FlaxRobertaForMultipleChoice"),
        ("roberta-prelayernorm", "FlaxRobertaPreLayerNormForMultipleChoice"),
        ("roformer", "FlaxRoFormerForMultipleChoice"),
        ("xlm-roberta", "FlaxXLMRobertaForMultipleChoice"),
    ]
)

lowerCamelCase			:				int 			=					OrderedDict(
    [
        ("bert", "FlaxBertForNextSentencePrediction"),
    ]
)

lowerCamelCase			:				str 			=					OrderedDict(
    [
        ("speech-encoder-decoder", "FlaxSpeechEncoderDecoderModel"),
        ("whisper", "FlaxWhisperForConditionalGeneration"),
    ]
)

lowerCamelCase			:				Union[str, Any] 			=					OrderedDict(
    [
        ("whisper", "FlaxWhisperForAudioClassification"),
    ]
)

lowerCamelCase			:				Optional[int] 			=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_MAPPING_NAMES)
lowerCamelCase			:				Optional[Any] 			=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_PRETRAINING_MAPPING_NAMES)
lowerCamelCase			:				Dict 			=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MASKED_LM_MAPPING_NAMES)
lowerCamelCase			:				int 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES
)
lowerCamelCase			:				Tuple 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase			:				str 			=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES)
lowerCamelCase			:				List[str] 			=					_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_CAUSAL_LM_MAPPING_NAMES)
lowerCamelCase			:				Optional[int] 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase			:				str 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES
)
lowerCamelCase			:				List[str] 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES
)
lowerCamelCase			:				Optional[int] 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES
)
lowerCamelCase			:				Dict 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES
)
lowerCamelCase			:				Tuple 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES
)
lowerCamelCase			:				Union[str, Any] 			=					_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_MAPPING

lowerCamelCase			:				List[str] 			=					auto_class_update(FlaxAutoModel)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_PRETRAINING_MAPPING

lowerCamelCase			:				List[str] 			=					auto_class_update(FlaxAutoModelForPreTraining, head_doc="pretraining")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING

lowerCamelCase			:				Optional[Any] 			=					auto_class_update(FlaxAutoModelForCausalLM, head_doc="causal language modeling")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_MASKED_LM_MAPPING

lowerCamelCase			:				int 			=					auto_class_update(FlaxAutoModelForMaskedLM, head_doc="masked language modeling")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING

lowerCamelCase			:				Tuple 			=					auto_class_update(
    FlaxAutoModelForSeqaSeqLM, head_doc="sequence-to-sequence language modeling", checkpoint_for_example="t5-base"
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

lowerCamelCase			:				int 			=					auto_class_update(
    FlaxAutoModelForSequenceClassification, head_doc="sequence classification"
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING

lowerCamelCase			:				Dict 			=					auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc="question answering")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING

lowerCamelCase			:				str 			=					auto_class_update(
    FlaxAutoModelForTokenClassification, head_doc="token classification"
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING

lowerCamelCase			:				str 			=					auto_class_update(FlaxAutoModelForMultipleChoice, head_doc="multiple choice")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING

lowerCamelCase			:				List[str] 			=					auto_class_update(
    FlaxAutoModelForNextSentencePrediction, head_doc="next sentence prediction"
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

lowerCamelCase			:				Union[str, Any] 			=					auto_class_update(
    FlaxAutoModelForImageClassification, head_doc="image classification"
)







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING

lowerCamelCase			:				Tuple 			=					auto_class_update(FlaxAutoModelForVisionaSeq, head_doc="vision-to-text modeling")







class 							A__   (	_BaseAutoModelClass  ):
  A__					=    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING

lowerCamelCase			:				Optional[int] 			=					auto_class_update(
    FlaxAutoModelForSpeechSeqaSeq, head_doc="sequence-to-sequence speech-to-text modeling"
)



'''simple docstring'''
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

lowerCamelCase			:				List[str] 			=					random.Random()


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




     if rng is None:
          _SCREAMING_SNAKE_CASE							   =global_rng

     _SCREAMING_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 							A__   (	unittest.TestCase  ):





  def __init__(		self				:     List[Any]							, _a				:     Tuple							, _a				:     Dict=7							, _a				:     List[Any]=400							, _a				:     List[str]=2000							, _a				:     Optional[Any]=10							, _a				:     Dict=160							, _a				:     Tuple=8							, _a				:     Any=0.0							, _a				:     Optional[Any]=4000							, _a				:     List[Any]=False							, _a				:     Dict=True							, )     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =batch_size
       _SCREAMING_SNAKE_CASE							   =min_seq_length
       _SCREAMING_SNAKE_CASE							   =max_seq_length
       _SCREAMING_SNAKE_CASE							   =(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
       _SCREAMING_SNAKE_CASE							   =padding_value
       _SCREAMING_SNAKE_CASE							   =sampling_rate
       _SCREAMING_SNAKE_CASE							   =return_attention_mask
       _SCREAMING_SNAKE_CASE							   =do_normalize
       _SCREAMING_SNAKE_CASE							   =feature_size
       _SCREAMING_SNAKE_CASE							   =chunk_length
       _SCREAMING_SNAKE_CASE							   =hop_length





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





       '''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 						A  (		self				:     Optional[Any]							, _a				:     Any=False							, _a				:     Union[str, Any]=False			)     ->   Optional[Any]:





       '''simple docstring'''






       def _flatten(_a				:     Union[str, Any]			):
            return list(itertools.chain(*_a			)			)

       if equal_length:
            _SCREAMING_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
            _SCREAMING_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:
            _SCREAMING_SNAKE_CASE							   =[np.asarray(_a			) for x in speech_inputs]
       return speech_inputs







@require_torch
@require_torchaudio
class 							A__   (	A__					,       unittest.TestCase  ):
  A__					=    WhisperFeatureExtractor if is_speech_available() else None





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =WhisperFeatureExtractionTester(self			)





  def 						A  (		self				:     str			)     ->   Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_dict			)

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

       _SCREAMING_SNAKE_CASE							   =feat_extract_first.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_first.mel_filters
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.mel_filters
       self.assertTrue(np.allclose(_a							, _a			)			)
       self.assertEqual(_a							, _a			)





  def 						A  (		self				:     Tuple			)     ->   Any:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_dict			)

       with tempfile.TemporaryDirectory() as tmpdirname:
            _SCREAMING_SNAKE_CASE							   =os.path.join(_a							, 'feat_extract.json'			)
            feat_extract_first.to_json_file(_a			)
            _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class.from_json_file(_a			)

       _SCREAMING_SNAKE_CASE							   =feat_extract_first.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.to_dict()
       _SCREAMING_SNAKE_CASE							   =feat_extract_first.mel_filters
       _SCREAMING_SNAKE_CASE							   =feat_extract_second.mel_filters
       self.assertTrue(np.allclose(_a							, _a			)			)
       self.assertEqual(_a							, _a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
       # create three inputs of length 800, 1000, and 1200
       _SCREAMING_SNAKE_CASE							   =[floats_list((1, x)			)[0] for x in range(800							, 1400							, 200			)]
       _SCREAMING_SNAKE_CASE							   =[np.asarray(_a			) for speech_input in speech_inputs]

       # Test feature size
       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, 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
       _SCREAMING_SNAKE_CASE							   =feature_extractor(speech_inputs[0]							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =feature_extractor(np_speech_inputs[0]							, return_tensors='np'			).input_features
       self.assertTrue(np.allclose(_a							, _a							, atol=1e-3			)			)

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

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

       # Test truncation required
       _SCREAMING_SNAKE_CASE							   =[floats_list((1, x)			)[0] for x in range(200							, (feature_extractor.n_samples + 500)							, 200			)]
       _SCREAMING_SNAKE_CASE							   =[np.asarray(_a			) for speech_input in speech_inputs]

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

       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='np'			).input_features
       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='np'			).input_features
       for enc_seq_a, enc_seq_a in zip(_a							, _a			):
            self.assertTrue(np.allclose(_a							, _a							, atol=1e-3			)			)





  def 						A  (		self				:     Any			)     ->   List[Any]:





       '''simple docstring'''






       import torch

       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
       _SCREAMING_SNAKE_CASE							   =np.random.rand(100							, 32			).astype(np.floataa			)
       _SCREAMING_SNAKE_CASE							   =np_speech_inputs.tolist()

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





  def 						A  (		self				:     Tuple							, _a				:     str			)     ->   Optional[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =load_dataset('hf-internal-testing/librispeech_asr_dummy'							, 'clean'							, split='validation'			)
       # automatic decoding with librispeech
       _SCREAMING_SNAKE_CASE							   =ds.sort('id'			).select(range(_a			)			)[:num_samples]['audio']

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





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =torch.tensor(
           [
               0.11_93, -0.09_46, -0.10_98, -0.01_96, 0.02_25, -0.06_90, -0.17_36, 0.09_51,
               0.09_71, -0.08_17, -0.07_02, 0.01_62, 0.02_60, 0.00_17, -0.01_92, -0.16_78,
               0.07_09, -0.18_67, -0.06_55, -0.02_74, -0.02_34, -0.18_84, -0.05_16, -0.05_54,
               -0.02_74, -0.14_25, -0.14_23, 0.08_37, 0.03_77, -0.08_54
           ]			)
       # fmt: on

       _SCREAMING_SNAKE_CASE							   =self._load_datasamples(1			)
       _SCREAMING_SNAKE_CASE							   =WhisperFeatureExtractor()
       _SCREAMING_SNAKE_CASE							   =feature_extractor(_a							, return_tensors='pt'			).input_features
       self.assertEqual(input_features.shape							, (1, 80, 3000)			)
       self.assertTrue(torch.allclose(input_features[0, 0, :30]							, _a							, atol=1e-4			)			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()			)
       _SCREAMING_SNAKE_CASE							   =self._load_datasamples(1			)[0]
       _SCREAMING_SNAKE_CASE							   =((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
       _SCREAMING_SNAKE_CASE							   =feat_extract.zero_mean_unit_var_norm([audio]							, attention_mask=_a			)[0]

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