



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


_lowercase     							=						{
    '''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      _A				(UpperCamelCase		:      Any )  ->Optional[int]:



			'''simple docstring'''







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

			lowerCamelCase__ :      Dict								=		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__ :      int								=		key.replace(UpperCamelCase      ,			UpperCamelCase )

						if re.match(UpperCamelCase      ,			UpperCamelCase ):
									lowerCamelCase__ :      Dict								=		int(re.match(UpperCamelCase      ,			UpperCamelCase ).group(2 ) )
									if layer_nb == 0:
												lowerCamelCase__ :      Tuple								=		key.replace("""layers.0"""      ,			"""proj_in""" )
									elif layer_nb == 1:
												lowerCamelCase__ :      Optional[int]								=		key.replace("""layers.1"""      ,			"""layers.0""" )
									elif layer_nb == 2:
												lowerCamelCase__ :      Optional[int]								=		key.replace("""layers.2"""      ,			"""proj_out""" )

						lowerCamelCase__ :      Tuple								=		value

			lowerCamelCase__ :      str								=		model_state_dict[
			    """prompt_encoder.shared_embedding.positional_embedding"""
			]

			return model_state_dict






def      _A				(UpperCamelCase		:      int      ,			UpperCamelCase		:      Dict      ,			UpperCamelCase		:      Tuple      ,			UpperCamelCase		:      Optional[int]="ybelkada/segment-anything" )  ->Optional[int]:



			'''simple docstring'''







			lowerCamelCase__ :      Union[str, Any]								=		hf_hub_download(UpperCamelCase      ,			f"checkpoints/{model_name}.pth" )

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

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

						lowerCamelCase__ :      Union[str, Any]								=		SamConfig(
						    vision_config=UpperCamelCase      ,			)

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

			lowerCamelCase__ :      List[str]								=		SamImageProcessor()

			lowerCamelCase__ :      List[str]								=		SamProcessor(image_processor=UpperCamelCase )
			lowerCamelCase__ :      Any								=		SamModel(UpperCamelCase )

			hf_model.load_state_dict(UpperCamelCase )
			lowerCamelCase__ :      List[str]								=		hf_model.to("""cuda""" )

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

			lowerCamelCase__ :      Optional[int]								=		[[[400, 650]]]
			lowerCamelCase__ :      str								=		[[1]]

			lowerCamelCase__ :      Tuple								=		processor(images=np.array(UpperCamelCase )      ,			return_tensors="""pt""" ).to("""cuda""" )

			with torch.no_grad():
						lowerCamelCase__ :      Any								=		hf_model(**UpperCamelCase )
			lowerCamelCase__ :      Any								=		output.iou_scores.squeeze()

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

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

						with torch.no_grad():
									lowerCamelCase__ :      Optional[int]								=		hf_model(**UpperCamelCase )
						lowerCamelCase__ :      List[str]								=		output.iou_scores.squeeze()

						assert scores[-1].item() == 0.9_712_603_092_193_604

						lowerCamelCase__ :      Union[str, Any]								=		((75, 275, 1725, 850),)

						lowerCamelCase__ :      Any								=		processor(images=np.array(UpperCamelCase )      ,			input_boxes=UpperCamelCase      ,			return_tensors="""pt""" ).to("""cuda""" )

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

						assert scores[-1].item() == 0.8_686_015_605_926_514

						# Test with 2 points and 1 image.
						lowerCamelCase__ :      Dict								=		[[[400, 650], [800, 650]]]
						lowerCamelCase__ :      List[Any]								=		[[1, 1]]

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

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

						assert scores[-1].item() == 0.9_936_047_792_434_692


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

				_lowercase     							=						parser.parse_args()

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








from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
				import PIL


_lowercase     							=						logging.get_logger(__name__)
class 				__A					( A_      ):
			UpperCamelCase					:Union[str, Any]     =			['''pixel_values''']





			def __init__(self							,    __magic_name__ = True							,    __magic_name__ = None							,    __magic_name__ = PIL.Image.BICUBIC							,    __magic_name__ = True							,    __magic_name__ = None							,    __magic_name__ = 1 / 255							,    __magic_name__ = True							,    __magic_name__ = True							,    __magic_name__ = None							,    __magic_name__ = None							,    **__magic_name__							,    ):
						super().__init__(**__magic_name__				)
						lowerCamelCase__ :      str								=		size if size is not None else {"""height""": 256, """width""": 256}
						lowerCamelCase__ :      Optional[int]								=		get_size_dict(__magic_name__				)
						lowerCamelCase__ :      Any								=		crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
						lowerCamelCase__ :      Optional[int]								=		get_size_dict(__magic_name__							,    param_name="""crop_size"""				)

						lowerCamelCase__ :      str								=		do_resize
						lowerCamelCase__ :      Any								=		size
						lowerCamelCase__ :      Tuple								=		resample
						lowerCamelCase__ :      Union[str, Any]								=		do_center_crop
						lowerCamelCase__ :      List[str]								=		crop_size
						lowerCamelCase__ :      int								=		do_rescale
						lowerCamelCase__ :      Any								=		rescale_factor
						lowerCamelCase__ :      Dict								=		do_normalize
						lowerCamelCase__ :      Dict								=		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
						lowerCamelCase__ :      int								=		image_std if image_std is not None else IMAGENET_STANDARD_STD





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__ = PIL.Image.BICUBIC							,    __magic_name__ = None							,    **__magic_name__							,    ):
						lowerCamelCase__ :      Optional[int]								=		get_size_dict(__magic_name__				)
						if "height" not in size or "width" not in size:
									raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"				)
						return resize(
						    __magic_name__							,    size=(size["""height"""], size["""width"""])							,    resample=__magic_name__							,    data_format=__magic_name__							,    **__magic_name__				)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__ = None							,    **__magic_name__							,    ):
						lowerCamelCase__ :      Tuple								=		get_size_dict(__magic_name__				)
						if "height" not in size or "width" not in size:
									raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"				)
						return center_crop(__magic_name__							,    size=(size["""height"""], size["""width"""])							,    data_format=__magic_name__							,    **__magic_name__				)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__ = None							,    **__magic_name__							,    ):
						return rescale(__magic_name__							,    scale=__magic_name__							,    data_format=__magic_name__							,    **__magic_name__				)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__ = None							,    **__magic_name__							,    ):
						return normalize(__magic_name__							,    mean=__magic_name__							,    std=__magic_name__							,    data_format=__magic_name__							,    **__magic_name__				)





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__=None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = None							,    __magic_name__ = ChannelDimension.FIRST							,    **__magic_name__							,    ):
						lowerCamelCase__ :      Tuple								=		do_resize if do_resize is not None else self.do_resize
						lowerCamelCase__ :      str								=		resample if resample is not None else self.resample
						lowerCamelCase__ :      str								=		do_center_crop if do_center_crop is not None else self.do_center_crop
						lowerCamelCase__ :      Optional[int]								=		do_rescale if do_rescale is not None else self.do_rescale
						lowerCamelCase__ :      str								=		rescale_factor if rescale_factor is not None else self.rescale_factor
						lowerCamelCase__ :      Union[str, Any]								=		do_normalize if do_normalize is not None else self.do_normalize
						lowerCamelCase__ :      Tuple								=		image_mean if image_mean is not None else self.image_mean
						lowerCamelCase__ :      List[Any]								=		image_std if image_std is not None else self.image_std

						lowerCamelCase__ :      str								=		size if size is not None else self.size
						lowerCamelCase__ :      List[str]								=		get_size_dict(__magic_name__				)
						lowerCamelCase__ :      Tuple								=		crop_size if crop_size is not None else self.crop_size
						lowerCamelCase__ :      Optional[Any]								=		get_size_dict(__magic_name__							,    param_name="""crop_size"""				)

						lowerCamelCase__ :      Optional[int]								=		make_list_of_images(__magic_name__				)

						if not valid_images(__magic_name__				):
									raise ValueError(
									    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
									    """torch.Tensor, tf.Tensor or jax.ndarray."""				)

						if do_resize and size is None or resample is None:
									raise ValueError("""Size and resample must be specified if do_resize is True."""				)

						if do_center_crop and crop_size is None:
									raise ValueError("""Crop size must be specified if do_center_crop is True."""				)

						if do_rescale and rescale_factor is None:
									raise ValueError("""Rescale factor must be specified if do_rescale is True."""				)

						if do_normalize and (image_mean is None or image_std is None):
									raise ValueError("""Image mean and std must be specified if do_normalize is True."""				)

						# All transformations expect numpy arrays.
						lowerCamelCase__ :      Optional[int]								=		[to_numpy_array(__magic_name__				) for image in images]

						if do_resize:
									lowerCamelCase__ :      int								=		[self.resize(image=__magic_name__							,    size=__magic_name__							,    resample=__magic_name__				) for image in images]

						if do_center_crop:
									lowerCamelCase__ :      List[Any]								=		[self.center_crop(image=__magic_name__							,    size=__magic_name__				) for image in images]

						if do_rescale:
									lowerCamelCase__ :      Dict								=		[self.rescale(image=__magic_name__							,    scale=__magic_name__				) for image in images]

						if do_normalize:
									lowerCamelCase__ :      Optional[Any]								=		[self.normalize(image=__magic_name__							,    mean=__magic_name__							,    std=__magic_name__				) for image in images]

						lowerCamelCase__ :      List[str]								=		[to_channel_dimension_format(__magic_name__							,    __magic_name__				) for image in images]

						lowerCamelCase__ :      Dict								=		{"""pixel_values""": images}
						return BatchFeature(data=__magic_name__							,    tensor_type=__magic_name__				)



