





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










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



