


'''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  a     (     _SCREAMING_SNAKE_CASE       ):
 # to overwrite at feature extractactor specific tests
 _lowerCAmelCase 					=	None
 _lowerCAmelCase 					=	None
 @property
 def 							__UpperCAmelCase		( self						)					->							Any:
      return self.feat_extract_tester.prepare_feat_extract_dict()
 def 							__UpperCAmelCase		( self						)					->							List[str]:
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      self.assertTrue(hasattr(__magic_name__      ,				'feature_size'						)						)
      self.assertTrue(hasattr(__magic_name__      ,				'sampling_rate'						)						)
      self.assertTrue(hasattr(__magic_name__      ,				'padding_value'						)						)
 def 							__UpperCAmelCase		( self						)					->							Dict:
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common()
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

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

      _a			      =							self.feat_extract_tester.prepare_inputs_for_common(equal_length=__magic_name__						)
      _a			      =							BatchFeature({input_name: speech_inputs}      ,				tensor_type='np'						)

      _a			      =							processed_features[input_name]

      if len(batch_features_input.shape						) < 3:
           _a			      =							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 							__UpperCAmelCase		( self						)					->							Tuple:
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common(equal_length=__magic_name__						)
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							feat_extract.model_input_names[0]

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

      _a			      =							processed_features[input_name]

      if len(batch_features_input.shape						) < 3:
           _a			      =							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 							__UpperCAmelCase		( self						)					->							Dict:
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common(equal_length=__magic_name__						)
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							feat_extract.model_input_names[0]

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

      _a			      =							processed_features[input_name]

      if len(batch_features_input.shape						) < 3:
           _a			      =							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 							__UpperCAmelCase		( self      ,				__magic_name__=False						)					->							List[str]:
      def _inputs_have_equal_length(__magic_name__						):
           _a			      =							len(input[0]						)
           for input_slice in input[1:]:
                if len(__magic_name__						) != length:
                     return False
           return True

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

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

      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common(numpify=__magic_name__						)
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

      _a			      =							self.feat_extract_tester.seq_length_diff
      _a			      =							self.feat_extract_tester.max_seq_length + pad_diff
      _a			      =							self.feat_extract_tester.min_seq_length
      _a			      =							self.feat_extract_tester.batch_size
      _a			      =							self.feat_extract_tester.feature_size

      # test padding for List[int] + numpy
      _a			      =							feat_extract.pad(__magic_name__      ,				padding=__magic_name__						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='longest'						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[-1]						)						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='longest'      ,				return_tensors='np'						)
      _a			      =							input_a[input_name]

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

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=__magic_name__      ,				return_tensors='np'						)
      _a			      =							input_a[input_name]

      self.assertFalse(_inputs_have_equal_length(__magic_name__						)						)
      self.assertTrue(_inputs_have_equal_length(__magic_name__						)						)
      self.assertTrue(_inputs_have_equal_length(__magic_name__						)						)
      self.assertTrue(_inputs_are_equal(__magic_name__      ,				__magic_name__						)						)
      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
      _a			      =							feat_extract.pad(__magic_name__      ,				pad_to_multiple_of=10						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='longest'      ,				pad_to_multiple_of=10						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				pad_to_multiple_of=10      ,				max_length=__magic_name__						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				pad_to_multiple_of=10      ,				max_length=__magic_name__      ,				return_tensors='np'      ,				)
      _a			      =							input_a[input_name]

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

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

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

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

      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common(numpify=__magic_name__						)
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

      # truncate to smallest
      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[0]						)      ,				truncation=__magic_name__						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[0]						)						)
      _a			      =							input_a[input_name]

      self.assertTrue(_inputs_have_equal_length(__magic_name__						)						)
      self.assertFalse(_inputs_have_equal_length(__magic_name__						)						)

      # truncate to smallest with np
      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[0]						)      ,				return_tensors='np'      ,				truncation=__magic_name__      ,				)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[0]						)      ,				return_tensors='np'						)
      _a			      =							input_a[input_name]

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

      # truncate to middle
      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[1]						)      ,				truncation=__magic_name__      ,				return_tensors='np'      ,				)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[1]						)      ,				truncation=__magic_name__						)
      _a			      =							input_a[input_name]

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[1]						)      ,				return_tensors='np'						)
      _a			      =							input_a[input_name]

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

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

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

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

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

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

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

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=len(speech_inputs[0]						)      ,				pad_to_multiple_of=__magic_name__      ,				)
      _a			      =							input_a[input_name]

      # retrieve expected_length as multiple of pad_to_multiple_of
      _a			      =							len(speech_inputs[0]						)
      if expected_length % pad_to_multiple_of != 0:
           _a			      =							((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(__magic_name__						)						)
      self.assertFalse(_inputs_have_equal_length(__magic_name__						)						)
 def 							__UpperCAmelCase		( self						)					->							int:
      self._check_padding(numpify=__magic_name__						)
 def 							__UpperCAmelCase		( self						)					->							int:
      self._check_padding(numpify=__magic_name__						)
 def 							__UpperCAmelCase		( self						)					->							Union[str, Any]:
      self._check_truncation(numpify=__magic_name__						)
 def 							__UpperCAmelCase		( self						)					->							str:
      self._check_truncation(numpify=__magic_name__						)
 @require_torch
 def 							__UpperCAmelCase		( self						)					->							List[str]:
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common()
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='longest'      ,				return_tensors='np'						)[input_name]
      _a			      =							feat_extract.pad(__magic_name__      ,				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 							__UpperCAmelCase		( self						)					->							Optional[Any]:
      _a			      =							self.feature_extraction_class(**self.feat_extract_dict						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common()
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

      _a			      =							feat_extract.pad(__magic_name__      ,				padding='longest'      ,				return_tensors='np'						)[input_name]
      _a			      =							feat_extract.pad(__magic_name__      ,				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 							__UpperCAmelCase		( self						)					->							Any:
      _a			      =							self.feat_extract_dict
      _a			      =							True
      _a			      =							self.feature_extraction_class(**__magic_name__						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common()
      _a			      =							[len(__magic_name__						) for x in speech_inputs]
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)

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




 def 							__UpperCAmelCase		( self						)					->							Optional[int]:
      _a			      =							self.feat_extract_dict
      _a			      =							True
      _a			      =							self.feature_extraction_class(**__magic_name__						)
      _a			      =							self.feat_extract_tester.prepare_inputs_for_common()
      _a			      =							[len(__magic_name__						) for x in speech_inputs]
      _a			      =							feat_extract.model_input_names[0]

      _a			      =							BatchFeature({input_name: speech_inputs}						)
      _a			      =							min(__magic_name__						)

      _a			      =							feat_extract.pad(
          __magic_name__      ,				padding='max_length'      ,				max_length=__magic_name__      ,				truncation=__magic_name__      ,				return_tensors='np'						)
      self.assertIn('attention_mask'      ,				__magic_name__						)
      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'''






