




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










import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
					import torch

if is_vision_available():
					from PIL import Image

					from transformers import SegformerImageProcessor





class        a__      (	unittest.TestCase		):






		def __init__(      self							, lowercase__							, lowercase__=7							, lowercase__=3							, lowercase__=30							, lowercase__=400							, lowercase__=True							, lowercase__=None							, lowercase__=True							, lowercase__=[0.5, 0.5, 0.5]							, lowercase__=[0.5, 0.5, 0.5]							, lowercase__=False							, )				->				Tuple:
				__A    =							size if size is not None else {"height": 30, "width": 30}
				__A    =							parent
				__A    =							batch_size
				__A    =							num_channels
				__A    =							min_resolution
				__A    =							max_resolution
				__A    =							do_resize
				__A    =							size
				__A    =							do_normalize
				__A    =							image_mean
				__A    =							image_std
				__A    =							do_reduce_labels






		def 					_lowerCamelCase					(      self						)				->				Union[str, Any]:
				return {
				    "do_resize": self.do_resize,
				    "size": self.size,
				    "do_normalize": self.do_normalize,
				    "image_mean": self.image_mean,
				    "image_std": self.image_std,
				    "do_reduce_labels": self.do_reduce_labels,
				}



def      UpperCAmelCase						( ):


		'''simple docstring'''

		__A    =							load_dataset("hf-internal-testing/fixtures_ade20k"					,     split="test"	)

		__A    =							Image.open(dataset[0]["file"]	)
		__A    =							Image.open(dataset[1]["file"]	)

		return image, map



def      UpperCAmelCase						( ):


		'''simple docstring'''

		__A    =							load_dataset("hf-internal-testing/fixtures_ade20k"					,     split="test"	)

		__A    =							Image.open(dataset[0]["file"]	)
		__A    =							Image.open(dataset[1]["file"]	)
		__A    =							Image.open(dataset[2]["file"]	)
		__A    =							Image.open(dataset[3]["file"]	)

		return [imagea, imagea], [mapa, mapa]





