




import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
 import tensorflow as tf
 from tensorflow.python.eager import context
 from tensorflow.python.framework import ops

 from transformers import GradientAccumulator, create_optimizer

@require_tf
class  _lowerCamelCase						(			unittest.TestCase   ):

      """simple docstring"""

      def       snake_case	(     self					: Union[str, Any] ,       snake_case					: List[Any] ,       snake_case					: Tuple ,       snake_case					: Union[str, Any]				):
          self.assertEqual(len(snake_case				) ,       len(snake_case				)				)
          for a, b in zip(snake_case ,       snake_case				):
              self.assertAlmostEqual(snake_case ,       snake_case ,       delta=snake_case				)







      def       snake_case	(     self					: Tuple				):
          __UpperCamelCase  		=						GradientAccumulator()
          accumulator([tf.constant([1.0, 2.0]				)]				)
          accumulator([tf.constant([-2.0, 1.0]				)]				)
          accumulator([tf.constant([-1.0, 2.0]				)]				)
          with self.assertRaises(snake_case				):
              accumulator([tf.constant([1.0, 1.0]				), tf.constant([2.0, 2.0]				)]				)
          self.assertEqual(accumulator.step ,       3				)
          self.assertEqual(len(accumulator.gradients				) ,       1				)
          self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist() ,       [-2.0, 5.0] ,       tol=1E-2				)
          accumulator.reset()
          self.assertEqual(accumulator.step ,       0				)
          self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist() ,       [0.0, 0.0] ,       tol=1E-2				)







      def       snake_case	(     self					: int				):
          __UpperCamelCase  		=						None
          ops.enable_eager_execution_internal()
          __UpperCamelCase  		=						tf.config.list_physical_devices('''CPU'''				)
          if len(snake_case				) == 1:
              tf.config.set_logical_device_configuration(
                  physical_devices[0] ,       [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]				)
          __UpperCamelCase  		=						tf.config.list_logical_devices(device_type='''CPU'''				)
          __UpperCamelCase  		=						tf.distribute.MirroredStrategy(devices=devices[:2]				)

          with strategy.scope():
              __UpperCamelCase  		=						GradientAccumulator()
              __UpperCamelCase  		=						tf.Variable([4.0, 3.0]				)
              __UpperCamelCase		,      __UpperCamelCase  		=						create_optimizer(5E-5 ,       10 ,       5				)
              __UpperCamelCase  		=						tf.Variable([0.0, 0.0] ,       trainable=snake_case				)

          def accumulate_on_replica(snake_case					: Dict				):
              accumulator([gradient]				)

          def apply_on_replica():
              optimizer.apply_gradients(list(zip(accumulator.gradients ,       [variable]				)				)				)

          @tf.function
          def accumulate(snake_case					: List[Any] ,       snake_case					: Optional[int]				):
              with strategy.scope():
                  __UpperCamelCase  		=						strategy.experimental_local_results(snake_case				)
                  local_variables[0].assign(snake_case				)
                  local_variables[1].assign(snake_case				)
                  strategy.run(snake_case ,       args=(gradient_placeholder,)				)

          @tf.function
          def apply_grad():
              with strategy.scope():
                  strategy.run(snake_case				)

          def _check_local_values(snake_case					: Any ,       snake_case					: Dict				):
              __UpperCamelCase  		=						strategy.experimental_local_results(accumulator._gradients[0]				)
              self.assertListAlmostEqual(values[0].value() ,       snake_case ,       tol=1E-2				)
              self.assertListAlmostEqual(values[1].value() ,       snake_case ,       tol=1E-2				)

          accumulate([1.0, 2.0] ,       [-1.0, 1.0]				)
          accumulate([3.0, -1.0] ,       [-1.0, -1.0]				)
          accumulate([-2.0, 2.0] ,       [3.0, -2.0]				)
          self.assertEqual(accumulator.step ,       3				)
          _check_local_values([2.0, 3.0] ,       [1.0, -2.0]				)
          apply_grad()
          self.assertListAlmostEqual(variable.value() ,       [4.0, 3.0] ,       tol=1E-2				)
          accumulator.reset()
          self.assertEqual(accumulator.step ,       0				)
          _check_local_values([0.0, 0.0] ,       [0.0, 0.0]				)












