



'''simple docstring'''


import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


lowercase							       =			random.Random()






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__=1.0       ,	lowercase__=None       ,	lowercase__=None       ):


     '''simple docstring'''







     if rng is None:
          a_       		=global_rng

     a_       		=[]
     for batch_idx in range(shape[0]       ):
          values.append([]       )
          for _ in range(shape[1]       ):
               values[-1].append(rng.random() * scale       )

     return values







@require_torch
class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 def __init__(   self							,  lowerCAmelCase_							,  lowerCAmelCase_=7							,  lowerCAmelCase_=4_0_0							,  lowerCAmelCase_=2_0_0_0							,  lowerCAmelCase_=1							,  lowerCAmelCase_=0.0							,  lowerCAmelCase_=1_6_0_0_0							,  lowerCAmelCase_=True							,  lowerCAmelCase_=8_0							,  lowerCAmelCase_=1_6							,  lowerCAmelCase_=6_4							,  lowerCAmelCase_="hann_window"							,  lowerCAmelCase_=8_0							,  lowerCAmelCase_=7_6_0_0							,  lowerCAmelCase_=1e-10							,  lowerCAmelCase_=True							,  ) ->      Any:



      """simple docstring"""







      a_       		=parent
      a_       		=batch_size
      a_       		=min_seq_length
      a_       		=max_seq_length
      a_       		=(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      a_       		=feature_size
      a_       		=padding_value
      a_       		=sampling_rate
      a_       		=do_normalize
      a_       		=num_mel_bins
      a_       		=hop_length
      a_       		=win_length
      a_       		=win_function
      a_       		=fmin
      a_       		=fmax
      a_       		=mel_floor
      a_       		=return_attention_mask




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



      """simple docstring"""







      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "do_normalize": self.do_normalize,
          "num_mel_bins": self.num_mel_bins,
          "hop_length": self.hop_length,
          "win_length": self.win_length,
          "win_function": self.win_function,
          "fmin": self.fmin,
          "fmax": self.fmax,
          "mel_floor": self.mel_floor,
          "return_attention_mask": self.return_attention_mask,
      }




 def       lowercase_  (   self							,  lowerCAmelCase_=False							,  lowerCAmelCase_=False) ->      Any:



      """simple docstring"""







      def _flatten(lowerCAmelCase_):
           return list(itertools.chain(*lowerCAmelCase_))

      if equal_length:
           a_       		=floats_list((self.batch_size, self.max_seq_length))
      else:
           # make sure that inputs increase in size
           a_       		=[
               _flatten(floats_list((x, self.feature_size)))
               for x in range(self.min_seq_length							,  self.max_seq_length							,  self.seq_length_diff)
           ]

      if numpify:
           a_       		=[np.asarray(lowerCAmelCase_) for x in speech_inputs]

      return speech_inputs




 def       lowercase_  (   self							,  lowerCAmelCase_=False							,  lowerCAmelCase_=False) ->      Any:



      """simple docstring"""







      if equal_length:
           a_       		=[floats_list((self.max_seq_length, self.num_mel_bins)) for _ in range(self.batch_size)]
      else:
           # make sure that inputs increase in size
           a_       		=[
               floats_list((x, self.num_mel_bins))
               for x in range(self.min_seq_length							,  self.max_seq_length							,  self.seq_length_diff)
           ]

      if numpify:
           a_       		=[np.asarray(lowerCAmelCase_) for x in speech_inputs]

      return speech_inputs







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


 '''simple docstring'''




 __magic_name__					: int  =      SpeechTaFeatureExtractor




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=SpeechTaFeatureExtractionTester(self)




 def       lowercase_  (   self							,  lowerCAmelCase_) ->      Union[str, Any]:



      """simple docstring"""







      self.assertTrue(np.all(np.mean(lowerCAmelCase_							,  axis=0) < 1e-3))
      self.assertTrue(np.all(np.abs(np.var(lowerCAmelCase_							,  axis=0) - 1) < 1e-3))




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



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      # create three inputs of length 800, 1000, and 1200
      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]
      a_       		=[np.asarray(lowerCAmelCase_) for speech_input in speech_inputs]

      # Test not batched input
      a_       		=feat_extract(speech_inputs[0]							,  return_tensors="np").input_values
      a_       		=feat_extract(np_speech_inputs[0]							,  return_tensors="np").input_values
      self.assertTrue(np.allclose(lowerCAmelCase_							,  lowerCAmelCase_							,  atol=1e-3))

      # Test batched
      a_       		=feat_extract(lowerCAmelCase_							,  return_tensors="np").input_values
      a_       		=feat_extract(lowerCAmelCase_							,  return_tensors="np").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_							,  lowerCAmelCase_):
           self.assertTrue(np.allclose(lowerCAmelCase_							,  lowerCAmelCase_							,  atol=1e-3))




 def       lowercase_  (   self) ->      List[Any]:



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]

      a_       		=["longest", "max_length", "do_not_pad"]
      a_       		=[None, 1_6_0_0, None]
      for max_length, padding in zip(lowerCAmelCase_							,  lowerCAmelCase_):
           a_       		=feat_extract(lowerCAmelCase_							,  padding=lowerCAmelCase_							,  max_length=lowerCAmelCase_							,  return_tensors="np")
           a_       		=processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
           self.assertTrue(input_values[0][8_0_0:].sum() < 1e-6)
           self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
           self.assertTrue(input_values[0][1_0_0_0:].sum() < 1e-6)
           self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      a_       		=range(8_0_0							,  1_4_0_0							,  2_0_0)
      a_       		=[floats_list((1, x))[0] for x in lengths]

      a_       		=["longest", "max_length", "do_not_pad"]
      a_       		=[None, 1_6_0_0, None]

      for max_length, padding in zip(lowerCAmelCase_							,  lowerCAmelCase_):
           a_       		=feat_extract(lowerCAmelCase_							,  max_length=lowerCAmelCase_							,  padding=lowerCAmelCase_)
           a_       		=processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:8_0_0])
           self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0])
           self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0])




 def       lowercase_  (   self) ->      Union[str, Any]:



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]
      a_       		=feat_extract(
          lowerCAmelCase_							,  truncation=lowerCAmelCase_							,  max_length=1_0_0_0							,  padding="max_length"							,  return_tensors="np")
      a_       		=processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1])
      self._check_zero_mean_unit_variance(input_values[2])




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



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]
      a_       		=feat_extract(
          lowerCAmelCase_							,  truncation=lowerCAmelCase_							,  max_length=1_0_0_0							,  padding="longest"							,  return_tensors="np")
      a_       		=processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
      self._check_zero_mean_unit_variance(input_values[2])

      # make sure that if max_length < longest -> then pad to max_length
      self.assertTrue(input_values.shape == (3, 1_0_0_0))

      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]
      a_       		=feat_extract(
          lowerCAmelCase_							,  truncation=lowerCAmelCase_							,  max_length=2_0_0_0							,  padding="longest"							,  return_tensors="np")
      a_       		=processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :8_0_0])
      self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0])
      self._check_zero_mean_unit_variance(input_values[2])

      # make sure that if max_length > longest -> then pad to longest
      self.assertTrue(input_values.shape == (3, 1_2_0_0))




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      a_       		=np.random.rand(1_0_0).astype(np.floataa)
      a_       		=np_speech_inputs.tolist()

      for inputs in [py_speech_inputs, np_speech_inputs]:
           a_       		=feature_extractor.pad([{"input_values": inputs}]							,  return_tensors="np")
           self.assertTrue(np_processed.input_values.dtype == np.floataa)
           a_       		=feature_extractor.pad([{"input_values": inputs}]							,  return_tensors="pt")
           self.assertTrue(pt_processed.input_values.dtype == torch.floataa)




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



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
      # create three inputs of length 800, 1000, and 1200
      a_       		=[floats_list((1, x))[0] for x in range(8_0_0							,  1_4_0_0							,  2_0_0)]
      a_       		=[np.asarray(lowerCAmelCase_) for speech_input in speech_inputs]

      # Test feature size
      a_       		=feature_extractor(audio_target=lowerCAmelCase_							,  padding=lowerCAmelCase_							,  return_tensors="np").input_values
      self.assertTrue(input_values.ndim == 3)
      self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins)

      # Test not batched input
      a_       		=feature_extractor(speech_inputs[0]							,  return_tensors="np").input_values
      a_       		=feature_extractor(np_speech_inputs[0]							,  return_tensors="np").input_values
      self.assertTrue(np.allclose(lowerCAmelCase_							,  lowerCAmelCase_							,  atol=1e-3))

      # Test batched
      a_       		=feature_extractor(lowerCAmelCase_							,  return_tensors="np").input_values
      a_       		=feature_extractor(lowerCAmelCase_							,  return_tensors="np").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_							,  lowerCAmelCase_):
           self.assertTrue(np.allclose(lowerCAmelCase_							,  lowerCAmelCase_							,  atol=1e-3))

      # Test 2-D numpy arrays are batched.
      a_       		=[floats_list((1, x))[0] for x in (8_0_0, 8_0_0, 8_0_0)]
      a_       		=np.asarray(lowerCAmelCase_)
      a_       		=feature_extractor(lowerCAmelCase_							,  return_tensors="np").input_values
      a_       		=feature_extractor(lowerCAmelCase_							,  return_tensors="np").input_values
      for enc_seq_a, enc_seq_a in zip(lowerCAmelCase_							,  lowerCAmelCase_):
           self.assertTrue(np.allclose(lowerCAmelCase_							,  lowerCAmelCase_							,  atol=1e-3))




 def       lowercase_  (   self) ->      int:



      """simple docstring"""







      a_       		=self.feat_extract_tester.prepare_inputs_for_target()
      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(lowerCAmelCase_) == len(lowerCAmelCase_) for x, y in zip(lowerCAmelCase_							,  processed_features[input_name])))

      a_       		=self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_)
      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.num_mel_bins))




 @require_torch
 def       lowercase_  (   self) ->      Optional[int]:



      """simple docstring"""







      a_       		=self.feat_extract_tester.prepare_inputs_for_target(equal_length=lowerCAmelCase_)
      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.num_mel_bins))




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



      """simple docstring"""







      a_       		=self.feature_extraction_class(**self.feat_extract_dict)
      a_       		=self.feat_extract_tester.prepare_inputs_for_target()
      a_       		=feat_extract.model_input_names[0]

      a_       		=BatchFeature({input_name: speech_inputs})

      a_       		=feat_extract.num_mel_bins  # hack!

      a_       		=feat_extract.pad(lowerCAmelCase_							,  padding="longest"							,  return_tensors="np")[input_name]
      a_       		=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)




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=self.feat_extract_dict
      a_       		=True
      a_       		=self.feature_extraction_class(**lowerCAmelCase_)
      a_       		=self.feat_extract_tester.prepare_inputs_for_target()
      a_       		=[len(lowerCAmelCase_) for x in speech_inputs]
      a_       		=feat_extract.model_input_names[0]

      a_       		=BatchFeature({input_name: speech_inputs})

      a_       		=feat_extract.num_mel_bins  # hack!

      a_       		=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       lowercase_  (   self) ->      Union[str, Any]:



      """simple docstring"""







      a_       		=self.feat_extract_dict
      a_       		=True
      a_       		=self.feature_extraction_class(**lowerCAmelCase_)
      a_       		=self.feat_extract_tester.prepare_inputs_for_target()
      a_       		=[len(lowerCAmelCase_) for x in speech_inputs]
      a_       		=feat_extract.model_input_names[0]

      a_       		=BatchFeature({input_name: speech_inputs})
      a_       		=min(lowerCAmelCase_)

      a_       		=feat_extract.num_mel_bins  # hack!

      a_       		=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])




 def       lowercase_  (   self							,  lowerCAmelCase_) ->      Union[str, Any]:



      """simple docstring"""







      from datasets import load_dataset

      a_       		=load_dataset("hf-internal-testing/librispeech_asr_dummy"							,  "clean"							,  split="validation")
      # automatic decoding with librispeech
      a_       		=ds.sort("id").select(range(lowerCAmelCase_))[:num_samples]["audio"]

      return [x["array"] for x in speech_samples]




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=torch.tensor(
          [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
           3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
           2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
           4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
           7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
           4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03])
      # fmt: on

      a_       		=self._load_datasamples(1)
      a_       		=SpeechTaFeatureExtractor()
      a_       		=feature_extractor(lowerCAmelCase_							,  return_tensors="pt").input_values
      self.assertEquals(input_values.shape							,  (1, 9_3_6_8_0))
      self.assertTrue(torch.allclose(input_values[0, :3_0]							,  lowerCAmelCase_							,  atol=1e-6))




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=torch.tensor(
          [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
           -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
           -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
           -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8])
      # fmt: on

      a_       		=self._load_datasamples(1)
      a_       		=SpeechTaFeatureExtractor()
      a_       		=feature_extractor(audio_target=lowerCAmelCase_							,  return_tensors="pt").input_values
      self.assertEquals(input_values.shape							,  (1, 3_6_6, 8_0))
      self.assertTrue(torch.allclose(input_values[0, 0, :3_0]							,  lowerCAmelCase_							,  atol=1e-4))







'''simple docstring'''


from typing import Any

import numpy as np






def  UpperCAmelCase_       (		lowercase__       ):


     '''simple docstring'''







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






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     a_       		=v.conjugate().T
     a_       		=v_star.dot(lowercase__       )
     assert isinstance(lowercase__       ,	np.ndarray       )
     return (v_star_dot.dot(lowercase__       )) / (v_star.dot(lowercase__       ))






def  UpperCAmelCase_       (		):


     '''simple docstring'''







     a_       		=np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]       )
     a_       		=np.array([[1], [2], [3]]       )
     assert is_hermitian(lowercase__       ), F"""{a} is not hermitian."""
     print(rayleigh_quotient(lowercase__       ,	lowercase__       )       )

     a_       		=np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]       )
     assert is_hermitian(lowercase__       ), F"""{a} is not hermitian."""
     assert rayleigh_quotient(lowercase__       ,	lowercase__       ) == float(3       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  tests()


