



'''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   :			Optional[int]					  =    {
    """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       __lowerCamelCase  (					_lowercase		)      ->			Tuple:
							UpperCAmelCase     :		str							     =		{}
							state_dict.pop("""pixel_mean"""	,				_lowercase		)
							state_dict.pop("""pixel_std"""	,				_lowercase		)

							UpperCAmelCase     :		Tuple							     =		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(_lowercase	,				_lowercase		)

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

														UpperCAmelCase     :		List[str]							     =		value

							UpperCAmelCase     :		List[str]							     =		model_state_dict[
							    """prompt_encoder.shared_embedding.positional_embedding"""
							]

							return model_state_dict



def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase	,				_lowercase="ybelkada/segment-anything"		)      ->			Optional[Any]:
							UpperCAmelCase     :		Dict							     =		hf_hub_download(_lowercase	,				F'''checkpoints/{model_name}.pth'''		)

							if "sam_vit_b" in model_name:
														UpperCAmelCase     :		int							     =		SamConfig()
							elif "sam_vit_l" in model_name:
														UpperCAmelCase     :		str							     =		SamVisionConfig(
														    hidden_size=1_0_2_4	,				num_hidden_layers=2_4	,				num_attention_heads=1_6	,				global_attn_indexes=[5, 1_1, 1_7, 2_3]	,				)

														UpperCAmelCase     :		Dict							     =		SamConfig(
														    vision_config=_lowercase	,				)
							elif "sam_vit_h" in model_name:
														UpperCAmelCase     :		str							     =		SamVisionConfig(
														    hidden_size=1_2_8_0	,				num_hidden_layers=3_2	,				num_attention_heads=1_6	,				global_attn_indexes=[7, 1_5, 2_3, 3_1]	,				)

														UpperCAmelCase     :		Optional[int]							     =		SamConfig(
														    vision_config=_lowercase	,				)

							UpperCAmelCase     :		Union[str, Any]							     =		torch.load(_lowercase	,				map_location="""cpu"""		)
							UpperCAmelCase     :		Union[str, Any]							     =		replace_keys(_lowercase		)

							UpperCAmelCase     :		Union[str, Any]							     =		SamImageProcessor()

							UpperCAmelCase     :		Union[str, Any]							     =		SamProcessor(image_processor=_lowercase		)
							UpperCAmelCase     :		Optional[int]							     =		SamModel(_lowercase		)

							hf_model.load_state_dict(_lowercase		)
							UpperCAmelCase     :		Dict							     =		hf_model.to("""cuda"""		)

							UpperCAmelCase     :		Optional[Any]							     =		"""https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"""
							UpperCAmelCase     :		List[Any]							     =		Image.open(requests.get(_lowercase	,				stream=_lowercase		).raw		).convert("""RGB"""		)

							UpperCAmelCase     :		List[Any]							     =		[[[4_0_0, 6_5_0]]]
							UpperCAmelCase     :		Any							     =		[[1]]

							UpperCAmelCase     :		Optional[Any]							     =		processor(images=np.array(_lowercase		)	,				return_tensors="""pt"""		).to("""cuda"""		)

							with torch.no_grad():
														UpperCAmelCase     :		Dict							     =		hf_model(**_lowercase		)
							UpperCAmelCase     :		str							     =		output.iou_scores.squeeze()

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

														UpperCAmelCase     :		Any							     =		processor(
														    images=np.array(_lowercase		)	,				input_points=_lowercase	,				input_labels=_lowercase	,				return_tensors="""pt"""		).to("""cuda"""		)

														with torch.no_grad():
																					UpperCAmelCase     :		List[str]							     =		hf_model(**_lowercase		)
														UpperCAmelCase     :		Optional[Any]							     =		output.iou_scores.squeeze()

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

														UpperCAmelCase     :		Optional[int]							     =		((7_5, 2_7_5, 1_7_2_5, 8_5_0),)

														UpperCAmelCase     :		Optional[int]							     =		processor(images=np.array(_lowercase		)	,				input_boxes=_lowercase	,				return_tensors="""pt"""		).to("""cuda"""		)

														with torch.no_grad():
																					UpperCAmelCase     :		int							     =		hf_model(**_lowercase		)
														UpperCAmelCase     :		List[str]							     =		output.iou_scores.squeeze()

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

														# Test with 2 points and 1 image.
														UpperCAmelCase     :		Any							     =		[[[4_0_0, 6_5_0], [8_0_0, 6_5_0]]]
														UpperCAmelCase     :		Optional[int]							     =		[[1, 1]]

														UpperCAmelCase     :		List[str]							     =		processor(
														    images=np.array(_lowercase		)	,				input_points=_lowercase	,				input_labels=_lowercase	,				return_tensors="""pt"""		).to("""cuda"""		)

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

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


if __name__ == "__main__":
							a   :			Optional[int]					  =    argparse.ArgumentParser()
							a   :			Any					  =    ["""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   :			Dict					  =    parser.parse_args()

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






'''simple docstring'''




import time
from contextlib import contextmanager
from pathlib import Path

import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder


a   :			List[Any]					  =    """__DUMMY_TRANSFORMERS_USER__"""
a   :			Tuple					  =    """Dummy User"""
a   :			Optional[Any]					  =    """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"""

a   :			Optional[Any]					  =    """https://hub-ci.huggingface.co"""
a   :			List[Any]					  =    CI_HUB_ENDPOINT + """/datasets/{repo_id}/resolve/{revision}/{path}"""
a   :			Tuple					  =    CI_HUB_ENDPOINT + """/{repo_id}/resolve/{revision}/{filename}"""
a   :			str					  =    Path("""~/.huggingface/hub_ci_token""").expanduser()



@pytest.fixture
def       __lowerCamelCase  (					_lowercase		)      ->			Optional[int]:
							monkeypatch.setattr(
							    """huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE"""	,				_lowercase		)



@pytest.fixture
def       __lowerCamelCase  (					_lowercase		)      ->			List[str]:
							monkeypatch.setattr("""datasets.config.HF_ENDPOINT"""	,				_lowercase		)
							monkeypatch.setattr("""datasets.config.HUB_DATASETS_URL"""	,				_lowercase		)



@pytest.fixture
def       __lowerCamelCase  (					_lowercase		)      ->			Any:
							monkeypatch.setattr("""huggingface_hub.hf_api.HfFolder.path_token"""	,				_lowercase		)



@pytest.fixture
def       __lowerCamelCase  (					_lowercase	,				_lowercase		)      ->			Optional[Any]:
							HfFolder.save_token(_lowercase		)
							yield
							HfFolder.delete_token()



@pytest.fixture(scope="""session"""		)
def       __lowerCamelCase  (					)      ->			str:
							return HfApi(endpoint=_lowercase		)



@pytest.fixture(scope="""session"""		)
def       __lowerCamelCase  (					_lowercase		)      ->			Union[str, Any]:
							UpperCAmelCase     :		str							     =		HfFolder.get_token()
							HfFolder.save_token(_lowercase		)
							yield CI_HUB_USER_TOKEN
							if previous_token is not None:
														HfFolder.save_token(_lowercase		)



@pytest.fixture
def       __lowerCamelCase  (					_lowercase		)      ->			Any:
							def _cleanup_repo(_lowercase		):
														hf_api.delete_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""		)

							return _cleanup_repo



@pytest.fixture
def       __lowerCamelCase  (					_lowercase		)      ->			List[str]:
							@contextmanager
							def _temporary_repo(_lowercase		):
														try:
																					yield repo_id
														finally:
																					cleanup_repo(_lowercase		)

							return _temporary_repo



@pytest.fixture(scope="""session"""		)
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			List[str]:
							UpperCAmelCase     :		str							     =		F'''repo_txt_data-{int(time.time() * 10e3		)}'''
							UpperCAmelCase     :		List[Any]							     =		F'''{CI_HUB_USER}/{repo_name}'''
							hf_api.create_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""	,				private=_lowercase		)
							hf_api.upload_file(
							    token=_lowercase	,				path_or_fileobj=str(_lowercase		)	,				path_in_repo="""data/text_data.txt"""	,				repo_id=_lowercase	,				repo_type="""dataset"""	,				)
							yield repo_id
							try:
														hf_api.delete_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""		)
							except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
														pass



@pytest.fixture()
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			List[Any]:
							return hf_private_dataset_repo_txt_data_



@pytest.fixture(scope="""session"""		)
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			Optional[int]:
							UpperCAmelCase     :		Optional[int]							     =		F'''repo_zipped_txt_data-{int(time.time() * 10e3		)}'''
							UpperCAmelCase     :		Optional[int]							     =		F'''{CI_HUB_USER}/{repo_name}'''
							hf_api.create_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""	,				private=_lowercase		)
							hf_api.upload_file(
							    token=_lowercase	,				path_or_fileobj=str(_lowercase		)	,				path_in_repo="""data.zip"""	,				repo_id=_lowercase	,				repo_type="""dataset"""	,				)
							yield repo_id
							try:
														hf_api.delete_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""		)
							except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
														pass



@pytest.fixture()
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			List[str]:
							return hf_private_dataset_repo_zipped_txt_data_



@pytest.fixture(scope="""session"""		)
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			Tuple:
							UpperCAmelCase     :		List[Any]							     =		F'''repo_zipped_img_data-{int(time.time() * 10e3		)}'''
							UpperCAmelCase     :		List[str]							     =		F'''{CI_HUB_USER}/{repo_name}'''
							hf_api.create_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""	,				private=_lowercase		)
							hf_api.upload_file(
							    token=_lowercase	,				path_or_fileobj=str(_lowercase		)	,				path_in_repo="""data.zip"""	,				repo_id=_lowercase	,				repo_type="""dataset"""	,				)
							yield repo_id
							try:
														hf_api.delete_repo(_lowercase	,				token=_lowercase	,				repo_type="""dataset"""		)
							except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
														pass



@pytest.fixture()
def       __lowerCamelCase  (					_lowercase	,				_lowercase	,				_lowercase		)      ->			List[Any]:
							return hf_private_dataset_repo_zipped_img_data_

