


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


_lowerCAmelCase:						str   				=       {
    '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   _lowercase(					__a				:						Optional[Any]     ):
							a__      ={}
							state_dict.pop('pixel_mean'    ,     _UpperCAmelCase     )
							state_dict.pop('pixel_std'    ,     _UpperCAmelCase     )

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

														if re.match(_UpperCAmelCase    ,     _UpperCAmelCase     ):
																					a__      =int(re.match(_UpperCAmelCase    ,     _UpperCAmelCase     ).group(2     )     )
																					if layer_nb == 0:
																												a__      =key.replace('layers.0'    ,     'proj_in'     )
																					elif layer_nb == 1:
																												a__      =key.replace('layers.1'    ,     'layers.0'     )
																					elif layer_nb == 2:
																												a__      =key.replace('layers.2'    ,     'proj_out'     )

														a__      =value

							a__      =model_state_dict[
							    'prompt_encoder.shared_embedding.positional_embedding'
							]

							return model_state_dict






def   _lowercase(					__a				:						Any    ,     __a				:						str    ,     __a				:						Dict    ,     __a				:						int="ybelkada/segment-anything"     ):
							a__      =hf_hub_download(_UpperCAmelCase    ,     f"""checkpoints/{model_name}.pth"""     )

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

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

														a__      =SamConfig(
														    vision_config=_UpperCAmelCase    ,     )

							a__      =torch.load(_UpperCAmelCase    ,     map_location='cpu'     )
							a__      =replace_keys(_UpperCAmelCase     )

							a__      =SamImageProcessor()

							a__      =SamProcessor(image_processor=_UpperCAmelCase     )
							a__      =SamModel(_UpperCAmelCase     )

							hf_model.load_state_dict(_UpperCAmelCase     )
							a__      =hf_model.to('cuda'     )

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

							a__      =[[[400, 650]]]
							a__      =[[1]]

							a__      =processor(images=np.array(_UpperCAmelCase     )    ,     return_tensors='pt'     ).to('cuda'     )

							with torch.no_grad():
														a__      =hf_model(**_UpperCAmelCase     )
							a__      =output.iou_scores.squeeze()

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

														a__      =processor(
														    images=np.array(_UpperCAmelCase     )    ,     input_points=_UpperCAmelCase    ,     input_labels=_UpperCAmelCase    ,     return_tensors='pt'     ).to('cuda'     )

														with torch.no_grad():
																					a__      =hf_model(**_UpperCAmelCase     )
														a__      =output.iou_scores.squeeze()

														assert scores[-1].item() == 0.97_12_60_30_92_19_36_04

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

														a__      =processor(images=np.array(_UpperCAmelCase     )    ,     input_boxes=_UpperCAmelCase    ,     return_tensors='pt'     ).to('cuda'     )

														with torch.no_grad():
																					a__      =hf_model(**_UpperCAmelCase     )
														a__      =output.iou_scores.squeeze()

														assert scores[-1].item() == 0.86_86_01_56_05_92_65_14

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

														a__      =processor(
														    images=np.array(_UpperCAmelCase     )    ,     input_points=_UpperCAmelCase    ,     input_labels=_UpperCAmelCase    ,     return_tensors='pt'     ).to('cuda'     )

														with torch.no_grad():
																					a__      =hf_model(**_UpperCAmelCase     )
														a__      =output.iou_scores.squeeze()

														assert scores[-1].item() == 0.99_36_04_77_92_43_46_92


if __name__ == "__main__":
	_lowerCAmelCase:						List[Any]   				=       argparse.ArgumentParser()
	_lowerCAmelCase:						List[str]   				=       ['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',
	)

	_lowerCAmelCase:						Any   				=       parser.parse_args()

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








import logging
import os
import threading
import time


try:
      import warnings
except ImportError:
      a__      :     Optional[Any]         =		None

try:
      import msvcrt
except ImportError:
      a__      :     List[str]         =		None

try:
      import fcntl
except ImportError:
      a__      :     Optional[int]         =		None


# Backward compatibility
# ------------------------------------------------
try:
      TimeoutError
except NameError:
      a__      :     List[str]         =		OSError


# Data
# ------------------------------------------------
a__      :     Union[str, Any]         =		[
    'Timeout',
    'BaseFileLock',
    'WindowsFileLock',
    'UnixFileLock',
    'SoftFileLock',
    'FileLock',
]

a__      :     str         =		'3.0.12'


a__      :     Optional[int]         =		None

def      UpperCAmelCase_    (    )	->				Tuple:
     '''simple docstring'''


     global _logger
     A_          =       _logger or logging.getLogger(__name__				)
     return _logger





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE ):


  def __init__(							self ,__snake_case ):



       """simple docstring"""





       A_          =       lock_file
       return None




  def __str__(							self ):



       """simple docstring"""





       A_          =       f'The file lock \'{self.lock_file}\' could not be acquired.'
       return temp





