"""simple docstring"""


import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
 import tensorflow as tf
 from tensorflow.python.framework.errors_impl import ResourceExhaustedError

 from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
 import pyanvml.pyanvml as nvml

lowerCAmelCase_:					Dict     =					logging.get_logger(__name__)







def 					__a   (		A    ,				A      ):






     '''simple docstring'''



     def run_func(A      ):
          @wraps(A      )
          def run_in_eager_mode(*A    ,				**A      ):
               return func(*A    ,				**A      )

          @wraps(A      )
          @tf.function(experimental_compile=A      )
          def run_in_graph_mode(*A    ,				**A      ):
               return func(*A    ,				**A      )

          if do_eager_mode is True:
               if use_xla is not False:
                    raise ValueError(
                        "Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`."      )
               return run_in_eager_mode
          else:
               return run_in_graph_mode

     return run_func







def 					__a   (		A    ,				A    ,				A      ):






     '''simple docstring'''



     lowercase__				 =							random.Random()
     lowercase__				 =							[rng.randint(0    ,				vocab_size - 1      ) for i in range(batch_size * sequence_length      )]
     return tf.constant(A    ,				shape=(batch_size, sequence_length)    ,				dtype=tf.intaa      )






class    a__    (   _a	):
   snake_case_							=      42
   snake_case_							=      42
   snake_case_							=      "TensorFlow"


   @property
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        return tf.__version__


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.args.strategy
        if strategy is None:
             raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
        lowercase__				 =							self._prepare_inference_func(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )
        return self._measure_speed(_inference  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.args.strategy
        if strategy is None:
             raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
        lowercase__				 =							self._prepare_train_func(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )
        return self._measure_speed(_train  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        if self.args.is_gpu:
             tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx],				_UpperCAmelCase  )
        lowercase__				 =							self.args.strategy
        if strategy is None:
             raise ValueError("A device strategy has to be initialized before using TensorFlow."  )
        lowercase__				 =							self._prepare_inference_func(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )
        return self._measure_memory(_inference  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        if self.args.is_gpu:
             tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx],				_UpperCAmelCase  )
        lowercase__				 =							self.args.strategy
        if strategy is None:
             raise ValueError("A device strategy has to be initialized before using TensorFlow."  )

        lowercase__				 =							self._prepare_train_func(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )
        return self._measure_memory(_train  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.config_dict[model_name]

        if self.args.fpaa:
             raise NotImplementedError("Mixed precision is currently not supported."  )

        lowercase__				 =							(
            hasattr(_UpperCAmelCase,				"architectures"  )
            and isinstance(config.architectures,				_UpperCAmelCase  )
            and len(config.architectures  ) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
             try:
                  lowercase__				 =							"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
                  lowercase__				 =							__import__("transformers",				fromlist=[model_class]  )
                  lowercase__				 =							getattr(_UpperCAmelCase,				_UpperCAmelCase  )
                  lowercase__				 =							model_cls(_UpperCAmelCase  )
             except ImportError:
                  raise ImportError(
                      F'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                      " set `--only_pretrain_model` or `args.only_pretrain_model=True`."  )
        else:
             lowercase__				 =							TF_MODEL_MAPPING[config.__class__](_UpperCAmelCase  )

        # encoder-decoder has vocab size saved differently
        lowercase__				 =							config.vocab_size if hasattr(_UpperCAmelCase,				"vocab_size"  ) else config.encoder.vocab_size
        lowercase__				 =							random_input_ids(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )

        @run_with_tf_optimizations(self.args.eager_mode,				self.args.use_xla  )
        def encoder_decoder_forward():
             return model(_UpperCAmelCase,				decoder_input_ids=_UpperCAmelCase,				training=_UpperCAmelCase  )

        @run_with_tf_optimizations(self.args.eager_mode,				self.args.use_xla  )
        def encoder_forward():
             return model(_UpperCAmelCase,				training=_UpperCAmelCase  )

        lowercase__				 =							encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

        return _inference


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.config_dict[model_name]

        if self.args.eager_mode is not False:
             raise ValueError("Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`."  )

        if self.args.fpaa:
             raise NotImplementedError("Mixed precision is currently not supported."  )

        lowercase__				 =							(
            hasattr(_UpperCAmelCase,				"architectures"  )
            and isinstance(config.architectures,				_UpperCAmelCase  )
            and len(config.architectures  ) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
             try:
                  lowercase__				 =							"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
                  lowercase__				 =							__import__("transformers",				fromlist=[model_class]  )
                  lowercase__				 =							getattr(_UpperCAmelCase,				_UpperCAmelCase  )
                  lowercase__				 =							model_cls(_UpperCAmelCase  )
             except ImportError:
                  raise ImportError(
                      F'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
                      " set `--only_pretrain_model` or `args.only_pretrain_model=True`."  )
        else:
             lowercase__				 =							TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_UpperCAmelCase  )

        # encoder-decoder has vocab size saved differently
        lowercase__				 =							config.vocab_size if hasattr(_UpperCAmelCase,				"vocab_size"  ) else config.encoder.vocab_size
        lowercase__				 =							random_input_ids(_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  )

        @run_with_tf_optimizations(self.args.eager_mode,				self.args.use_xla  )
        def encoder_decoder_train():
             lowercase__				 =							model(_UpperCAmelCase,				decoder_input_ids=_UpperCAmelCase,				labels=_UpperCAmelCase,				training=_UpperCAmelCase  )[0]
             lowercase__				 =							tf.gradients(_UpperCAmelCase,				model.trainable_variables  )
             return gradients

        @run_with_tf_optimizations(self.args.eager_mode,				self.args.use_xla  )
        def encoder_train():
             lowercase__				 =							model(_UpperCAmelCase,				labels=_UpperCAmelCase,				training=_UpperCAmelCase  )[0]
             lowercase__				 =							tf.gradients(_UpperCAmelCase,				model.trainable_variables  )
             return gradients

        lowercase__				 =							encoder_decoder_train if config.is_encoder_decoder else encoder_train

        return _train


   def 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''simple docstring'''



        with self.args.strategy.scope():
             try:
                  if self.args.is_tpu or self.args.use_xla:
                       # run additional 10 times to stabilize compilation for tpu
                       logger.info("Do inference on TPU. Running model 5 times to stabilize compilation"  )
                       timeit.repeat(_UpperCAmelCase,				repeat=1,				number=5  )

                  # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
                  lowercase__				 =							timeit.repeat(
                      _UpperCAmelCase,				repeat=self.args.repeat,				number=10,				)

                  return min(_UpperCAmelCase  ) / 10.0
             except ResourceExhaustedError as e:
                  self.print_fn(F'''Doesn\'t fit on GPU. {e}'''  )


   def 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''simple docstring'''



        logger.info(
            "Note that TensorFlow allocates more memory than "
            "it might need to speed up computation. "
            "The memory reported here corresponds to the memory "
            "reported by `nvidia-smi`, which can vary depending "
            "on total available memory on the GPU that is used."  )
        with self.args.strategy.scope():
             try:
                  if self.args.trace_memory_line_by_line:
                       if not self.args.eager_mode:
                            raise ValueError(
                                "`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory"
                                " consumption line by line."  )
                       lowercase__				 =							start_memory_tracing("transformers"  )

                  if self.args.is_tpu:
                       # tpu
                       raise NotImplementedError(
                           "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking"
                           " with `args.memory=False`"  )
                  elif self.args.is_gpu:
                       # gpu
                       if not is_pyanvml_available():
                            logger.warning(
                                "py3nvml not installed, we won't log GPU memory usage. "
                                "Install py3nvml (pip install py3nvml) to log information about GPU."  )
                            lowercase__				 =							"N/A"
                       else:
                            logger.info(
                                "Measuring total GPU usage on GPU device. Make sure to not have additional processes"
                                " running on the same GPU."  )
                            # init nvml
                            nvml.nvmlInit()
                            func()
                            lowercase__				 =							nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx  )
                            lowercase__				 =							nvml.nvmlDeviceGetMemoryInfo(_UpperCAmelCase  )
                            lowercase__				 =							meminfo.used
                            lowercase__				 =							Memory(_UpperCAmelCase  )
                            # shutdown nvml
                            nvml.nvmlShutdown()
                  else:
                       # cpu
                       if self.args.trace_memory_line_by_line:
                            logger.info(
                                "When enabling line by line tracing, the max peak memory for CPU is inaccurate in"
                                " TensorFlow."  )
                            lowercase__				 =							None
                       else:
                            lowercase__				 =							measure_peak_memory_cpu(_UpperCAmelCase  )
                            lowercase__				 =							Memory(_UpperCAmelCase  ) if isinstance(_UpperCAmelCase,				_UpperCAmelCase  ) else memory_bytes
                  if self.args.trace_memory_line_by_line:
                       lowercase__				 =							stop_memory_tracing(_UpperCAmelCase  )
                       if memory is None:
                            lowercase__				 =							summary.total
                  else:
                       lowercase__				 =							None

                  return memory, summary
             except ResourceExhaustedError as e:
                  self.print_fn(F'''Doesn\'t fit on GPU. {e}'''  )
                  return "N/A", None





"""simple docstring"""


from math import ceil
from typing import List, Optional, Union

import numpy as np

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


lowerCAmelCase_:					Union[str, Any]     =					logging.get_logger(__name__)






class    a__    (   _a	):
   snake_case_							=      ["audio_values", "audio_mask"]


   def __init__(     self,				_UpperCAmelCase=2048,				_UpperCAmelCase=1,				_UpperCAmelCase=[16, 16],				_UpperCAmelCase=128,				_UpperCAmelCase=4_4100,				_UpperCAmelCase=86,				_UpperCAmelCase=2048,				_UpperCAmelCase=0.0,				**_UpperCAmelCase,				):
        '''simple docstring'''



        super().__init__(
            feature_size=_UpperCAmelCase,				sampling_rate=_UpperCAmelCase,				padding_value=_UpperCAmelCase,				**_UpperCAmelCase,				)

        lowercase__				 =							spectrogram_length
        lowercase__				 =							num_channels
        lowercase__				 =							patch_size
        lowercase__				 =							feature_size // self.patch_size[1]
        lowercase__				 =							n_fft
        lowercase__				 =							sampling_rate // hop_length_to_sampling_rate
        lowercase__				 =							sampling_rate
        lowercase__				 =							padding_value
        lowercase__				 =							mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2,				num_mel_filters=_UpperCAmelCase,				min_frequency=0.0,				max_frequency=22_050.0,				sampling_rate=_UpperCAmelCase,				norm="slaney",				mel_scale="slaney",				).T


   def 	snake_case__	(     self,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							spectrogram(
            _UpperCAmelCase,				window_function(self.n_fft,				"hann"  ),				frame_length=self.n_fft,				hop_length=self.hop_length,				power=2.0,				mel_filters=self.mel_filters.T,				log_mel="dB",				db_range=80.0,				)
        lowercase__				 =							log_spec[:, :-1]
        lowercase__				 =							log_spec - 20.0
        lowercase__				 =							np.clip(log_spec / 40.0,				-2.0,				0.0  ) + 1.0
        return log_spec


   def __call__(     self,				_UpperCAmelCase,				_UpperCAmelCase = None,				_UpperCAmelCase = True,				_UpperCAmelCase = None,				_UpperCAmelCase = False,				_UpperCAmelCase = False,				**_UpperCAmelCase,				):
        '''simple docstring'''



        if sampling_rate is not None:
             if sampling_rate != self.sampling_rate:
                  raise ValueError(
                      "This feature extractor is set to support sampling rate"
                      F''' of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled'''
                      F''' 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."  )

        lowercase__				 =							isinstance(_UpperCAmelCase,				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}'''  )
        lowercase__				 =							is_batched_numpy or (
            isinstance(_UpperCAmelCase,				(list, tuple)  ) and (isinstance(raw_speech[0],				(np.ndarray, tuple, list)  ))
        )
        if is_batched:
             lowercase__				 =							[np.asarray([speech],				dtype=np.floataa  ).T for speech in raw_speech]
        elif not is_batched and not isinstance(_UpperCAmelCase,				np.ndarray  ):
             lowercase__				 =							np.asarray(_UpperCAmelCase,				dtype=np.floataa  )
        elif isinstance(_UpperCAmelCase,				np.ndarray  ) and raw_speech.dtype is np.dtype(np.floataa  ):
             lowercase__				 =							raw_speech.astype(np.floataa  )
        # always return batch
        if not is_batched:
             lowercase__				 =							[np.asarray([raw_speech]  ).T]

        # Convert audio signals to log mel spectrograms, truncate by time axis
        lowercase__				 =							[
            self._np_extract_fbank_features(waveform.squeeze()  ).T[: self.spectrogram_length] for waveform in raw_speech
        ]
        if isinstance(audio_features[0],				_UpperCAmelCase  ):
             lowercase__				 =							[np.asarray(_UpperCAmelCase,				dtype=np.floataa  ) for feature in audio_features]

        # Create audio attention mask
        lowercase__				 =							max(
            [ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len for feature in audio_features]  )  # The maximum number of audio patches in a batch
        if return_attention_mask:
             lowercase__				 =							[
                 (ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [1]
                 + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [0]
                 for feature in audio_features
             ]
             lowercase__				 =							np.array(_UpperCAmelCase  ).astype(np.floataa  )

        # convert into correct format for padding
        lowercase__				 =							max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
        lowercase__				 =							np.ones([len(_UpperCAmelCase  ), 1, max_time_len, self.feature_size]  ).astype(np.floataa  )
        lowercase__				 =							padded_audio_features * self.padding_value
        for i in range(len(_UpperCAmelCase  )  ):
             lowercase__				 =							audio_features[i]
             lowercase__				 =							feature

        # return as BatchFeature
        if return_attention_mask:
             lowercase__				 =							{"audio_values": padded_audio_features, "audio_mask": audio_mask}
        else:
             lowercase__				 =							{"audio_values": padded_audio_features}

        lowercase__				 =							BatchFeature(data=_UpperCAmelCase,				tensor_type=_UpperCAmelCase  )
        return encoded_inputs




