





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


_snake_case           =							{
    """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       (   __magic_name__	):
   lowercase__			       =  {}
   state_dict.pop("pixel_mean"  , a_	)
   state_dict.pop("pixel_std"  , a_	)

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

      if re.match(a_  , a_	):
         lowercase__			       =  int(re.match(a_  , a_	).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       (   __magic_name__  , __magic_name__  , __magic_name__  , __magic_name__="ybelkada/segment-anything"	):
   lowercase__			       =  hf_hub_download(a_  , 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=a_  , )
   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=a_  , )

   lowercase__			       =  torch.load(a_  , map_location="cpu"	)
   lowercase__			       =  replace_keys(a_	)

   lowercase__			       =  SamImageProcessor()

   lowercase__			       =  SamProcessor(image_processor=a_	)
   lowercase__			       =  SamModel(a_	)

   hf_model.load_state_dict(a_	)
   lowercase__			       =  hf_model.to("cuda"	)

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

   lowercase__			       =  [[[400, 650]]]
   lowercase__			       =  [[1]]

   lowercase__			       =  processor(images=np.array(a_	)  , return_tensors="pt"	).to("cuda"	)

   with torch.no_grad():
      lowercase__			       =  hf_model(**a_	)
   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(a_	)  , input_points=a_  , input_labels=a_  , return_tensors="pt"	).to("cuda"	)

      with torch.no_grad():
         lowercase__			       =  hf_model(**a_	)
      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(a_	)  , input_boxes=a_  , return_tensors="pt"	).to("cuda"	)

      with torch.no_grad():
         lowercase__			       =  hf_model(**a_	)
      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(a_	)  , input_points=a_  , input_labels=a_  , return_tensors="pt"	).to("cuda"	)

      with torch.no_grad():
         lowercase__			       =  hf_model(**a_	)
      lowercase__			       =  output.iou_scores.squeeze()

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


if __name__ == "__main__":
  _snake_case           =							argparse.ArgumentParser()
  _snake_case           =							["""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""",
  )

  _snake_case           =							parser.parse_args()

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













def _A       (   __magic_name__  , __magic_name__  , __magic_name__  , __magic_name__	):
   if height >= 1:
      move_tower(height - 1  , __magic_name__  , __magic_name__  , __magic_name__	)
      move_disk(__magic_name__  , __magic_name__	)
      move_tower(height - 1  , __magic_name__  , __magic_name__  , __magic_name__	)


def _A       (   __magic_name__  , __magic_name__	):
   print("moving disk from"  , __magic_name__  , "to"  , __magic_name__	)


def _A       (   ):
   lowercase__			       =  int(input("Height of hanoi: "	).strip()	)
   move_tower(__magic_name__  , "A"  , "B"  , "C"	)


if __name__ == "__main__":
  main()






