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      :			Optional[Any]							       =		logging.get_logger(__name__)



def      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	bool			,					__UpperCamelCase   :	bool     )							-> Optional[Any]:







  """simple docstring"""





  def run_func(__UpperCamelCase   :	Any     ):
    @wraps(__UpperCamelCase     )
    def run_in_eager_mode(*__UpperCamelCase   :	Any			,					**__UpperCamelCase   :	Optional[int]     ):
      return func(*__UpperCamelCase			,					**__UpperCamelCase     )

    @wraps(__UpperCamelCase     )
    @tf.function(experimental_compile=__UpperCamelCase     )
    def run_in_graph_mode(*__UpperCamelCase   :	Optional[Any]			,					**__UpperCamelCase   :	Optional[Any]     ):
      return func(*__UpperCamelCase			,					**__UpperCamelCase     )

    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      __SCREAMING_SNAKE_CASE  ( __UpperCamelCase   :	int			,					__UpperCamelCase   :	int			,					__UpperCamelCase   :	int     )							-> Dict:







  """simple docstring"""





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







class __snake_case    (						__lowerCAmelCase		):






   """simple docstring"""




   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							"TensorFlow"




   @property
   def      __a						(   self      :    Dict				):



     """simple docstring"""






     return tf.__version__




   def      __a						(   self      :    Optional[int]	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






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




   def      __a						(   self      :    Union[str, Any]	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






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




   def      __a						(   self      :    str	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






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




   def      __a						(   self      :    str	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






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

     SCREAMING_SNAKE_CASE__      							=				self._prepare_train_func(lowerCamelCase__	,     lowerCamelCase__	,     lowerCamelCase__				)
     return self._measure_memory(_train				)




   def      __a						(   self      :    List[Any]	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.config_dict[model_name]

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

     SCREAMING_SNAKE_CASE__      							=				(
         hasattr(lowerCamelCase__	,     """architectures"""				)
         and isinstance(config.architectures	,     lowerCamelCase__				)
         and len(config.architectures				) > 0
     )
     if not self.args.only_pretrain_model and has_model_class_in_config:
       try:
         SCREAMING_SNAKE_CASE__      							=				'''TF''' + config.architectures[0]  # prepend 'TF' for tensorflow model
         SCREAMING_SNAKE_CASE__      							=				__import__("""transformers"""	,     fromlist=[model_class]				)
         SCREAMING_SNAKE_CASE__      							=				getattr(lowerCamelCase__	,     lowerCamelCase__				)
         SCREAMING_SNAKE_CASE__      							=				model_cls(lowerCamelCase__				)
       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:
       SCREAMING_SNAKE_CASE__      							=				TF_MODEL_MAPPING[config.__class__](lowerCamelCase__				)

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

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

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

     SCREAMING_SNAKE_CASE__      							=				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

     return _inference




   def      __a						(   self      :    List[str]	,     _lowercase      :    str	,     _lowercase      :    int	,     _lowercase      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				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."""				)

     SCREAMING_SNAKE_CASE__      							=				(
         hasattr(lowerCamelCase__	,     """architectures"""				)
         and isinstance(config.architectures	,     lowerCamelCase__				)
         and len(config.architectures				) > 0
     )
     if not self.args.only_pretrain_model and has_model_class_in_config:
       try:
         SCREAMING_SNAKE_CASE__      							=				'''TF''' + config.architectures[0]  # prepend 'TF' for tensorflow model
         SCREAMING_SNAKE_CASE__      							=				__import__("""transformers"""	,     fromlist=[model_class]				)
         SCREAMING_SNAKE_CASE__      							=				getattr(lowerCamelCase__	,     lowerCamelCase__				)
         SCREAMING_SNAKE_CASE__      							=				model_cls(lowerCamelCase__				)
       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:
       SCREAMING_SNAKE_CASE__      							=				TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](lowerCamelCase__				)

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

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

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

     SCREAMING_SNAKE_CASE__      							=				encoder_decoder_train if config.is_encoder_decoder else encoder_train

     return _train




   def      __a						(   self      :    Optional[Any]	,     _lowercase      :    Tuple				):



     """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(lowerCamelCase__	,     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
         SCREAMING_SNAKE_CASE__      							=				timeit.repeat(
             lowerCamelCase__	,     repeat=self.args.repeat	,     number=10	,     )

         return min(lowerCamelCase__				) / 10.0
       except ResourceExhaustedError as e:
         self.print_fn(f"""Doesn't fit on GPU. {e}"""				)




   def      __a						(   self      :    Union[str, Any]	,     _lowercase      :    Callable[[], None]				):



     """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."""				)
           SCREAMING_SNAKE_CASE__      							=				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."""				)
             SCREAMING_SNAKE_CASE__      							=				'''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()
             SCREAMING_SNAKE_CASE__      							=				nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx				)
             SCREAMING_SNAKE_CASE__      							=				nvml.nvmlDeviceGetMemoryInfo(lowerCamelCase__				)
             SCREAMING_SNAKE_CASE__      							=				meminfo.used
             SCREAMING_SNAKE_CASE__      							=				Memory(lowerCamelCase__				)
             # 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."""				)
             SCREAMING_SNAKE_CASE__      							=				None
           else:
             SCREAMING_SNAKE_CASE__      							=				measure_peak_memory_cpu(lowerCamelCase__				)
             SCREAMING_SNAKE_CASE__      							=				Memory(lowerCamelCase__				) if isinstance(lowerCamelCase__	,     lowerCamelCase__				) else memory_bytes
         if self.args.trace_memory_line_by_line:
           SCREAMING_SNAKE_CASE__      							=				stop_memory_tracing(lowerCamelCase__				)
           if memory is None:
             SCREAMING_SNAKE_CASE__      							=				summary.total
         else:
           SCREAMING_SNAKE_CASE__      							=				None

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

from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels
