






import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase__     =	"▁"

UpperCamelCase__     =	get_tests_dir("fixtures/test_sentencepiece.model")

@require_sentencepiece
@require_tokenizers
class     __SCREAMING_SNAKE_CASE   (       _a				,						unittest.TestCase    ):
							snake_case       : List[Any]         =    BigBirdTokenizer
							snake_case       : Union[str, Any]         =    BigBirdTokenizerFast
							snake_case       : Tuple         =    True
							snake_case       : List[str]         =    True






							def 			_lowerCamelCase						(  self					):
														super().setUp()

														UpperCamelCase__			       =     self.tokenizer_class(__lowerCAmelCase					,	keep_accents=__lowerCAmelCase					)
														tokenizer.save_pretrained(self.tmpdirname					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     """<s>"""
														UpperCamelCase__			       =     1

														self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCAmelCase					)					,	__lowerCAmelCase					)
														self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCAmelCase					)					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     list(self.get_tokenizer().get_vocab().keys()					)

														self.assertEqual(vocab_keys[0]					,	"""<unk>"""					)
														self.assertEqual(vocab_keys[1]					,	"""<s>"""					)
														self.assertEqual(vocab_keys[-1]					,	"""[MASK]"""					)
														self.assertEqual(len(__lowerCAmelCase					)					,	1004					)






							def 			_lowerCamelCase						(  self					):
														self.assertEqual(self.get_tokenizer().vocab_size					,	1000					)






							def 			_lowerCamelCase						(  self					):
														if not self.test_rust_tokenizer:
																					return

														UpperCamelCase__			       =     self.get_tokenizer()
														UpperCamelCase__			       =     self.get_rust_tokenizer()

														UpperCamelCase__			       =     """I was born in 92000, and this is falsé."""

														UpperCamelCase__			       =     tokenizer.tokenize(__lowerCAmelCase					)
														UpperCamelCase__			       =     rust_tokenizer.tokenize(__lowerCAmelCase					)
														self.assertListEqual(__lowerCAmelCase					,	__lowerCAmelCase					)

														UpperCamelCase__			       =     tokenizer.encode(__lowerCAmelCase					,	add_special_tokens=__lowerCAmelCase					)
														UpperCamelCase__			       =     rust_tokenizer.encode(__lowerCAmelCase					,	add_special_tokens=__lowerCAmelCase					)
														self.assertListEqual(__lowerCAmelCase					,	__lowerCAmelCase					)

														UpperCamelCase__			       =     self.get_rust_tokenizer()
														UpperCamelCase__			       =     tokenizer.encode(__lowerCAmelCase					)
														UpperCamelCase__			       =     rust_tokenizer.encode(__lowerCAmelCase					)
														self.assertListEqual(__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     BigBirdTokenizer(__lowerCAmelCase					,	keep_accents=__lowerCAmelCase					)

														UpperCamelCase__			       =     tokenizer.tokenize("""This is a test"""					)
														self.assertListEqual(__lowerCAmelCase					,	["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]					)

														self.assertListEqual(
														    tokenizer.convert_tokens_to_ids(__lowerCAmelCase					)					,	[285, 46, 10, 170, 382]					,	)

														UpperCamelCase__			       =     tokenizer.tokenize("""I was born in 92000, and this is falsé."""					)
														self.assertListEqual(
														    __lowerCAmelCase					,	[
														        SPIECE_UNDERLINE + """I""",
														        SPIECE_UNDERLINE + """was""",
														        SPIECE_UNDERLINE + """b""",
														        """or""",
														        """n""",
														        SPIECE_UNDERLINE + """in""",
														        SPIECE_UNDERLINE + """""",
														        """9""",
														        """2""",
														        """0""",
														        """0""",
														        """0""",
														        """,""",
														        SPIECE_UNDERLINE + """and""",
														        SPIECE_UNDERLINE + """this""",
														        SPIECE_UNDERLINE + """is""",
														        SPIECE_UNDERLINE + """f""",
														        """al""",
														        """s""",
														        """é""",
														        """.""",
														    ]					,	)
														UpperCamelCase__			       =     tokenizer.convert_tokens_to_ids(__lowerCAmelCase					)
														self.assertListEqual(
														    __lowerCAmelCase					,	[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]					,	)

														UpperCamelCase__			       =     tokenizer.convert_ids_to_tokens(__lowerCAmelCase					)
														self.assertListEqual(
														    __lowerCAmelCase					,	[
														        SPIECE_UNDERLINE + """I""",
														        SPIECE_UNDERLINE + """was""",
														        SPIECE_UNDERLINE + """b""",
														        """or""",
														        """n""",
														        SPIECE_UNDERLINE + """in""",
														        SPIECE_UNDERLINE + """""",
														        """<unk>""",
														        """2""",
														        """0""",
														        """0""",
														        """0""",
														        """,""",
														        SPIECE_UNDERLINE + """and""",
														        SPIECE_UNDERLINE + """this""",
														        SPIECE_UNDERLINE + """is""",
														        SPIECE_UNDERLINE + """f""",
														        """al""",
														        """s""",
														        """<unk>""",
														        """.""",
														    ]					,	)






							@cached_property
							def 			_lowerCamelCase						(  self					):
														return BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""					)






							@slow
							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     """Hello World!"""
														UpperCamelCase__			       =     [65, 18536, 2260, 101, 66]

														self.assertListEqual(__lowerCAmelCase					,	self.big_tokenizer.encode(__lowerCAmelCase					)					)






							@slow
							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     (
														    """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
														    """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
														)
														# fmt: off
														UpperCamelCase__			       =     [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 34324, 497, 391, 408, 11342, 1244, 385, 100, 938, 985, 456, 574, 362, 12597, 3200, 3129, 1172, 66]  # noqa: E231
														# fmt: on
														self.assertListEqual(__lowerCAmelCase					,	self.big_tokenizer.encode(__lowerCAmelCase					)					)






							@require_torch
							@slow
							def 			_lowerCamelCase						(  self					):
														import torch

														from transformers import BigBirdConfig, BigBirdModel

														# Build sequence
														UpperCamelCase__			       =     list(self.big_tokenizer.get_vocab().keys()					)[:10]
														UpperCamelCase__			       =     """ """.join(__lowerCAmelCase					)
														UpperCamelCase__			       =     self.big_tokenizer.encode_plus(__lowerCAmelCase					,	return_tensors="""pt"""					,	return_token_type_ids=__lowerCAmelCase					)
														UpperCamelCase__			       =     self.big_tokenizer.batch_encode_plus(
														    [sequence + """ """ + sequence]					,	return_tensors="""pt"""					,	return_token_type_ids=__lowerCAmelCase					)

														UpperCamelCase__			       =     BigBirdConfig(attention_type="""original_full"""					)
														UpperCamelCase__			       =     BigBirdModel(__lowerCAmelCase					)

														assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

														with torch.no_grad():
																					model(**__lowerCAmelCase					)
																					model(**__lowerCAmelCase					)






							@slow
							def 			_lowerCamelCase						(  self					):
														UpperCamelCase__			       =     BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""					)
														UpperCamelCase__			       =     tokenizer.decode(tokenizer("""Paris is the [MASK]."""					).input_ids					)

														self.assertTrue(decoded_text == """[CLS] Paris is the[MASK].[SEP]"""					)







							@slow
							def 			_lowerCamelCase						(  self					):
														# fmt: off
														UpperCamelCase__			       =     {"""input_ids""": [[65, 39286, 458, 36335, 2001, 456, 13073, 13266, 455, 113, 7746, 1741, 11157, 391, 13073, 13266, 455, 113, 3967, 35412, 113, 4936, 109, 3870, 2377, 113, 30084, 45720, 458, 134, 17496, 112, 503, 11672, 113, 118, 112, 5665, 13347, 38687, 112, 1496, 31389, 112, 3268, 47264, 134, 962, 112, 16377, 8035, 23130, 430, 12169, 15518, 28592, 458, 146, 41697, 109, 391, 12169, 15518, 16689, 458, 146, 41358, 109, 452, 726, 4034, 111, 763, 35412, 5082, 388, 1903, 111, 9051, 391, 2870, 48918, 1900, 1123, 550, 998, 112, 9586, 15985, 455, 391, 410, 22955, 37636, 114, 66], [65, 448, 17496, 419, 3663, 385, 763, 113, 27533, 2870, 3283, 13043, 1639, 24713, 523, 656, 24013, 18550, 2521, 517, 27014, 21244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 11786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 21932, 18146, 726, 363, 17032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
														# fmt: on

														self.tokenizer_integration_test_util(
														    expected_encoding=__lowerCAmelCase					,	model_name="""google/bigbird-roberta-base"""					,	revision="""215c99f1600e06f83acce68422f2035b2b5c3510"""					,	)











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

UpperCamelCase__     =	random.Random()





def       _UpperCamelCase       (a__				:Any				,     a__				:Union[str, Any]=1.0				,     a__				:Tuple=None				,     a__				:str=None    ):






							"""simple docstring"""





							if rng is None:
														UpperCamelCase__			       =     global_rng

							UpperCamelCase__			       =     []
							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     __SCREAMING_SNAKE_CASE   (       unittest.TestCase    ):






							def __init__(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=7					,	__lowerCAmelCase=400					,	__lowerCAmelCase=2000					,	__lowerCAmelCase=10					,	__lowerCAmelCase=160					,	__lowerCAmelCase=8					,	__lowerCAmelCase=0.0					,	__lowerCAmelCase=4000					,	__lowerCAmelCase=False					,	__lowerCAmelCase=True					,	):
														UpperCamelCase__			       =     parent
														UpperCamelCase__			       =     batch_size
														UpperCamelCase__			       =     min_seq_length
														UpperCamelCase__			       =     max_seq_length
														UpperCamelCase__			       =     (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
														UpperCamelCase__			       =     padding_value
														UpperCamelCase__			       =     sampling_rate
														UpperCamelCase__			       =     return_attention_mask
														UpperCamelCase__			       =     do_normalize
														UpperCamelCase__			       =     feature_size
														UpperCamelCase__			       =     chunk_length
														UpperCamelCase__			       =     hop_length






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

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






@require_torch
@require_torchaudio
class     __SCREAMING_SNAKE_CASE   (       _a				,						unittest.TestCase    ):
							snake_case       : int         =    WhisperFeatureExtractor if is_speech_available() else None






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






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

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

														UpperCamelCase__			       =     feat_extract_first.to_dict()
														UpperCamelCase__			       =     feat_extract_second.to_dict()
														UpperCamelCase__			       =     feat_extract_first.mel_filters
														UpperCamelCase__			       =     feat_extract_second.mel_filters
														self.assertTrue(np.allclose(__lowerCAmelCase					,	__lowerCAmelCase					)					)
														self.assertEqual(__lowerCAmelCase					,	__lowerCAmelCase					)






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

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

														UpperCamelCase__			       =     feat_extract_first.to_dict()
														UpperCamelCase__			       =     feat_extract_second.to_dict()
														UpperCamelCase__			       =     feat_extract_first.mel_filters
														UpperCamelCase__			       =     feat_extract_second.mel_filters
														self.assertTrue(np.allclose(__lowerCAmelCase					,	__lowerCAmelCase					)					)
														self.assertEqual(__lowerCAmelCase					,	__lowerCAmelCase					)






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

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

														# Test batched
														UpperCamelCase__			       =     feature_extractor(__lowerCAmelCase					,	return_tensors="""np"""					).input_features
														UpperCamelCase__			       =     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.
														UpperCamelCase__			       =     [floats_list((1, x)					)[0] for x in (800, 800, 800)]
														UpperCamelCase__			       =     np.asarray(__lowerCAmelCase					)
														UpperCamelCase__			       =     feature_extractor(__lowerCAmelCase					,	return_tensors="""np"""					).input_features
														UpperCamelCase__			       =     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
														UpperCamelCase__			       =     [floats_list((1, x)					)[0] for x in range(200					,	(feature_extractor.n_samples + 500)					,	200					)]
														UpperCamelCase__			       =     [np.asarray(__lowerCAmelCase					) for speech_input in speech_inputs]

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

														UpperCamelCase__			       =     feature_extractor(__lowerCAmelCase					,	return_tensors="""np"""					).input_features
														UpperCamelCase__			       =     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					):
														import torch

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

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






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

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






							def 			_lowerCamelCase						(  self					):
														# fmt: off
														UpperCamelCase__			       =     torch.tensor(
														    [
														        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
														        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
														        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
														        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
														    ]					)
														# fmt: on

														UpperCamelCase__			       =     self._load_datasamples(1					)
														UpperCamelCase__			       =     WhisperFeatureExtractor()
														UpperCamelCase__			       =     feature_extractor(__lowerCAmelCase					,	return_tensors="""pt"""					).input_features
														self.assertEqual(input_features.shape					,	(1, 80, 3000)					)
														self.assertTrue(torch.allclose(input_features[0, 0, :30]					,	__lowerCAmelCase					,	atol=1E-4					)					)







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




