



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 __future__ import annotations

import string
from itertools import cycle, product
from pathlib import Path

_lowercase     							=						(
    string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
_lowercase     							=						[ord(letter) for letter in string.ascii_lowercase]
_lowercase     							=						{ord(char) for char in VALID_CHARS}

_lowercase     							=						["the", "be", "to", "of", "and", "in", "that", "have"]






def      _A				(UpperCamelCase		:      list[int]      ,			UpperCamelCase		:      tuple[int, ...] )  ->str | None:



			'''simple docstring'''







			lowerCamelCase__ :      str								=		""
			lowerCamelCase__ :      int
			lowerCamelCase__ :      int
			lowerCamelCase__ :      int

			for keychar, cipherchar in zip(cycle(UpperCamelCase )      ,			UpperCamelCase ):
						lowerCamelCase__ :      str								=		cipherchar ^ keychar
						if decodedchar not in VALID_INTS:
									return None
						decoded += chr(UpperCamelCase )

			return decoded






def      _A				(UpperCamelCase		:      list[int] )  ->list[str]:



			'''simple docstring'''







			lowerCamelCase__ :      list[str]								=		[]
			for key in product(UpperCamelCase      ,			repeat=3 ):
						lowerCamelCase__ :      Union[str, Any]								=		try_key(UpperCamelCase      ,			UpperCamelCase )
						if encoded is not None:
									possibles.append(UpperCamelCase )
			return possibles






def      _A				(UpperCamelCase		:      list[str]      ,			UpperCamelCase		:      str )  ->list[str]:



			'''simple docstring'''







			return [possible for possible in possibles if common_word in possible.lower()]






def      _A				(UpperCamelCase		:      str = "p059_cipher.txt" )  ->int:



			'''simple docstring'''







			lowerCamelCase__ :      list[int]
			lowerCamelCase__ :      list[str]
			lowerCamelCase__ :      str
			lowerCamelCase__ :      str
			lowerCamelCase__ :      str								=		Path(UpperCamelCase ).parent.joinpath(UpperCamelCase ).read_text(encoding="""utf-8""" )

			lowerCamelCase__ :      str								=		[int(UpperCamelCase ) for number in data.strip().split(""",""" )]

			lowerCamelCase__ :      Optional[Any]								=		filter_valid_chars(UpperCamelCase )
			for common_word in COMMON_WORDS:
						lowerCamelCase__ :      Optional[int]								=		filter_common_word(UpperCamelCase      ,			UpperCamelCase )
						if len(UpperCamelCase ) == 1:
									break

			lowerCamelCase__ :      Union[str, Any]								=		possibles[0]
			return sum(ord(UpperCamelCase ) for char in decoded_text )


if __name__ == "__main__":
				print(F'''{solution() = }''')