class UpperCAmelCase_				:


  def __init__(							self ,__snake_case ):



       """simple docstring"""





       A_          =       lock
       return None


  def __enter__(							self ):



       """simple docstring"""





       return self.lock




  def __exit__(							self ,__snake_case ,__snake_case ,__snake_case ):



       """simple docstring"""





       self.lock.release()
       return None





class UpperCAmelCase_				:


  def __init__(							self ,__snake_case ,__snake_case=-1 ,__snake_case=None ):



       """simple docstring"""





       A_          =       max_filename_length if max_filename_length is not None else 2_5_5
       # Hash the filename if it's too long
       A_          =       self.hash_filename_if_too_long(__snake_case ,__snake_case )
       # The path to the lock file.
       A_          =       lock_file

       # The file descriptor for the *_lock_file* as it is returned by the
       # os.open() function.
       # This file lock is only NOT None, if the object currently holds the
       # lock.
       A_          =       None

       # The default timeout value.
       A_          =       timeout

       # We use this lock primarily for the lock counter.
       A_          =       threading.Lock()

       # The lock counter is used for implementing the nested locking
       # mechanism. Whenever the lock is acquired, the counter is increased and
       # the lock is only released, when this value is 0 again.
       A_          =       0
       return None


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self._lock_file


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self._timeout


  @timeout.setter
  def 						__UpperCAmelCase     (							self ,__snake_case ):



       """simple docstring"""





       A_          =       float(__snake_case )
       return None


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       raise NotImplementedError()


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       raise NotImplementedError()


  @property
  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       return self._lock_file_fd is not None


  def 						__UpperCAmelCase     (							self ,__snake_case=None ,__snake_case=0.05 ):



       """simple docstring"""





       if timeout is None:
            A_          =       self.timeout

       # Increment the number right at the beginning.
       # We can still undo it, if something fails.
       with self._thread_lock:
            self._lock_counter += 1

       A_          =       id(self )
       A_          =       self._lock_file
       A_          =       time.time()
       try:
            while True:
                 with self._thread_lock:
                      if not self.is_locked:
                           logger().debug(f'Attempting to acquire lock {lock_id} on {lock_filename}' )
                           self._acquire()

                 if self.is_locked:
                      logger().debug(f'Lock {lock_id} acquired on {lock_filename}' )
                      break
                 elif timeout >= 0 and time.time() - start_time > timeout:
                      logger().debug(f'Timeout on acquiring lock {lock_id} on {lock_filename}' )
                      raise Timeout(self._lock_file )
                 else:
                      logger().debug(
                          f'Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ...' )
                      time.sleep(__snake_case )
       except:  # noqa
            # Something did go wrong, so decrement the counter.
            with self._thread_lock:
                 A_          =       max(0 ,self._lock_counter - 1 )

            raise
       return _Acquire_ReturnProxy(lock=self )


  def 						__UpperCAmelCase     (							self ,__snake_case=False ):



       """simple docstring"""





       with self._thread_lock:
            if self.is_locked:
                 self._lock_counter -= 1

                 if self._lock_counter == 0 or force:
                      A_          =       id(self )
                      A_          =       self._lock_file

                      logger().debug(f'Attempting to release lock {lock_id} on {lock_filename}' )
                      self._release()
                      A_          =       0
                      logger().debug(f'Lock {lock_id} released on {lock_filename}' )

       return None


  def __enter__(							self ):



       """simple docstring"""





       self.acquire()
       return self


  def __exit__(							self ,__snake_case ,__snake_case ,__snake_case ):



       """simple docstring"""





       self.release()
       return None


  def __del__(							self ):



       """simple docstring"""





       self.release(force=__snake_case )
       return None




  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case ):



       """simple docstring"""





       A_          =       os.path.basename(__snake_case )
       if len(__snake_case ) > max_length and max_length > 0:
            A_          =       os.path.dirname(__snake_case )
            A_          =       str(hash(__snake_case ) )
            A_          =       filename[: max_length - len(__snake_case ) - 8] + '''...''' + hashed_filename + '''.lock'''
            return os.path.join(__snake_case ,__snake_case )
       else:
            return path





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE ):


  def __init__(							self ,__snake_case ,__snake_case=-1 ,__snake_case=None ):



       """simple docstring"""





       from .file_utils import relative_to_absolute_path

       super().__init__(__snake_case ,timeout=__snake_case ,max_filename_length=__snake_case )
       A_          =       '''\\\\?\\''' + relative_to_absolute_path(self.lock_file )


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       os.O_RDWR | os.O_CREAT | os.O_TRUNC

       try:
            A_          =       os.open(self._lock_file ,__snake_case )
       except OSError:
            pass
       else:
            try:
                 msvcrt.locking(__snake_case ,msvcrt.LK_NBLCK ,1 )
            except OSError:
                 os.close(__snake_case )
            else:
                 A_          =       fd
       return None




  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self._lock_file_fd
       A_          =       None
       msvcrt.locking(__snake_case ,msvcrt.LK_UNLCK ,1 )
       os.close(__snake_case )

       try:
            os.remove(self._lock_file )
       # Probably another instance of the application
       # that acquired the file lock.
       except OSError:
            pass
       return None





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE ):


  def __init__(							self ,__snake_case ,__snake_case=-1 ,__snake_case=None ):



       """simple docstring"""





       A_          =       os.statvfs(os.path.dirname(__snake_case ) ).f_namemax
       super().__init__(__snake_case ,timeout=__snake_case ,max_filename_length=__snake_case )


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       os.O_RDWR | os.O_CREAT | os.O_TRUNC
       A_          =       os.open(self._lock_file ,__snake_case )

       try:
            fcntl.flock(__snake_case ,fcntl.LOCK_EX | fcntl.LOCK_NB )
       except OSError:
            os.close(__snake_case )
       else:
            A_          =       fd
       return None




  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       self._lock_file_fd
       A_          =       None
       fcntl.flock(__snake_case ,fcntl.LOCK_UN )
       os.close(__snake_case )
       return None





class UpperCAmelCase_				( _SCREAMING_SNAKE_CASE ):


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
       try:
            A_          =       os.open(self._lock_file ,__snake_case )
       except OSError:
            pass
       else:
            A_          =       fd
       return None




  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       os.close(self._lock_file_fd )
       A_          =       None

       try:
            os.remove(self._lock_file )
       # The file is already deleted and that's what we want.
       except OSError:
            pass
       return None




a__      :     Union[str, Any]         =		None

if msvcrt:
      a__      :     Dict         =		WindowsFileLock
elif fcntl:
      a__      :     Dict         =		UnixFileLock
else:
      a__      :     Optional[int]         =		SoftFileLock

      if warnings is not None:
            warnings.warn('only soft file lock is available')