import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np
import torch

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


a_   		=     logging.get_logger(__name__)

class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      lowerCAmelCase__			: Dict    =					["input_features", "is_longer"]







      def __init__(     self					: Dict ,       snake_case					: int=64 ,       snake_case					: Dict=48000 ,       snake_case					: Tuple=480 ,       snake_case					: Optional[Any]=10 ,       snake_case					: Union[str, Any]=1024 ,       snake_case					: Union[str, Any]=0.0 ,       snake_case					: List[str]=False ,       snake_case					: float = 0 ,       snake_case					: float = 14000 ,       snake_case					: int = None ,       snake_case					: str = "fusion" ,       snake_case					: str = "repeatpad" ,       **snake_case					: int ,       ):
          super().__init__(
              feature_size=snake_case ,       sampling_rate=snake_case ,       padding_value=snake_case ,       return_attention_mask=snake_case ,       **snake_case ,       )
          __UpperCamelCase  		=						top_db
          __UpperCamelCase  		=						truncation
          __UpperCamelCase  		=						padding
          __UpperCamelCase  		=						fft_window_size
          __UpperCamelCase  		=						(fft_window_size >> 1) + 1
          __UpperCamelCase  		=						hop_length
          __UpperCamelCase  		=						max_length_s
          __UpperCamelCase  		=						max_length_s * sampling_rate
          __UpperCamelCase  		=						sampling_rate
          __UpperCamelCase  		=						frequency_min
          __UpperCamelCase  		=						frequency_max
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm=snake_case ,       mel_scale='''htk''' ,       )
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm='''slaney''' ,       mel_scale='''slaney''' ,       )







      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						copy.deepcopy(self.__dict__				)
          __UpperCamelCase  		=						self.__class__.__name__
          if "mel_filters" in output:
              del output["mel_filters"]
          if "mel_filters_slaney" in output:
              del output["mel_filters_slaney"]
          return output







      def       snake_case	(     self					: Tuple ,       snake_case					: np.array ,       snake_case					: Optional[np.array] = None				):
          __UpperCamelCase  		=						spectrogram(
              snake_case ,       window_function(self.fft_window_size ,       '''hann'''				) ,       frame_length=self.fft_window_size ,       hop_length=self.hop_length ,       power=2.0 ,       mel_filters=snake_case ,       log_mel='''dB''' ,       )
          return log_mel_spectrogram.T







      def       snake_case	(     self					: Optional[int] ,       snake_case					: Any ,       snake_case					: List[Any] ,       snake_case					: int				):
          __UpperCamelCase  		=						np.array_split(list(range(0 ,       total_frames - chunk_frames + 1				)				) ,       3				)
          if len(ranges[1]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          if len(ranges[2]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          # randomly choose index for each part
          __UpperCamelCase  		=						np.random.choice(ranges[0]				)
          __UpperCamelCase  		=						np.random.choice(ranges[1]				)
          __UpperCamelCase  		=						np.random.choice(ranges[2]				)

          __UpperCamelCase  		=						mel[idx_front : idx_front + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_middle : idx_middle + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_back : idx_back + chunk_frames, :]

          __UpperCamelCase  		=						torch.tensor(mel[None, None, :]				)
          __UpperCamelCase  		=						torch.nn.functional.interpolate(
              snake_case ,       size=[chunk_frames, 64] ,       mode='''bilinear''' ,       align_corners=snake_case				)
          __UpperCamelCase  		=						mel_shrink[0][0].numpy()
          __UpperCamelCase  		=						np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,       axis=0				)
          return mel_fusion







      def       snake_case	(     self					: Optional[Any] ,       snake_case					: np.array ,       snake_case					: Optional[int] ,       snake_case					: Tuple ,       snake_case					: str				):
          if waveform.shape[0] > max_length:
              if truncation == "rand_trunc":
                  __UpperCamelCase  		=						True
                  # random crop to max_length (for compatibility) -> this should be handled by self.pad
                  __UpperCamelCase  		=						len(snake_case				) - max_length
                  __UpperCamelCase  		=						np.random.randint(0 ,       overflow + 1				)
                  __UpperCamelCase  		=						waveform[idx : idx + max_length]
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]
              elif truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
                  __UpperCamelCase  		=						mel.shape[0]
                  if chunk_frames == total_frames:
                      # there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
                      # In this case, we just use the whole audio.
                      __UpperCamelCase  		=						np.stack([mel, mel, mel, mel] ,       axis=0				)
                      __UpperCamelCase  		=						False
                  else:
                      __UpperCamelCase  		=						self._random_mel_fusion(snake_case ,       snake_case ,       snake_case				)
                      __UpperCamelCase  		=						True
              else:
                  raise NotImplementedError(F"data_truncating {truncation} not implemented"				)

          else:
              __UpperCamelCase  		=						False
              # only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
              if waveform.shape[0] < max_length:
                  if padding == "repeat":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       n_repeat + 1				)				)[:max_length]
                  if padding == "repeatpad":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       snake_case				)				)
                  __UpperCamelCase  		=						np.pad(snake_case ,       (0, max_length - waveform.shape[0]) ,       mode='''constant''' ,       constant_values=0				)

              if truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						np.stack([input_mel, input_mel, input_mel, input_mel] ,       axis=0				)
              else:
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]

          return input_mel, longer







      def __call__(     self					: List[str] ,       snake_case					: Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,       snake_case					: str = None ,       snake_case					: Optional[str] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[Union[str, TensorType]] = None ,       **snake_case					: Any ,       ):
          __UpperCamelCase  		=						truncation if truncation is not None else self.truncation
          __UpperCamelCase  		=						padding if padding else self.padding

          if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                  raise ValueError(
                      F"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
                      F" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
                      F" was sampled with {self.sampling_rate} and not {sampling_rate}."				)
          else:
              logger.warning(
                  '''It is strongly recommended to pass the `sampling_rate` argument to this function. '''
                  '''Failing to do so can result in silent errors that might be hard to debug.'''				)

          __UpperCamelCase  		=						isinstance(snake_case ,       np.ndarray				) and len(raw_speech.shape				) > 1
          if is_batched_numpy and len(raw_speech.shape				) > 2:
              raise ValueError(F"Only mono-channel audio is supported for input to {self}"				)
          __UpperCamelCase  		=						is_batched_numpy or (
              isinstance(snake_case ,       (list, tuple)				) and (isinstance(raw_speech[0] ,       (np.ndarray, tuple, list)				))
          )

          if is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for speech in raw_speech]
          elif not is_batched and not isinstance(snake_case ,       np.ndarray				):
              __UpperCamelCase  		=						np.asarray(snake_case ,       dtype=np.floataa				)
          elif isinstance(snake_case ,       np.ndarray				) and raw_speech.dtype is np.dtype(np.floataa				):
              __UpperCamelCase  		=						raw_speech.astype(np.floataa				)

          # always return batch
          if not is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case				)]

          # convert to mel spectrogram, truncate and pad if needed.
          __UpperCamelCase  		=						[
              self._get_input_mel(snake_case ,       max_length if max_length else self.nb_max_samples ,       snake_case ,       snake_case				)
              for waveform in raw_speech
          ]

          __UpperCamelCase  		=						[]
          __UpperCamelCase  		=						[]
          for mel, longer in padded_inputs:
              input_mel.append(snake_case				)
              is_longer.append(snake_case				)

          if truncation == "fusion" and sum(snake_case				) == 0:
              # if no audio is longer than 10s, then randomly select one audio to be longer
              __UpperCamelCase  		=						np.random.randint(0 ,       len(snake_case				)				)
              __UpperCamelCase  		=						True

          if isinstance(input_mel[0] ,       snake_case				):
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for feature in input_mel]

          # is_longer is a list of bool
          __UpperCamelCase  		=						[[longer] for longer in is_longer]

          __UpperCamelCase  		=						{'''input_features''': input_mel, '''is_longer''': is_longer}
          __UpperCamelCase  		=						BatchFeature(snake_case				)

          if return_tensors is not None:
              __UpperCamelCase  		=						input_features.convert_to_tensors(snake_case				)

          return input_features






