code: 
  
  
  
  
  
  '''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
  
  
  
  
style_context: 
  
  
  
  
  
  '''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
  
  
  
  