
'''simple docstring'''





import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
      import torch

      from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
      import pyanvml.pyanvml as nvml


SCREAMING_SNAKE_CASE    =     logging.get_logger(__name__)






class        UpperCAmelCase_       (						A							):

 '''simple docstring'''
 lowercase_				:						PyTorchBenchmarkArguments
 lowercase_				:						PretrainedConfig
 lowercase_				:						str				=       "PyTorch"







 @property
 def        UpperCamelCase     (				self		:     int   ):



   '''simple docstring'''




   return torch.__version__







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



   '''simple docstring'''




   UpperCAmelCase__			:				List[str]												=       self._prepare_inference_func(snake_case__ ,							snake_case__ ,							snake_case__   )
   return self._measure_speed(_inference   )







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



   '''simple docstring'''




   UpperCAmelCase__			:				Any												=       self._prepare_inference_func(snake_case__ ,							snake_case__ ,							snake_case__   )
   return self._measure_memory(_inference   )







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



   '''simple docstring'''




   UpperCAmelCase__			:				List[Any]												=       self._prepare_train_func(snake_case__ ,							snake_case__ ,							snake_case__   )
   return self._measure_speed(_train   )







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



   '''simple docstring'''




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







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



   '''simple docstring'''




   UpperCAmelCase__			:				Any												=       self.config_dict[model_name]

   if self.args.torchscript:
     UpperCAmelCase__			:				Union[str, Any]												=       True

   UpperCAmelCase__			:				Optional[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__			:				Dict												=       config.architectures[0]
       UpperCAmelCase__			:				int												=       __import__("transformers" ,							fromlist=[model_class]   )
       UpperCAmelCase__			:				List[Any]												=       getattr(snake_case__ ,							snake_case__   )
       UpperCAmelCase__			:				Optional[int]												=       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]												=       MODEL_MAPPING[config.__class__](snake_case__   )

   model.eval()
   model.to(self.args.device   )

   # encoder-decoder has vocab size saved differently
   UpperCAmelCase__			:				str												=       config.vocab_size if hasattr(snake_case__ ,							"vocab_size"   ) else config.encoder.vocab_size
   UpperCAmelCase__			:				Union[str, Any]												=       torch.randint(snake_case__ ,							(batch_size, sequence_length) ,							dtype=torch.long ,							device=self.args.device   )

   if self.args.fpaa:
     logger.info("Running training in Mixed Precision..."   )
     if not self.args.is_gpu:
       raise ValueError("Mixed precision is possible only for GPU."   )
     # amp seems to have memory leaks so that memory usage
     # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
     model.half()

   if self.args.torchscript:
     with torch.no_grad():
       UpperCAmelCase__			:				Any												=       torch.jit.trace(snake_case__ ,							snake_case__   )
   else:
     UpperCAmelCase__			:				Dict												=       model

   def encoder_decoder_forward():
     with torch.no_grad():
       UpperCAmelCase__			:				List[str]												=       inference_model(snake_case__ ,							decoder_input_ids=snake_case__   )
     return outputs

   def encoder_forward():
     with torch.no_grad():
       UpperCAmelCase__			:				Tuple												=       inference_model(snake_case__   )
     return outputs

   UpperCAmelCase__			:				str												=       encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
   return _forward







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



   '''simple docstring'''




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

   UpperCAmelCase__			:				Optional[int]												=       (
       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												=       config.architectures[0]
       UpperCAmelCase__			:				List[str]												=       __import__("transformers" ,							fromlist=[model_class]   )
       UpperCAmelCase__			:				List[str]												=       getattr(snake_case__ ,							snake_case__   )
       UpperCAmelCase__			:				int												=       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__			:				Tuple												=       MODEL_WITH_LM_HEAD_MAPPING[config.__class__](snake_case__   )

   if self.args.torchscript:
     raise NotImplementedError("Training for torchscript is currently not implemented"   )
   else:
     UpperCAmelCase__			:				int												=       model

   model.train()
   model.to(self.args.device   )

   # encoder-decoder has vocab size saved differently
   UpperCAmelCase__			:				Tuple												=       config.vocab_size if hasattr(snake_case__ ,							"vocab_size"   ) else config.encoder.vocab_size
   UpperCAmelCase__			:				int												=       torch.randint(snake_case__ ,							(batch_size, sequence_length) ,							dtype=torch.long ,							device=self.args.device   )

   if self.args.fpaa:
     logger.info("Running training in Mixed Precision..."   )
     if not self.args.is_gpu:
       raise ValueError("Mixed precision is possible only for GPU."   )

     # amp seems to have memory leaks so that memory usage
     # is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
     model.half()

   def compute_loss_and_backprob_encoder():
     UpperCAmelCase__			:				List[str]												=       train_model(snake_case__ ,							labels=snake_case__   )[0]
     loss.backward()
     return loss

   def compute_loss_and_backprob_encoder_decoder():
     UpperCAmelCase__			:				int												=       train_model(snake_case__ ,							decoder_input_ids=snake_case__ ,							labels=snake_case__   )[0]
     loss.backward()
     return loss

   UpperCAmelCase__			:				Dict												=       (
       compute_loss_and_backprob_encoder_decoder
       if config.is_encoder_decoder
       else compute_loss_and_backprob_encoder
   )
   return _train







 def        UpperCamelCase     (				self		:     Tuple ,							snake_case__		:     Optional[int]   ):



   '''simple docstring'''




   try:
     if self.args.is_tpu or self.args.torchscript:
       # run additional 10 times to stabilize compilation for tpu and torchscript
       logger.info("Do inference on TPU or torchscript. 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__			:				int												=       timeit.repeat(
         snake_case__ ,							repeat=self.args.repeat ,							number=10 ,							)

     if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
       import torch_xla.debug.metrics as met

       self.print_fn(met.metrics_report()   )

     return min(snake_case__   ) / 10.0
   except RuntimeError as e:
     self.print_fn(F"""Doesn't fit on GPU. {e}"""   )
     return "N/A"







 def        UpperCamelCase     (				self		:     List[str] ,							snake_case__		:     Callable[[], None]   ):



   '''simple docstring'''




   try:
     if self.args.trace_memory_line_by_line:
       UpperCAmelCase__			:				Dict												=       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"
           " `--no-memory` or `args.memory=False`"   )
     elif self.args.is_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__			:				str												=       "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__			:				Tuple												=       nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx   )
         UpperCAmelCase__			:				Any												=       nvml.nvmlDeviceGetMemoryInfo(snake_case__   )
         UpperCAmelCase__			:				List[str]												=       meminfo.used
         UpperCAmelCase__			:				Dict												=       Memory(snake_case__   )
         # shutdown nvml
         nvml.nvmlShutdown()
     else:
       # cpu
       UpperCAmelCase__			:				Tuple												=       measure_peak_memory_cpu(snake_case__   )
       UpperCAmelCase__			:				Any												=       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__   )
     else:
       UpperCAmelCase__			:				List[str]												=       None

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





'''simple docstring'''





from doctest import testmod
from math import sqrt







def snake_case_    (				lowercase__		):
  UpperCAmelCase__			:				list[int]												=       []
  if num < 1:
    return facs
  facs.append(1		)
  if num == 1:
    return facs
  facs.append(lowercase__		)
  for i in range(2      ,					int(sqrt(lowercase__		)		) + 1		):
    if num % i == 0:  # If i is a factor of num
      facs.append(lowercase__		)
      UpperCAmelCase__			:				Tuple												=       num // i  # num//i is the other factor of num
      if d != i:  # If d and i are distinct
        facs.append(lowercase__		)  # we have found another factor
  facs.sort()
  return facs


if __name__ == "__main__":
      testmod(name="""factors_of_a_number""", verbose=True)



