

"""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   _A  (  UpperCamelCase_					:	Any)     ->						str:
   '''simple docstring'''


   __lowercase								=						{}
   state_dict.pop("pixel_mean",      UpperCamelCase_)
   state_dict.pop("pixel_std",      UpperCamelCase_)

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

      if re.match(UpperCamelCase_,      UpperCamelCase_):
         __lowercase								=						int(re.match(UpperCamelCase_,      UpperCamelCase_).group(2))
         if layer_nb == 0:
            __lowercase								=						key.replace("layers.0",      "proj_in")
         elif layer_nb == 1:
            __lowercase								=						key.replace("layers.1",      "layers.0")
         elif layer_nb == 2:
            __lowercase								=						key.replace("layers.2",      "proj_out")

      __lowercase								=						value

   __lowercase								=						model_state_dict[
       "prompt_encoder.shared_embedding.positional_embedding"
   ]

   return model_state_dict




def   _A  (  UpperCamelCase_					:	Tuple,      UpperCamelCase_					:	Tuple,      UpperCamelCase_					:	int,      UpperCamelCase_					:	int="ybelkada/segment-anything")     ->						str:
   '''simple docstring'''


   __lowercase								=						hf_hub_download(UpperCamelCase_,      F"""checkpoints/{model_name}.pth""")

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

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

      __lowercase								=						SamConfig(
          vision_config=UpperCamelCase_,      )

   __lowercase								=						torch.load(UpperCamelCase_,      map_location="cpu")
   __lowercase								=						replace_keys(UpperCamelCase_)

   __lowercase								=						SamImageProcessor()

   __lowercase								=						SamProcessor(image_processor=UpperCamelCase_)
   __lowercase								=						SamModel(UpperCamelCase_)

   hf_model.load_state_dict(UpperCamelCase_)
   __lowercase								=						hf_model.to("cuda")

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

   __lowercase								=						[[[400, 650]]]
   __lowercase								=						[[1]]

   __lowercase								=						processor(images=np.array(UpperCamelCase_),      return_tensors="pt").to("cuda")

   with torch.no_grad():
      __lowercase								=						hf_model(**UpperCamelCase_)
   __lowercase								=						output.iou_scores.squeeze()

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

      __lowercase								=						processor(
          images=np.array(UpperCamelCase_),      input_points=UpperCamelCase_,      input_labels=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						output.iou_scores.squeeze()

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

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

      __lowercase								=						processor(images=np.array(UpperCamelCase_),      input_boxes=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						output.iou_scores.squeeze()

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

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

      __lowercase								=						processor(
          images=np.array(UpperCamelCase_),      input_points=UpperCamelCase_,      input_labels=UpperCamelCase_,      return_tensors="pt").to("cuda")

      with torch.no_grad():
         __lowercase								=						hf_model(**UpperCamelCase_)
      __lowercase								=						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)







"""simple docstring"""





# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


_a							=							'Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine'




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


   __lowercase								=						_ask_options(
       "In which compute environment are you running?",      ["This machine", "AWS (Amazon SageMaker)"],      _convert_compute_environment,      )
   if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
      __lowercase								=						get_sagemaker_input()
   else:
      __lowercase								=						get_cluster_input()
   return config




def   _A  (  UpperCamelCase_					:	Union[str, Any]=None)     ->						Union[str, Any]:
   '''simple docstring'''


   if subparsers is not None:
      __lowercase								=						subparsers.add_parser("config",      description=UpperCamelCase_)
   else:
      __lowercase								=						argparse.ArgumentParser("Accelerate config command",      description=UpperCamelCase_)

   parser.add_argument(
       "--config_file",      default=UpperCamelCase_,      help=(
           "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
           "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
           "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
           "with 'huggingface'."
       ),      )

   if subparsers is not None:
      parser.set_defaults(func=UpperCamelCase_)
   return parser




def   _A  (  UpperCamelCase_					:	Dict)     ->						str:
   '''simple docstring'''


   __lowercase								=						get_user_input()
   if args.config_file is not None:
      __lowercase								=						args.config_file
   else:
      if not os.path.isdir(UpperCamelCase_):
         os.makedirs(UpperCamelCase_)
      __lowercase								=						default_yaml_config_file

   if config_file.endswith(".json"):
      config.to_json_file(UpperCamelCase_)
   else:
      config.to_yaml_file(UpperCamelCase_)
   print(F"""accelerate configuration saved at {config_file}""")




def   _A  (  )     ->						Optional[Any]:
   '''simple docstring'''


   __lowercase								=						config_command_parser()
   __lowercase								=						parser.parse_args()
   config_command(UpperCamelCase_)


if __name__ == "__main__":
   main()




