




'''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		:	int       =      logging.get_logger(__name__)




class      UpperCamelCase       (	snake_case__       ):
  a     :PyTorchBenchmarkArguments
  a     :PretrainedConfig
  a     :str          =					"PyTorch"



  @property
  def     a_							(			self ):







      '''simple docstring'''


      return torch.__version__



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Optional[int]							       =      self._prepare_inference_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_speed(_inference )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							List[str]							       =      self._prepare_inference_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_memory(_inference )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							List[Any]							       =      self._prepare_train_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_speed(_train )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Any							       =      self._prepare_train_func(__lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase )
      return self._measure_memory(_train )



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							Tuple							       =      self.config_dict[model_name]

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

      _a				:							Any							       =      (
          hasattr(__lowerCAmelCase		,     """architectures""" )
          and isinstance(config.architectures		,     __lowerCAmelCase )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
              _a				:							Optional[int]							       =      config.architectures[0]
              _a				:							str							       =      __import__("""transformers"""		,     fromlist=[model_class] )
              _a				:							str							       =      getattr(__lowerCAmelCase		,     __lowerCAmelCase )
              _a				:							List[Any]							       =      model_cls(__lowerCAmelCase )
          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:
          _a				:							List[str]							       =      MODEL_MAPPING[config.__class__](__lowerCAmelCase )

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

      # encoder-decoder has vocab size saved differently
      _a				:							str							       =      config.vocab_size if hasattr(__lowerCAmelCase		,     """vocab_size""" ) else config.encoder.vocab_size
      _a				:							int							       =      torch.randint(__lowerCAmelCase		,     (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():
              _a				:							str							       =      torch.jit.trace(__lowerCAmelCase		,     __lowerCAmelCase )
      else:
          _a				:							Tuple							       =      model

      def encoder_decoder_forward():
          with torch.no_grad():
              _a				:							Tuple							       =      inference_model(__lowerCAmelCase		,     decoder_input_ids=__lowerCAmelCase )
          return outputs

      def encoder_forward():
          with torch.no_grad():
              _a				:							Union[str, Any]							       =      inference_model(__lowerCAmelCase )
          return outputs

      _a				:							Union[str, Any]							       =      encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
      return _forward



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase ):







      '''simple docstring'''


      _a				:							int							       =      self.config_dict[model_name]

      _a				:							List[str]							       =      (
          hasattr(__lowerCAmelCase		,     """architectures""" )
          and isinstance(config.architectures		,     __lowerCAmelCase )
          and len(config.architectures ) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
          try:
              _a				:							Dict							       =      config.architectures[0]
              _a				:							Optional[Any]							       =      __import__("""transformers"""		,     fromlist=[model_class] )
              _a				:							int							       =      getattr(__lowerCAmelCase		,     __lowerCAmelCase )
              _a				:							List[str]							       =      model_cls(__lowerCAmelCase )
          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:
          _a				:							Any							       =      MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__lowerCAmelCase )

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

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

      # encoder-decoder has vocab size saved differently
      _a				:							Dict							       =      config.vocab_size if hasattr(__lowerCAmelCase		,     """vocab_size""" ) else config.encoder.vocab_size
      _a				:							Tuple							       =      torch.randint(__lowerCAmelCase		,     (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():
          _a				:							int							       =      train_model(__lowerCAmelCase		,     labels=__lowerCAmelCase )[0]
          loss.backward()
          return loss

      def compute_loss_and_backprob_encoder_decoder():
          _a				:							str							       =      train_model(__lowerCAmelCase		,     decoder_input_ids=__lowerCAmelCase		,     labels=__lowerCAmelCase )[0]
          loss.backward()
          return loss

      _a				:							Any							       =      (
          compute_loss_and_backprob_encoder_decoder
          if config.is_encoder_decoder
          else compute_loss_and_backprob_encoder
      )
      return _train



  def     a_							(			self		,     __lowerCAmelCase ):







      '''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(
                  __lowerCAmelCase		,     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
          _a				:							List[str]							       =      timeit.repeat(
              __lowerCAmelCase		,     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(__lowerCAmelCase ) / 10.0
      except RuntimeError as e:
          self.print_fn(f'''Doesn\'t fit on GPU. {e}''' )
          return "N/A"



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      try:
          if self.args.trace_memory_line_by_line:
              _a				:							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"""
                  """ `--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.""" )
                  _a				:							Tuple							       =      """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()
                  _a				:							Optional[Any]							       =      nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx )
                  _a				:							str							       =      nvml.nvmlDeviceGetMemoryInfo(__lowerCAmelCase )
                  _a				:							Any							       =      meminfo.used
                  _a				:							str							       =      Memory(__lowerCAmelCase )
                  # shutdown nvml
                  nvml.nvmlShutdown()
          else:
              # cpu
              _a				:							Tuple							       =      measure_peak_memory_cpu(__lowerCAmelCase )
              _a				:							str							       =      Memory(__lowerCAmelCase ) if isinstance(__lowerCAmelCase		,     __lowerCAmelCase ) else memory_bytes

          if self.args.trace_memory_line_by_line:
              _a				:							str							       =      stop_memory_tracing(__lowerCAmelCase )
          else:
              _a				:							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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase  		=			{
    """configuration_flaubert""": ["""FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """FlaubertConfig""", """FlaubertOnnxConfig"""],
    """tokenization_flaubert""": ["""FlaubertTokenizer"""],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  		=			[
					    """FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """FlaubertForMultipleChoice""",
					    """FlaubertForQuestionAnswering""",
					    """FlaubertForQuestionAnsweringSimple""",
					    """FlaubertForSequenceClassification""",
					    """FlaubertForTokenClassification""",
					    """FlaubertModel""",
					    """FlaubertWithLMHeadModel""",
					    """FlaubertPreTrainedModel""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  		=			[
					    """TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFFlaubertForMultipleChoice""",
					    """TFFlaubertForQuestionAnsweringSimple""",
					    """TFFlaubertForSequenceClassification""",
					    """TFFlaubertForTokenClassification""",
					    """TFFlaubertModel""",
					    """TFFlaubertPreTrainedModel""",
					    """TFFlaubertWithLMHeadModel""",
					]


if TYPE_CHECKING:
					from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
					from .tokenization_flaubert import FlaubertTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flaubert import (
										    FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    FlaubertForMultipleChoice,
										    FlaubertForQuestionAnswering,
										    FlaubertForQuestionAnsweringSimple,
										    FlaubertForSequenceClassification,
										    FlaubertForTokenClassification,
										    FlaubertModel,
										    FlaubertPreTrainedModel,
										    FlaubertWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_flaubert import (
										    TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFFlaubertForMultipleChoice,
										    TFFlaubertForQuestionAnsweringSimple,
										    TFFlaubertForSequenceClassification,
										    TFFlaubertForTokenClassification,
										    TFFlaubertModel,
										    TFFlaubertPreTrainedModel,
										    TFFlaubertWithLMHeadModel,
										)

else:
					import sys

					lowercase  		=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





