
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     :	List[str]       			=  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'''





  __magic_name__								=			random.Random()
  __magic_name__								=			[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 			UpperCAmelCase_     (					_A	):


  '''simple docstring'''







  a__       			=						42
  a__       			=						42
  a__       			=						"TensorFlow"
  @property
  def 				_lowercase				(					self     :					Optional[int]       )     ->      str:







    """simple docstring"""






    return tf.__version__
  def 				_lowercase				(					self     :					Union[str, Any]     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      float:







    """simple docstring"""






    __magic_name__								=			self.args.strategy
    if strategy is None:
      raise ValueError("""A device strategy has to be initialized before using TensorFlow."""       )
    __magic_name__								=			self._prepare_inference_func(UpperCamelCase__     ,				UpperCamelCase__     ,				UpperCamelCase__       )
    return self._measure_speed(_inference       )
  def 				_lowercase				(					self     :					Any     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      float:







    """simple docstring"""






    __magic_name__								=			self.args.strategy
    if strategy is None:
      raise ValueError("""A device strategy has to be initialized before using TensorFlow."""       )
    __magic_name__								=			self._prepare_train_func(UpperCamelCase__     ,				UpperCamelCase__     ,				UpperCamelCase__       )
    return self._measure_speed(_train       )
  def 				_lowercase				(					self     :					Union[str, Any]     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      [Memory, Optional[MemorySummary]]:







    """simple docstring"""






    if self.args.is_gpu:
      tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]     ,				UpperCamelCase__       )
    __magic_name__								=			self.args.strategy
    if strategy is None:
      raise ValueError("""A device strategy has to be initialized before using TensorFlow."""       )
    __magic_name__								=			self._prepare_inference_func(UpperCamelCase__     ,				UpperCamelCase__     ,				UpperCamelCase__       )
    return self._measure_memory(_inference       )
  def 				_lowercase				(					self     :					str     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      [Memory, Optional[MemorySummary]]:







    """simple docstring"""






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

    __magic_name__								=			self._prepare_train_func(UpperCamelCase__     ,				UpperCamelCase__     ,				UpperCamelCase__       )
    return self._measure_memory(_train       )
  def 				_lowercase				(					self     :					List[Any]     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      Callable[[], None]:







    """simple docstring"""






    __magic_name__								=			self.config_dict[model_name]

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

    __magic_name__								=			(
        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:
        __magic_name__								=			"""TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
        __magic_name__								=			__import__("""transformers"""     ,				fromlist=[model_class]       )
        __magic_name__								=			getattr(UpperCamelCase__     ,				UpperCamelCase__       )
        __magic_name__								=			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:
      __magic_name__								=			TF_MODEL_MAPPING[config.__class__](UpperCamelCase__       )

    # encoder-decoder has vocab size saved differently
    __magic_name__								=			config.vocab_size if hasattr(UpperCamelCase__     ,				"""vocab_size"""       ) else config.encoder.vocab_size
    __magic_name__								=			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__       )

    __magic_name__								=			encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

    return _inference
  def 				_lowercase				(					self     :					Optional[Any]     ,				UpperCamelCase__     :					str     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int       )     ->      Callable[[], None]:







    """simple docstring"""






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

    __magic_name__								=			(
        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:
        __magic_name__								=			"""TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
        __magic_name__								=			__import__("""transformers"""     ,				fromlist=[model_class]       )
        __magic_name__								=			getattr(UpperCamelCase__     ,				UpperCamelCase__       )
        __magic_name__								=			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:
      __magic_name__								=			TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](UpperCamelCase__       )

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

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

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

    __magic_name__								=			encoder_decoder_train if config.is_encoder_decoder else encoder_train

    return _train
  def 				_lowercase				(					self     :					int     ,				UpperCamelCase__     :					str       )     ->      float:







    """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
        __magic_name__								=			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 				_lowercase				(					self     :					int     ,				UpperCamelCase__     :					Callable[[], None]       )     ->      [Memory, MemorySummary]:







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

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



def a__       (			A_=28123   ):






  '''simple docstring'''





  __magic_name__								=			[1] * (limit + 1)

  for i in range(2,	int(limit**0.5   ) + 1   ):
    sum_divs[i * i] += i
    for k in range(i + 1,	limit // i + 1   ):
      sum_divs[k * i] += k + i

  __magic_name__								=			set()
  __magic_name__								=			0

  for n in range(1,	limit + 1   ):
    if sum_divs[n] > n:
      abundants.add(A_   )

    if not any((n - a in abundants) for a in abundants   ):
      res += n

  return res


if __name__ == "__main__":
    print(solution())

