




import argparse
import re

import numpy as np
import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SamConfig,
    SamImageProcessor,
    SamModel,
    SamProcessor,
    SamVisionConfig,
)


UpperCAmelCase_						={
    """iou_prediction_head.layers.0""": """iou_prediction_head.proj_in""",
    """iou_prediction_head.layers.1""": """iou_prediction_head.layers.0""",
    """iou_prediction_head.layers.2""": """iou_prediction_head.proj_out""",
    """mask_decoder.output_upscaling.0""": """mask_decoder.upscale_conv1""",
    """mask_decoder.output_upscaling.1""": """mask_decoder.upscale_layer_norm""",
    """mask_decoder.output_upscaling.3""": """mask_decoder.upscale_conv2""",
    """mask_downscaling.0""": """mask_embed.conv1""",
    """mask_downscaling.1""": """mask_embed.layer_norm1""",
    """mask_downscaling.3""": """mask_embed.conv2""",
    """mask_downscaling.4""": """mask_embed.layer_norm2""",
    """mask_downscaling.6""": """mask_embed.conv3""",
    """point_embeddings""": """point_embed""",
    """pe_layer.positional_encoding_gaussian_matrix""": """shared_embedding.positional_embedding""",
    """image_encoder""": """vision_encoder""",
    """neck.0""": """neck.conv1""",
    """neck.1""": """neck.layer_norm1""",
    """neck.2""": """neck.conv2""",
    """neck.3""": """neck.layer_norm2""",
    """patch_embed.proj""": """patch_embed.projection""",
    """.norm""": """.layer_norm""",
    """blocks""": """layers""",
}



def       UpperCAmelCase       (     _snake_case							):
							lowerCAmelCase   =		{}
							state_dict.pop('''pixel_mean'''						, _snake_case							)
							state_dict.pop('''pixel_std'''						, _snake_case							)

							lowerCAmelCase   =		R'''.*.output_hypernetworks_mlps.(\d+).layers.(\d+).*'''

							for key, value in state_dict.items():
														for key_to_modify, new_key in KEYS_TO_MODIFY_MAPPING.items():
																					if key_to_modify in key:
																												lowerCAmelCase   =		key.replace(_snake_case						, _snake_case							)

														if re.match(_snake_case						, _snake_case							):
																					lowerCAmelCase   =		int(re.match(_snake_case						, _snake_case							).group(2							)							)
																					if layer_nb == 0:
																												lowerCAmelCase   =		key.replace('''layers.0'''						, '''proj_in'''							)
																					elif layer_nb == 1:
																												lowerCAmelCase   =		key.replace('''layers.1'''						, '''layers.0'''							)
																					elif layer_nb == 2:
																												lowerCAmelCase   =		key.replace('''layers.2'''						, '''proj_out'''							)

														lowerCAmelCase   =		value

							lowerCAmelCase   =		model_state_dict[
							    '''prompt_encoder.shared_embedding.positional_embedding'''
							]

							return model_state_dict



