code: 
  
  
  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
  
  
  lowerCAmelCase__   	=				logging.get_logger(__name__)
  
  
  
  
  
  
  
  class   lowerCAmelCase__ (       a):
  
  
  
  
       '''simple docstring'''
       __SCREAMING_SNAKE_CASE						    =				42
       __SCREAMING_SNAKE_CASE						    =				42
       __SCREAMING_SNAKE_CASE						    =				"PyTorch"
  
  
       @property
       def 				_lowerCamelCase				(		self)    ->       Tuple:
              return torch.__version__
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       float:
              _A   : List[str]       					=				self._prepare_inference_func(__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)
              return self._measure_speed(_inference)
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       [Memory, Optional[MemorySummary]]:
              _A   : List[Any]       					=				self._prepare_inference_func(__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)
              return self._measure_memory(_inference)
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       float:
              _A   : Union[str, Any]       					=				self._prepare_train_func(__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)
              return self._measure_speed(_train)
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       [Memory, Optional[MemorySummary]]:
              _A   : Union[str, Any]       					=				self._prepare_train_func(__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)
              return self._measure_memory(_train)
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       Callable[[], None]:
              _A   : Union[str, Any]       					=				self.config_dict[model_name]
  
              if self.args.torchscript:
                     _A   : Tuple       					=				True
  
              _A   : Tuple       					=				(
                  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   : List[Any]       					=				__import__("transformers"				,		fromlist=[model_class])
                            _A   : List[str]       					=				getattr(__lowerCamelCase				,		__lowerCamelCase)
                            _A   : Dict       					=				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_MAPPING[config.__class__](__lowerCamelCase)
  
              model.eval()
              model.to(self.args.device)
  
              # encoder-decoder has vocab size saved differently
              _A   : Tuple       					=				config.vocab_size if hasattr(__lowerCamelCase				,		"vocab_size") else config.encoder.vocab_size
              _A   : Optional[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   : Optional[int]       					=				torch.jit.trace(__lowerCamelCase				,		__lowerCamelCase)
              else:
                     _A   : List[Any]       					=				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   : Tuple       					=				inference_model(__lowerCamelCase)
                     return outputs
  
              _A   : List[str]       					=				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
              return _forward
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase				,		__lowerCamelCase				,		__lowerCamelCase)    ->       Callable[[], None]:
              _A   : Dict       					=				self.config_dict[model_name]
  
              _A   : Tuple       					=				(
                  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   : List[Any]       					=				config.architectures[0]
                            _A   : Optional[int]       					=				__import__("transformers"				,		fromlist=[model_class])
                            _A   : List[Any]       					=				getattr(__lowerCamelCase				,		__lowerCamelCase)
                            _A   : Optional[int]       					=				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   : Optional[Any]       					=				MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__lowerCamelCase)
  
              if self.args.torchscript:
                     raise NotImplementedError("Training for torchscript is currently not implemented")
              else:
                     _A   : str       					=				model
  
              model.train()
              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   : 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   : Any       					=				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   : List[Any]       					=				(
                  compute_loss_and_backprob_encoder_decoder
                  if config.is_encoder_decoder
                  else compute_loss_and_backprob_encoder
              )
              return _train
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase)    ->       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(
                                __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   : Any       					=				timeit.repeat(
                         __lowerCamelCase				,		repeat=self.args.repeat				,		number=1_0				,		)
  
                     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) / 1_0.0
              except RuntimeError as e:
                     self.print_fn(F"Doesn't fit on GPU. {e}")
                     return "N/A"
  
  
       def 				_lowerCamelCase				(		self				,		__lowerCamelCase)    ->       [Memory, MemorySummary]:
              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   : Any       					=				"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   : int       					=				nvml.nvmlDeviceGetMemoryInfo(__lowerCamelCase)
                                   _A   : List[str]       					=				meminfo.used
                                   _A   : List[Any]       					=				Memory(__lowerCamelCase)
                                   # shutdown nvml
                                   nvml.nvmlShutdown()
                     else:
                            # cpu
                            _A   : Tuple       					=				measure_peak_memory_cpu(__lowerCamelCase)
                            _A   : Union[str, Any]       					=				Memory(__lowerCamelCase) if isinstance(__lowerCamelCase				,		__lowerCamelCase) else memory_bytes
  
                     if self.args.trace_memory_line_by_line:
                            _A   : Dict       					=				stop_memory_tracing(__lowerCamelCase)
                     else:
                            _A   : List[Any]       					=				None
  
                     return memory, summary
              except RuntimeError as e:
                     self.print_fn(F"Doesn't fit on GPU. {e}")
                     return "N/A", None
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_tf_available,
      is_torch_available,
      is_vision_available,
  )
  
  
  lowerCAmelCase__   	=				{
      'configuration_segformer': ['SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SegformerConfig', 'SegformerOnnxConfig']
  }
  
  try:
      if not is_vision_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				['SegformerFeatureExtractor']
      lowerCAmelCase__   	=				['SegformerImageProcessor']
  
  try:
      if not is_torch_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				[
          'SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'SegformerDecodeHead',
          'SegformerForImageClassification',
          'SegformerForSemanticSegmentation',
          'SegformerLayer',
          'SegformerModel',
          'SegformerPreTrainedModel',
      ]
  
  try:
      if not is_tf_available():
          raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
      pass
  else:
      lowerCAmelCase__   	=				[
          'TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFSegformerDecodeHead',
          'TFSegformerForImageClassification',
          'TFSegformerForSemanticSegmentation',
          'TFSegformerModel',
          'TFSegformerPreTrainedModel',
      ]
  
  
  if TYPE_CHECKING:
      from .configuration_segformer import SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, SegformerConfig, SegformerOnnxConfig
  
      try:
          if not is_vision_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .feature_extraction_segformer import SegformerFeatureExtractor
          from .image_processing_segformer import SegformerImageProcessor
  
      try:
          if not is_torch_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_segformer import (
              SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              SegformerDecodeHead,
              SegformerForImageClassification,
              SegformerForSemanticSegmentation,
              SegformerLayer,
              SegformerModel,
              SegformerPreTrainedModel,
          )
      try:
          if not is_tf_available():
              raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
          pass
      else:
          from .modeling_tf_segformer import (
              TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFSegformerDecodeHead,
              TFSegformerForImageClassification,
              TFSegformerForSemanticSegmentation,
              TFSegformerModel,
              TFSegformerPreTrainedModel,
          )
  
  else:
      import sys
  
      lowerCAmelCase__   	=				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  