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


A__   :						Optional[int] 							=     logging.get_logger(__name__)







class 	_lowercase    (							lowerCAmelCase_					):


     '''simple docstring'''





     _A		    =				42
     _A		    =				42
     _A		    =				"PyTorch"



     @property
     def 			lowerCAmelCase__							(   self	)->       Optional[Any]:
          return torch.__version__



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       float:
          UpperCAmelCase__				:			Tuple							=    self._prepare_inference_func(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)
          return self._measure_speed(_inference	)



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       [Memory, Optional[MemorySummary]]:
          UpperCAmelCase__				:			Union[str, Any]							=    self._prepare_inference_func(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)
          return self._measure_memory(_inference	)



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       float:
          UpperCAmelCase__				:			Optional[int]							=    self._prepare_train_func(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)
          return self._measure_speed(_train	)



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       [Memory, Optional[MemorySummary]]:
          UpperCAmelCase__				:			Optional[int]							=    self._prepare_train_func(__UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)
          return self._measure_memory(_train	)



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       Callable[[], None]:
          UpperCAmelCase__				:			List[str]							=    self.config_dict[model_name]

          if self.args.torchscript:
               UpperCAmelCase__				:			Any							=    True

          UpperCAmelCase__				:			Dict							=    (
              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:
                    UpperCAmelCase__				:			Tuple							=    config.architectures[0]
                    UpperCAmelCase__				:			Union[str, Any]							=    __import__("transformers"			,      fromlist=[model_class]	)
                    UpperCAmelCase__				:			Tuple							=    getattr(__UpperCamelCase			,      __UpperCamelCase	)
                    UpperCAmelCase__				:			Any							=    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:
               UpperCAmelCase__				:			str							=    MODEL_MAPPING[config.__class__](__UpperCamelCase	)

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

          # encoder-decoder has vocab size saved differently
          UpperCAmelCase__				:			int							=    config.vocab_size if hasattr(__UpperCamelCase			,      "vocab_size"	) else config.encoder.vocab_size
          UpperCAmelCase__				:			Optional[Any]							=    torch.randint(__UpperCamelCase			,      (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(__UpperCamelCase			,      __UpperCamelCase	)
          else:
               UpperCAmelCase__				:			Dict							=    model

          def encoder_decoder_forward():
               with torch.no_grad():
                    UpperCAmelCase__				:			Union[str, Any]							=    inference_model(__UpperCamelCase			,      decoder_input_ids=__UpperCamelCase	)
               return outputs

          def encoder_forward():
               with torch.no_grad():
                    UpperCAmelCase__				:			Dict							=    inference_model(__UpperCamelCase	)
               return outputs

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



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase			,      __UpperCamelCase			,      __UpperCamelCase	)->       Callable[[], None]:
          UpperCAmelCase__				:			Optional[int]							=    self.config_dict[model_name]

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

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

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

          # encoder-decoder has vocab size saved differently
          UpperCAmelCase__				:			Optional[Any]							=    config.vocab_size if hasattr(__UpperCamelCase			,      "vocab_size"	) else config.encoder.vocab_size
          UpperCAmelCase__				:			List[Any]							=    torch.randint(__UpperCamelCase			,      (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[Any]							=    train_model(__UpperCamelCase			,      labels=__UpperCamelCase	)[0]
               loss.backward()
               return loss

          def compute_loss_and_backprob_encoder_decoder():
               UpperCAmelCase__				:			Optional[Any]							=    train_model(__UpperCamelCase			,      decoder_input_ids=__UpperCamelCase			,      labels=__UpperCamelCase	)[0]
               loss.backward()
               return loss

          UpperCAmelCase__				:			List[str]							=    (
              compute_loss_and_backprob_encoder_decoder
              if config.is_encoder_decoder
              else compute_loss_and_backprob_encoder
          )
          return _train



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase	)->       float:
          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(
                        __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
               UpperCAmelCase__				:			int							=    timeit.repeat(
                   __UpperCamelCase			,      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(__UpperCamelCase	) / 10.0
          except RuntimeError as e:
               self.print_fn(F"Doesn't fit on GPU. {e}"	)
               return "N/A"



     def 			lowerCAmelCase__							(   self			,      __UpperCamelCase	)->       [Memory, MemorySummary]:
          try:
               if self.args.trace_memory_line_by_line:
                    UpperCAmelCase__				:			List[str]							=    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__				:			Dict							=    "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__				:			Dict							=    nvml.nvmlDeviceGetMemoryInfo(__UpperCamelCase	)
                         UpperCAmelCase__				:			Optional[Any]							=    meminfo.used
                         UpperCAmelCase__				:			Optional[int]							=    Memory(__UpperCamelCase	)
                         # shutdown nvml
                         nvml.nvmlShutdown()
               else:
                    # cpu
                    UpperCAmelCase__				:			Optional[Any]							=    measure_peak_memory_cpu(__UpperCamelCase	)
                    UpperCAmelCase__				:			Tuple							=    Memory(__UpperCamelCase	) if isinstance(__UpperCamelCase			,      __UpperCamelCase	) else memory_bytes

               if self.args.trace_memory_line_by_line:
                    UpperCAmelCase__				:			Any							=    stop_memory_tracing(__UpperCamelCase	)
               else:
                    UpperCAmelCase__				:			Optional[Any]							=    None

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





"""simple docstring"""




def 				a__			(					lowerCAmelCase						:							str		):






     '''simple docstring'''
     UpperCAmelCase__				:			Optional[Any]							=    str(lowerCAmelCase		).strip()
     if not oct_string:
          raise ValueError("Empty string was passed to the function"		)
     UpperCAmelCase__				:			Tuple							=    oct_string[0] == "-"
     if is_negative:
          UpperCAmelCase__				:			List[Any]							=    oct_string[1:]
     if not oct_string.isdigit() or not all(0 <= int(lowerCAmelCase		) <= 7 for char in oct_string		):
          raise ValueError("Non-octal value was passed to the function"		)
     UpperCAmelCase__				:			Optional[int]							=    0
     for char in oct_string:
          UpperCAmelCase__				:			Tuple							=    8 * decimal_number + int(lowerCAmelCase		)
     if is_negative:
          UpperCAmelCase__				:			int							=    -decimal_number
     return decimal_number


if __name__ == "__main__":
    from doctest import testmod

    testmod()