import logging

import numpy as np
import pytest
from scipy.linalg import eigh

logging.basicConfig(level=logging.INFO, format="%(message)s")






def 	_A				(lowerCAmelCase__  :np.ndarray		)   ->  np.ndarray:




     '''simple docstring'''



     return input_array.reshape((input_array.size, 1)		)






def 	_A				(lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :int		)   ->  np.ndarray:




     '''simple docstring'''



     _a			      =							np.nan
     for i in range(lowerCAmelCase__		):
          _a			      =							features[:, labels == i]
          _a			      =							data.mean(1		)
          # Centralize the data of class i
          _a			      =							data - column_reshape(lowerCAmelCase__		)
          if i > 0:
               # If covariance_sum is not None
               covariance_sum += np.dot(lowerCAmelCase__				,						centered_data.T		)
          else:
               # If covariance_sum is np.nan (i.e. first loop)
               _a			      =							np.dot(lowerCAmelCase__				,						centered_data.T		)

     return covariance_sum / features.shape[1]






def 	_A				(lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :int		)   ->  np.ndarray:




     '''simple docstring'''



     _a			      =							features.mean(1		)
     _a			      =							np.nan
     for i in range(lowerCAmelCase__		):
          _a			      =							features[:, labels == i]
          _a			      =							data.shape[1]
          _a			      =							data.mean(1		)
          if i > 0:
               # If covariance_sum is not None
               covariance_sum += device_data * np.dot(
                   column_reshape(lowerCAmelCase__		) - column_reshape(lowerCAmelCase__		)				,						(column_reshape(lowerCAmelCase__		) - column_reshape(lowerCAmelCase__		)).T				,						)
          else:
               # If covariance_sum is np.nan (i.e. first loop)
               _a			      =							device_data * np.dot(
                   column_reshape(lowerCAmelCase__		) - column_reshape(lowerCAmelCase__		)				,						(column_reshape(lowerCAmelCase__		) - column_reshape(lowerCAmelCase__		)).T				,						)

     return covariance_sum / features.shape[1]