@require_torch
@require_vision
class        a__      (	lowerCAmelCase__	,       unittest.TestCase		):
		UpperCAmelCase_							:       Dict 					= SegformerImageProcessor if is_vision_available() else None






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				__A    =							SegformerImageProcessingTester(self						)






		@property
		def 					_lowerCamelCase					(      self						)				->				str:
				return self.image_processor_tester.prepare_image_processor_dict()






		def 					_lowerCamelCase					(      self						)				->				Union[str, Any]:
				__A    =							self.image_processing_class(**self.image_processor_dict						)
				self.assertTrue(hasattr(lowercase__							, "do_resize"						)						)
				self.assertTrue(hasattr(lowercase__							, "size"						)						)
				self.assertTrue(hasattr(lowercase__							, "do_normalize"						)						)
				self.assertTrue(hasattr(lowercase__							, "image_mean"						)						)
				self.assertTrue(hasattr(lowercase__							, "image_std"						)						)
				self.assertTrue(hasattr(lowercase__							, "do_reduce_labels"						)						)






		def 					_lowerCamelCase					(      self						)				->				Union[str, Any]:
				__A    =							self.image_processing_class.from_dict(self.image_processor_dict						)
				self.assertEqual(image_processor.size							, {"height": 30, "width": 30}						)
				self.assertEqual(image_processor.do_reduce_labels							, lowercase__						)

				__A    =							self.image_processing_class.from_dict(self.image_processor_dict							, size=42							, reduce_labels=lowercase__						)
				self.assertEqual(image_processor.size							, {"height": 42, "width": 42}						)
				self.assertEqual(image_processor.do_reduce_labels							, lowercase__						)






		def 					_lowerCamelCase					(      self						)				->				Optional[int]:
				pass






		def 					_lowerCamelCase					(      self						)				->				Union[str, Any]:
				# Initialize image_processing
				__A    =							self.image_processing_class(**self.image_processor_dict						)
				# create random PIL images
				__A    =							prepare_image_inputs(self.image_processor_tester							, equal_resolution=lowercase__						)
				for image in image_inputs:
						self.assertIsInstance(lowercase__							, Image.Image						)

				# Test not batched input
				__A    =							image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )

				# Test batched
				__A    =							image_processing(lowercase__							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				# Initialize image_processing
				__A    =							self.image_processing_class(**self.image_processor_dict						)
				# create random numpy tensors
				__A    =							prepare_image_inputs(self.image_processor_tester							, equal_resolution=lowercase__							, numpify=lowercase__						)
				for image in image_inputs:
						self.assertIsInstance(lowercase__							, np.ndarray						)

				# Test not batched input
				__A    =							image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )

				# Test batched
				__A    =							image_processing(lowercase__							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )






		def 					_lowerCamelCase					(      self						)				->				List[str]:
				# Initialize image_processing
				__A    =							self.image_processing_class(**self.image_processor_dict						)
				# create random PyTorch tensors
				__A    =							prepare_image_inputs(self.image_processor_tester							, equal_resolution=lowercase__							, torchify=lowercase__						)
				for image in image_inputs:
						self.assertIsInstance(lowercase__							, torch.Tensor						)

				# Test not batched input
				__A    =							image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )

				# Test batched
				__A    =							image_processing(lowercase__							, return_tensors="pt"						).pixel_values
				self.assertEqual(
				    encoded_images.shape							, (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )






		def 					_lowerCamelCase					(      self						)				->				Dict:
				# Initialize image_processing
				__A    =							self.image_processing_class(**self.image_processor_dict						)
				# create random PyTorch tensors
				__A    =							prepare_image_inputs(self.image_processor_tester							, equal_resolution=lowercase__							, torchify=lowercase__						)
				__A    =							[]
				for image in image_inputs:
						self.assertIsInstance(lowercase__							, torch.Tensor						)
						maps.append(torch.zeros(image.shape[-2:]						).long()						)

				# Test not batched input
				__A    =							image_processing(image_inputs[0]							, maps[0]							, return_tensors="pt"						)
				self.assertEqual(
				    encoding["pixel_values"].shape							, (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(
				    encoding["labels"].shape							, (
				        1,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(encoding["labels"].dtype							, torch.long						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 255						)

				# Test batched
				__A    =							image_processing(lowercase__							, lowercase__							, return_tensors="pt"						)
				self.assertEqual(
				    encoding["pixel_values"].shape							, (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(
				    encoding["labels"].shape							, (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(encoding["labels"].dtype							, torch.long						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 255						)

				# Test not batched input (PIL images)
				__A ,   __A    =							prepare_semantic_single_inputs()

				__A    =							image_processing(lowercase__							, lowercase__							, return_tensors="pt"						)
				self.assertEqual(
				    encoding["pixel_values"].shape							, (
				        1,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(
				    encoding["labels"].shape							, (
				        1,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(encoding["labels"].dtype							, torch.long						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 255						)

				# Test batched input (PIL images)
				__A ,   __A    =							prepare_semantic_batch_inputs()

				__A    =							image_processing(lowercase__							, lowercase__							, return_tensors="pt"						)
				self.assertEqual(
				    encoding["pixel_values"].shape							, (
				        2,
				        self.image_processor_tester.num_channels,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(
				    encoding["labels"].shape							, (
				        2,
				        self.image_processor_tester.size["height"],
				        self.image_processor_tester.size["width"],
				    )							, )
				self.assertEqual(encoding["labels"].dtype							, torch.long						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 255						)






		def 					_lowerCamelCase					(      self						)				->				Tuple:
				# Initialize image_processing
				__A    =							self.image_processing_class(**self.image_processor_dict						)

				# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
				__A ,   __A    =							prepare_semantic_single_inputs()
				__A    =							image_processing(lowercase__							, lowercase__							, return_tensors="pt"						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 150						)

				__A    =							True
				__A    =							image_processing(lowercase__							, lowercase__							, return_tensors="pt"						)
				self.assertTrue(encoding["labels"].min().item() >= 0						)
				self.assertTrue(encoding["labels"].max().item() <= 255						)

