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

SCREAMING_SNAKE_CASE     =       logging.get_logger(__name__)







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

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

    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_     (					lowercase__   ,       lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					List[str]				       =							random.Random()
  UpperCAmelCase__      :					Dict				       =							[rng.randint(0   ,       vocab_size - 1		) for i in range(batch_size * sequence_length		)]
  return tf.constant(lowercase__   ,       shape=(batch_size, sequence_length)   ,       dtype=tf.intaa		)






class 							UpperCAmelCase_							(    A				):

 '''simple docstring'''
 lowercase_					:    TensorFlowBenchmarkArguments
 lowercase_					:    PretrainedConfig
 lowercase_					:    str				=							"TensorFlow"







 @property
 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   return tf.__version__







 def 							UpperCamelCase  (					self		:  str			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					List[str]				       =							self.args.strategy
   if strategy is None:
     raise ValueError("A device strategy has to be initialized before using TensorFlow." )
   UpperCAmelCase__      :					List[Any]				       =							self._prepare_inference_func(snake_case__			,				snake_case__			,				snake_case__ )
   return self._measure_speed(_inference )







 def 							UpperCamelCase  (					self		:  str			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  str			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




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







 def 							UpperCamelCase  (					self		:  Union[str, Any]			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




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

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







 def 							UpperCamelCase  (					self		:  Union[str, Any]			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							self.config_dict[model_name]

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

   UpperCAmelCase__      :					List[Any]				       =							(
       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:
       UpperCAmelCase__      :					Tuple				       =							"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
       UpperCAmelCase__      :					Dict				       =							__import__("transformers"			,				fromlist=[model_class] )
       UpperCAmelCase__      :					Union[str, Any]				       =							getattr(snake_case__			,				snake_case__ )
       UpperCAmelCase__      :					Tuple				       =							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:
     UpperCAmelCase__      :					Dict				       =							TF_MODEL_MAPPING[config.__class__](snake_case__ )

   # encoder-decoder has vocab size saved differently
   UpperCAmelCase__      :					Any				       =							config.vocab_size if hasattr(snake_case__			,				"vocab_size" ) else config.encoder.vocab_size
   UpperCAmelCase__      :					List[Any]				       =							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__ )

   UpperCAmelCase__      :					List[str]				       =							encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

   return _inference







 def 							UpperCamelCase  (					self		:  List[Any]			,				snake_case__		:  str			,				snake_case__		:  int			,				snake_case__		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Union[str, 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." )

   UpperCAmelCase__      :					Union[str, Any]				       =							(
       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:
       UpperCAmelCase__      :					Union[str, Any]				       =							"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
       UpperCAmelCase__      :					int				       =							__import__("transformers"			,				fromlist=[model_class] )
       UpperCAmelCase__      :					Dict				       =							getattr(snake_case__			,				snake_case__ )
       UpperCAmelCase__      :					List[str]				       =							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:
     UpperCAmelCase__      :					Union[str, Any]				       =							TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](snake_case__ )

   # encoder-decoder has vocab size saved differently
   UpperCAmelCase__      :					Dict				       =							config.vocab_size if hasattr(snake_case__			,				"vocab_size" ) else config.encoder.vocab_size
   UpperCAmelCase__      :					Union[str, Any]				       =							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():
     UpperCAmelCase__      :					Any				       =							model(snake_case__			,				decoder_input_ids=snake_case__			,				labels=snake_case__			,				training=snake_case__ )[0]
     UpperCAmelCase__      :					List[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():
     UpperCAmelCase__      :					Tuple				       =							model(snake_case__			,				labels=snake_case__			,				training=snake_case__ )[0]
     UpperCAmelCase__      :					List[Any]				       =							tf.gradients(snake_case__			,				model.trainable_variables )
     return gradients

   UpperCAmelCase__      :					Optional[Any]				       =							encoder_decoder_train if config.is_encoder_decoder else encoder_train

   return _train







 def 							UpperCamelCase  (					self		:  Optional[Any]			,				snake_case__		:  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(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
       UpperCAmelCase__      :					List[str]				       =							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 							UpperCamelCase  (					self		:  int			,				snake_case__		:  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." )
         UpperCAmelCase__      :					Optional[Any]				       =							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." )
           UpperCAmelCase__      :					List[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()
           UpperCAmelCase__      :					Optional[int]				       =							nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
           UpperCAmelCase__      :					int				       =							nvml.nvmlDeviceGetMemoryInfo(snake_case__ )
           UpperCAmelCase__      :					Optional[int]				       =							meminfo.used
           UpperCAmelCase__      :					Dict				       =							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." )
           UpperCAmelCase__      :					Tuple				       =							None
         else:
           UpperCAmelCase__      :					str				       =							measure_peak_memory_cpu(snake_case__ )
           UpperCAmelCase__      :					Tuple				       =							Memory(snake_case__ ) if isinstance(snake_case__			,				snake_case__ ) else memory_bytes
       if self.args.trace_memory_line_by_line:
         UpperCAmelCase__      :					str				       =							stop_memory_tracing(snake_case__ )
         if memory is None:
           UpperCAmelCase__      :					Any				       =							summary.total
       else:
         UpperCAmelCase__      :					Optional[Any]				       =							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_     (					lowercase__		):
  return sum(i for i in range(1   ,       number // 2 + 1		) if number % i == 0		) == number


if __name__ == "__main__":
      print("""Program to check whether a number is a Perfect number or not...""")
      SCREAMING_SNAKE_CASE     =       int(input("""Enter number: """).strip())
      print(F'{number} is {"" if perfect(number) else "not "}a Perfect Number.')