def 	_A				(lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :int		)   ->  np.ndarray:




     '''simple docstring'''



     if features.any():
          _a			      =							features.mean(1		)
          # Center the dataset
          _a			      =							features - np.reshape(lowerCAmelCase__				,						(data_mean.size, 1)		)
          _a			      =							np.dot(lowerCAmelCase__				,						centered_data.T		) / features.shape[1]
          _a      ,   _a			      =							np.linalg.eigh(lowerCAmelCase__		)
          # Take all the columns in the reverse order (-1), and then takes only the first
          _a			      =							eigenvectors[:, ::-1][:, 0:dimensions]
          # Project the database on the new space
          _a			      =							np.dot(filtered_eigenvectors.T				,						lowerCAmelCase__		)
          logging.info('Principal Component Analysis computed'		)

          return projected_data
     else:
          logging.basicConfig(level=logging.ERROR				,						format='%(message)s'				,						force=lowerCAmelCase__		)
          logging.error('Dataset empty'		)
          raise AssertionError






def 	_A				(lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :np.ndarray				,						lowerCAmelCase__  :int				,						lowerCAmelCase__  :int		)   ->  np.ndarray:




     '''simple docstring'''



     assert classes > dimensions

     # Check if features have been already loaded
     if features.any:
          _a      ,   _a			      =							eigh(
              covariance_between_classes(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)				,						covariance_within_classes(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)				,						)
          _a			      =							eigenvectors[:, ::-1][:, :dimensions]
          _a      ,   _a      ,   _a			      =							np.linalg.svd(lowerCAmelCase__		)
          _a			      =							svd_matrix[:, 0:dimensions]
          _a			      =							np.dot(filtered_svd_matrix.T				,						lowerCAmelCase__		)
          logging.info('Linear Discriminant Analysis computed'		)

          return projected_data
     else:
          logging.basicConfig(level=logging.ERROR				,						format='%(message)s'				,						force=lowerCAmelCase__		)
          logging.error('Dataset empty'		)
          raise AssertionError






def 	_A				()   ->  None:




     '''simple docstring'''



     _a			      =							np.array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]]		)
     _a			      =							np.array([0, 0, 0, 1, 1]		)
     _a			      =							2
     _a			      =							2

     # Assert that the function raises an AssertionError if dimensions > classes
     with pytest.raises(lowerCAmelCase__		) as error_info:
          _a			      =							linear_discriminant_analysis(
              lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)
          if isinstance(lowerCAmelCase__				,						np.ndarray		):
               raise AssertionError(
                   'Did not raise AssertionError for dimensions > classes'		)
          assert error_info.type is AssertionError






def 	_A				()   ->  None:




     '''simple docstring'''



     _a			      =							np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]		)
     _a			      =							2
     _a			      =							np.array([[6.9_2_8_2_0_3_2_3, 8.6_6_0_2_5_4_0_4, 1_0.3_9_2_3_0_4_8_5], [3.0, 3.0, 3.0]]		)

     with pytest.raises(lowerCAmelCase__		) as error_info:
          _a			      =							principal_component_analysis(lowerCAmelCase__				,						lowerCAmelCase__		)
          if not np.allclose(lowerCAmelCase__				,						lowerCAmelCase__		):
               raise AssertionError
          assert error_info.type is AssertionError


if __name__ == "__main__":
 import doctest

 doctest.testmod()

