




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


UpperCAmelCase_						={
    """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       UpperCAmelCase       (     _snake_case							):
       lowerCAmelCase   =		{}
       state_dict.pop('''pixel_mean'''						, lowerCAmelCase__							)
       state_dict.pop('''pixel_std'''						, lowerCAmelCase__							)

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

              if re.match(lowerCAmelCase__						, lowerCAmelCase__							):
                     lowerCAmelCase   =		int(re.match(lowerCAmelCase__						, lowerCAmelCase__							).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       UpperCAmelCase       (     _snake_case						, _snake_case						, _snake_case						, _snake_case="ybelkada/segment-anything"							):
       lowerCAmelCase   =		hf_hub_download(lowerCAmelCase__						, 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=1024						, num_hidden_layers=24						, num_attention_heads=16						, global_attn_indexes=[5, 11, 17, 23]						, )

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

              lowerCAmelCase   =		SamConfig(
                  vision_config=lowerCAmelCase__						, )

       lowerCAmelCase   =		torch.load(lowerCAmelCase__						, map_location='''cpu'''							)
       lowerCAmelCase   =		replace_keys(lowerCAmelCase__							)

       lowerCAmelCase   =		SamImageProcessor()

       lowerCAmelCase   =		SamProcessor(image_processor=lowerCAmelCase__							)
       lowerCAmelCase   =		SamModel(lowerCAmelCase__							)

       hf_model.load_state_dict(lowerCAmelCase__							)
       lowerCAmelCase   =		hf_model.to('''cuda'''							)

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

       lowerCAmelCase   =		[[[400, 650]]]
       lowerCAmelCase   =		[[1]]

       lowerCAmelCase   =		processor(images=np.array(lowerCAmelCase__							)						, return_tensors='''pt'''							).to('''cuda'''							)

       with torch.no_grad():
              lowerCAmelCase   =		hf_model(**lowerCAmelCase__							)
       lowerCAmelCase   =		output.iou_scores.squeeze()

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

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

              with torch.no_grad():
                     lowerCAmelCase   =		hf_model(**lowerCAmelCase__							)
              lowerCAmelCase   =		output.iou_scores.squeeze()

              assert scores[-1].item() == 0.9712603092193604

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

              lowerCAmelCase   =		processor(images=np.array(lowerCAmelCase__							)						, input_boxes=lowerCAmelCase__						, return_tensors='''pt'''							).to('''cuda'''							)

              with torch.no_grad():
                     lowerCAmelCase   =		hf_model(**lowerCAmelCase__							)
              lowerCAmelCase   =		output.iou_scores.squeeze()

              assert scores[-1].item() == 0.8686015605926514

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

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

              with torch.no_grad():
                     lowerCAmelCase   =		hf_model(**lowerCAmelCase__							)
              lowerCAmelCase   =		output.iou_scores.squeeze()

              assert scores[-1].item() == 0.9936047792434692


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

  UpperCAmelCase_						=parser.parse_args()

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









import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class 							__UpperCamelCase			( unittest.TestCase  ):





				'''simple docstring'''



				__a							: str										=MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING



				def       __snake_case		( self       , UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_						):
											lowerCAmelCase   =		hf_hub_download(
											    repo_id='''nateraw/video-demo'''       , filename='''archery.mp4'''       , repo_type='''dataset'''						)
											lowerCAmelCase   =		VideoClassificationPipeline(model=UpperCAmelCase_       , image_processor=UpperCAmelCase_       , top_k=2						)
											lowerCAmelCase   =		[
											    example_video_filepath,
											    '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
											]
											return video_classifier, examples



				def       __snake_case		( self       , UpperCAmelCase_       , UpperCAmelCase_						):
											for example in examples:
																		lowerCAmelCase   =		video_classifier(UpperCAmelCase_						)

																		self.assertEqual(
																		    UpperCAmelCase_       , [
																		        {'''score''': ANY(UpperCAmelCase_						), '''label''': ANY(UpperCAmelCase_						)},
																		        {'''score''': ANY(UpperCAmelCase_						), '''label''': ANY(UpperCAmelCase_						)},
																		    ]       , )



				@require_torch
				def       __snake_case		( self						):
											lowerCAmelCase   =		'''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
											lowerCAmelCase   =		VideoMAEFeatureExtractor(
											    size={'''shortest_edge''': 10}       , crop_size={'''height''': 10, '''width''': 10}						)
											lowerCAmelCase   =		pipeline(
											    '''video-classification'''       , model=UpperCAmelCase_       , feature_extractor=UpperCAmelCase_       , frame_sampling_rate=4						)

											lowerCAmelCase   =		hf_hub_download(repo_id='''nateraw/video-demo'''       , filename='''archery.mp4'''       , repo_type='''dataset'''						)
											lowerCAmelCase   =		video_classifier(UpperCAmelCase_       , top_k=2						)
											self.assertEqual(
											    nested_simplify(UpperCAmelCase_       , decimals=4						)       , [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}]       , )

											lowerCAmelCase   =		video_classifier(
											    [
											        video_file_path,
											        video_file_path,
											    ]       , top_k=2       , )
											self.assertEqual(
											    nested_simplify(UpperCAmelCase_       , decimals=4						)       , [
											        [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
											        [{'''score''': 0.5199, '''label''': '''LABEL_0'''}, {'''score''': 0.4801, '''label''': '''LABEL_1'''}],
											    ]       , )






				@require_tf
				def       __snake_case		( self						):
											pass



