



"""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 							lowerCamelCase_:





     '''simple docstring'''



     def __init__(    self				,       lowerCamelCase__				,       lowerCamelCase__=1_3				,       lowerCamelCase__=3_0				,       lowerCamelCase__=2				,       lowerCamelCase__=3				,       lowerCamelCase__=True				,       lowerCamelCase__=True				,       lowerCamelCase__=3_2				,       lowerCamelCase__=5				,       lowerCamelCase__=4				,       lowerCamelCase__=3_7				,       lowerCamelCase__="gelu"				,       lowerCamelCase__=0.1				,       lowerCamelCase__=0.1				,       lowerCamelCase__=1_0				,       lowerCamelCase__=0.0_2				,       lowerCamelCase__=3				,       lowerCamelCase__=0.6				,       lowerCamelCase__=None				,       ):
         _lowerCamelCase        =				parent
         _lowerCamelCase        =				batch_size
         _lowerCamelCase        =				image_size
         _lowerCamelCase        =				patch_size
         _lowerCamelCase        =				num_channels
         _lowerCamelCase        =				is_training
         _lowerCamelCase        =				use_labels
         _lowerCamelCase        =				hidden_size
         _lowerCamelCase        =				num_hidden_layers
         _lowerCamelCase        =				num_attention_heads
         _lowerCamelCase        =				intermediate_size
         _lowerCamelCase        =				hidden_act
         _lowerCamelCase        =				hidden_dropout_prob
         _lowerCamelCase        =				attention_probs_dropout_prob
         _lowerCamelCase        =				type_sequence_label_size
         _lowerCamelCase        =				initializer_range
         _lowerCamelCase        =				mask_ratio
         _lowerCamelCase        =				scope

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

     def 			snake_case__      (    self   ):
         _lowerCamelCase        =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

         _lowerCamelCase        =				self.get_config()

         return config, pixel_values, labels

     def 			snake_case__      (    self   ):
         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=_lowerCAmelCase				,       initializer_range=self.initializer_range				,       mask_ratio=self.mask_ratio				,       )

     def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
         _lowerCamelCase        =				ViTMAEModel(config=_lowerCAmelCase   )
         model.to(_lowerCAmelCase   )
         model.eval()
         _lowerCamelCase        =				model(_lowerCAmelCase   )
         self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)   )

     def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
         _lowerCamelCase        =				ViTMAEForPreTraining(_lowerCAmelCase   )
         model.to(_lowerCAmelCase   )
         model.eval()
         _lowerCamelCase        =				model(_lowerCAmelCase   )
         _lowerCamelCase        =				(self.image_size // self.patch_size) ** 2
         _lowerCamelCase        =				self.patch_size**2 * self.num_channels
         self.parent.assertEqual(result.logits.shape				,       (self.batch_size, num_patches, expected_num_channels)   )

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





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


@require_torch
class 							lowerCamelCase_(   _lowerCAmelCase,				_lowerCAmelCase,				unittest.TestCase    ):





     '''simple docstring'''



     lowercase__   :       Tuple										= (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
     lowercase__   :       Optional[int]										= {'feature-extraction': ViTMAEModel} if is_torch_available() else {}

     lowercase__   :       Optional[int]										= False
     lowercase__   :       str										= False
     lowercase__   :       Dict										= False
     lowercase__   :       Any										= False

     def 			snake_case__      (    self   ):
         _lowerCamelCase        =				ViTMAEModelTester(self   )
         _lowerCamelCase        =				ConfigTester(self				,       config_class=_lowerCAmelCase				,       has_text_modality=_lowerCAmelCase				,       hidden_size=3_7   )

     def 			snake_case__      (    self   ):
         self.config_tester.run_common_tests()

     @unittest.skip(reason='''ViTMAE does not use inputs_embeds'''   )
     def 			snake_case__      (    self   ):
         pass

     def 			snake_case__      (    self   ):
         _lowerCamelCase  ,     _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs_for_common()

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

     def 			snake_case__      (    self   ):
         _lowerCamelCase  ,     _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs_for_common()

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

             _lowerCamelCase        =				['''pixel_values''']
             self.assertListEqual(arg_names[:1]				,       _lowerCAmelCase   )

     def 			snake_case__      (    self   ):
         _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase   )

     def 			snake_case__      (    self   ):
         _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_pretraining(*_lowerCAmelCase   )

     def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__				,       lowerCamelCase__   ):
         np.random.seed(2   )

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

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

         super().check_pt_tf_models(_lowerCAmelCase				,       _lowerCAmelCase				,       _lowerCAmelCase   )

     def 			snake_case__      (    self   ):
         _lowerCamelCase  ,     _lowerCamelCase        =				self.model_tester.prepare_config_and_inputs_for_common()

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

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

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

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

     @unittest.skip(
         reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''   )
     def 			snake_case__      (    self   ):
         pass

     @unittest.skip(
         reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''   )
     def 			snake_case__      (    self   ):
         pass

     @unittest.skip(
         reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''   )
     def 			snake_case__      (    self   ):
         pass

     @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''   )
     def 			snake_case__      (    self   ):
         pass

     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
     def 			snake_case__      (    self   ):
         pass





     @slow
     def 			snake_case__      (    self   ):







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



def        lowerCAmelCase_(   )	->       int:
    _lowerCamelCase        =				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
    return image




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





     '''simple docstring'''



     @cached_property
     def 			snake_case__      (    self   ):
         return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''   ) if is_vision_available() else None





     @slow
     def 			snake_case__      (    self   ):
         np.random.seed(2   )

         _lowerCamelCase        =				ViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''   ).to(_lowerCAmelCase   )

         _lowerCamelCase        =				self.default_image_processor
         _lowerCamelCase        =				prepare_img()
         _lowerCamelCase        =				image_processor(images=_lowerCAmelCase				,       return_tensors='''pt'''   ).to(_lowerCAmelCase   )

         # 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)
         _lowerCamelCase        =				ViTMAEConfig()
         _lowerCamelCase        =				int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2   )
         _lowerCamelCase        =				np.random.uniform(size=(1, num_patches)   )

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

         # verify the logits
         _lowerCamelCase        =				torch.Size((1, 1_9_6, 7_6_8)   )
         self.assertEqual(outputs.logits.shape				,       _lowerCAmelCase   )

         _lowerCamelCase        =				torch.tensor(
             [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]   )

         self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]				,       expected_slice.to(_lowerCAmelCase   )				,       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

__SCREAMING_SNAKE_CASE  :						Dict    							=      random.Random()



def        lowerCAmelCase_(   lowercase_     :							Dict						,   lowercase_     :							int=1.0						,   lowercase_     :							str=None						,   lowercase_     :							Optional[int]=None							)	->       Any:
				if rng is None:
								_lowerCamelCase        =				global_rng

				_lowerCamelCase        =				[]
				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				,       lowerCamelCase__				,       lowerCamelCase__=7				,       lowerCamelCase__=4_0_0				,       lowerCamelCase__=2_0_0_0				,       lowerCamelCase__=1_0				,       lowerCamelCase__=1_6_0				,       lowerCamelCase__=8				,       lowerCamelCase__=0.0				,       lowerCamelCase__=4_0_0_0				,       lowerCamelCase__=False				,       lowerCamelCase__=True				,       ):
									_lowerCamelCase        =				parent
									_lowerCamelCase        =				batch_size
									_lowerCamelCase        =				min_seq_length
									_lowerCamelCase        =				max_seq_length
									_lowerCamelCase        =				(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									_lowerCamelCase        =				padding_value
									_lowerCamelCase        =				sampling_rate
									_lowerCamelCase        =				return_attention_mask
									_lowerCamelCase        =				do_normalize
									_lowerCamelCase        =				feature_size
									_lowerCamelCase        =				chunk_length
									_lowerCamelCase        =				hop_length

					def 			snake_case__      (    self   ):
									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 			snake_case__      (    self				,       lowerCamelCase__=False				,       lowerCamelCase__=False   ):
									def _flatten(lowerCamelCase__   ):
													return list(itertools.chain(*lowerCamelCase__   )   )

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


@require_torch
@require_torchaudio
class 							lowerCamelCase_(   A__,				unittest.TestCase    ):





					'''simple docstring'''



					lowercase__   :       Optional[int]										= WhisperFeatureExtractor if is_speech_available() else None

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				WhisperFeatureExtractionTester(self   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.feature_extraction_class(**self.feat_extract_dict   )

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

									_lowerCamelCase        =				feat_extract_first.to_dict()
									_lowerCamelCase        =				feat_extract_second.to_dict()
									_lowerCamelCase        =				feat_extract_first.mel_filters
									_lowerCamelCase        =				feat_extract_second.mel_filters
									self.assertTrue(np.allclose(lowerCamelCase__				,       lowerCamelCase__   )   )
									self.assertEqual(lowerCamelCase__				,       lowerCamelCase__   )

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.feature_extraction_class(**self.feat_extract_dict   )

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

									_lowerCamelCase        =				feat_extract_first.to_dict()
									_lowerCamelCase        =				feat_extract_second.to_dict()
									_lowerCamelCase        =				feat_extract_first.mel_filters
									_lowerCamelCase        =				feat_extract_second.mel_filters
									self.assertTrue(np.allclose(lowerCamelCase__				,       lowerCamelCase__   )   )
									self.assertEqual(lowerCamelCase__				,       lowerCamelCase__   )

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

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

									# Test batched
									_lowerCamelCase        =				feature_extractor(lowerCamelCase__				,       return_tensors='''np'''   ).input_features
									_lowerCamelCase        =				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.
									_lowerCamelCase        =				[floats_list((1, x)   )[0] for x in (8_0_0, 8_0_0, 8_0_0)]
									_lowerCamelCase        =				np.asarray(lowerCamelCase__   )
									_lowerCamelCase        =				feature_extractor(lowerCamelCase__				,       return_tensors='''np'''   ).input_features
									_lowerCamelCase        =				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
									_lowerCamelCase        =				[floats_list((1, x)   )[0] for x in range(2_0_0				,       (feature_extractor.n_samples + 5_0_0)				,       2_0_0   )]
									_lowerCamelCase        =				[np.asarray(lowerCamelCase__   ) for speech_input in speech_inputs]

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

									_lowerCamelCase        =				feature_extractor(lowerCamelCase__				,       return_tensors='''np'''   ).input_features
									_lowerCamelCase        =				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 			snake_case__      (    self   ):
									import torch

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

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

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

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

					def 			snake_case__      (    self   ):
									# fmt: off
									_lowerCamelCase        =				torch.tensor(
									    [
									        0.1_1_9_3, -0.0_9_4_6, -0.1_0_9_8, -0.0_1_9_6, 0.0_2_2_5, -0.0_6_9_0, -0.1_7_3_6, 0.0_9_5_1,
									        0.0_9_7_1, -0.0_8_1_7, -0.0_7_0_2, 0.0_1_6_2, 0.0_2_6_0, 0.0_0_1_7, -0.0_1_9_2, -0.1_6_7_8,
									        0.0_7_0_9, -0.1_8_6_7, -0.0_6_5_5, -0.0_2_7_4, -0.0_2_3_4, -0.1_8_8_4, -0.0_5_1_6, -0.0_5_5_4,
									        -0.0_2_7_4, -0.1_4_2_5, -0.1_4_2_3, 0.0_8_3_7, 0.0_3_7_7, -0.0_8_5_4
									    ]   )
									# fmt: on

									_lowerCamelCase        =				self._load_datasamples(1   )
									_lowerCamelCase        =				WhisperFeatureExtractor()
									_lowerCamelCase        =				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 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()   )
									_lowerCamelCase        =				self._load_datasamples(1   )[0]
									_lowerCamelCase        =				((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
									_lowerCamelCase        =				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   )   )
