






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   (	a						:	Optional[int] ):
							snake_case__	  =       {}
							state_dict.pop("""pixel_mean"""  ,					a )
							state_dict.pop("""pixel_std"""  ,					a )

							snake_case__	  =       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:
																												snake_case__	  =       key.replace(a  ,					a )

														if re.match(a  ,					a ):
																					snake_case__	  =       int(re.match(a  ,					a ).group(2 ) )
																					if layer_nb == 0:
																												snake_case__	  =       key.replace("""layers.0"""  ,					"""proj_in""" )
																					elif layer_nb == 1:
																												snake_case__	  =       key.replace("""layers.1"""  ,					"""layers.0""" )
																					elif layer_nb == 2:
																												snake_case__	  =       key.replace("""layers.2"""  ,					"""proj_out""" )

														snake_case__	  =       value

							snake_case__	  =       model_state_dict[
							    """prompt_encoder.shared_embedding.positional_embedding"""
							]

							return model_state_dict

def _UpperCAmelCase   (	a						:	str  ,					a						:	Union[str, Any]  ,					a						:	Optional[int]  ,					a						:	int="ybelkada/segment-anything" ):
							snake_case__	  =       hf_hub_download(a  ,					F'''checkpoints/{model_name}.pth''' )

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

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

														snake_case__	  =       SamConfig(
														    vision_config=a  ,					)

							snake_case__	  =       torch.load(a  ,					map_location="""cpu""" )
							snake_case__	  =       replace_keys(a )

							snake_case__	  =       SamImageProcessor()

							snake_case__	  =       SamProcessor(image_processor=a )
							snake_case__	  =       SamModel(a )

							hf_model.load_state_dict(a )
							snake_case__	  =       hf_model.to("""cuda""" )

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

							snake_case__	  =       [[[400, 650]]]
							snake_case__	  =       [[1]]

							snake_case__	  =       processor(images=np.array(a )  ,					return_tensors="""pt""" ).to("""cuda""" )

							with torch.no_grad():
														snake_case__	  =       hf_model(**a )
							snake_case__	  =       output.iou_scores.squeeze()

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

														snake_case__	  =       processor(
														    images=np.array(a )  ,					input_points=a  ,					input_labels=a  ,					return_tensors="""pt""" ).to("""cuda""" )

														with torch.no_grad():
																					snake_case__	  =       hf_model(**a )
														snake_case__	  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9712_6030_9219_3604

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

														snake_case__	  =       processor(images=np.array(a )  ,					input_boxes=a  ,					return_tensors="""pt""" ).to("""cuda""" )

														with torch.no_grad():
																					snake_case__	  =       hf_model(**a )
														snake_case__	  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.8686_0156_0592_6514

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

														snake_case__	  =       processor(
														    images=np.array(a )  ,					input_points=a  ,					input_labels=a  ,					return_tensors="""pt""" ).to("""cuda""" )

														with torch.no_grad():
																					snake_case__	  =       hf_model(**a )
														snake_case__	  =       output.iou_scores.squeeze()

														assert scores[-1].item() == 0.9936_0477_9243_4692


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)








from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
	import torch

if is_torch_tpu_available(check_device=False):
	import torch_xla.core.xla_model as xm


a__       =     logging.get_logger(__name__)


@dataclass
class    _lowerCAmelCase			(		lowercase_      ):



				"""simple docstring"""



				_lowercase				:   Dict      =  [
				    '''no_inference''',
				    '''no_cuda''',
				    '''no_tpu''',
				    '''no_speed''',
				    '''no_memory''',
				    '''no_env_print''',
				    '''no_multi_process''',
				]



				def __init__(      self    :    str			,		**UpperCamelCase__    :    Dict):






											'''simple docstring'''







											for deprecated_arg in self.deprecated_args:
																		if deprecated_arg in kwargs:
																									snake_case__	  =       deprecated_arg[3:]
																									setattr(self			,		UpperCamelCase__			,		not kwargs.pop(UpperCamelCase__))
																									logger.warning(
																									    F'''{deprecated_arg} is depreciated. Please use --no_{positive_arg} or'''
																									    F''' {positive_arg}={kwargs[positive_arg]}''')

											snake_case__	  =       kwargs.pop("""torchscript"""			,		self.torchscript)
											snake_case__	  =       kwargs.pop("""torch_xla_tpu_print_metrics"""			,		self.torch_xla_tpu_print_metrics)
											snake_case__	  =       kwargs.pop("""fp16_opt_level"""			,		self.fpaa_opt_level)
											super().__init__(**UpperCamelCase__)

				_lowercase				:   bool      =  field(default=lowercase_     ,      metadata={'''help''': '''Trace the models using torchscript'''}      )
				_lowercase				:   bool      =  field(default=lowercase_     ,      metadata={'''help''': '''Print Xla/PyTorch tpu metrics'''}      )
				_lowercase				:   str      =  field(
				    default='''O1'''     ,      metadata={
				        '''help''': (
				            '''For fp16: Apex AMP optimization level selected in [\'O0\', \'O1\', \'O2\', and \'O3\']. '''
				            '''See details at https://nvidia.github.io/apex/amp.html'''
				        )
				    }     ,      )



				@cached_property
				def 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







											requires_backends(self			,		["""torch"""])
											logger.info("""PyTorch: setting up devices""")
											if not self.cuda:
																		snake_case__	  =       torch.device("""cpu""")
																		snake_case__	  =       0
											elif is_torch_tpu_available():
																		snake_case__	  =       xm.xla_device()
																		snake_case__	  =       0
											else:
																		snake_case__	  =       torch.device("""cuda""" if torch.cuda.is_available() else """cpu""")
																		snake_case__	  =       torch.cuda.device_count()
											return device, n_gpu



				@property
				def 					__magic_name__							(      self    :    Union[str, Any]):






											'''simple docstring'''







											return is_torch_tpu_available() and self.tpu



				@property
				def 					__magic_name__							(      self    :    List[str]):






											'''simple docstring'''







											requires_backends(self			,		["""torch"""])
											# TODO(PVP): currently only single GPU is supported
											return torch.cuda.current_device()



				@property
				def 					__magic_name__							(      self    :    Union[str, Any]):






											'''simple docstring'''







											requires_backends(self			,		["""torch"""])
											return self._setup_devices[0]



				@property
				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											requires_backends(self			,		["""torch"""])
											return self._setup_devices[1]



				@property
				def 					__magic_name__							(      self    :    str):






											'''simple docstring'''







											return self.n_gpu > 0
