




"""simple docstring"""





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


A				=							{
    """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     (      UpperCamelCase				)      ->      str:


			"""simple docstring"""
			__UpperCAmelCase						:			Optional[Any]												=       {}
			state_dict.pop("pixel_mean"					,							UpperCamelCase				)
			state_dict.pop("pixel_std"					,							UpperCamelCase				)

			__UpperCAmelCase						:			Any												=       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:
												__UpperCAmelCase						:			Union[str, Any]												=       key.replace(UpperCamelCase					,							UpperCamelCase				)

						if re.match(UpperCamelCase					,							UpperCamelCase				):
									__UpperCAmelCase						:			int												=       int(re.match(UpperCamelCase					,							UpperCamelCase				).group(2				)				)
									if layer_nb == 0:
												__UpperCAmelCase						:			Dict												=       key.replace("layers.0"					,							"proj_in"				)
									elif layer_nb == 1:
												__UpperCAmelCase						:			int												=       key.replace("layers.1"					,							"layers.0"				)
									elif layer_nb == 2:
												__UpperCAmelCase						:			Union[str, Any]												=       key.replace("layers.2"					,							"proj_out"				)

						__UpperCAmelCase						:			Tuple												=       value

			__UpperCAmelCase						:			Any												=       model_state_dict[
			    "prompt_encoder.shared_embedding.positional_embedding"
			]

			return model_state_dict

def        _UpperCamelCase     (      UpperCamelCase					,							UpperCamelCase					,							UpperCamelCase					,							UpperCamelCase="ybelkada/segment-anything"				)      ->      Dict:


			"""simple docstring"""
			__UpperCAmelCase						:			int												=       hf_hub_download(UpperCamelCase					,							f"checkpoints/{model_name}.pth"				)

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

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

						__UpperCAmelCase						:			List[Any]												=       SamConfig(
						    vision_config=UpperCamelCase					,							)

			__UpperCAmelCase						:			str												=       torch.load(UpperCamelCase					,							map_location="cpu"				)
			__UpperCAmelCase						:			Optional[Any]												=       replace_keys(UpperCamelCase				)

			__UpperCAmelCase						:			Tuple												=       SamImageProcessor()

			__UpperCAmelCase						:			Optional[Any]												=       SamProcessor(image_processor=UpperCamelCase				)
			__UpperCAmelCase						:			List[Any]												=       SamModel(UpperCamelCase				)

			hf_model.load_state_dict(UpperCamelCase				)
			__UpperCAmelCase						:			Any												=       hf_model.to("cuda"				)

			__UpperCAmelCase						:			Tuple												=       "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
			__UpperCAmelCase						:			int												=       Image.open(requests.get(UpperCamelCase					,							stream=UpperCamelCase				).raw				).convert("RGB"				)

			__UpperCAmelCase						:			List[Any]												=       [[[400, 650]]]
			__UpperCAmelCase						:			str												=       [[1]]

			__UpperCAmelCase						:			List[Any]												=       processor(images=np.array(UpperCamelCase				)					,							return_tensors="pt"				).to("cuda"				)

			with torch.no_grad():
						__UpperCAmelCase						:			int												=       hf_model(**UpperCamelCase				)
			__UpperCAmelCase						:			int												=       output.iou_scores.squeeze()

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

						__UpperCAmelCase						:			str												=       processor(
						    images=np.array(UpperCamelCase				)					,							input_points=UpperCamelCase					,							input_labels=UpperCamelCase					,							return_tensors="pt"				).to("cuda"				)

						with torch.no_grad():
									__UpperCAmelCase						:			List[Any]												=       hf_model(**UpperCamelCase				)
						__UpperCAmelCase						:			int												=       output.iou_scores.squeeze()

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

						__UpperCAmelCase						:			Dict												=       ((75, 275, 1725, 850),)

						__UpperCAmelCase						:			List[Any]												=       processor(images=np.array(UpperCamelCase				)					,							input_boxes=UpperCamelCase					,							return_tensors="pt"				).to("cuda"				)

						with torch.no_grad():
									__UpperCAmelCase						:			Tuple												=       hf_model(**UpperCamelCase				)
						__UpperCAmelCase						:			int												=       output.iou_scores.squeeze()

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

						# Test with 2 points and 1 image.
						__UpperCAmelCase						:			List[str]												=       [[[400, 650], [800, 650]]]
						__UpperCAmelCase						:			int												=       [[1, 1]]

						__UpperCAmelCase						:			List[Any]												=       processor(
						    images=np.array(UpperCamelCase				)					,							input_points=UpperCamelCase					,							input_labels=UpperCamelCase					,							return_tensors="pt"				).to("cuda"				)

						with torch.no_grad():
									__UpperCAmelCase						:			Optional[int]												=       hf_model(**UpperCamelCase				)
						__UpperCAmelCase						:			Optional[Any]												=       output.iou_scores.squeeze()

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


if __name__ == "__main__":
					A				=							argparse.ArgumentParser()
					A				=							["""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""",
					)

					A				=							parser.parse_args()

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






def     __SCREAMING_SNAKE_CASE							(       lowercase_      ,       lowercase_      )		->     int:




						'''simple docstring'''







						return 1 if input_a == input_a else 0




def     __SCREAMING_SNAKE_CASE							(       )		->     None:




						'''simple docstring'''







						assert xnor_gate(0      ,       0      ) == 1
						assert xnor_gate(0      ,       1      ) == 0
						assert xnor_gate(1      ,       0      ) == 0
						assert xnor_gate(1      ,       1      ) == 1


if __name__ == "__main__":
				print(xnor_gate(0, 0))
				print(xnor_gate(0, 1))
				print(xnor_gate(1, 0))
				print(xnor_gate(1, 1))

