


'''simple docstring'''






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    __magic_name__				(						lowerCAmelCase							):
       # to overwrite at feature extractactor specific tests
       UpperCAmelCase		 =None
       UpperCAmelCase		 =None






       @property
       def      lowerCAmelCase						(     self)		->    List[str]:




          '''simple docstring'''
          return self.feat_extract_tester.prepare_feat_extract_dict()






       def      lowerCAmelCase						(     self)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[int]				       =self.feature_extraction_class(**self.feat_extract_dict)
          self.assertTrue(hasattr(snake_case    ,				'feature_size'))
          self.assertTrue(hasattr(snake_case    ,				'sampling_rate'))
          self.assertTrue(hasattr(snake_case    ,				'padding_value'))






       def      lowerCAmelCase						(     self)		->    str:




          '''simple docstring'''
          _UpperCAmelCase  :  str				       =self.feat_extract_tester.prepare_inputs_for_common()
          _UpperCAmelCase  :  Dict				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  List[str]				       =feat_extract.model_input_names[0]

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

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

          _UpperCAmelCase  :  Dict				       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case)
          _UpperCAmelCase  :  List[Any]				       =BatchFeature({input_name: speech_inputs}    ,				tensor_type='np')

          _UpperCAmelCase  :  List[str]				       =processed_features[input_name]

          if len(batch_features_input.shape) < 3:
             _UpperCAmelCase  :  List[str]				       =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      lowerCAmelCase						(     self)		->    Union[str, Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  int				       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case)
          _UpperCAmelCase  :  str				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  Dict				       =feat_extract.model_input_names[0]

          _UpperCAmelCase  :  str				       =BatchFeature({input_name: speech_inputs}    ,				tensor_type='pt')

          _UpperCAmelCase  :  Optional[int]				       =processed_features[input_name]

          if len(batch_features_input.shape) < 3:
             _UpperCAmelCase  :  Dict				       =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      lowerCAmelCase						(     self)		->    List[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =self.feat_extract_tester.prepare_inputs_for_common(equal_length=snake_case)
          _UpperCAmelCase  :  Tuple				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  List[str]				       =feat_extract.model_input_names[0]

          _UpperCAmelCase  :  str				       =BatchFeature({input_name: speech_inputs}    ,				tensor_type='tf')

          _UpperCAmelCase  :  Any				       =processed_features[input_name]

          if len(batch_features_input.shape) < 3:
             _UpperCAmelCase  :  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))






       def      lowerCAmelCase						(     self    ,				snake_case=False)		->    Tuple:




          '''simple docstring'''
          def _inputs_have_equal_length(snake_case):
             _UpperCAmelCase  :  List[str]				       =len(input[0])
             for input_slice in input[1:]:
                if len(snake_case) != length:
                   return False
             return True

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

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

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

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

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

          # test padding for List[int] + numpy
          _UpperCAmelCase  :  List[Any]				       =feat_extract.pad(snake_case    ,				padding=snake_case)
          _UpperCAmelCase  :  int				       =input_a[input_name]

          _UpperCAmelCase  :  List[str]				       =feat_extract.pad(snake_case    ,				padding='longest')
          _UpperCAmelCase  :  Tuple				       =input_a[input_name]

          _UpperCAmelCase  :  Union[str, Any]				       =feat_extract.pad(snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[-1]))
          _UpperCAmelCase  :  Dict				       =input_a[input_name]

          _UpperCAmelCase  :  Tuple				       =feat_extract.pad(snake_case    ,				padding='longest'    ,				return_tensors='np')
          _UpperCAmelCase  :  str				       =input_a[input_name]

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

          _UpperCAmelCase  :  List[str]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=snake_case    ,				return_tensors='np')
          _UpperCAmelCase  :  str				       =input_a[input_name]

          self.assertFalse(_inputs_have_equal_length(snake_case))
          self.assertTrue(_inputs_have_equal_length(snake_case))
          self.assertTrue(_inputs_have_equal_length(snake_case))
          self.assertTrue(_inputs_are_equal(snake_case    ,				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
          _UpperCAmelCase  :  Tuple				       =feat_extract.pad(snake_case    ,				pad_to_multiple_of=1_0)
          _UpperCAmelCase  :  Union[str, Any]				       =input_a[input_name]

          _UpperCAmelCase  :  Any				       =feat_extract.pad(snake_case    ,				padding='longest'    ,				pad_to_multiple_of=1_0)
          _UpperCAmelCase  :  List[str]				       =input_a[input_name]

          _UpperCAmelCase  :  str				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				pad_to_multiple_of=1_0    ,				max_length=snake_case)
          _UpperCAmelCase  :  str				       =input_a[input_name]

          _UpperCAmelCase  :  List[Any]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				pad_to_multiple_of=1_0    ,				max_length=snake_case    ,				return_tensors='np'    ,				)
          _UpperCAmelCase  :  Tuple				       =input_a[input_name]

          self.assertTrue(all(len(snake_case) % 1_0 == 0 for x in input_a))
          self.assertTrue(_inputs_are_equal(snake_case    ,				snake_case))

          _UpperCAmelCase  :  Dict				       =pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
          self.assertTrue(all(len(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
          _UpperCAmelCase  :  List[str]				       =(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      lowerCAmelCase						(     self    ,				snake_case=False)		->    Dict:




          '''simple docstring'''
          def _inputs_have_equal_length(snake_case):
             _UpperCAmelCase  :  str				       =len(input[0])
             for input_slice in input[1:]:
                if len(snake_case) != length:
                   return False
             return True

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

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

          _UpperCAmelCase  :  int				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  Tuple				       =self.feat_extract_tester.prepare_inputs_for_common(numpify=snake_case)
          _UpperCAmelCase  :  Union[str, Any]				       =feat_extract.model_input_names[0]

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

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

          _UpperCAmelCase  :  str				       =feat_extract.pad(snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[0]))
          _UpperCAmelCase  :  Optional[int]				       =input_a[input_name]

          self.assertTrue(_inputs_have_equal_length(snake_case))
          self.assertFalse(_inputs_have_equal_length(snake_case))

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

          _UpperCAmelCase  :  str				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[0])    ,				return_tensors='np')
          _UpperCAmelCase  :  Optional[int]				       =input_a[input_name]

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

          # truncate to middle
          _UpperCAmelCase  :  List[str]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[1])    ,				truncation=snake_case    ,				return_tensors='np'    ,				)
          _UpperCAmelCase  :  Optional[int]				       =input_a[input_name]

          _UpperCAmelCase  :  List[str]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[1])    ,				truncation=snake_case)
          _UpperCAmelCase  :  int				       =input_a[input_name]

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

          self.assertTrue(input_a.shape[1] == len(speech_inputs[1]))
          self.assertTrue(_inputs_have_equal_length(snake_case))
          self.assertTrue(_inputs_have_equal_length(snake_case))
          self.assertTrue(_inputs_are_equal(snake_case    ,				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(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(snake_case):
             feat_extract.pad(snake_case    ,				truncation=snake_case)[input_name]

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

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

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

          # test truncation for `pad_to_multiple_of` for List[int] + numpy
          _UpperCAmelCase  :  Optional[int]				       =1_2
          _UpperCAmelCase  :  Union[str, Any]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[0])    ,				pad_to_multiple_of=snake_case    ,				truncation=snake_case    ,				)
          _UpperCAmelCase  :  Any				       =input_a[input_name]

          _UpperCAmelCase  :  Optional[int]				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=len(speech_inputs[0])    ,				pad_to_multiple_of=snake_case    ,				)
          _UpperCAmelCase  :  int				       =input_a[input_name]

          # retrieve expected_length as multiple of pad_to_multiple_of
          _UpperCAmelCase  :  Dict				       =len(speech_inputs[0])
          if expected_length % pad_to_multiple_of != 0:
             _UpperCAmelCase  :  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(snake_case))
          self.assertFalse(_inputs_have_equal_length(snake_case))






       def      lowerCAmelCase						(     self)		->    Any:




          '''simple docstring'''
          self._check_padding(numpify=snake_case)






       def      lowerCAmelCase						(     self)		->    Tuple:




          '''simple docstring'''
          self._check_padding(numpify=snake_case)






       def      lowerCAmelCase						(     self)		->    List[str]:




          '''simple docstring'''
          self._check_truncation(numpify=snake_case)






       def      lowerCAmelCase						(     self)		->    List[str]:




          '''simple docstring'''
          self._check_truncation(numpify=snake_case)






       @require_torch
       def      lowerCAmelCase						(     self)		->    Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase  :  List[Any]				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  List[str]				       =self.feat_extract_tester.prepare_inputs_for_common()
          _UpperCAmelCase  :  List[str]				       =feat_extract.model_input_names[0]

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

          _UpperCAmelCase  :  str				       =feat_extract.pad(snake_case    ,				padding='longest'    ,				return_tensors='np')[input_name]
          _UpperCAmelCase  :  str				       =feat_extract.pad(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      lowerCAmelCase						(     self)		->    Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase  :  Optional[Any]				       =self.feature_extraction_class(**self.feat_extract_dict)
          _UpperCAmelCase  :  Optional[Any]				       =self.feat_extract_tester.prepare_inputs_for_common()
          _UpperCAmelCase  :  Tuple				       =feat_extract.model_input_names[0]

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

          _UpperCAmelCase  :  str				       =feat_extract.pad(snake_case    ,				padding='longest'    ,				return_tensors='np')[input_name]
          _UpperCAmelCase  :  List[str]				       =feat_extract.pad(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      lowerCAmelCase						(     self)		->    str:




          '''simple docstring'''
          _UpperCAmelCase  :  List[Any]				       =self.feat_extract_dict
          _UpperCAmelCase  :  Union[str, Any]				       =True
          _UpperCAmelCase  :  int				       =self.feature_extraction_class(**snake_case)
          _UpperCAmelCase  :  Dict				       =self.feat_extract_tester.prepare_inputs_for_common()
          _UpperCAmelCase  :  int				       =[len(snake_case) for x in speech_inputs]
          _UpperCAmelCase  :  Dict				       =feat_extract.model_input_names[0]

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

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






       def      lowerCAmelCase						(     self)		->    Any:




          '''simple docstring'''
          _UpperCAmelCase  :  Tuple				       =self.feat_extract_dict
          _UpperCAmelCase  :  Any				       =True
          _UpperCAmelCase  :  Dict				       =self.feature_extraction_class(**snake_case)
          _UpperCAmelCase  :  str				       =self.feat_extract_tester.prepare_inputs_for_common()
          _UpperCAmelCase  :  Dict				       =[len(snake_case) for x in speech_inputs]
          _UpperCAmelCase  :  Optional[Any]				       =feat_extract.model_input_names[0]

          _UpperCAmelCase  :  List[str]				       =BatchFeature({input_name: speech_inputs})
          _UpperCAmelCase  :  Any				       =min(snake_case)

          _UpperCAmelCase  :  str				       =feat_extract.pad(
              snake_case    ,				padding='max_length'    ,				max_length=snake_case    ,				truncation=snake_case    ,				return_tensors='np')
          self.assertIn('attention_mask'    ,				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 typing import Any

import numpy as np





def lowerCamelCase__     (		__lowerCamelCase			:				np.ndarray				):







   '''simple docstring'''




   return np.array_equal(__lowerCamelCase			,       matrix.conjugate().T				)





def lowerCamelCase__     (		__lowerCamelCase			:				np.ndarray			,       __lowerCamelCase			:				np.ndarray				):







   '''simple docstring'''




   _UpperCAmelCase  :  str				       =v.conjugate().T
   _UpperCAmelCase  :  Optional[int]				       =v_star.dot(__lowerCamelCase				)
   assert isinstance(__lowerCamelCase			,       np.ndarray				)
   return (v_star_dot.dot(__lowerCamelCase				)) / (v_star.dot(__lowerCamelCase				))





def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  Optional[Any]				       =np.array([[2, 2 + 1J, 4], [2 - 1J, 3, 1J], [4, -1J, 1]]				)
   _UpperCAmelCase  :  List[str]				       =np.array([[1], [2], [3]]				)
   assert is_hermitian(__lowerCamelCase				), f"{a} is not hermitian."
   print(rayleigh_quotient(__lowerCamelCase			,       __lowerCamelCase				)				)

   _UpperCAmelCase  :  List[str]				       =np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]				)
   assert is_hermitian(__lowerCamelCase				), f"{a} is not hermitian."
   assert rayleigh_quotient(__lowerCamelCase			,       __lowerCamelCase				) == float(3				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 tests()

