





"""simple docstring"""





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__A											=						logging.get_logger(__name__)

__A											=						{
    """microsoft/swin-tiny-patch4-window7-224""": (
        """https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json"""
    ),
    # See all Swin models at https://huggingface.co/models?filter=swin
}






class    _lowerCAmelCase  (	a    ,  a			):
       """simple docstring"""




       __magic_name__	:List[str]						    =   """swin"""

       __magic_name__	:List[Any]						    =   {
           """num_attention_heads""": """num_heads""",
           """num_hidden_layers""": """num_layers""",
       }






       def __init__(       self       ,					__UpperCAmelCase=2_2_4       ,					__UpperCAmelCase=4       ,					__UpperCAmelCase=3       ,					__UpperCAmelCase=9_6       ,					__UpperCAmelCase=[2, 2, 6, 2]       ,					__UpperCAmelCase=[3, 6, 1_2, 2_4]       ,					__UpperCAmelCase=7       ,					__UpperCAmelCase=4.0       ,					__UpperCAmelCase=True       ,					__UpperCAmelCase=0.0       ,					__UpperCAmelCase=0.0       ,					__UpperCAmelCase=0.1       ,					__UpperCAmelCase="gelu"       ,					__UpperCAmelCase=False       ,					__UpperCAmelCase=0.02       ,					__UpperCAmelCase=1E-5       ,					__UpperCAmelCase=3_2       ,					__UpperCAmelCase=None       ,					__UpperCAmelCase=None       ,					**__UpperCAmelCase       ,					):



         '''simple docstring'''

         super().__init__(**__UpperCAmelCase )

         lowerCAmelCase__     :Tuple											=				image_size
         lowerCAmelCase__     :Tuple											=				patch_size
         lowerCAmelCase__     :Tuple											=				num_channels
         lowerCAmelCase__     :Tuple											=				embed_dim
         lowerCAmelCase__     :Union[str, Any]											=				depths
         lowerCAmelCase__     :Union[str, Any]											=				len(__UpperCAmelCase )
         lowerCAmelCase__     :int											=				num_heads
         lowerCAmelCase__     :str											=				window_size
         lowerCAmelCase__     :Union[str, Any]											=				mlp_ratio
         lowerCAmelCase__     :Optional[int]											=				qkv_bias
         lowerCAmelCase__     :List[str]											=				hidden_dropout_prob
         lowerCAmelCase__     :Optional[Any]											=				attention_probs_dropout_prob
         lowerCAmelCase__     :List[str]											=				drop_path_rate
         lowerCAmelCase__     :Any											=				hidden_act
         lowerCAmelCase__     :List[Any]											=				use_absolute_embeddings
         lowerCAmelCase__     :Dict											=				layer_norm_eps
         lowerCAmelCase__     :Optional[Any]											=				initializer_range
         lowerCAmelCase__     :List[str]											=				encoder_stride
         # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
         # this indicates the channel dimension after the last stage of the model
         lowerCAmelCase__     :Union[str, Any]											=				int(embed_dim * 2 ** (len(__UpperCAmelCase ) - 1) )
         lowerCAmelCase__     :Any											=				['stem'] + [F"stage{idx}" for idx in range(1       ,					len(__UpperCAmelCase ) + 1 )]
         lowerCAmelCase__				,							lowerCAmelCase__     :str											=				get_aligned_output_features_output_indices(
             out_features=__UpperCAmelCase       ,					out_indices=__UpperCAmelCase       ,					stage_names=self.stage_names )






