



# Lint as: python3
import os
import re
import urllib.parse
from pathlib import Path
from typing import Callable, List, Optional, Union
from zipfile import ZipFile

from ..utils.file_utils import cached_path, hf_github_url
from ..utils.logging import get_logger
from ..utils.version import Version


a_								=       get_logger(__name__)



class 			__lowerCAmelCase  :
 lowerCAmelCase__							       =	"""dummy_data"""
 lowerCAmelCase__							       =	"""datasets"""
 lowerCAmelCase__							       =	False




 def __init__(    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase = None						,					__UpperCAmelCase = False						,					__UpperCAmelCase = True						,					__UpperCAmelCase = None						,					):



    '''simple docstring'''
    __lowerCamelCase    				=     0
    __lowerCamelCase    				=     dataset_name
    __lowerCamelCase    				=     cache_dir
    __lowerCamelCase    				=     use_local_dummy_data
    __lowerCamelCase    				=     config
    # download_callbacks take a single url as input
    __lowerCamelCase    				=     download_callbacks or []
    # if False, it doesn't load existing files and it returns the paths of the dummy files relative
    # to the dummy_data zip file root
    __lowerCamelCase    				=     load_existing_dummy_data

    # TODO(PVP, QL) might need to make this more general
    __lowerCamelCase    				=     str(__UpperCAmelCase					)
    # to be downloaded
    __lowerCamelCase    				=     None
    __lowerCamelCase    				=     None




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    if self._dummy_file is None:
       __lowerCamelCase    				=     self.download_dummy_data()
    return self._dummy_file




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    if self.config is not None:
       # structure is dummy / config_name / version_name
       return os.path.join('''dummy'''						,					self.config.name						,					self.version_name					)
    # structure is dummy / version_name
    return os.path.join('''dummy'''						,					self.version_name					)




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return os.path.join(self.dummy_data_folder						,					'''dummy_data.zip'''					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     (
        self.local_path_to_dummy_data if self.use_local_dummy_data is True else self.github_path_to_dummy_data
    )

    __lowerCamelCase    				=     cached_path(
        __UpperCAmelCase						,					cache_dir=self.cache_dir						,					extract_compressed_file=__UpperCAmelCase						,					force_extract=__UpperCAmelCase					)

    return os.path.join(__UpperCAmelCase						,					self.dummy_file_name					)




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return os.path.join(self.datasets_scripts_dir						,					self.dataset_name						,					self.dummy_zip_file					)




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    if self._bucket_url is None:
       __lowerCamelCase    				=     hf_github_url(self.dataset_name						,					self.dummy_zip_file.replace(os.sep						,					'''/'''					)					)
    return self._bucket_url




 @property
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    # return full path if its a dir
    if os.path.isdir(self.dummy_file					):
       return self.dummy_file
    # else cut off path to file -> example `xsum`.
    return "/".join(self.dummy_file.replace(os.sep						,					'''/'''					).split('''/'''					)[:-1]					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					*__UpperCAmelCase					):



    '''simple docstring'''
    if self.load_existing_dummy_data:
       # dummy data is downloaded and tested
       __lowerCamelCase    				=     self.dummy_file
    else:
       # dummy data cannot be downloaded and only the path to dummy file is returned
       __lowerCamelCase    				=     self.dummy_file_name

    # special case when data_url is a dict
    if isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
       return self.create_dummy_data_dict(__UpperCAmelCase						,					__UpperCAmelCase					)
    elif isinstance(__UpperCAmelCase						,					(list, tuple)					):
       return self.create_dummy_data_list(__UpperCAmelCase						,					__UpperCAmelCase					)
    else:
       return self.create_dummy_data_single(__UpperCAmelCase						,					__UpperCAmelCase					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					*__UpperCAmelCase					):



    '''simple docstring'''
    return self.download_and_extract(__UpperCAmelCase					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    return self.download_and_extract(__UpperCAmelCase					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					*__UpperCAmelCase						,					**__UpperCAmelCase					):



    '''simple docstring'''
    return path




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    return {}




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     {}
    for key, single_urls in data_url.items():
       for download_callback in self.download_callbacks:
          if isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
             for single_url in single_urls:
                download_callback(__UpperCAmelCase					)
          else:
             __lowerCamelCase    				=     single_urls
             download_callback(__UpperCAmelCase					)
            # we force the name of each key to be the last file / folder name of the url path
            # if the url has arguments, we need to encode them with urllib.parse.quote_plus
       if isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
          __lowerCamelCase    				=     [os.path.join(__UpperCAmelCase						,					urllib.parse.quote_plus(Path(__UpperCAmelCase					).name					)					) for x in single_urls]
       else:
          __lowerCamelCase    				=     single_urls
          __lowerCamelCase    				=     os.path.join(__UpperCAmelCase						,					urllib.parse.quote_plus(Path(__UpperCAmelCase					).name					)					)
       __lowerCamelCase    				=     value

    # make sure that values are unique
    if all(isinstance(__UpperCAmelCase						,					__UpperCAmelCase					) for i in dummy_data_dict.values()					) and len(set(dummy_data_dict.values()					)					) < len(
        dummy_data_dict.values()					):
       # append key to value to make its name unique
       __lowerCamelCase    				=     {key: value + key for key, value in dummy_data_dict.items()}

    return dummy_data_dict




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     []
    # trick: if there are many shards named like `data.txt-000001-of-00300`, only use the first one
    __lowerCamelCase    				=     all(bool(re.findall('''[0-9]{3,}-of-[0-9]{3,}'''						,					__UpperCAmelCase					)					) for url in data_url					)
    __lowerCamelCase    				=     all(
        url.startswith('''https://ftp.ncbi.nlm.nih.gov/pubmed/baseline/pubmed'''					) for url in data_url					)
    if data_url and (is_tf_records or is_pubmed_records):
       __lowerCamelCase    				=     [data_url[0]] * len(__UpperCAmelCase					)
    for single_url in data_url:
       for download_callback in self.download_callbacks:
          download_callback(__UpperCAmelCase					)
       # we force the name of each key to be the last file / folder name of the url path
       # if the url has arguments, we need to encode them with urllib.parse.quote_plus
       __lowerCamelCase    				=     os.path.join(__UpperCAmelCase						,					urllib.parse.quote_plus(single_url.split('''/'''					)[-1]					)					)
       dummy_data_list.append(__UpperCAmelCase					)
    return dummy_data_list




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    for download_callback in self.download_callbacks:
       download_callback(__UpperCAmelCase					)
    # we force the name of each key to be the last file / folder name of the url path
    # if the url has arguments, we need to encode them with urllib.parse.quote_plus
    __lowerCamelCase    				=     os.path.join(__UpperCAmelCase						,					urllib.parse.quote_plus(data_url.split('''/'''					)[-1]					)					)
    if os.path.exists(__UpperCAmelCase					) or not self.load_existing_dummy_data:
       return value
    else:
       # Backward compatibility, maybe deprecate at one point.
       # For many datasets with single url calls to dl_manager.download_and_extract,
       # the dummy_data.zip file is actually the zipped downloaded file
       # while now we expected the dummy_data.zip file to be a directory containing
       # the downloaded file.
       return path_to_dummy_data




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    pass




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    pass




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    def _iter_archive_members(__UpperCAmelCase					):
       # this preserves the order of the members inside the ZIP archive
       __lowerCamelCase    				=     Path(self.dummy_file					).parent
       __lowerCamelCase    				=     path.relative_to(__UpperCAmelCase					)
       with ZipFile(self.local_path_to_dummy_data					) as zip_file:
          __lowerCamelCase    				=     zip_file.namelist()
       for member in members:
          if member.startswith(relative_path.as_posix()					):
             yield dummy_parent_path.joinpath(__UpperCAmelCase					)

    __lowerCamelCase    				=     Path(__UpperCAmelCase					)
    __lowerCamelCase    				=     _iter_archive_members(__UpperCAmelCase					) if self.use_local_dummy_data else path.rglob('''*'''					)
    for file_path in file_paths:
       if file_path.is_file() and not file_path.name.startswith(('''.''', '''__''')					):
          yield file_path.relative_to(__UpperCAmelCase					).as_posix(), file_path.open('''rb'''					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase					):



    '''simple docstring'''
    if not isinstance(__UpperCAmelCase						,					__UpperCAmelCase					):
       __lowerCamelCase    				=     [paths]
    for path in paths:
       if os.path.isfile(__UpperCAmelCase					):
          if os.path.basename(__UpperCAmelCase					).startswith(('''.''', '''__''')					):
             return
          yield path
       else:
          for dirpath, dirnames, filenames in os.walk(__UpperCAmelCase					):
             if os.path.basename(__UpperCAmelCase					).startswith(('''.''', '''__''')					):
                continue
             dirnames.sort()
             for filename in sorted(__UpperCAmelCase					):
                if filename.startswith(('''.''', '''__''')					):
                   continue
                yield os.path.join(__UpperCAmelCase						,					__UpperCAmelCase					)











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 		a__      (		_UpperCamelCase      :			Optional[Any]				):
   __lowerCamelCase    				=     {}
   state_dict.pop('''pixel_mean'''			,_UpperCamelCase				)
   state_dict.pop('''pixel_std'''			,_UpperCamelCase				)

   __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(_UpperCamelCase			,_UpperCamelCase				)

      if re.match(_UpperCamelCase			,_UpperCamelCase				):
         __lowerCamelCase    				=     int(re.match(_UpperCamelCase			,_UpperCamelCase				).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 		a__      (		_UpperCamelCase      :			Tuple			,_UpperCamelCase      :			Dict			,_UpperCamelCase      :			Any			,_UpperCamelCase      :			Optional[int]="ybelkada/segment-anything"				):
   __lowerCamelCase    				=     hf_hub_download(_UpperCamelCase			,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=10_24			,num_hidden_layers=24			,num_attention_heads=16			,global_attn_indexes=[5, 11, 17, 23]			,)

      __lowerCamelCase    				=     SamConfig(
          vision_config=_UpperCamelCase			,)
   elif "sam_vit_h" in model_name:
      __lowerCamelCase    				=     SamVisionConfig(
          hidden_size=12_80			,num_hidden_layers=32			,num_attention_heads=16			,global_attn_indexes=[7, 15, 23, 31]			,)

      __lowerCamelCase    				=     SamConfig(
          vision_config=_UpperCamelCase			,)

   __lowerCamelCase    				=     torch.load(_UpperCamelCase			,map_location='''cpu'''				)
   __lowerCamelCase    				=     replace_keys(_UpperCamelCase				)

   __lowerCamelCase    				=     SamImageProcessor()

   __lowerCamelCase    				=     SamProcessor(image_processor=_UpperCamelCase				)
   __lowerCamelCase    				=     SamModel(_UpperCamelCase				)

   hf_model.load_state_dict(_UpperCamelCase				)
   __lowerCamelCase    				=     hf_model.to('''cuda'''				)

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

   __lowerCamelCase    				=     [[[4_00, 6_50]]]
   __lowerCamelCase    				=     [[1]]

   __lowerCamelCase    				=     processor(images=np.array(_UpperCamelCase				)			,return_tensors='''pt'''				).to('''cuda'''				)

   with torch.no_grad():
      __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
   __lowerCamelCase    				=     output.iou_scores.squeeze()

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

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

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

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

      __lowerCamelCase    				=     ((75, 2_75, 17_25, 8_50),)

      __lowerCamelCase    				=     processor(images=np.array(_UpperCamelCase				)			,input_boxes=_UpperCamelCase			,return_tensors='''pt'''				).to('''cuda'''				)

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

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

      # Test with 2 points and 1 image.
      __lowerCamelCase    				=     [[[4_00, 6_50], [8_00, 6_50]]]
      __lowerCamelCase    				=     [[1, 1]]

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

      with torch.no_grad():
         __lowerCamelCase    				=     hf_model(**_UpperCamelCase				)
      __lowerCamelCase    				=     output.iou_scores.squeeze()

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


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)






