



import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


SCREAMING_SNAKE_CASE__   			=   get_tests_dir('''fixtures/test_sentencepiece.model''')


@require_sentencepiece
@require_tokenizers
class   __lowerCAmelCase  (		UpperCAmelCase_				,  unittest.TestCase   ):
					"""simple docstring"""






					A__					:		List[str]      							=     XLNetTokenizer
					A__					:		str      							=     XLNetTokenizerFast
					A__					:		int      							=     True
					A__					:		List[str]      							=     True



					def      _a				(  self       :							Optional[int]       ):






								"""simple docstring"""


								super().setUp()

								# We have a SentencePiece fixture for testing
								A__	  =     XLNetTokenizer(_snake_case					,       keep_accents=_snake_case       )
								tokenizer.sanitize_special_tokens()
								tokenizer.save_pretrained(self.tmpdirname       )



					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     '<s>'
								A__	  =     1

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



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								A__	  =     list(self.get_tokenizer().get_vocab().keys()       )

								self.assertEqual(vocab_keys[0]					,       '<unk>'       )
								self.assertEqual(vocab_keys[1]					,       '<s>'       )
								self.assertEqual(vocab_keys[-1]					,       '<eod>'       )
								self.assertEqual(len(_snake_case       )					,       10_06       )



					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								self.assertEqual(self.get_tokenizer().vocab_size					,       10_00       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								A__	  =     XLNetTokenizer(_snake_case					,       keep_accents=_snake_case       )

								A__	  =     tokenizer.tokenize('This is a test'       )
								self.assertListEqual(_snake_case					,       ['▁This', '▁is', '▁a', '▁t', 'est']       )

								self.assertListEqual(tokenizer.convert_tokens_to_ids(_snake_case       )					,       [2_85, 46, 10, 1_70, 3_82]       )

								A__	  =     tokenizer.tokenize('I was born in 92000, and this is falsé.'       )
								self.assertListEqual(
								    _snake_case					,       [
								        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',
								        'é',
								        '.',
								    ]					,       )
								A__	  =     tokenizer.convert_tokens_to_ids(_snake_case       )
								self.assertListEqual(_snake_case					,       [8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]       )

								A__	  =     tokenizer.convert_ids_to_tokens(_snake_case       )
								self.assertListEqual(
								    _snake_case					,       [
								        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>',
								        '.',
								    ]					,       )



					def      _a				(  self       :							List[Any]       ):






								"""simple docstring"""


								A__	  =     XLNetTokenizer(_snake_case					,       do_lower_case=_snake_case       )
								A__	  =     tokenizer.tokenize('I was born in 92000, and this is falsé.'       )
								self.assertListEqual(
								    _snake_case					,       [
								        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',
								        'se',
								        '.',
								    ]					,       )
								self.assertListEqual(tokenizer.tokenize('H\u00E9llo'       )					,       ['▁he', 'll', 'o']       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								A__	  =     XLNetTokenizer(_snake_case					,       do_lower_case=_snake_case       )
								A__	  =     tokenizer.tokenize('I was born in 92000, and this is falsé.'       )
								self.assertListEqual(
								    _snake_case					,       [
								        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',
								        'se',
								        '.',
								    ]					,       )



					@slow
					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     XLNetTokenizer.from_pretrained('xlnet-base-cased'       )

								A__	  =     tokenizer.encode('sequence builders'					,       add_special_tokens=_snake_case       )
								A__	  =     tokenizer.encode('multi-sequence build'					,       add_special_tokens=_snake_case       )

								A__	  =     tokenizer.build_inputs_with_special_tokens(_snake_case       )
								A__	  =     tokenizer.build_inputs_with_special_tokens(_snake_case					,       _snake_case       )

								assert encoded_sentence == text + [4, 3]
								assert encoded_pair == text + [4] + text_a + [4, 3]



					@slow
					def      _a				(  self       :							str       ):






								"""simple docstring"""


								A__	  =     {'input_ids': [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], 'token_type_ids': [[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, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], '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], [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, 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, 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, 1, 1]]}  # noqa: E501
								# fmt: on

								self.tokenizer_integration_test_util(
								    expected_encoding=_snake_case					,       model_name='xlnet-base-cased'					,       revision='c841166438c31ec7ca9a106dee7bb312b73ae511'					,       )









import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


SCREAMING_SNAKE_CASE__   			=   logging.get_logger(__name__)


class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






					A__					:		Optional[Any]      							=     ["input_values", "attention_mask"]



					def __init__(  self       :							str					,       _snake_case       :							int = 1					,       _snake_case       :							int = 1_60_00					,       _snake_case       :							float = 0.0					,       _snake_case       :							bool = False					,       _snake_case       :							int = 80					,       _snake_case       :							int = 16					,       _snake_case       :							int = 64					,       _snake_case       :							str = "hann_window"					,       _snake_case       :							float = 1.0					,       _snake_case       :							float = 80					,       _snake_case       :							float = 76_00					,       _snake_case       :							float = 1E-10					,       _snake_case       :							int = 2					,       _snake_case       :							bool = True					,       **_snake_case       :							Union[str, Any]					,       ):






								"""simple docstring"""


								super().__init__(feature_size=_snake_case					,       sampling_rate=_snake_case					,       padding_value=_snake_case					,       **_snake_case       )
								A__	  =     do_normalize
								A__	  =     return_attention_mask

								A__	  =     num_mel_bins
								A__	  =     hop_length
								A__	  =     win_length
								A__	  =     win_function
								A__	  =     frame_signal_scale
								A__	  =     fmin
								A__	  =     fmax
								A__	  =     mel_floor
								A__	  =     reduction_factor

								A__	  =     win_length * sampling_rate // 10_00
								A__	  =     hop_length * sampling_rate // 10_00
								A__	  =     optimal_fft_length(self.sample_size       )
								A__	  =     (self.n_fft // 2) + 1

								A__	  =     window_function(window_length=self.sample_size					,       name=self.win_function					,       periodic=_snake_case       )

								A__	  =     mel_filter_bank(
								    num_frequency_bins=self.n_freqs					,       num_mel_filters=self.num_mel_bins					,       min_frequency=self.fmin					,       max_frequency=self.fmax					,       sampling_rate=self.sampling_rate					,       norm='slaney'					,       mel_scale='slaney'					,       )

								if frame_signal_scale != 1.0:
											warnings.warn(
											    'The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'					,       _snake_case					,       )
								if reduction_factor != 2.0:
											warnings.warn(
											    'The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'					,       _snake_case					,       )



					@staticmethod
					# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
					def      _a				(  _snake_case       :							List[np.ndarray]					,       _snake_case       :							List[np.ndarray]					,       _snake_case       :							float = 0.0       ):






								"""simple docstring"""


								if attention_mask is not None:
											A__	  =     np.array(_snake_case					,       np.intaa       )
											A__	  =     []

											for vector, length in zip(_snake_case					,       attention_mask.sum(-1       )       ):
														A__	  =     (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7       )
														if length < normed_slice.shape[0]:
																	A__	  =     padding_value

														normed_input_values.append(_snake_case       )
								else:
											A__	  =     [(x - x.mean()) / np.sqrt(x.var() + 1E-7       ) for x in input_values]

								return normed_input_values



					def      _a				(  self       :							Tuple					,       _snake_case       :							np.ndarray					,       ):






								"""simple docstring"""


								A__	  =     spectrogram(
								    _snake_case					,       window=self.window					,       frame_length=self.sample_size					,       hop_length=self.sample_stride					,       fft_length=self.n_fft					,       mel_filters=self.mel_filters					,       mel_floor=self.mel_floor					,       log_mel='log10'					,       )
								return log_mel_spec.T



					def __call__(  self       :							List[str]					,       _snake_case       :							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None					,       _snake_case       :							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None					,       _snake_case       :							Union[bool, str, PaddingStrategy] = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							bool = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							Optional[bool] = None					,       _snake_case       :							Optional[Union[str, TensorType]] = None					,       _snake_case       :							Optional[int] = None					,       **_snake_case       :							Tuple					,       ):






								"""simple docstring"""


								if audio is None and audio_target is None:
											raise ValueError('You must provide either `audio` or `audio_target` values.'       )

								if sampling_rate is not None:
											if sampling_rate != self.sampling_rate:
														raise ValueError(
														    F'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
														    F''' {self.sampling_rate}. Please make sure that the provided audio input was sampled with'''
														    F''' {self.sampling_rate} and not {sampling_rate}.'''       )
								else:
											logger.warning(
											    'It is strongly recommended to pass the ``sampling_rate`` argument to this function. '
											    'Failing to do so can result in silent errors that might be hard to debug.'       )

								if audio is not None:
											A__	  =     self._process_audio(
											    _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       **_snake_case					,       )
								else:
											A__	  =     None

								if audio_target is not None:
											A__	  =     self._process_audio(
											    _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       **_snake_case					,       )

											if inputs is None:
														return inputs_target
											else:
														A__	  =     inputs_target['input_values']
														A__	  =     inputs_target.get('attention_mask'       )
														if decoder_attention_mask is not None:
																	A__	  =     decoder_attention_mask

								return inputs



					def      _a				(  self       :							Tuple					,       _snake_case       :							Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]					,       _snake_case       :							bool = False					,       _snake_case       :							Union[bool, str, PaddingStrategy] = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							bool = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							Optional[bool] = None					,       _snake_case       :							Optional[Union[str, TensorType]] = None					,       **_snake_case       :							Tuple					,       ):






								"""simple docstring"""


								A__	  =     isinstance(_snake_case					,       np.ndarray       ) and len(speech.shape       ) > 1
								if is_batched_numpy and len(speech.shape       ) > 2:
											raise ValueError(F'''Only mono-channel audio is supported for input to {self}'''       )
								A__	  =     is_batched_numpy or (
								    isinstance(_snake_case					,       (list, tuple)       ) and (isinstance(speech[0]					,       (np.ndarray, tuple, list)       ))
								)

								if is_batched:
											A__	  =     [np.asarray(_snake_case					,       dtype=np.floataa       ) for speech in speech]
								elif not is_batched and not isinstance(_snake_case					,       np.ndarray       ):
											A__	  =     np.asarray(_snake_case					,       dtype=np.floataa       )
								elif isinstance(_snake_case					,       np.ndarray       ) and speech.dtype is np.dtype(np.floataa       ):
											A__	  =     speech.astype(np.floataa       )

								# always return batch
								if not is_batched:
											A__	  =     [speech]

								# needed to make pad() work on spectrogram inputs
								A__	  =     self.feature_size

								# convert into correct format for padding
								if is_target:
											A__	  =     [self._extract_mel_features(_snake_case       ) for waveform in speech]
											A__	  =     BatchFeature({'input_values': features}       )
											A__	  =     self.num_mel_bins
								else:
											A__	  =     BatchFeature({'input_values': speech}       )

								A__	  =     self.pad(
								    _snake_case					,       padding=_snake_case					,       max_length=_snake_case					,       truncation=_snake_case					,       pad_to_multiple_of=_snake_case					,       return_attention_mask=_snake_case					,       **_snake_case					,       )

								A__	  =     feature_size_hack

								# convert input values to correct format
								A__	  =     padded_inputs['input_values']
								if not isinstance(input_values[0]					,       np.ndarray       ):
											A__	  =     [np.asarray(_snake_case					,       dtype=np.floataa       ) for array in input_values]
								elif (
								    not isinstance(_snake_case					,       np.ndarray       )
								    and isinstance(input_values[0]					,       np.ndarray       )
								    and input_values[0].dtype is np.dtype(np.floataa       )
								):
											A__	  =     [array.astype(np.floataa       ) for array in input_values]
								elif isinstance(_snake_case					,       np.ndarray       ) and input_values.dtype is np.dtype(np.floataa       ):
											A__	  =     input_values.astype(np.floataa       )

								# convert attention_mask to correct format
								A__	  =     padded_inputs.get('attention_mask'       )
								if attention_mask is not None:
											A__	  =     [np.asarray(_snake_case					,       dtype=np.intaa       ) for array in attention_mask]

								# zero-mean and unit-variance normalization
								if not is_target and self.do_normalize:
											A__	  =     (
											    attention_mask
											    if self._get_padding_strategies(_snake_case					,       max_length=_snake_case       ) is not PaddingStrategy.DO_NOT_PAD
											    else None
											)
											A__	  =     self.zero_mean_unit_var_norm(
											    padded_inputs['input_values']					,       attention_mask=_snake_case					,       padding_value=self.padding_value       )

								if return_tensors is not None:
											A__	  =     padded_inputs.convert_to_tensors(_snake_case       )

								return padded_inputs



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     super().to_dict()

								# Don't serialize these as they are derived from the other properties.
								A__	  =     ['window', 'mel_filters', 'sample_size', 'sample_stride', 'n_fft', 'n_freqs']
								for name in names:
											if name in output:
														del output[name]

								return output