def       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case						, _snake_case="ybelkada/segment-anything"							):
							lowerCAmelCase   =		hf_hub_download(_snake_case						, F"""checkpoints/{model_name}.pth"""							)

							if "sam_vit_b" in model_name:
														lowerCAmelCase   =		SamConfig()
							elif "sam_vit_l" in model_name:
														lowerCAmelCase   =		SamVisionConfig(
														    hidden_size=1024						, num_hidden_layers=24						, num_attention_heads=16						, global_attn_indexes=[5, 11, 17, 23]						, )

														lowerCAmelCase   =		SamConfig(
														    vision_config=_snake_case						, )
							elif "sam_vit_h" in model_name:
														lowerCAmelCase   =		SamVisionConfig(
														    hidden_size=1280						, num_hidden_layers=32						, num_attention_heads=16						, global_attn_indexes=[7, 15, 23, 31]						, )

														lowerCAmelCase   =		SamConfig(
														    vision_config=_snake_case						, )

							lowerCAmelCase   =		torch.load(_snake_case						, map_location='''cpu'''							)
							lowerCAmelCase   =		replace_keys(_snake_case							)

							lowerCAmelCase   =		SamImageProcessor()

							lowerCAmelCase   =		SamProcessor(image_processor=_snake_case							)
							lowerCAmelCase   =		SamModel(_snake_case							)

							hf_model.load_state_dict(_snake_case							)
							lowerCAmelCase   =		hf_model.to('''cuda'''							)

							lowerCAmelCase   =		'''https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png'''
							lowerCAmelCase   =		Image.open(requests.get(_snake_case						, stream=_snake_case							).raw							).convert('''RGB'''							)

							lowerCAmelCase   =		[[[400, 650]]]
							lowerCAmelCase   =		[[1]]

							lowerCAmelCase   =		processor(images=np.array(_snake_case							)						, return_tensors='''pt'''							).to('''cuda'''							)

							with torch.no_grad():
														lowerCAmelCase   =		hf_model(**_snake_case							)
							lowerCAmelCase   =		output.iou_scores.squeeze()

							if model_name == "sam_vit_h_4b8939":
														assert scores[-1].item() == 0.579890251159668

														lowerCAmelCase   =		processor(
														    images=np.array(_snake_case							)						, input_points=_snake_case						, input_labels=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9712603092193604

														lowerCAmelCase   =		((75, 275, 1725, 850),)

														lowerCAmelCase   =		processor(images=np.array(_snake_case							)						, input_boxes=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.8686015605926514

														# Test with 2 points and 1 image.
														lowerCAmelCase   =		[[[400, 650], [800, 650]]]
														lowerCAmelCase   =		[[1, 1]]

														lowerCAmelCase   =		processor(
														    images=np.array(_snake_case							)						, input_points=_snake_case						, input_labels=_snake_case						, return_tensors='''pt'''							).to('''cuda'''							)

														with torch.no_grad():
																					lowerCAmelCase   =		hf_model(**_snake_case							)
														lowerCAmelCase   =		output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9936047792434692


if __name__ == "__main__":
		UpperCAmelCase_						=argparse.ArgumentParser()
		UpperCAmelCase_						=["""sam_vit_b_01ec64""", """sam_vit_h_4b8939""", """sam_vit_l_0b3195"""]
		parser.add_argument(
		    """--model_name""",
		    default="""sam_vit_h_4b8939""",
		    choices=choices,
		    type=str,
		    help="""Path to hf config.json of model to convert""",
		)
		parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
		parser.add_argument(
		    """--push_to_hub""",
		    action="""store_true""",
		    help="""Whether to push the model and processor to the hub after converting""",
		)
		parser.add_argument(
		    """--model_hub_id""",
		    default="""ybelkada/segment-anything""",
		    choices=choices,
		    type=str,
		    help="""Path to hf config.json of model to convert""",
		)

		UpperCAmelCase_						=parser.parse_args()

		convert_sam_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub, args.model_hub_id)









from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_						=logging.get_logger(__name__)

UpperCAmelCase_						={
    """google/switch-base-8""": """https://huggingface.co/google/switch-base-8/blob/main/config.json""",
}


class 							__UpperCamelCase			( __UpperCAmelCase  ):





				'''simple docstring'''



				__a							: Any										="""switch_transformers"""
				__a							: Union[str, Any]										=["""past_key_values"""]
				__a							: Dict										={"""hidden_size""": """d_model""", """num_attention_heads""": """num_heads""", """num_hidden_layers""": """num_layers"""}



				def __init__( self       , UpperCAmelCase_=3_21_28       , UpperCAmelCase_=7_68       , UpperCAmelCase_=64       , UpperCAmelCase_=20_48       , UpperCAmelCase_=64       , UpperCAmelCase_=12       , UpperCAmelCase_=3       , UpperCAmelCase_=12       , UpperCAmelCase_=3       , UpperCAmelCase_=12       , UpperCAmelCase_=8       , UpperCAmelCase_=False       , UpperCAmelCase_=0.01       , UpperCAmelCase_="float32"       , UpperCAmelCase_=False       , UpperCAmelCase_=32       , UpperCAmelCase_=1_28       , UpperCAmelCase_=0.1       , UpperCAmelCase_=1E-6       , UpperCAmelCase_=0.001       , UpperCAmelCase_=0.001       , UpperCAmelCase_=1.0       , UpperCAmelCase_="relu"       , UpperCAmelCase_=True       , UpperCAmelCase_=False       , UpperCAmelCase_=True       , UpperCAmelCase_=0       , UpperCAmelCase_=1       , **UpperCAmelCase_       , ):
											lowerCAmelCase   =		vocab_size
											lowerCAmelCase   =		d_model
											lowerCAmelCase   =		d_kv
											lowerCAmelCase   =		d_ff

											lowerCAmelCase   =		num_sparse_encoder_layers

											lowerCAmelCase   =		num_layers
											lowerCAmelCase   =		(
											    num_decoder_layers if num_decoder_layers is not None else self.num_layers
											)  # default = symmetry
											lowerCAmelCase   =		num_sparse_decoder_layers

											# This tells us, each how many encoder layer we'll have to set a sparse layer.
											if self.num_sparse_encoder_layers > 0:
																		lowerCAmelCase   =		self.num_layers // self.num_sparse_encoder_layers
											else:
																		lowerCAmelCase   =		self.num_layers  # HACK: this will create 0 sparse layers

											# This tells us, each how many encoder layer we'll have to set a sparse layer.
											if self.num_sparse_decoder_layers > 0:
																		lowerCAmelCase   =		self.num_decoder_layers // self.num_sparse_decoder_layers
											else:
																		lowerCAmelCase   =		self.num_decoder_layers  # HACK: this will create 0 sparse layers

											lowerCAmelCase   =		num_heads
											lowerCAmelCase   =		num_experts
											lowerCAmelCase   =		expert_capacity
											lowerCAmelCase   =		router_bias
											lowerCAmelCase   =		router_jitter_noise
											if router_dtype not in ["float32", "float16", "bfloat16"]:
																		raise ValueError(F"""`router_dtype` must be one of 'float32', 'float16' or 'bfloat16', got {router_dtype}"""						)
											lowerCAmelCase   =		router_dtype

											lowerCAmelCase   =		router_ignore_padding_tokens
											lowerCAmelCase   =		relative_attention_num_buckets
											lowerCAmelCase   =		relative_attention_max_distance

											lowerCAmelCase   =		dropout_rate
											lowerCAmelCase   =		layer_norm_epsilon
											lowerCAmelCase   =		initializer_factor
											lowerCAmelCase   =		feed_forward_proj
											lowerCAmelCase   =		use_cache
											lowerCAmelCase   =		add_router_probs

											lowerCAmelCase   =		router_z_loss_coef
											lowerCAmelCase   =		router_aux_loss_coef

											lowerCAmelCase   =		self.feed_forward_proj.split('''-'''						)
											lowerCAmelCase   =		act_info[-1]
											lowerCAmelCase   =		act_info[0] == '''gated'''

											if len(UpperCAmelCase_						) > 1 and act_info[0] != "gated" or len(UpperCAmelCase_						) > 2:
																		raise ValueError(
																		    F"""`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer."""
																		    '''Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '''
																		    '''\'gated-gelu\' or \'relu\''''						)

											# for backwards compatibility
											if feed_forward_proj == "gated-gelu":
																		lowerCAmelCase   =		'''gelu_new'''

											super().__init__(
											    pad_token_id=UpperCAmelCase_       , eos_token_id=UpperCAmelCase_       , is_encoder_decoder=UpperCAmelCase_       , **UpperCAmelCase_       , )



