




import inspect
import unittest

from transformers import YolosConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import YolosForObjectDetection, YolosModel
		from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor
class 						UpperCAmelCase  :







						'''simple docstring'''





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






							"""simple docstring"""






							snake_case_						       =	parent
							snake_case_						       =	batch_size
							snake_case_						       =	image_size
							snake_case_						       =	patch_size
							snake_case_						       =	num_channels
							snake_case_						       =	is_training
							snake_case_						       =	use_labels
							snake_case_						       =	hidden_size
							snake_case_						       =	num_hidden_layers
							snake_case_						       =	num_attention_heads
							snake_case_						       =	intermediate_size
							snake_case_						       =	hidden_act
							snake_case_						       =	hidden_dropout_prob
							snake_case_						       =	attention_probs_dropout_prob
							snake_case_						       =	type_sequence_label_size
							snake_case_						       =	initializer_range
							snake_case_						       =	num_labels
							snake_case_						       =	scope
							snake_case_						       =	n_targets
							snake_case_						       =	num_detection_tokens
							# we set the expected sequence length (which is used in several tests)
							# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
							snake_case_						       =	(image_size[1] // patch_size) * (image_size[0] // patch_size)
							snake_case_						       =	num_patches + 1 + self.num_detection_tokens






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]		)

							snake_case_						       =	None
							if self.use_labels:
								# labels is a list of Dict (each Dict being the labels for a given example in the batch)
								snake_case_						       =	[]
								for i in range(self.batch_size		):
									snake_case_						       =	{}
									snake_case_						       =	torch.randint(
									    high=self.num_labels			,      size=(self.n_targets,)			,      device=__lowercase		)
									snake_case_						       =	torch.rand(self.n_targets			,      4			,      device=__lowercase		)
									labels.append(__lowercase		)

							snake_case_						       =	self.get_config()

							return config, pixel_values, labels






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							return YolosConfig(
							    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=__lowercase			,      initializer_range=self.initializer_range			,      num_detection_tokens=self.num_detection_tokens			,      num_labels=self.num_labels			,      )






						def 			snake_case__		(		self				:	Optional[Any]			,      __lowercase				:	Tuple			,      __lowercase				:	Optional[int]			,      __lowercase				:	Tuple		):






							"""simple docstring"""






							snake_case_						       =	YolosModel(config=__lowercase		)
							model.to(__lowercase		)
							model.eval()
							snake_case_						       =	model(__lowercase		)
							self.parent.assertEqual(
							    result.last_hidden_state.shape			,      (self.batch_size, self.expected_seq_len, self.hidden_size)		)






						def 			snake_case__		(		self				:	List[str]			,      __lowercase				:	Optional[Any]			,      __lowercase				:	List[str]			,      __lowercase				:	Union[str, Any]		):






							"""simple docstring"""






							snake_case_						       =	YolosForObjectDetection(__lowercase		)
							model.to(__lowercase		)
							model.eval()

							snake_case_						       =	model(pixel_values=__lowercase		)
							snake_case_						       =	model(__lowercase		)

							self.parent.assertEqual(result.logits.shape			,      (self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
							self.parent.assertEqual(result.pred_boxes.shape			,      (self.batch_size, self.num_detection_tokens, 4)		)

							snake_case_						       =	model(pixel_values=__lowercase			,      labels=__lowercase		)

							self.parent.assertEqual(result.loss.shape			,      ()		)
							self.parent.assertEqual(result.logits.shape			,      (self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
							self.parent.assertEqual(result.pred_boxes.shape			,      (self.batch_size, self.num_detection_tokens, 4)		)






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	self.prepare_config_and_inputs()
							snake_case_       , snake_case_       , snake_case_						       =	config_and_inputs
							snake_case_						       =	{"pixel_values": pixel_values}
							return config, inputs_dict







@require_torch
class 						UpperCAmelCase  (							UpperCAmelCase__			,  UpperCAmelCase__			,  unittest.TestCase     ):







						'''simple docstring'''





						lowerCAmelCase_							=  (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
						lowerCAmelCase_							=  (
						    {'''feature-extraction''': YolosModel, '''object-detection''': YolosForObjectDetection} if is_torch_available() else {}
						)

						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False






						def 			snake_case__		(		self				:	Tuple			,      __lowercase				:	int			,      __lowercase				:	List[Any]			,      __lowercase				:	int=False		):






							"""simple docstring"""






							snake_case_						       =	super()._prepare_for_class(__lowercase			,      __lowercase			,      return_labels=__lowercase		)

							if return_labels:
								if model_class.__name__ == "YolosForObjectDetection":
									snake_case_						       =	[]
									for i in range(self.model_tester.batch_size		):
										snake_case_						       =	{}
										snake_case_						       =	torch.ones(
										    size=(self.model_tester.n_targets,)			,      device=__lowercase			,      dtype=torch.long		)
										snake_case_						       =	torch.ones(
										    self.model_tester.n_targets			,      4			,      device=__lowercase			,      dtype=torch.float		)
										labels.append(__lowercase		)
									snake_case_						       =	labels

							return inputs_dict






						def 			snake_case__		(		self				:	List[str]		):






							"""simple docstring"""






							snake_case_						       =	YolosModelTester(self		)
							snake_case_						       =	ConfigTester(self			,      config_class=__lowercase			,      has_text_modality=__lowercase			,      hidden_size=37		)






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							self.config_tester.run_common_tests()






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							pass






						def 			snake_case__		(		self				:	Union[str, Any]		):






							"""simple docstring"""






							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

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






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

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

								snake_case_						       =	["pixel_values"]
								self.assertListEqual(arg_names[:1]			,      __lowercase		)






						def 			snake_case__		(		self				:	str		):






							"""simple docstring"""






							snake_case_						       =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__lowercase		)






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()
							snake_case_						       =	True

							# in YOLOS, the seq_len is different
							snake_case_						       =	self.model_tester.expected_seq_len
							for model_class in self.all_model_classes:
								snake_case_						       =	True
								snake_case_						       =	False
								snake_case_						       =	True
								snake_case_						       =	model_class(__lowercase		)
								model.to(__lowercase		)
								model.eval()
								with torch.no_grad():
									snake_case_						       =	model(**self._prepare_for_class(__lowercase			,      __lowercase		)		)
								snake_case_						       =	outputs.attentions
								self.assertEqual(len(__lowercase		)			,      self.model_tester.num_hidden_layers		)

								# check that output_attentions also work using config
								del inputs_dict["output_attentions"]
								snake_case_						       =	True
								snake_case_						       =	model_class(__lowercase		)
								model.to(__lowercase		)
								model.eval()
								with torch.no_grad():
									snake_case_						       =	model(**self._prepare_for_class(__lowercase			,      __lowercase		)		)
								snake_case_						       =	outputs.attentions
								self.assertEqual(len(__lowercase		)			,      self.model_tester.num_hidden_layers		)

								self.assertListEqual(
								    list(attentions[0].shape[-3:]		)			,      [self.model_tester.num_attention_heads, seq_len, seq_len]			,      )
								snake_case_						       =	len(__lowercase		)

								# Check attention is always last and order is fine
								snake_case_						       =	True
								snake_case_						       =	True
								snake_case_						       =	model_class(__lowercase		)
								model.to(__lowercase		)
								model.eval()
								with torch.no_grad():
									snake_case_						       =	model(**self._prepare_for_class(__lowercase			,      __lowercase		)		)

								snake_case_						       =	1
								self.assertEqual(out_len + added_hidden_states			,      len(__lowercase		)		)

								snake_case_						       =	outputs.attentions

								self.assertEqual(len(__lowercase		)			,      self.model_tester.num_hidden_layers		)
								self.assertListEqual(
								    list(self_attentions[0].shape[-3:]		)			,      [self.model_tester.num_attention_heads, seq_len, seq_len]			,      )






						def 			snake_case__		(		self				:	Union[str, Any]		):






							"""simple docstring"""






							def check_hidden_states_output(__lowercase				:	Optional[Any]			,      __lowercase				:	Any			,      __lowercase				:	Dict		):
								snake_case_						       =	model_class(__lowercase		)
								model.to(__lowercase		)
								model.eval()

								with torch.no_grad():
									snake_case_						       =	model(**self._prepare_for_class(__lowercase			,      __lowercase		)		)

								snake_case_						       =	outputs.hidden_states

								snake_case_						       =	getattr(
								    self.model_tester			,      "expected_num_hidden_layers"			,      self.model_tester.num_hidden_layers + 1		)
								self.assertEqual(len(__lowercase		)			,      __lowercase		)

								# YOLOS has a different seq_length
								snake_case_						       =	self.model_tester.expected_seq_len

								self.assertListEqual(
								    list(hidden_states[0].shape[-2:]		)			,      [seq_length, self.model_tester.hidden_size]			,      )

							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						       =	True
								check_hidden_states_output(__lowercase			,      __lowercase			,      __lowercase		)

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								snake_case_						       =	True

								check_hidden_states_output(__lowercase			,      __lowercase			,      __lowercase		)






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							snake_case_						       =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_object_detection(*__lowercase		)






						@slow
						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								snake_case_						       =	YolosModel.from_pretrained(__lowercase		)
								self.assertIsNotNone(__lowercase		)







def 		lowerCamelCase__       (						):







	'''simple docstring'''





	snake_case_						       =	Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
	return image






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







						'''simple docstring'''





						@cached_property
						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							return AutoImageProcessor.from_pretrained("hustvl/yolos-small"		) if is_vision_available() else None






						@slow
						def 			snake_case__		(		self				:	Optional[int]		):






							"""simple docstring"""






							snake_case_						       =	YolosForObjectDetection.from_pretrained("hustvl/yolos-small"		).to(__lowercase		)

							snake_case_						       =	self.default_image_processor
							snake_case_						       =	prepare_img()
							snake_case_						       =	image_processor(images=__lowercase			,      return_tensors="pt"		).to(__lowercase		)

							# forward pass
							with torch.no_grad():
								snake_case_						       =	model(inputs.pixel_values		)

							# verify outputs
							snake_case_						       =	torch.Size((1, 1_00, 92)		)
							self.assertEqual(outputs.logits.shape			,      __lowercase		)

							snake_case_						       =	torch.tensor(
							    [[-24.0248, -10.3024, -14.8290], [-42.0392, -16.8200, -27.4334], [-27.2743, -11.8154, -18.7148]]			,      device=__lowercase			,      )
							snake_case_						       =	torch.tensor(
							    [[0.2559, 0.5455, 0.4706], [0.2989, 0.7279, 0.1875], [0.7732, 0.4017, 0.4462]]			,      device=__lowercase		)
							self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]			,      __lowercase			,      atol=1E-4		)		)
							self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]			,      __lowercase			,      atol=1E-4		)		)

							# verify postprocessing
							snake_case_						       =	image_processor.post_process_object_detection(
							    __lowercase			,      threshold=0.3			,      target_sizes=[image.size[::-1]]		)[0]
							snake_case_						       =	torch.tensor([0.9994, 0.9790, 0.9964, 0.9972, 0.9861]		).to(__lowercase		)
							snake_case_						       =	[75, 75, 17, 63, 17]
							snake_case_						       =	torch.tensor([335.0609, 79.3848, 375.4216, 187.2495]		).to(__lowercase		)

							self.assertEqual(len(results["scores"]		)			,      5		)
							self.assertTrue(torch.allclose(results["scores"]			,      __lowercase			,      atol=1E-4		)		)
							self.assertSequenceEqual(results["labels"].tolist()			,      __lowercase		)
							self.assertTrue(torch.allclose(results["boxes"][0, :]			,      __lowercase		)		)






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


