





'''simple docstring'''
import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import ViTMAEForPreTraining, ViTMAEModel
     from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import ViTImageProcessor







class 							A__   :





  def __init__(		self				:     List[str]							, _a				:     Tuple							, _a				:     List[Any]=13							, _a				:     Optional[int]=30							, _a				:     Any=2							, _a				:     Dict=3							, _a				:     Optional[Any]=True							, _a				:     Optional[int]=True							, _a				:     List[Any]=32							, _a				:     Dict=5							, _a				:     Union[str, Any]=4							, _a				:     Optional[int]=37							, _a				:     List[str]="gelu"							, _a				:     Optional[int]=0.1							, _a				:     Any=0.1							, _a				:     Tuple=10							, _a				:     Tuple=0.02							, _a				:     List[str]=3							, _a				:     Any=0.6							, _a				:     List[Any]=None							, )     ->   List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =parent
       _SCREAMING_SNAKE_CASE							   =batch_size
       _SCREAMING_SNAKE_CASE							   =image_size
       _SCREAMING_SNAKE_CASE							   =patch_size
       _SCREAMING_SNAKE_CASE							   =num_channels
       _SCREAMING_SNAKE_CASE							   =is_training
       _SCREAMING_SNAKE_CASE							   =use_labels
       _SCREAMING_SNAKE_CASE							   =hidden_size
       _SCREAMING_SNAKE_CASE							   =num_hidden_layers
       _SCREAMING_SNAKE_CASE							   =num_attention_heads
       _SCREAMING_SNAKE_CASE							   =intermediate_size
       _SCREAMING_SNAKE_CASE							   =hidden_act
       _SCREAMING_SNAKE_CASE							   =hidden_dropout_prob
       _SCREAMING_SNAKE_CASE							   =attention_probs_dropout_prob
       _SCREAMING_SNAKE_CASE							   =type_sequence_label_size
       _SCREAMING_SNAKE_CASE							   =initializer_range
       _SCREAMING_SNAKE_CASE							   =mask_ratio
       _SCREAMING_SNAKE_CASE							   =scope

       # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
       # (we add 1 for the [CLS] token)
       _SCREAMING_SNAKE_CASE							   =(image_size // patch_size) ** 2
       _SCREAMING_SNAKE_CASE							   =int(math.ceil((1 - mask_ratio) * (num_patches + 1)			)			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

       _SCREAMING_SNAKE_CASE							   =None
       if self.use_labels:
            _SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size]							, self.type_sequence_label_size			)

       _SCREAMING_SNAKE_CASE							   =self.get_config()

       return config, pixel_values, labels





  def 						A  (		self				:     Dict			)     ->   str:





       '''simple docstring'''






       return ViTMAEConfig(
           image_size=self.image_size							, patch_size=self.patch_size							, num_channels=self.num_channels							, 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							, is_decoder=_a							, initializer_range=self.initializer_range							, mask_ratio=self.mask_ratio							, )





  def 						A  (		self				:     Union[str, Any]							, _a				:     Optional[int]							, _a				:     int							, _a				:     Dict			)     ->   str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ViTMAEModel(config=_a			)
       model.to(_a			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       self.parent.assertEqual(result.last_hidden_state.shape							, (self.batch_size, self.seq_length, self.hidden_size)			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ViTMAEForPreTraining(_a			)
       model.to(_a			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       _SCREAMING_SNAKE_CASE							   =(self.image_size // self.patch_size) ** 2
       _SCREAMING_SNAKE_CASE							   =self.patch_size**2 * self.num_channels
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, num_patches, expected_num_channels)			)

       # test greyscale images
       _SCREAMING_SNAKE_CASE							   =1
       _SCREAMING_SNAKE_CASE							   =ViTMAEForPreTraining(_a			)
       model.to(_a			)
       model.eval()
       _SCREAMING_SNAKE_CASE							   =floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
       _SCREAMING_SNAKE_CASE							   =model(_a			)
       _SCREAMING_SNAKE_CASE							   =self.patch_size**2
       self.parent.assertEqual(result.logits.shape							, (self.batch_size, num_patches, expected_num_channels)			)





  def 						A  (		self				:     Dict			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.prepare_config_and_inputs()
       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =config_and_inputs
       _SCREAMING_SNAKE_CASE							   ={'pixel_values': pixel_values}
       return config, inputs_dict







@require_torch
class 							A__   (	A__					,       A__					,       unittest.TestCase  ):
  A__					=    (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
  A__					=    {'feature-extraction': ViTMAEModel} if is_torch_available() else {}

  A__					=    False
  A__					=    False
  A__					=    False
  A__					=    False





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =ViTMAEModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, has_text_modality=_a							, hidden_size=37			)





  def 						A  (		self				:     str			)     ->   Dict:





       '''simple docstring'''






       self.config_tester.run_common_tests()





  @unittest.skip(reason='ViTMAE does not use inputs_embeds'			)
  def 						A  (		self				:     Union[str, Any]			)     ->   Dict:





       '''simple docstring'''






       pass





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE							   =model_class(_a			)
            self.assertIsInstance(model.get_input_embeddings()							, (nn.Module)			)
            _SCREAMING_SNAKE_CASE							   =model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(_a							, nn.Linear			)			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE							   =model_class(_a			)
            _SCREAMING_SNAKE_CASE							   =inspect.signature(model.forward			)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            _SCREAMING_SNAKE_CASE							   =[*signature.parameters.keys()]

            _SCREAMING_SNAKE_CASE							   =['pixel_values']
            self.assertListEqual(arg_names[:1]							, _a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*_a			)





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





       '''simple docstring'''






       np.random.seed(2			)

       _SCREAMING_SNAKE_CASE							   =int((pt_model.config.image_size // pt_model.config.patch_size) ** 2			)
       _SCREAMING_SNAKE_CASE							   =np.random.uniform(size=(self.model_tester.batch_size, num_patches)			)
       _SCREAMING_SNAKE_CASE							   =torch.from_numpy(_a			)

       # Add `noise` argument.
       # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
       _SCREAMING_SNAKE_CASE							   =pt_noise

       super().check_pt_tf_models(_a							, _a							, _a			)





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





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            _SCREAMING_SNAKE_CASE							   =model_class(_a			)
            model.to(_a			)
            model.eval()
            # make random mask reproducible
            torch.manual_seed(2			)
            with torch.no_grad():
                 _SCREAMING_SNAKE_CASE							   =model(**self._prepare_for_class(_a							, _a			)			)

            _SCREAMING_SNAKE_CASE							   =outputs[0].cpu().numpy()
            _SCREAMING_SNAKE_CASE							   =0

            with tempfile.TemporaryDirectory() as tmpdirname:
                 model.save_pretrained(_a			)
                 _SCREAMING_SNAKE_CASE							   =model_class.from_pretrained(_a			)
                 model.to(_a			)
                 # make random mask reproducible
                 torch.manual_seed(2			)
                 with torch.no_grad():
                      _SCREAMING_SNAKE_CASE							   =model(**self._prepare_for_class(_a							, _a			)			)

                 # Make sure we don't have nans
                 _SCREAMING_SNAKE_CASE							   =after_outputs[0].cpu().numpy()
                 _SCREAMING_SNAKE_CASE							   =0
                 _SCREAMING_SNAKE_CASE							   =np.amax(np.abs(out_a - out_a			)			)
                 self.assertLessEqual(_a							, 1e-5			)





  @unittest.skip(
      reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'			)
  def 						A  (		self				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       pass





  @unittest.skip(
      reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'			)
  def 						A  (		self				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






       pass





  @unittest.skip(
      reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.'			)
  def 						A  (		self				:     Dict			)     ->   str:





       '''simple docstring'''






       pass





  @unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'			)
  def 						A  (		self				:     int			)     ->   Union[str, Any]:





       '''simple docstring'''






       pass





  @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'			)
  def 						A  (		self				:     List[str]			)     ->   Any:





       '''simple docstring'''






       pass





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





       '''simple docstring'''






       for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            _SCREAMING_SNAKE_CASE							   =ViTMAEModel.from_pretrained(_a			)
            self.assertIsNotNone(_a			)


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




     _SCREAMING_SNAKE_CASE							   =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
     return image







@require_torch
@require_vision
class 							A__   (	unittest.TestCase  ):





  @cached_property
  def 						A  (		self				:     Tuple			)     ->   Dict:





       '''simple docstring'''






       return ViTImageProcessor.from_pretrained('facebook/vit-mae-base'			) if is_vision_available() else None





  @slow
  def 						A  (		self				:     Dict			)     ->   Tuple:





       '''simple docstring'''






       np.random.seed(2			)

       _SCREAMING_SNAKE_CASE							   =ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base'			).to(_a			)

       _SCREAMING_SNAKE_CASE							   =self.default_image_processor
       _SCREAMING_SNAKE_CASE							   =prepare_img()
       _SCREAMING_SNAKE_CASE							   =image_processor(images=_a							, return_tensors='pt'			).to(_a			)

       # prepare a noise vector that will be also used for testing the TF model
       # (this way we can ensure that the PT and TF models operate on the same inputs)
       _SCREAMING_SNAKE_CASE							   =ViTMAEConfig()
       _SCREAMING_SNAKE_CASE							   =int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2			)
       _SCREAMING_SNAKE_CASE							   =np.random.uniform(size=(1, num_patches)			)

       # forward pass
       with torch.no_grad():
            _SCREAMING_SNAKE_CASE							   =model(**_a							, noise=torch.from_numpy(_a			).to(device=_a			)			)

       # verify the logits
       _SCREAMING_SNAKE_CASE							   =torch.Size((1, 196, 768)			)
       self.assertEqual(outputs.logits.shape							, _a			)

       _SCREAMING_SNAKE_CASE							   =torch.tensor(
           [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]			)

       self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]							, expected_slice.to(_a			)							, atol=1e-4			)			)



'''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			)			)
