code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  import glob
  import os
  from typing import Dict, List, Union
  
  import torch
  
  from diffusers.utils import is_safetensors_available
  
  
  if is_safetensors_available():
  			import safetensors.torch
  
  from huggingface_hub import snapshot_download
  
  from diffusers import DiffusionPipeline, __version__
  from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
  from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME
  
  
  
  
  
  
  class 							__snake_case    (				__magic_name__       ):
  
  
  
  
  
  	def __init__(		self		)			->		Optional[int]:
  		self.register_to_config()
  		super().__init__()
  
  
  
  
  
  	def      _snake_case      (		self			,					UpperCamelCase_			,					UpperCamelCase_		)			->		List[str]:
  		if dicta == dicta:
  			return True
  		else:
  			snake_case__					,     snake_case__  					=      self._remove_meta_keys(UpperCamelCase_		)
  			snake_case__					,     snake_case__  					=      self._remove_meta_keys(UpperCamelCase_		)
  			if configa == configa:
  				print(F'''Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}.'''		)
  				return True
  		return False
  
  
  
  
  
  	def      _snake_case      (		self			,					UpperCamelCase_		)			->		int:
  		snake_case__  					=      []
  		snake_case__  					=      config_dict.copy()
  		for key in config_dict.keys():
  			if key.startswith('_'		):
  				temp_dict.pop(UpperCamelCase_		)
  				meta_keys.append(UpperCamelCase_		)
  		return (temp_dict, meta_keys)
  
  
  
  
  
  	@torch.no_grad()
  	def      _snake_case      (		self			,					UpperCamelCase_			,					**UpperCamelCase_		)			->		str:
  		snake_case__  					=      kwargs.pop('cache_dir'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('resume_download'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('force_download'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('proxies'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('local_files_only'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('use_auth_token'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('revision'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('torch_dtype'			,					UpperCamelCase_		)
  		snake_case__  					=      kwargs.pop('device_map'			,					UpperCamelCase_		)
  
  		snake_case__  					=      kwargs.pop('alpha'			,					0.5		)
  		snake_case__  					=      kwargs.pop('interp'			,					UpperCamelCase_		)
  
  		print('Received list'			,					UpperCamelCase_		)
  		print(F'''Combining with alpha={alpha}, interpolation mode={interp}'''		)
  
  		snake_case__  					=      len(UpperCamelCase_		)
  		# Ignore result from model_index_json comparision of the two checkpoints
  		snake_case__  					=      kwargs.pop('force'			,					UpperCamelCase_		)
  
  		# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
  		if checkpoint_count > 3 or checkpoint_count < 2:
  			raise ValueError(
  			    'Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being'
  			    ' passed.'		)
  
  		print('Received the right number of checkpoints'		)
  		# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
  		# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None
  
  		# Validate that the checkpoints can be merged
  		# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
  		snake_case__  					=      []
  		for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
  			snake_case__  					=      DiffusionPipeline.load_config(
  			    UpperCamelCase_			,					cache_dir=UpperCamelCase_			,					resume_download=UpperCamelCase_			,					force_download=UpperCamelCase_			,					proxies=UpperCamelCase_			,					local_files_only=UpperCamelCase_			,					use_auth_token=UpperCamelCase_			,					revision=UpperCamelCase_			,					)
  			config_dicts.append(UpperCamelCase_		)
  
  		snake_case__  					=      True
  		for idx in range(1			,					len(UpperCamelCase_		)		):
  			comparison_result &= self._compare_model_configs(config_dicts[idx - 1]			,					config_dicts[idx]		)
  			if not force and comparison_result is False:
  				raise ValueError('Incompatible checkpoints. Please check model_index.json for the models.'		)
  				print(config_dicts[0]			,					config_dicts[1]		)
  		print('Compatible model_index.json files found'		)
  		# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
  		snake_case__  					=      []
  		for pretrained_model_name_or_path, config_dict in zip(UpperCamelCase_			,					UpperCamelCase_		):
  			snake_case__  					=      [k for k in config_dict.keys() if not k.startswith('_'		)]
  			snake_case__  					=      [os.path.join(UpperCamelCase_			,					'*'		) for k in folder_names]
  			allow_patterns += [
  			    WEIGHTS_NAME,
  			    SCHEDULER_CONFIG_NAME,
  			    CONFIG_NAME,
  			    ONNX_WEIGHTS_NAME,
  			    DiffusionPipeline.config_name,
  			]
  			snake_case__  					=      config_dict.get('_class_name'		)
  			snake_case__  					=      {'diffusers': __version__, 'pipeline_class': requested_pipeline_class}
  
  			snake_case__  					=      (
  			    pretrained_model_name_or_path
  			    if os.path.isdir(UpperCamelCase_		)
  			    else snapshot_download(
  			        UpperCamelCase_			,					cache_dir=UpperCamelCase_			,					resume_download=UpperCamelCase_			,					proxies=UpperCamelCase_			,					local_files_only=UpperCamelCase_			,					use_auth_token=UpperCamelCase_			,					revision=UpperCamelCase_			,					allow_patterns=UpperCamelCase_			,					user_agent=UpperCamelCase_			,					)
  			)
  			print('Cached Folder'			,					UpperCamelCase_		)
  			cached_folders.append(UpperCamelCase_		)
  
  		# Step 3:-
  		# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
  		snake_case__  					=      DiffusionPipeline.from_pretrained(
  		    cached_folders[0]			,					torch_dtype=UpperCamelCase_			,					device_map=UpperCamelCase_		)
  		final_pipe.to(self.device		)
  
  		snake_case__  					=      None
  		if len(UpperCamelCase_		) > 2:
  			snake_case__  					=      os.path.join(cached_folders[2]		)
  
  		if interp == "sigmoid":
  			snake_case__  					=      CheckpointMergerPipeline.sigmoid
  		elif interp == "inv_sigmoid":
  			snake_case__  					=      CheckpointMergerPipeline.inv_sigmoid
  		elif interp == "add_diff":
  			snake_case__  					=      CheckpointMergerPipeline.add_difference
  		else:
  			snake_case__  					=      CheckpointMergerPipeline.weighted_sum
  
  		# Find each module's state dict.
  		for attr in final_pipe.config.keys():
  			if not attr.startswith('_'		):
  				snake_case__  					=      os.path.join(cached_folders[1]			,					UpperCamelCase_		)
  				if os.path.exists(UpperCamelCase_		):
  					snake_case__  					=      [
  					    *glob.glob(os.path.join(UpperCamelCase_			,					'*.safetensors'		)		),
  					    *glob.glob(os.path.join(UpperCamelCase_			,					'*.bin'		)		),
  					]
  					snake_case__  					=      files[0] if len(UpperCamelCase_		) > 0 else None
  				if len(UpperCamelCase_		) < 3:
  					snake_case__  					=      None
  				else:
  					snake_case__  					=      os.path.join(cached_folders[2]			,					UpperCamelCase_		)
  					if os.path.exists(UpperCamelCase_		):
  						snake_case__  					=      [
  						    *glob.glob(os.path.join(UpperCamelCase_			,					'*.safetensors'		)		),
  						    *glob.glob(os.path.join(UpperCamelCase_			,					'*.bin'		)		),
  						]
  						snake_case__  					=      files[0] if len(UpperCamelCase_		) > 0 else None
                  # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                  # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
  				if checkpoint_path_a is None and checkpoint_path_a is None:
  					print(F'''Skipping {attr}: not present in 2nd or 3d model'''		)
  					continue
  				try:
  					snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
  					if isinstance(UpperCamelCase_			,					UpperCamelCase_		):  # ignore requires_safety_checker boolean
  						continue
  					snake_case__  					=      getattr(UpperCamelCase_			,					'state_dict'		)
  					snake_case__  					=      theta_a()
  
  					snake_case__  					=      getattr(UpperCamelCase_			,					'load_state_dict'		)
  					snake_case__  					=      (
  					    safetensors.torch.load_file(UpperCamelCase_		)
  					    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'		))
  					    else torch.load(UpperCamelCase_			,					map_location='cpu'		)
  					)
  					snake_case__  					=      None
  					if checkpoint_path_a:
  						snake_case__  					=      (
  						    safetensors.torch.load_file(UpperCamelCase_		)
  						    if (is_safetensors_available() and checkpoint_path_a.endswith('.safetensors'		))
  						    else torch.load(UpperCamelCase_			,					map_location='cpu'		)
  						)
  
  					if not theta_a.keys() == theta_a.keys():
  						print(F'''Skipping {attr}: key mismatch'''		)
  						continue
  					if theta_a and not theta_a.keys() == theta_a.keys():
  						print(F'''Skipping {attr}:y mismatch'''		)
  				except Exception as e:
  					print(F'''Skipping {attr} do to an unexpected error: {str(UpperCamelCase_		)}'''		)
  					continue
  				print(F'''MERGING {attr}'''		)
  
  				for key in theta_a.keys():
  					if theta_a:
  						snake_case__  					=      theta_func(theta_a[key]			,					theta_a[key]			,					theta_a[key]			,					UpperCamelCase_		)
  					else:
  						snake_case__  					=      theta_func(theta_a[key]			,					theta_a[key]			,					UpperCamelCase_			,					UpperCamelCase_		)
  
  				del theta_a
  				del theta_a
  				update_theta_a(UpperCamelCase_		)
  
  				del theta_a
  		return final_pipe
  
  
  
  
  
  	@staticmethod
  	def      _snake_case      (		UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		List[Any]:
  		return ((1 - alpha) * thetaa) + (alpha * thetaa)
  
  
  
  
  
  	@staticmethod
  	def      _snake_case      (		UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		Dict:
  		snake_case__  					=      alpha * alpha * (3 - (2 * alpha))
  		return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
  
  	@staticmethod
  	def      _snake_case      (		UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		List[str]:
  		import math
  
  		snake_case__  					=      0.5 - math.sin(math.asin(1.0 - 2.0 * alpha		) / 3.0		)
  		return thetaa + ((thetaa - thetaa) * alpha)
  
  
  
  
  
  	@staticmethod
  	def      _snake_case      (		UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_			,					UpperCamelCase_		)			->		Optional[int]:
  		return thetaa + (thetaa - thetaa) * (1.0 - alpha)
  
  
  
  
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
  
  
  
  