



'''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

__a          =		logging.get_logger(__name__)





def 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase		)		-> List[Any]:
      def run_func(_lowerCAmelCase		):
            @wraps(_lowerCAmelCase		)
            def run_in_eager_mode(*_lowerCAmelCase     ,   **_lowerCAmelCase		):
                  return func(*_lowerCAmelCase     ,   **_lowerCAmelCase		)

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

            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 						__snake_case(				_lowerCAmelCase     ,   _lowerCAmelCase     ,   _lowerCAmelCase		)		-> ["tf.Tensor"]:
      snake_case__  :    Optional[int]    						=      random.Random()
      snake_case__  :    List[str]    						=      [rng.randint(0     ,   vocab_size - 1		) for i in range(batch_size * sequence_length		)]
      return tf.constant(_lowerCAmelCase     ,   shape=(batch_size, sequence_length)     ,   dtype=tf.intaa		)







class     UpperCAmelCase_       (       _a	):
    """simple docstring"""







    lowercase					=		42
    lowercase					=		42
    lowercase					=		"TensorFlow"




    @property
    def lowerCamelCase       (    self					:     Dict						):
          return tf.__version__




    def lowerCamelCase       (    self					:     Optional[Any] ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          # initialize GPU on separate process
          snake_case__  :    Any    						=      self.args.strategy
          if strategy is None:
                raise ValueError("""A device strategy has to be initialized before using TensorFlow."""						)
          snake_case__  :    List[Any]    						=      self._prepare_inference_func(snake_case_ ,     snake_case_ ,     snake_case_						)
          return self._measure_speed(_inference						)




    def lowerCamelCase       (    self					:     Tuple ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          snake_case__  :    List[Any]    						=      self.args.strategy
          if strategy is None:
                raise ValueError("""A device strategy has to be initialized before using TensorFlow."""						)
          snake_case__  :    List[Any]    						=      self._prepare_train_func(snake_case_ ,     snake_case_ ,     snake_case_						)
          return self._measure_speed(_train						)




    def lowerCamelCase       (    self					:     Optional[int] ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          # initialize GPU on separate process
          if self.args.is_gpu:
                tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] ,     snake_case_						)
          snake_case__  :    Optional[Any]    						=      self.args.strategy
          if strategy is None:
                raise ValueError("""A device strategy has to be initialized before using TensorFlow."""						)
          snake_case__  :    Optional[int]    						=      self._prepare_inference_func(snake_case_ ,     snake_case_ ,     snake_case_						)
          return self._measure_memory(_inference						)




    def lowerCamelCase       (    self					:     List[str] ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          if self.args.is_gpu:
                tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx] ,     snake_case_						)
          snake_case__  :    Dict    						=      self.args.strategy
          if strategy is None:
                raise ValueError("""A device strategy has to be initialized before using TensorFlow."""						)

          snake_case__  :    str    						=      self._prepare_train_func(snake_case_ ,     snake_case_ ,     snake_case_						)
          return self._measure_memory(_train						)




    def lowerCamelCase       (    self					:     Dict ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          snake_case__  :    Dict    						=      self.config_dict[model_name]

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

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

          # encoder-decoder has vocab size saved differently
          snake_case__  :    Optional[int]    						=      config.vocab_size if hasattr(snake_case_ ,     """vocab_size"""						) else config.encoder.vocab_size
          snake_case__  :    Optional[int]    						=      random_input_ids(snake_case_ ,     snake_case_ ,     snake_case_						)

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

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

          snake_case__  :    Any    						=      encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

          return _inference




    def lowerCamelCase       (    self					:     List[str] ,     snake_case_					:     str ,     snake_case_					:     int ,     snake_case_					:     int						):
          snake_case__  :    List[Any]    						=      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."""						)

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

          # encoder-decoder has vocab size saved differently
          snake_case__  :    int    						=      config.vocab_size if hasattr(snake_case_ ,     """vocab_size"""						) else config.encoder.vocab_size
          snake_case__  :    Dict    						=      random_input_ids(snake_case_ ,     snake_case_ ,     snake_case_						)

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

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

          snake_case__  :    List[Any]    						=      encoder_decoder_train if config.is_encoder_decoder else encoder_train

          return _train




    def lowerCamelCase       (    self					:     List[str] ,     snake_case_					:     Any						):
          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(snake_case_ ,     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
                      snake_case__  :    List[Any]    						=      timeit.repeat(
                          snake_case_ ,     repeat=self.args.repeat ,     number=10 ,     )

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




    def lowerCamelCase       (    self					:     Union[str, Any] ,     snake_case_					:     Callable[[], None]						):
          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."""						)
                            snake_case__  :    int    						=      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."""						)
                                  snake_case__  :    Union[str, Any]    						=      """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()
                                  snake_case__  :    Tuple    						=      nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx						)
                                  snake_case__  :    List[Any]    						=      nvml.nvmlDeviceGetMemoryInfo(snake_case_						)
                                  snake_case__  :    List[str]    						=      meminfo.used
                                  snake_case__  :    int    						=      Memory(snake_case_						)
                                  # 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."""						)
                                  snake_case__  :    List[Any]    						=      None
                            else:
                                  snake_case__  :    Any    						=      measure_peak_memory_cpu(snake_case_						)
                                  snake_case__  :    str    						=      Memory(snake_case_						) if isinstance(snake_case_ ,     snake_case_						) else memory_bytes
                      if self.args.trace_memory_line_by_line:
                            snake_case__  :    Optional[int]    						=      stop_memory_tracing(snake_case_						)
                            if memory is None:
                                  snake_case__  :    Union[str, Any]    						=      summary.total
                      else:
                            snake_case__  :    List[str]    						=      None

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





'''simple docstring'''





def 						__snake_case(				_lowerCAmelCase = 1_000		)		-> int:
      return sum(e for e in range(3     ,   _lowerCAmelCase		) if e % 3 == 0 or e % 5 == 0		)


if __name__ == "__main__":
       print(F"{solution() = }")