class    _lowerCAmelCase  (	a			):
       """simple docstring"""




       __magic_name__	:str						    =   version.parse("""1.11"""			)






       @property
       def 	snake_case		(       self ):



         '''simple docstring'''

         return OrderedDict(
             [
                 ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
             ] )






       @property
       def 	snake_case		(       self ):



         '''simple docstring'''

         return 1E-4







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 						UpperCamelCase_  (  snake_case__							):
					# to overwrite at feature extractactor specific tests
					_a      :						str						    =					None
					_a      :						Tuple						    =					None



					@property
					def   __a     (		self     :     str						):
							return self.feat_extract_tester.prepare_feat_extract_dict()



					def   __a     (		self     :     int						):
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'feature_size'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'sampling_rate'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'padding_value'						)						)



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

							lowerCamelCase_	:     Optional[int] 						=      BatchFeature({input_name: speech_inputs}						)

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

							lowerCamelCase_	:     Tuple 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     Union[str, Any] 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='np'						)

							lowerCamelCase_	:     int 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     Union[str, 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   __a     (		self     :     Dict						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='pt'						)

							lowerCamelCase_	:     Optional[int] 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     Optional[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   __a     (		self     :     Tuple						):
							lowerCamelCase_	:     int 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     int 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     List[str] 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='tf'						)

							lowerCamelCase_	:     Union[str, Any] 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     int=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Union[str, Any]						):
									lowerCamelCase_	:     Any 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

							def _inputs_are_equal(lowerCamelCase     :     List[str]       ,      lowerCamelCase     :     Dict						):
									if len(lowerCamelCase						) != len(lowerCamelCase						):
											return False

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

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

							lowerCamelCase_	:     List[Any] 						=      BatchFeature({input_name: speech_inputs}						)

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

							# test padding for List[int] + numpy
							lowerCamelCase_	:     int 						=      feat_extract.pad(lowerCamelCase       ,      padding=lowerCamelCase						)
							lowerCamelCase_	:     Tuple 						=      input_a[input_name]

							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'						)
							lowerCamelCase_	:     Optional[Any] 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[-1]						)						)
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

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

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      return_tensors='np'						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_are_equal(lowerCamelCase       ,      lowerCamelCase						)						)
							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
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.pad(lowerCamelCase       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     Any 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     str 						=      input_a[input_name]

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

							lowerCamelCase_	:     Dict 						=      pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
							self.assertTrue(all(len(lowerCamelCase						) == 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
							lowerCamelCase_	:     Dict 						=      (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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     Any=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Dict						):
									lowerCamelCase_	:     Dict 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

							def _inputs_are_equal(lowerCamelCase     :     int       ,      lowerCamelCase     :     List[str]						):
									if len(lowerCamelCase						) != len(lowerCamelCase						):
											return False

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

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

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

							# truncate to smallest
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)

							# truncate to smallest with np
							lowerCamelCase_	:     Optional[int] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'       ,      truncation=lowerCamelCase       ,      )
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     int 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'						)
							lowerCamelCase_	:     Tuple 						=      input_a[input_name]

							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							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(lowerCamelCase						)						)

							# truncate to middle
							lowerCamelCase_	:     Tuple 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     Any 						=      input_a[input_name]

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

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

							# 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(lowerCamelCase						)						)
							self.assertTrue(len(input_a[-1]						) == len(speech_inputs[-1]						)						)

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

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

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

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

							# test truncation for `pad_to_multiple_of` for List[int] + numpy
							lowerCamelCase_	:     str 						=      12
							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      pad_to_multiple_of=lowerCamelCase       ,      truncation=lowerCamelCase       ,      )
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      pad_to_multiple_of=lowerCamelCase       ,      )
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							# retrieve expected_length as multiple of pad_to_multiple_of
							lowerCamelCase_	:     Optional[Any] 						=      len(speech_inputs[0]						)
							if expected_length % pad_to_multiple_of != 0:
									lowerCamelCase_	:     str 						=      ((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(lowerCamelCase						)						)
							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)



					def   __a     (		self     :     Any						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     List[Any]						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     int						):
							self._check_truncation(numpify=lowerCamelCase						)



					def   __a     (		self     :     Optional[int]						):
							self._check_truncation(numpify=lowerCamelCase						)



					@require_torch
					def   __a     (		self     :     str						):
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

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

							lowerCamelCase_	:     int 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     Any						):
							lowerCamelCase_	:     Union[str, Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

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

							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     str						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_dict
							lowerCamelCase_	:     Optional[Any] 						=      True
							lowerCamelCase_	:     Dict 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     Optional[int] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     List[str] 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     List[Any] 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     List[str] 						=      BatchFeature({input_name: speech_inputs}						)

							lowerCamelCase_	:     Tuple 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)
							self.assertIn('attention_mask'       ,      lowerCamelCase						)
							self.assertListEqual(list(processed.attention_mask.shape						)       ,      list(processed[input_name].shape[:2]						)						)
							self.assertListEqual(processed.attention_mask.sum(-1						).tolist()       ,      lowerCamelCase						)





					def   __a     (		self     :     Dict						):
							lowerCamelCase_	:     int 						=      self.feat_extract_dict
							lowerCamelCase_	:     Any 						=      True
							lowerCamelCase_	:     int 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     str 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}						)
							lowerCamelCase_	:     Optional[Any] 						=      min(lowerCamelCase						)

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      truncation=lowerCamelCase       ,      return_tensors='np'						)
							self.assertIn('attention_mask'       ,      lowerCamelCase						)
							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]						)
