





'''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 lowerCAmelCase__(__snake_case							)       ->   Optional[int]:







	'''simple docstring'''







	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 lowerCAmelCase__(__snake_case ,__snake_case ,__snake_case ,__snake_case="ybelkada/segment-anything"							)       ->   List[Any]:







	'''simple docstring'''







	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.5_7_9_8_9_0_2_5_1_1_5_9_6_6_8

		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.9_7_1_2_6_0_3_0_9_2_1_9_3_6_0_4

		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.8_6_8_6_0_1_5_6_0_5_9_2_6_5_1_4

		# 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.9_9_3_6_0_4_7_7_9_2_4_3_4_6_9_2


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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_a						=   {
    "configuration_funnel": ["FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP", "FunnelConfig"],
    "convert_funnel_original_tf_checkpoint_to_pytorch": [],
    "tokenization_funnel": ["FunnelTokenizer"],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_a						=   ["FunnelTokenizerFast"]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_a						=   [
			    "FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "FunnelBaseModel",
			    "FunnelForMaskedLM",
			    "FunnelForMultipleChoice",
			    "FunnelForPreTraining",
			    "FunnelForQuestionAnswering",
			    "FunnelForSequenceClassification",
			    "FunnelForTokenClassification",
			    "FunnelModel",
			    "FunnelPreTrainedModel",
			    "load_tf_weights_in_funnel",
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_a						=   [
			    "TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "TFFunnelBaseModel",
			    "TFFunnelForMaskedLM",
			    "TFFunnelForMultipleChoice",
			    "TFFunnelForPreTraining",
			    "TFFunnelForQuestionAnswering",
			    "TFFunnelForSequenceClassification",
			    "TFFunnelForTokenClassification",
			    "TFFunnelModel",
			    "TFFunnelPreTrainedModel",
			]


if TYPE_CHECKING:
			from .configuration_funnel import FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP, FunnelConfig
			from .tokenization_funnel import FunnelTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_funnel_fast import FunnelTokenizerFast

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_funnel import (
						    FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
						    FunnelBaseModel,
						    FunnelForMaskedLM,
						    FunnelForMultipleChoice,
						    FunnelForPreTraining,
						    FunnelForQuestionAnswering,
						    FunnelForSequenceClassification,
						    FunnelForTokenClassification,
						    FunnelModel,
						    FunnelPreTrainedModel,
						    load_tf_weights_in_funnel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_funnel import (
						    TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFFunnelBaseModel,
						    TFFunnelForMaskedLM,
						    TFFunnelForMultipleChoice,
						    TFFunnelForPreTraining,
						    TFFunnelForQuestionAnswering,
						    TFFunnelForSequenceClassification,
						    TFFunnelForTokenClassification,
						    TFFunnelModel,
						    TFFunnelPreTrainedModel,
						)

else:
			import sys

			_a						=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