lowercase__							:	Tuple											=		logging.get_logger(__name__)
class 						UpperCAmelCase  (							UpperCAmelCase__     ):







						'''simple docstring'''





						lowerCAmelCase_							=  ['''input_values''', '''attention_mask''']






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






							"""simple docstring"""






							super().__init__(feature_size=__lowercase			,      sampling_rate=__lowercase			,      padding_value=__lowercase			,      **__lowercase		)
							snake_case_						       =	do_normalize
							snake_case_						       =	return_attention_mask

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

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

							snake_case_						       =	window_function(window_length=self.sample_size			,      name=self.win_function			,      periodic=__lowercase		)

							snake_case_						       =	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"			,      __lowercase			,      )
							if reduction_factor != 2.0:
								warnings.warn(
								    "The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"			,      __lowercase			,      )






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






							"""simple docstring"""






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

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

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

							return normed_input_values






						def 			snake_case__		(		self				:	str			,      __lowercase				:	np.ndarray			,      ):






							"""simple docstring"""






							snake_case_						       =	spectrogram(
							    __lowercase			,      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				:	Optional[int]			,      __lowercase				:	Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None			,      __lowercase				:	Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None			,      __lowercase				:	Union[bool, str, PaddingStrategy] = False			,      __lowercase				:	Optional[int] = None			,      __lowercase				:	bool = False			,      __lowercase				:	Optional[int] = None			,      __lowercase				:	Optional[bool] = None			,      __lowercase				:	Optional[Union[str, TensorType]] = None			,      __lowercase				:	Optional[int] = None			,      **__lowercase				:	List[str]			,      ):






							"""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:
								snake_case_						       =	self._process_audio(
								    __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      **__lowercase			,      )
							else:
								snake_case_						       =	None

							if audio_target is not None:
								snake_case_						       =	self._process_audio(
								    __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      __lowercase			,      **__lowercase			,      )

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

							return inputs






						def 			snake_case__		(		self				:	Dict			,      __lowercase				:	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]			,      __lowercase				:	bool = False			,      __lowercase				:	Union[bool, str, PaddingStrategy] = False			,      __lowercase				:	Optional[int] = None			,      __lowercase				:	bool = False			,      __lowercase				:	Optional[int] = None			,      __lowercase				:	Optional[bool] = None			,      __lowercase				:	Optional[Union[str, TensorType]] = None			,      **__lowercase				:	Optional[Any]			,      ):






							"""simple docstring"""






							snake_case_						       =	isinstance(__lowercase			,      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}"		)
							snake_case_						       =	is_batched_numpy or (
							    isinstance(__lowercase			,      (list, tuple)		) and (isinstance(speech[0]			,      (np.ndarray, tuple, list)		))
							)

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

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

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

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

							snake_case_						       =	self.pad(
							    __lowercase			,      padding=__lowercase			,      max_length=__lowercase			,      truncation=__lowercase			,      pad_to_multiple_of=__lowercase			,      return_attention_mask=__lowercase			,      **__lowercase			,      )

							snake_case_						       =	feature_size_hack

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

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

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

							if return_tensors is not None:
								snake_case_						       =	padded_inputs.convert_to_tensors(__lowercase		)

							return padded_inputs






						def 			snake_case__		(		self				:	Tuple		):






							"""simple docstring"""






							snake_case_						       =	super().to_dict()

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

							return output
