code: 
  '''simple docstring'''
  from ...configuration_utils import PretrainedConfig
  from ...utils import is_detectrona_available, logging
  
  
  snake_case						=			logging.get_logger(__name__)
  
  snake_case						=			{
      "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__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	"""layoutlmv2"""
  
  
  
  		def __init__(			self							: List[str]     ,  UpperCamelCase__							: str=3_0522     ,  UpperCamelCase__							: Any=768     ,  UpperCamelCase__							: Dict=12     ,  UpperCamelCase__							: List[str]=12     ,  UpperCamelCase__							: Optional[int]=3072     ,  UpperCamelCase__							: List[Any]="gelu"     ,  UpperCamelCase__							: Optional[int]=0.1     ,  UpperCamelCase__							: str=0.1     ,  UpperCamelCase__							: Optional[Any]=512     ,  UpperCamelCase__							: int=2     ,  UpperCamelCase__							: List[Any]=0.02     ,  UpperCamelCase__							: Optional[int]=1e-1_2     ,  UpperCamelCase__							: Union[str, Any]=0     ,  UpperCamelCase__							: int=1024     ,  UpperCamelCase__							: List[Any]=128     ,  UpperCamelCase__							: List[str]=32     ,  UpperCamelCase__							: Optional[int]=True     ,  UpperCamelCase__							: List[str]=256     ,  UpperCamelCase__							: List[str]=64     ,  UpperCamelCase__							: Dict=True     ,  UpperCamelCase__							: Tuple=[7, 7, 256]     ,  UpperCamelCase__							: Optional[Any]=128     ,  UpperCamelCase__							: int=128     ,  UpperCamelCase__							: Union[str, Any]=True     ,  UpperCamelCase__							: Any=True     ,  UpperCamelCase__							: Optional[int]=False     ,  UpperCamelCase__							: List[str]=None     ,  **UpperCamelCase__							: str     ,  )	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				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     :					Optional[int]     =	max_ad_position_embeddings
  				snake_case     :					Optional[int]     =	max_rel_pos
  				snake_case     :					Optional[Any]     =	rel_pos_bins
  				snake_case     :					int     =	fast_qkv
  				snake_case     :					int     =	max_rel_ad_pos
  				snake_case     :					str     =	rel_ad_pos_bins
  				snake_case     :					Optional[int]     =	convert_sync_batchnorm
  				snake_case     :					Any     =	image_feature_pool_shape
  				snake_case     :					Optional[int]     =	coordinate_size
  				snake_case     :					Union[str, Any]     =	shape_size
  				snake_case     :					Optional[int]     =	has_relative_attention_bias
  				snake_case     :					str     =	has_spatial_attention_bias
  				snake_case     :					Any     =	has_visual_segment_embedding
  				snake_case     :					Union[str, Any]     =	(
  				    detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
  				)
  
  
  
  		@classmethod
  		def 			lowerCAmelCase							(			self							: Optional[int]			)	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				return {
  				    "MODEL.MASK_ON": True,
  				    "MODEL.PIXEL_STD": [57.375, 57.120, 58.395],
  				    "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 			lowerCAmelCase							(			self							: Any			)	-> str:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					int     =	detectrona.config.get_cfg()
  				for k, v in self.detectrona_config_args.items():
  						snake_case     :					Optional[int]     =	k.split('''.'''			)
  						snake_case     :					Optional[Any]     =	detectrona_config
  						for attribute in attributes[:-1]:
  								snake_case     :					List[Any]     =	getattr(UpperCamelCase__     ,  UpperCamelCase__			)
  						setattr(UpperCamelCase__     ,  attributes[-1]     ,  UpperCamelCase__			)
  
  				return detectrona_config
  
  
  
style_context: 
  '''simple docstring'''
  import torch
  
  from transformers import AutoTokenizer
  
  
  
  
  
  
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def __init__(			self							: Union[str, Any]     ,  UpperCamelCase__							: List[str]			)	-> List[str]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[Any]     =	AutoTokenizer.from_pretrained(UpperCamelCase__			)
  
  
  
  		def 			lowerCAmelCase							(			self							: Any     ,  UpperCamelCase__							: str			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				if isinstance(UpperCamelCase__     ,  UpperCamelCase__			) and all(isinstance(_x     ,  UpperCamelCase__			) for _x in x			):
  						snake_case     :					Any     =	None
  						for l in x:
  								snake_case     :					str     =	self.tokenizer(
  								    UpperCamelCase__     ,  padding='''max_length'''     ,  max_length=384     ,  truncation=UpperCamelCase__     ,  return_tensors='''pt'''     ,  )
  								snake_case     :					Tuple     =	torch.tensor([len(UpperCamelCase__			)]			)
  								if d is not None:
  										for k in d.keys():
  												snake_case     :					int     =	torch.cat((d[k], t[k])     ,  0			)
  								else:
  										snake_case     :					List[str]     =	t
  
  						snake_case     :					Union[str, Any]     =	torch.tensor(self.tokenizer.convert_tokens_to_ids('''[E]'''			)			)
  						snake_case     :					int     =	torch.tensor(self.tokenizer.convert_tokens_to_ids('''[/E]'''			)			)
  
  				elif isinstance(UpperCamelCase__     ,  UpperCamelCase__			) and all(isinstance(_x     ,  UpperCamelCase__			) for _x in x			):
  						snake_case     :					Optional[int]     =	self.tokenizer(
  						    UpperCamelCase__     ,  padding='''max_length'''     ,  max_length=384     ,  truncation=UpperCamelCase__     ,  return_tensors='''pt'''     ,  )
  
  				else:
  						raise Exception(
  						    '''Type of parameter x was not recognized! Only `list of strings` for query or `list of lists of'''
  						    ''' strings` for supports are supported.'''			)
  
  				return d
  
  
  
  		def 			lowerCAmelCase							(			self							: int     ,  UpperCamelCase__							: List[Any]     ,  UpperCamelCase__							: List[Any]     ,  UpperCamelCase__							: Any     ,  UpperCamelCase__							: Tuple     ,  UpperCamelCase__							: Any=0.70			)	-> Dict:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					str     =	[]
  				for idx in range(len(W_query['''input_ids''']			)			):
  						snake_case     :					Optional[int]     =	range(p_start.shape[1]			)
  
  						snake_case     :					str     =	[]
  						for start_id in start_indexes:
  								for end_id in end_indexes:
  										if start_id < end_id:
  												output.append(
  												    (
  												        start_id,
  												        end_id,
  												        p_start[idx][start_id].item(),
  												        p_end[idx][end_id].item(),
  												    )			)
  
  						output.sort(key=lambda UpperCamelCase__			: (tup[2] * tup[3])     ,  reverse=UpperCamelCase__			)
  						snake_case     :					int     =	[]
  						for k in range(len(UpperCamelCase__			)			):
  								if output[k][2] * output[k][3] >= thresh:
  										snake_case ,snake_case     :					Tuple     =	output[k][0], output[k][1]
  										snake_case     :					str     =	self.tokenizer.decode(W_query['''input_ids'''][idx][c_start_pos:c_end_pos]			)
  										temp.append((decoded, output[k][2] * output[k][3])			)
  
  						final_outputs.append(UpperCamelCase__			)
  
  				return final_outputs
  
  
  