






"""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 :    Optional[Any]    =						logging.get_logger(__name__)






class 					a						( __snake_case		):
    SCREAMING_SNAKE_CASE						:					PyTorchBenchmarkArguments
    SCREAMING_SNAKE_CASE						:					PretrainedConfig
    SCREAMING_SNAKE_CASE						:					str						=			"PyTorch"






    @property
    def        UpperCamelCase	(	self					:							str )					->		List[Any]:
      return torch.__version__






    def        UpperCamelCase	(	self					:							Union[str, Any]	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		float:
      lowerCamelCase_   					=						self._prepare_inference_func(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
      return self._measure_speed(_inference )






    def        UpperCamelCase	(	self					:							Union[str, Any]	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		[Memory, Optional[MemorySummary]]:
      lowerCamelCase_   					=						self._prepare_inference_func(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
      return self._measure_memory(_inference )






    def        UpperCamelCase	(	self					:							List[Any]	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		float:
      lowerCamelCase_   					=						self._prepare_train_func(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
      return self._measure_speed(_train )






    def        UpperCamelCase	(	self					:							str	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		[Memory, Optional[MemorySummary]]:
      lowerCamelCase_   					=						self._prepare_train_func(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
      return self._measure_memory(_train )






    def        UpperCamelCase	(	self					:							Any	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		Callable[[], None]:
      lowerCamelCase_   					=						self.config_dict[model_name]

      if self.args.torchscript:
        lowerCamelCase_   					=						True

      lowerCamelCase_   					=						(
          hasattr(__SCREAMING_SNAKE_CASE	,						'architectures' )
          and isinstance(config.architectures	,						__SCREAMING_SNAKE_CASE )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
        try:
          lowerCamelCase_   					=						config.architectures[0]
          lowerCamelCase_   					=						__import__('transformers'	,						fromlist=[model_class] )
          lowerCamelCase_   					=						getattr(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
          lowerCamelCase_   					=						model_cls(__SCREAMING_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:
        lowerCamelCase_   					=						MODEL_MAPPING[config.__class__](__SCREAMING_SNAKE_CASE )

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

      # encoder-decoder has vocab size saved differently
      lowerCamelCase_   					=						config.vocab_size if hasattr(__SCREAMING_SNAKE_CASE	,						'vocab_size' ) else config.encoder.vocab_size
      lowerCamelCase_   					=						torch.randint(__SCREAMING_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():
          lowerCamelCase_   					=						torch.jit.trace(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
      else:
        lowerCamelCase_   					=						model

      def encoder_decoder_forward():
        with torch.no_grad():
          lowerCamelCase_   					=						inference_model(__SCREAMING_SNAKE_CASE	,						decoder_input_ids=__SCREAMING_SNAKE_CASE )
        return outputs

      def encoder_forward():
        with torch.no_grad():
          lowerCamelCase_   					=						inference_model(__SCREAMING_SNAKE_CASE )
        return outputs

      lowerCamelCase_   					=						encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
      return _forward






    def        UpperCamelCase	(	self					:							List[str]	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							int	,						__SCREAMING_SNAKE_CASE					:							int )					->		Callable[[], None]:
      lowerCamelCase_   					=						self.config_dict[model_name]

      lowerCamelCase_   					=						(
          hasattr(__SCREAMING_SNAKE_CASE	,						'architectures' )
          and isinstance(config.architectures	,						__SCREAMING_SNAKE_CASE )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
        try:
          lowerCamelCase_   					=						config.architectures[0]
          lowerCamelCase_   					=						__import__('transformers'	,						fromlist=[model_class] )
          lowerCamelCase_   					=						getattr(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE )
          lowerCamelCase_   					=						model_cls(__SCREAMING_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:
        lowerCamelCase_   					=						MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__SCREAMING_SNAKE_CASE )

      if self.args.torchscript:
        raise NotImplementedError('Training for torchscript is currently not implemented' )
      else:
        lowerCamelCase_   					=						model

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

      # encoder-decoder has vocab size saved differently
      lowerCamelCase_   					=						config.vocab_size if hasattr(__SCREAMING_SNAKE_CASE	,						'vocab_size' ) else config.encoder.vocab_size
      lowerCamelCase_   					=						torch.randint(__SCREAMING_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():
        lowerCamelCase_   					=						train_model(__SCREAMING_SNAKE_CASE	,						labels=__SCREAMING_SNAKE_CASE )[0]
        loss.backward()
        return loss

      def compute_loss_and_backprob_encoder_decoder():
        lowerCamelCase_   					=						train_model(__SCREAMING_SNAKE_CASE	,						decoder_input_ids=__SCREAMING_SNAKE_CASE	,						labels=__SCREAMING_SNAKE_CASE )[0]
        loss.backward()
        return loss

      lowerCamelCase_   					=						(
          compute_loss_and_backprob_encoder_decoder
          if config.is_encoder_decoder
          else compute_loss_and_backprob_encoder
      )
      return _train






    def        UpperCamelCase	(	self					:							Tuple	,						__SCREAMING_SNAKE_CASE					:							int )					->		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(
              __SCREAMING_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
        lowerCamelCase_   					=						timeit.repeat(
            __SCREAMING_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(__SCREAMING_SNAKE_CASE ) / 10.0
      except RuntimeError as e:
        self.print_fn(F'''Doesn\'t fit on GPU. {e}''' )
        return "N/A"






    def        UpperCamelCase	(	self					:							Dict	,						__SCREAMING_SNAKE_CASE					:							Callable[[], None] )					->		[Memory, MemorySummary]:
      try:
        if self.args.trace_memory_line_by_line:
          lowerCamelCase_   					=						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.' )
            lowerCamelCase_   					=						'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()
            lowerCamelCase_   					=						nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
            lowerCamelCase_   					=						nvml.nvmlDeviceGetMemoryInfo(__SCREAMING_SNAKE_CASE )
            lowerCamelCase_   					=						meminfo.used
            lowerCamelCase_   					=						Memory(__SCREAMING_SNAKE_CASE )
            # shutdown nvml
            nvml.nvmlShutdown()
        else:
          # cpu
          lowerCamelCase_   					=						measure_peak_memory_cpu(__SCREAMING_SNAKE_CASE )
          lowerCamelCase_   					=						Memory(__SCREAMING_SNAKE_CASE ) if isinstance(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE ) else memory_bytes

        if self.args.trace_memory_line_by_line:
          lowerCamelCase_   					=						stop_memory_tracing(__SCREAMING_SNAKE_CASE )
        else:
          lowerCamelCase_   					=						None

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












"""simple docstring"""





import numpy as np







def 					lowerCamelCase__	(							_lowerCamelCase	:		Dict		,    _lowerCamelCase	:		Any		,    _lowerCamelCase	:		Tuple			)				->    str:
  lowerCamelCase_   					=						n_draws * class_counts / class_counts.sum()
  # floored means we don't overshoot n_samples, but probably undershoot
  lowerCamelCase_   					=						np.floor(_lowerCamelCase			)
  # we add samples according to how much "left over" probability
  # they had, until we arrive at n_samples
  lowerCamelCase_   					=						int(n_draws - floored.sum()			)
  if need_to_add > 0:
    lowerCamelCase_   					=						continuous - floored
    lowerCamelCase_   					=						np.sort(np.unique(_lowerCamelCase			)			)[::-1]
    # add according to remainder, but break ties
    # randomly to avoid biases
    for value in values:
      ((lowerCamelCase_)					,     )   					=						np.where(remainder == value			)
      # if we need_to_add less than what's in inds
      # we draw randomly from them.
      # if we need to add more, we add them all and
      # go to the next value
      lowerCamelCase_   					=						min(len(_lowerCamelCase			)		,    _lowerCamelCase			)
      lowerCamelCase_   					=						rng.choice(_lowerCamelCase		,    size=_lowerCamelCase		,    replace=_lowerCamelCase			)
      floored[inds] += 1
      need_to_add -= add_now
      if need_to_add == 0:
        break
  return floored.astype(np.intaa			)







def 					lowerCamelCase__	(							_lowerCamelCase	:		Any		,    _lowerCamelCase	:		int		,    _lowerCamelCase	:		Optional[Any]		,    _lowerCamelCase	:		List[str]		,    _lowerCamelCase	:		Optional[int]=10			)				->    Any:
  lowerCamelCase_					,     lowerCamelCase_   					=						np.unique(_lowerCamelCase		,    return_inverse=_lowerCamelCase			)
  lowerCamelCase_   					=						classes.shape[0]
  lowerCamelCase_   					=						np.bincount(_lowerCamelCase			)
  if np.min(_lowerCamelCase			) < 2:
    raise ValueError('Minimum class count error'			)
  if n_train < n_classes:
    raise ValueError(
        'The train_size = %d should be greater or ' 'equal to the number of classes = %d' % (n_train, n_classes)			)
  if n_test < n_classes:
    raise ValueError(
        'The test_size = %d should be greater or ' 'equal to the number of classes = %d' % (n_test, n_classes)			)
  lowerCamelCase_   					=						np.split(np.argsort(_lowerCamelCase		,    kind='mergesort'			)		,    np.cumsum(_lowerCamelCase			)[:-1]			)
  for _ in range(_lowerCamelCase			):
    lowerCamelCase_   					=						approximate_mode(_lowerCamelCase		,    _lowerCamelCase		,    _lowerCamelCase			)
    lowerCamelCase_   					=						class_counts - n_i
    lowerCamelCase_   					=						approximate_mode(_lowerCamelCase		,    _lowerCamelCase		,    _lowerCamelCase			)

    lowerCamelCase_   					=						[]
    lowerCamelCase_   					=						[]

    for i in range(_lowerCamelCase			):
      lowerCamelCase_   					=						rng.permutation(class_counts[i]			)
      lowerCamelCase_   					=						class_indices[i].take(_lowerCamelCase		,    mode='clip'			)
      train.extend(perm_indices_class_i[: n_i[i]]			)
      test.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]]			)
    lowerCamelCase_   					=						rng.permutation(_lowerCamelCase			)
    lowerCamelCase_   					=						rng.permutation(_lowerCamelCase			)

    yield train, test




