
import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin



class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				__UpperCamelCase   :		List[Any]       =     None
				__UpperCamelCase   :		int       =     None



				@property
				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											return self.feat_extract_tester.prepare_feat_extract_dict()



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     self.feature_extraction_class(**self.feat_extract_dict					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """feature_size"""					)					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """sampling_rate"""					)					)
											self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__     , """padding_value"""					)					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[str]     =     self.feat_extract_tester.prepare_inputs_for_common()
											SCREAMING_SNAKE_CASE__		: str     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Any     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: Any     =     BatchFeature({input_name: speech_inputs}					)

											self.assertTrue(all(len(SCREAMING_SNAKE_CASE__					) == len(SCREAMING_SNAKE_CASE__					) for x, y in zip(SCREAMING_SNAKE_CASE__     , processed_features[input_name]					)					)					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[Any]     =     BatchFeature({input_name: speech_inputs}     , tensor_type="""np"""					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_SNAKE_CASE__		: List[Any]     =     batch_features_input[:, :, None]

											self.assertTrue(
											    batch_features_input.shape
											    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)



				@require_torch
				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: str     =     BatchFeature({input_name: speech_inputs}     , tensor_type="""pt"""					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_SNAKE_CASE__		: int     =     batch_features_input[:, :, None]

											self.assertTrue(
											    batch_features_input.shape
											    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)



				@require_tf
				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: str     =     self.feat_extract_tester.prepare_inputs_for_common(equal_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: List[Any]     =     BatchFeature({input_name: speech_inputs}     , tensor_type="""tf"""					)

											SCREAMING_SNAKE_CASE__		: str     =     processed_features[input_name]

											if len(batch_features_input.shape					) < 3:
																		SCREAMING_SNAKE_CASE__		: List[Any]     =     batch_features_input[:, :, None]

											self.assertTrue(
											    batch_features_input.shape
											    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.feature_size)					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__=False					)      ->	Union[str, Any]:



											"""simple docstring"""




											def _inputs_have_equal_length(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: int     =     len(input[0]					)
																		for input_slice in input[1:]:
																									if len(SCREAMING_SNAKE_CASE__					) != length:
																																return False
																		return True

											def _inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																		if len(SCREAMING_SNAKE_CASE__					) != len(SCREAMING_SNAKE_CASE__					):
																									return False

																		for input_slice_a, input_slice_a in zip(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																									if not np.allclose(np.asarray(SCREAMING_SNAKE_CASE__					)     , np.asarray(SCREAMING_SNAKE_CASE__					)     , atol=1E-3					):
																																return False
																		return True

											SCREAMING_SNAKE_CASE__		: Tuple     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Any     =     self.feat_extract_tester.prepare_inputs_for_common(numpify=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Dict     =     self.feat_extract_tester.seq_length_diff
											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.feat_extract_tester.max_seq_length + pad_diff
											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.feat_extract_tester.min_seq_length
											SCREAMING_SNAKE_CASE__		: int     =     self.feat_extract_tester.batch_size
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.feat_extract_tester.feature_size

											# test padding for List[int] + numpy
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""					)
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[-1]					)					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: List[str]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

											# max_length parameter has to be provided when setting `padding="max_length"`
											with self.assertRaises(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""max_length"""					)[input_name]

											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: int     =     input_a[input_name]

											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(len(input_a[0]					) == pad_min_length					)
											self.assertTrue(len(input_a[1]					) == pad_min_length + pad_diff					)
											self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]					))					)
											self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)					)

											if feature_size > 1:
																		self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size					)

											# test padding for `pad_to_multiple_of` for List[int] + numpy
											SCREAMING_SNAKE_CASE__		: Any     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , pad_to_multiple_of=10					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , pad_to_multiple_of=10					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , pad_to_multiple_of=10     , max_length=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Tuple     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , pad_to_multiple_of=10     , max_length=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""     , )
											SCREAMING_SNAKE_CASE__		: str     =     input_a[input_name]

											self.assertTrue(all(len(SCREAMING_SNAKE_CASE__					) % 10 == 0 for x in input_a					)					)
											self.assertTrue(_inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)					)

											SCREAMING_SNAKE_CASE__		: str     =     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
											self.assertTrue(all(len(SCREAMING_SNAKE_CASE__					) == expected_mult_pad_length for x in input_a					)					)
											self.assertEqual(input_a.shape[:2]     , (batch_size, expected_mult_pad_length)					)

											if feature_size > 1:
																		self.assertTrue(input_a.shape[2] == feature_size					)

											# Check padding value is correct
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     (np.ones(self.feat_extract_tester.feature_size					) * feat_extract.padding_value).sum()
											self.assertTrue(
											    abs(np.asarray(input_a[0]					)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					)
											    < 1E-3					)
											self.assertTrue(
											    abs(
											        np.asarray(input_a[1]					)[pad_min_length + pad_diff :].sum()
											        - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)					)
											    < 1E-3					)
											self.assertTrue(
											    abs(
											        np.asarray(input_a[2]					)[pad_min_length + 2 * pad_diff :].sum()
											        - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)					)
											    < 1E-3					)
											self.assertTrue(
											    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)					) < 1E-3					)
											self.assertTrue(
											    abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)					)
											    < 1E-3					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__=False					)      ->	List[str]:



											"""simple docstring"""




											def _inputs_have_equal_length(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: Tuple     =     len(input[0]					)
																		for input_slice in input[1:]:
																									if len(SCREAMING_SNAKE_CASE__					) != length:
																																return False
																		return True

											def _inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																		if len(SCREAMING_SNAKE_CASE__					) != len(SCREAMING_SNAKE_CASE__					):
																									return False

																		for input_slice_a, input_slice_a in zip(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					):
																									if not np.allclose(np.asarray(SCREAMING_SNAKE_CASE__					)     , np.asarray(SCREAMING_SNAKE_CASE__					)     , atol=1E-3					):
																																return False
																		return True

											SCREAMING_SNAKE_CASE__		: Dict     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.feat_extract_tester.prepare_inputs_for_common(numpify=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: int     =     BatchFeature({input_name: speech_inputs}					)

											# truncate to smallest
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , truncation=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Any     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Any     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     input_a[input_name]

											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)

											# truncate to smallest with np
											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , return_tensors="""np"""     , truncation=SCREAMING_SNAKE_CASE__     , )
											SCREAMING_SNAKE_CASE__		: List[str]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(input_a.shape[1] == len(speech_inputs[0]					)					)

											# since truncation forces padding to be smaller than longest input
											# function can't return `np.ndarray`, but has to return list
											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)

											# truncate to middle
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , truncation=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""     , )
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , truncation=SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[1]					)     , return_tensors="""np"""					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     input_a[input_name]

											self.assertTrue(input_a.shape[1] == len(speech_inputs[1]					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(_inputs_are_equal(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)					)

											# since truncation forces padding to be smaller than longest input
											# function can't return `np.ndarray`, but has to return list
											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertTrue(len(input_a[-1]					) == len(speech_inputs[-1]					)					)

											# padding has to be max_length when setting `truncation=True`
											with self.assertRaises(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , truncation=SCREAMING_SNAKE_CASE__					)[input_name]

											# padding has to be max_length when setting `truncation=True`
											with self.assertRaises(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , truncation=SCREAMING_SNAKE_CASE__					)[input_name]

											# padding has to be max_length when setting `truncation=True`
											with self.assertRaises(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , truncation=SCREAMING_SNAKE_CASE__					)[input_name]

											# max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
											with self.assertRaises(SCREAMING_SNAKE_CASE__					):
																		feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , truncation=SCREAMING_SNAKE_CASE__					)[input_name]

											# test truncation for `pad_to_multiple_of` for List[int] + numpy
											SCREAMING_SNAKE_CASE__		: str     =     12
											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , pad_to_multiple_of=SCREAMING_SNAKE_CASE__     , truncation=SCREAMING_SNAKE_CASE__     , )
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     input_a[input_name]

											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=len(speech_inputs[0]					)     , pad_to_multiple_of=SCREAMING_SNAKE_CASE__     , )
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     input_a[input_name]

											# retrieve expected_length as multiple of pad_to_multiple_of
											SCREAMING_SNAKE_CASE__		: int     =     len(speech_inputs[0]					)
											if expected_length % pad_to_multiple_of != 0:
																		SCREAMING_SNAKE_CASE__		: List[Any]     =     ((len(speech_inputs[0]					) // pad_to_multiple_of) + 1) * pad_to_multiple_of

											self.assertTrue(len(input_a[0]					) == expected_length					)
											self.assertTrue(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)
											self.assertFalse(_inputs_have_equal_length(SCREAMING_SNAKE_CASE__					)					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											self._check_padding(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	str:



											"""simple docstring"""




											self._check_padding(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											self._check_truncation(numpify=SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											self._check_truncation(numpify=SCREAMING_SNAKE_CASE__					)



				@require_torch
				def 			__magic_name__					(self					)      ->	Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.feat_extract_tester.prepare_inputs_for_common()
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: str     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)[input_name]
											SCREAMING_SNAKE_CASE__		: List[str]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""pt"""					)[input_name]

											self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1E-2					)



				@require_tf
				def 			__magic_name__					(self					)      ->	List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: List[Any]     =     self.feature_extraction_class(**self.feat_extract_dict					)
											SCREAMING_SNAKE_CASE__		: str     =     self.feat_extract_tester.prepare_inputs_for_common()
											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: str     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)[input_name]
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""tf"""					)[input_name]

											self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_tf.numpy().astype(np.floataa					).sum()					) < 1E-2					)



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     self.feat_extract_dict
											SCREAMING_SNAKE_CASE__		: int     =     True
											SCREAMING_SNAKE_CASE__		: Tuple     =     self.feature_extraction_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Dict     =     self.feat_extract_tester.prepare_inputs_for_common()
											SCREAMING_SNAKE_CASE__		: List[Any]     =     [len(SCREAMING_SNAKE_CASE__					) for x in speech_inputs]
											SCREAMING_SNAKE_CASE__		: int     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: Tuple     =     BatchFeature({input_name: speech_inputs}					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     feat_extract.pad(SCREAMING_SNAKE_CASE__     , padding="""longest"""     , return_tensors="""np"""					)
											self.assertIn("""attention_mask"""     , SCREAMING_SNAKE_CASE__					)
											self.assertListEqual(list(processed.attention_mask.shape					)     , list(processed[input_name].shape[:2]					)					)
											self.assertListEqual(processed.attention_mask.sum(-1					).tolist()     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     self.feat_extract_dict
											SCREAMING_SNAKE_CASE__		: List[str]     =     True
											SCREAMING_SNAKE_CASE__		: int     =     self.feature_extraction_class(**SCREAMING_SNAKE_CASE__					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.feat_extract_tester.prepare_inputs_for_common()
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     [len(SCREAMING_SNAKE_CASE__					) for x in speech_inputs]
											SCREAMING_SNAKE_CASE__		: Tuple     =     feat_extract.model_input_names[0]

											SCREAMING_SNAKE_CASE__		: int     =     BatchFeature({input_name: speech_inputs}					)
											SCREAMING_SNAKE_CASE__		: Any     =     min(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Dict     =     feat_extract.pad(
											    SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , max_length=SCREAMING_SNAKE_CASE__     , truncation=SCREAMING_SNAKE_CASE__     , return_tensors="""np"""					)
											self.assertIn("""attention_mask"""     , SCREAMING_SNAKE_CASE__					)
											self.assertListEqual(
											    list(processed_pad.attention_mask.shape					)     , [processed_pad[input_name].shape[0], max_length]					)
											self.assertListEqual(
											    processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()     , [max_length for x in speech_inputs]					)






"""simple docstring"""




from manim import *



class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     Rectangle(height=0.5     , width=0.5					)
											SCREAMING_SNAKE_CASE__		: Dict     =     Rectangle(height=0.46     , width=0.46					).set_stroke(width=0					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     Rectangle(height=0.25     , width=0.25					)

											SCREAMING_SNAKE_CASE__		: Any     =     [mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: int     =     [mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: Any     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: Any     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     VGroup(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: List[str]     =     Text("""CPU"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											cpu.move_to([-2.5, -0.5, 0]					)
											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     [mem.copy() for i in range(4					)]
											SCREAMING_SNAKE_CASE__		: List[Any]     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: Any     =     Text("""GPU"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: int     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											gpu.move_to([-1, -1, 0]					)
											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     [mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     Text("""Model"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: Dict     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											model.move_to([3, -1.0, 0]					)
											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     []
											SCREAMING_SNAKE_CASE__		: Any     =     []

											for i, rect in enumerate(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: List[str]     =     fill.copy().set_fill(SCREAMING_SNAKE_CASE__     , opacity=0.8					)
																		target.move_to(SCREAMING_SNAKE_CASE__					)
																		model_arr.append(SCREAMING_SNAKE_CASE__					)

																		SCREAMING_SNAKE_CASE__		: List[str]     =     Rectangle(height=0.46     , width=0.46					).set_stroke(width=0.0					).set_fill(SCREAMING_SNAKE_CASE__     , opacity=0.8					)
																		cpu_target.move_to(cpu_left_col_base[i]					)
																		model_cpu_arr.append(SCREAMING_SNAKE_CASE__					)

											self.add(*SCREAMING_SNAKE_CASE__     , *SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     [meta_mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: List[str]     =     [meta_mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: Any     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: int     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     VGroup(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     Text("""Disk"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: Any     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											disk.move_to([-4, -1.25, 0]					)
											self.add(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Any     =     Square(side_length=2.2					)
											key.move_to([-5, 2, 0]					)

											SCREAMING_SNAKE_CASE__		: List[str]     =     MarkupText(
											    F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''     , font_size=18     , )

											key_text.move_to([-5, 2.4, 0]					)

											self.add(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Any     =     MarkupText(
											    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''     , font_size=18     , )

											blue_text.next_to(SCREAMING_SNAKE_CASE__     , DOWN * 2.4     , aligned_edge=key_text.get_left()					)
											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     MarkupText(
											    F'''Now watch as an input is passed through the model\nand how the memory is utilized and handled.'''     , font_size=24     , )
											step_a.move_to([2, 2, 0]					)

											self.play(Write(SCREAMING_SNAKE_CASE__					)					)

											SCREAMING_SNAKE_CASE__		: Dict     =     Square(0.3					)
											input.set_fill(SCREAMING_SNAKE_CASE__     , opacity=1.0					)
											input.set_stroke(width=0.0					)
											input.next_to(model_base[0]     , SCREAMING_SNAKE_CASE__     , buff=0.5					)

											self.play(Write(SCREAMING_SNAKE_CASE__					)					)

											input.generate_target()
											input.target.next_to(model_arr[0]     , direction=SCREAMING_SNAKE_CASE__     , buff=0.02					)
											self.play(MoveToTarget(SCREAMING_SNAKE_CASE__					)					)

											self.play(FadeOut(SCREAMING_SNAKE_CASE__					)					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     Arrow(start=SCREAMING_SNAKE_CASE__     , end=SCREAMING_SNAKE_CASE__     , color=SCREAMING_SNAKE_CASE__     , buff=0.5					)
											a.next_to(model_arr[0].get_left()     , SCREAMING_SNAKE_CASE__     , buff=0.2					)

											model_cpu_arr[0].generate_target()
											model_cpu_arr[0].target.move_to(gpu_rect[0]					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     MarkupText(
											    F'''As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.'''     , font_size=24     , )
											step_a.move_to([2, 2, 0]					)

											self.play(Write(SCREAMING_SNAKE_CASE__     , run_time=3					)					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.02}

											self.play(
											    Write(SCREAMING_SNAKE_CASE__					)     , Circumscribe(model_arr[0]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(model_cpu_arr[0]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(gpu_rect[0]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , )
											self.play(MoveToTarget(model_cpu_arr[0]					)					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     a.copy()
											for i in range(6					):
																		a_c.next_to(model_arr[i].get_right() + 0.02     , SCREAMING_SNAKE_CASE__     , buff=0.2					)

																		input.generate_target()
																		input.target.move_to(model_arr[i].get_right() + 0.02					)

																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     AnimationGroup(
																		    FadeOut(SCREAMING_SNAKE_CASE__     , run_time=0.5					)     , MoveToTarget(SCREAMING_SNAKE_CASE__     , run_time=0.5					)     , FadeIn(SCREAMING_SNAKE_CASE__     , run_time=0.5					)     , lag_ratio=0.2					)

																		self.play(SCREAMING_SNAKE_CASE__					)

																		model_cpu_arr[i].generate_target()
																		model_cpu_arr[i].target.move_to(cpu_left_col_base[i]					)

																		if i < 5:
																									model_cpu_arr[i + 1].generate_target()
																									model_cpu_arr[i + 1].target.move_to(gpu_rect[0]					)
																									if i >= 1:
																																SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     0.7

																									self.play(
																									    Circumscribe(model_arr[i]     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(cpu_left_col_base[i]     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(cpu_left_col_base[i + 1]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(gpu_rect[0]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(model_arr[i + 1]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , )
																									if i < 1:
																																self.play(
																																    MoveToTarget(model_cpu_arr[i]					)     , MoveToTarget(model_cpu_arr[i + 1]					)     , )
																									else:
																																self.play(
																																    MoveToTarget(model_cpu_arr[i]     , run_time=0.7					)     , MoveToTarget(model_cpu_arr[i + 1]     , run_time=0.7					)     , )
																		else:
																									model_cpu_arr[i].generate_target()
																									model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]					)
																									input.generate_target()
																									input.target.next_to(model_arr[-1].get_right()     , RIGHT + 0.02     , buff=0.2					)

																									self.play(
																									    Circumscribe(model_arr[-1]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(cpu_left_col_base[-1]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , Circumscribe(gpu_rect[0]     , color=SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)     , )

																									self.play(MoveToTarget(model_cpu_arr[i]					)					)

																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     a_c
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     a_c.copy()

											input.generate_target()
											input.target.next_to(model_base[-1]     , RIGHT + 0.02     , buff=0.5					)
											self.play(
											    FadeOut(SCREAMING_SNAKE_CASE__					)     , FadeOut(SCREAMING_SNAKE_CASE__     , run_time=0.5					)     , )

											SCREAMING_SNAKE_CASE__		: Dict     =     MarkupText(F'''Inference on a model too large for GPU memory\nis successfully completed.'''     , font_size=24					)
											step_a.move_to([2, 2, 0]					)

											self.play(Write(SCREAMING_SNAKE_CASE__     , run_time=3					)     , MoveToTarget(SCREAMING_SNAKE_CASE__					)					)

											self.wait()




