





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






class 							__snake_case    (				__magic_name__       ):
	__lowerCAmelCase						=     42
	__lowerCAmelCase						=     42
	__lowerCAmelCase						=     "PyTorch"





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





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		float:
		snake_case__  					=      self._prepare_inference_func(UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)
		return self._measure_speed(_inference		)





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		[Memory, Optional[MemorySummary]]:
		snake_case__  					=      self._prepare_inference_func(UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)
		return self._measure_memory(_inference		)





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		float:
		snake_case__  					=      self._prepare_train_func(UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)
		return self._measure_speed(_train		)





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		[Memory, Optional[MemorySummary]]:
		snake_case__  					=      self._prepare_train_func(UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)
		return self._measure_memory(_train		)





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		Callable[[], None]:
		snake_case__  					=      self.config_dict[model_name]

		if self.args.torchscript:
			snake_case__  					=      True

		snake_case__  					=      (
		    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:
				snake_case__  					=      config.architectures[0]
				snake_case__  					=      __import__('transformers'			,					fromlist=[model_class]		)
				snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
				snake_case__  					=      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:
			snake_case__  					=      MODEL_MAPPING[config.__class__](UpperCamelCase_		)

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

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

		def encoder_decoder_forward():
			with torch.no_grad():
				snake_case__  					=      inference_model(UpperCamelCase_			,					decoder_input_ids=UpperCamelCase_		)
			return outputs

		def encoder_forward():
			with torch.no_grad():
				snake_case__  					=      inference_model(UpperCamelCase_		)
			return outputs

		snake_case__  					=      encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
		return _forward





	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		Callable[[], None]:
		snake_case__  					=      self.config_dict[model_name]

		snake_case__  					=      (
		    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:
				snake_case__  					=      config.architectures[0]
				snake_case__  					=      __import__('transformers'			,					fromlist=[model_class]		)
				snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
				snake_case__  					=      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:
			snake_case__  					=      MODEL_WITH_LM_HEAD_MAPPING[config.__class__](UpperCamelCase_		)

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

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

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

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

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





	def      _snake_case      (		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
			snake_case__  					=      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_		) / 1_0.0
		except RuntimeError as e:
			self.print_fn(F'''Doesn\'t fit on GPU. {e}'''		)
			return "N/A"





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

			if self.args.trace_memory_line_by_line:
				snake_case__  					=      stop_memory_tracing(UpperCamelCase_		)
			else:
				snake_case__  					=      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 ...configuration_utils import PretrainedConfig
from ...utils import is_detectrona_available, logging


a__				: Optional[Any]									=    logging.get_logger(__name__)

a__				: List[str]									=    {
    '''layoutlmv2-base-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json''',
    '''layoutlmv2-large-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json''',
    # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
}

# soft dependency
if is_detectrona_available():
			import detectrona






class 							__snake_case    (				__magic_name__       ):
	__lowerCAmelCase						=     '''layoutlmv2'''





	def __init__(		self			,					UpperCamelCase_=3_0522			,					UpperCamelCase_=768			,					UpperCamelCase_=12			,					UpperCamelCase_=12			,					UpperCamelCase_=3072			,					UpperCamelCase_="gelu"			,					UpperCamelCase_=0.1			,					UpperCamelCase_=0.1			,					UpperCamelCase_=512			,					UpperCamelCase_=2			,					UpperCamelCase_=0.0_2			,					UpperCamelCase_=1E-1_2			,					UpperCamelCase_=0			,					UpperCamelCase_=1024			,					UpperCamelCase_=128			,					UpperCamelCase_=32			,					UpperCamelCase_=True			,					UpperCamelCase_=256			,					UpperCamelCase_=64			,					UpperCamelCase_=True			,					UpperCamelCase_=[7, 7, 256]			,					UpperCamelCase_=128			,					UpperCamelCase_=128			,					UpperCamelCase_=True			,					UpperCamelCase_=True			,					UpperCamelCase_=False			,					UpperCamelCase_=None			,					**UpperCamelCase_			,					)			->		Tuple:
		super().__init__(
		    vocab_size=UpperCamelCase_			,					hidden_size=UpperCamelCase_			,					num_hidden_layers=UpperCamelCase_			,					num_attention_heads=UpperCamelCase_			,					intermediate_size=UpperCamelCase_			,					hidden_act=UpperCamelCase_			,					hidden_dropout_prob=UpperCamelCase_			,					attention_probs_dropout_prob=UpperCamelCase_			,					max_position_embeddings=UpperCamelCase_			,					type_vocab_size=UpperCamelCase_			,					initializer_range=UpperCamelCase_			,					layer_norm_eps=UpperCamelCase_			,					pad_token_id=UpperCamelCase_			,					**UpperCamelCase_			,					)
		snake_case__  					=      max_ad_position_embeddings
		snake_case__  					=      max_rel_pos
		snake_case__  					=      rel_pos_bins
		snake_case__  					=      fast_qkv
		snake_case__  					=      max_rel_ad_pos
		snake_case__  					=      rel_ad_pos_bins
		snake_case__  					=      convert_sync_batchnorm
		snake_case__  					=      image_feature_pool_shape
		snake_case__  					=      coordinate_size
		snake_case__  					=      shape_size
		snake_case__  					=      has_relative_attention_bias
		snake_case__  					=      has_spatial_attention_bias
		snake_case__  					=      has_visual_segment_embedding
		snake_case__  					=      (
		    detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
		)





	@classmethod
	def      _snake_case      (		self		)			->		Dict:
		return {
		    "MODEL.MASK_ON": True,
		    "MODEL.PIXEL_STD": [5_7.3_7_5, 5_7.1_2_0, 5_8.3_9_5],
		    "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
		    "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
		    "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [128], [256], [512]],
		    "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
		    "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 2000,
		    "MODEL.RPN.PRE_NMS_TOPK_TEST": 1000,
		    "MODEL.RPN.POST_NMS_TOPK_TRAIN": 1000,
		    "MODEL.POST_NMS_TOPK_TEST": 1000,
		    "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
		    "MODEL.ROI_HEADS.NUM_CLASSES": 5,
		    "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
		    "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
		    "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
		    "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
		    "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
		    "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
		    "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
		    "MODEL.RESNETS.DEPTH": 101,
		    "MODEL.RESNETS.SIZES": [[32], [64], [128], [256], [512]],
		    "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
		    "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
		    "MODEL.RESNETS.NUM_GROUPS": 32,
		    "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
		    "MODEL.RESNETS.STRIDE_IN_1X1": False,
		}





	def      _snake_case      (		self		)			->		Optional[Any]:
		snake_case__  					=      detectrona.config.get_cfg()
		for k, v in self.detectrona_config_args.items():
			snake_case__  					=      k.split('.'		)
			snake_case__  					=      detectrona_config
			for attribute in attributes[:-1]:
				snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
			setattr(UpperCamelCase_			,					attributes[-1]			,					UpperCamelCase_		)

		return detectrona_config



