
import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD







def 						_snake_case(  )			->   int:
       lowercase							:					Optional[int]	     =				"""https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
       lowercase							:					str	     =				Image.open(requests.get(SCREAMING_SNAKE_CASE__ ,     stream=SCREAMING_SNAKE_CASE__    ).raw    ).convert("""RGB"""    )

       return image







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   Any:
       lowercase							:					List[str]	     =				[]
       # fmt: off

       # vision encoder
       rename_keys.append(("""visual_encoder.cls_token""", """vision_model.embeddings.class_embedding""")    )
       rename_keys.append(("""visual_encoder.pos_embed""", """vision_model.embeddings.position_embedding""")    )
       rename_keys.append(("""visual_encoder.patch_embed.proj.weight""", """vision_model.embeddings.patch_embedding.weight""")    )
       rename_keys.append(("""visual_encoder.patch_embed.proj.bias""", """vision_model.embeddings.patch_embedding.bias""")    )
       rename_keys.append(("""ln_vision.weight""", """vision_model.post_layernorm.weight""")    )
       rename_keys.append(("""ln_vision.bias""", """vision_model.post_layernorm.bias""")    )

       for i in range(config.vision_config.num_hidden_layers    ):
              rename_keys.append((f"visual_encoder.blocks.{i}.norm1.weight", f"vision_model.encoder.layers.{i}.layer_norm1.weight")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.norm1.bias", f"vision_model.encoder.layers.{i}.layer_norm1.bias")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.norm2.weight", f"vision_model.encoder.layers.{i}.layer_norm2.weight")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.norm2.bias", f"vision_model.encoder.layers.{i}.layer_norm2.bias")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.attn.qkv.weight", f"vision_model.encoder.layers.{i}.self_attn.qkv.weight")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.weight", f"vision_model.encoder.layers.{i}.self_attn.projection.weight",)    )
              rename_keys.append((f"visual_encoder.blocks.{i}.attn.proj.bias", f"vision_model.encoder.layers.{i}.self_attn.projection.bias")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.weight", f"vision_model.encoder.layers.{i}.mlp.fc1.weight")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc1.bias", f"vision_model.encoder.layers.{i}.mlp.fc1.bias")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.weight", f"vision_model.encoder.layers.{i}.mlp.fc2.weight")    )
              rename_keys.append((f"visual_encoder.blocks.{i}.mlp.fc2.bias", f"vision_model.encoder.layers.{i}.mlp.fc2.bias")    )

       # QFormer
       rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.weight""", """qformer.layernorm.weight""")    )
       rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.bias""", """qformer.layernorm.bias""")    )

       # fmt: on
       return rename_keys







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   List[Any]:
       lowercase							:					str	     =				dct.pop(SCREAMING_SNAKE_CASE__    )
       lowercase							:					Any	     =				val







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Optional[int]:
       for i in range(config.vision_config.num_hidden_layers    ):
              # read in original q and v biases
              lowercase							:					List[str]	     =				state_dict.pop(f"visual_encoder.blocks.{i}.attn.q_bias"    )
              lowercase							:					int	     =				state_dict.pop(f"visual_encoder.blocks.{i}.attn.v_bias"    )

              # next, set bias in the state dict
              lowercase							:					List[str]	     =				torch.cat((q_bias, torch.zeros_like(SCREAMING_SNAKE_CASE__ ,     requires_grad=SCREAMING_SNAKE_CASE__    ), v_bias)    )
              lowercase							:					Any	     =				qkv_bias







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   Union[str, Any]:
       lowercase							:					str	     =				364 if """coco""" in model_name else 224
       lowercase							:					Any	     =				BlipaVisionConfig(image_size=SCREAMING_SNAKE_CASE__    ).to_dict()

       # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
       # seems like flan-T5 models don't have bos_token_id properly set?
       if "opt-2.7b" in model_name:
              lowercase							:					Dict	     =				OPTConfig.from_pretrained("""facebook/opt-2.7b""" ,     eos_token_id=SCREAMING_SNAKE_CASE__    ).to_dict()
       elif "opt-6.7b" in model_name:
              lowercase							:					Any	     =				OPTConfig.from_pretrained("""facebook/opt-6.7b""" ,     eos_token_id=SCREAMING_SNAKE_CASE__    ).to_dict()
       elif "t5-xl" in model_name:
              lowercase							:					int	     =				TaConfig.from_pretrained("""google/flan-t5-xl""" ,     dense_act_fn="""gelu""" ,     bos_token_id=1    ).to_dict()
       elif "t5-xxl" in model_name:
              lowercase							:					Union[str, Any]	     =				TaConfig.from_pretrained("""google/flan-t5-xxl""" ,     dense_act_fn="""gelu""" ,     bos_token_id=1    ).to_dict()

       lowercase							:					Optional[int]	     =				BlipaConfig(vision_config=SCREAMING_SNAKE_CASE__ ,     text_config=SCREAMING_SNAKE_CASE__    )

       return config, image_size







@torch.no_grad()
def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__=None ,     SCREAMING_SNAKE_CASE__=False    )			->   Any:
       lowercase							:					Dict	     =				(
           AutoTokenizer.from_pretrained("""facebook/opt-2.7b"""    )
           if """opt""" in model_name
           else AutoTokenizer.from_pretrained("""google/flan-t5-xl"""    )
       )
       lowercase							:					List[str]	     =				tokenizer("""\n""" ,     add_special_tokens=SCREAMING_SNAKE_CASE__    ).input_ids[0]
       lowercase     ,      lowercase							:					Optional[int]	     =				get_blipa_config(SCREAMING_SNAKE_CASE__ ,     eos_token_id=SCREAMING_SNAKE_CASE__    )

       lowercase							:					Tuple	     =				BlipaForConditionalGeneration(SCREAMING_SNAKE_CASE__    ).eval()

       lowercase							:					str	     =				{
           """blip2-opt-2.7b""": ("""blip2_opt""", """pretrain_opt2.7b"""),
           """blip2-opt-6.7b""": ("""blip2_opt""", """pretrain_opt6.7b"""),
           """blip2-opt-2.7b-coco""": ("""blip2_opt""", """caption_coco_opt2.7b"""),
           """blip2-opt-6.7b-coco""": ("""blip2_opt""", """caption_coco_opt6.7b"""),
           """blip2-flan-t5-xl""": ("""blip2_t5""", """pretrain_flant5xl"""),
           """blip2-flan-t5-xl-coco""": ("""blip2_t5""", """caption_coco_flant5xl"""),
           """blip2-flan-t5-xxl""": ("""blip2_t5""", """pretrain_flant5xxl"""),
       }

       lowercase     ,      lowercase							:					int	     =				model_name_to_original[model_name]

       # load original model
       print("""Loading original model..."""    )
       lowercase							:					Tuple	     =				"""cuda""" if torch.cuda.is_available() else """cpu"""
       lowercase     ,      lowercase     ,      lowercase							:					Tuple	     =				load_model_and_preprocess(
           name=SCREAMING_SNAKE_CASE__ ,     model_type=SCREAMING_SNAKE_CASE__ ,     is_eval=SCREAMING_SNAKE_CASE__ ,     device=SCREAMING_SNAKE_CASE__    )
       original_model.eval()
       print("""Done!"""    )

       # update state dict keys
       lowercase							:					List[Any]	     =				original_model.state_dict()
       lowercase							:					Dict	     =				create_rename_keys(SCREAMING_SNAKE_CASE__    )
       for src, dest in rename_keys:
              rename_key(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )

       # some keys can be renamed efficiently
       for key, val in state_dict.copy().items():
              lowercase							:					List[str]	     =				state_dict.pop(SCREAMING_SNAKE_CASE__    )
              if key.startswith("""Qformer.bert"""    ):
                     lowercase							:					Union[str, Any]	     =				key.replace("""Qformer.bert""" ,     """qformer"""    )
              if "attention.self" in key:
                     lowercase							:					Any	     =				key.replace("""self""" ,     """attention"""    )
              if "opt_proj" in key:
                     lowercase							:					Optional[int]	     =				key.replace("""opt_proj""" ,     """language_projection"""    )
              if "t5_proj" in key:
                     lowercase							:					Any	     =				key.replace("""t5_proj""" ,     """language_projection"""    )
              if key.startswith("""opt"""    ):
                     lowercase							:					Optional[int]	     =				key.replace("""opt""" ,     """language"""    )
              if key.startswith("""t5"""    ):
                     lowercase							:					str	     =				key.replace("""t5""" ,     """language"""    )
              lowercase							:					Union[str, Any]	     =				val

       # read in qv biases
       read_in_q_v_bias(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )

       lowercase     ,      lowercase							:					Optional[Any]	     =				hf_model.load_state_dict(SCREAMING_SNAKE_CASE__ ,     strict=SCREAMING_SNAKE_CASE__    )
       assert len(SCREAMING_SNAKE_CASE__    ) == 0
       assert unexpected_keys == ["qformer.embeddings.position_ids"]

       lowercase							:					Optional[Any]	     =				load_demo_image()
       lowercase							:					Optional[Any]	     =				vis_processors["""eval"""](SCREAMING_SNAKE_CASE__    ).unsqueeze(0    ).to(SCREAMING_SNAKE_CASE__    )
       lowercase							:					Tuple	     =				tokenizer(["""\n"""] ,     return_tensors="""pt"""    ).input_ids.to(SCREAMING_SNAKE_CASE__    )

       # create processor
       lowercase							:					Union[str, Any]	     =				BlipImageProcessor(
           size={"""height""": image_size, """width""": image_size} ,     image_mean=SCREAMING_SNAKE_CASE__ ,     image_std=SCREAMING_SNAKE_CASE__    )
       lowercase							:					Union[str, Any]	     =				BlipaProcessor(image_processor=SCREAMING_SNAKE_CASE__ ,     tokenizer=SCREAMING_SNAKE_CASE__    )
       lowercase							:					Optional[int]	     =				processor(images=SCREAMING_SNAKE_CASE__ ,     return_tensors="""pt"""    ).pixel_values.to(SCREAMING_SNAKE_CASE__    )

       # make sure processor creates exact same pixel values
       assert torch.allclose(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )

       original_model.to(SCREAMING_SNAKE_CASE__    )
       hf_model.to(SCREAMING_SNAKE_CASE__    )
       with torch.no_grad():
              if "opt" in model_name:
                     lowercase							:					Union[str, Any]	     =				original_model({"""image""": original_pixel_values, """text_input""": [""""""]}    ).logits
                     lowercase							:					Optional[Any]	     =				hf_model(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    ).logits
              else:
                     lowercase							:					Union[str, Any]	     =				original_model(
                         {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}    ).logits
                     lowercase							:					Any	     =				input_ids.masked_fill(input_ids == tokenizer.pad_token_id ,     -100    )
                     lowercase							:					Union[str, Any]	     =				hf_model(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     labels=SCREAMING_SNAKE_CASE__    ).logits

       assert original_logits.shape == logits.shape
       print("""First values of original logits:""" ,     original_logits[0, :3, :3]    )
       print("""First values of HF logits:""" ,     logits[0, :3, :3]    )

       # assert values
       if model_name == "blip2-flan-t5-xl":
              lowercase							:					List[str]	     =				torch.tensor(
                  [[-41.5850, -4.4440, -8.9922], [-47.4322, -5.9143, -1.7340]] ,     device=SCREAMING_SNAKE_CASE__    )
              assert torch.allclose(logits[0, :3, :3] ,     SCREAMING_SNAKE_CASE__ ,     atol=1e-4    )
       elif model_name == "blip2-flan-t5-xl-coco":
              lowercase							:					int	     =				torch.tensor(
                  [[-57.0109, -9.8967, -12.6280], [-68.6578, -12.7191, -10.5065]] ,     device=SCREAMING_SNAKE_CASE__    )
       else:
              # cast to same type
              lowercase							:					str	     =				logits.dtype
              assert torch.allclose(original_logits.to(SCREAMING_SNAKE_CASE__    ) ,     SCREAMING_SNAKE_CASE__ ,     atol=1e-2    )
       print("""Looks ok!"""    )

       print("""Generating a caption..."""    )
       lowercase							:					str	     =				""""""
       lowercase							:					Optional[int]	     =				tokenizer(SCREAMING_SNAKE_CASE__ ,     return_tensors="""pt"""    ).input_ids.to(SCREAMING_SNAKE_CASE__    )

       lowercase							:					Tuple	     =				original_model.generate({"""image""": original_pixel_values}    )
       lowercase							:					Any	     =				hf_model.generate(
           SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     do_sample=SCREAMING_SNAKE_CASE__ ,     num_beams=5 ,     max_length=30 ,     min_length=1 ,     top_p=0.9 ,     repetition_penalty=1.0 ,     length_penalty=1.0 ,     temperature=1 ,     )
       print("""Original generation:""" ,     SCREAMING_SNAKE_CASE__    )
       lowercase							:					Optional[Any]	     =				input_ids.shape[1]
       lowercase							:					Optional[int]	     =				processor.batch_decode(outputs[:, prompt_length:] ,     skip_special_tokens=SCREAMING_SNAKE_CASE__    )
       lowercase							:					List[Any]	     =				[text.strip() for text in output_text]
       print("""HF generation:""" ,     SCREAMING_SNAKE_CASE__    )

       if pytorch_dump_folder_path is not None:
              processor.save_pretrained(SCREAMING_SNAKE_CASE__    )
              hf_model.save_pretrained(SCREAMING_SNAKE_CASE__    )

       if push_to_hub:
              processor.push_to_hub(f"nielsr/{model_name}"    )
              hf_model.push_to_hub(f"nielsr/{model_name}"    )


if __name__ == "__main__":
  lowercase  : List[str]						   =							argparse.ArgumentParser()
  lowercase  : str						   =							[
      """blip2-opt-2.7b""",
      """blip2-opt-6.7b""",
      """blip2-opt-2.7b-coco""",
      """blip2-opt-6.7b-coco""",
      """blip2-flan-t5-xl""",
      """blip2-flan-t5-xl-coco""",
      """blip2-flan-t5-xxl""",
  ]
  parser.add_argument(
      """--model_name""",
      default="""blip2-opt-2.7b""",
      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""",
  )

  lowercase  : Union[str, Any]						   =							parser.parse_args()

  convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)


import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel







def 						_snake_case(  SCREAMING_SNAKE_CASE__    )			->   List[str]:
       # vision encoder
       if "img_encoder.pos_embed" in name:
              lowercase							:					Dict	     =				name.replace("""img_encoder.pos_embed""" ,     """vision_model.embeddings.position_embeddings"""    )
       if "img_encoder.patch_embed.proj" in name:
              lowercase							:					Any	     =				name.replace("""img_encoder.patch_embed.proj""" ,     """vision_model.embeddings.patch_embeddings.projection"""    )
       if "img_encoder.patch_embed.norm" in name:
              lowercase							:					Tuple	     =				name.replace("""img_encoder.patch_embed.norm""" ,     """vision_model.embeddings.layernorm"""    )
       if "img_encoder.layers" in name:
              lowercase							:					Tuple	     =				name.replace("""img_encoder.layers""" ,     """vision_model.encoder.stages"""    )
       if "blocks" in name and "res" not in name:
              lowercase							:					Optional[Any]	     =				name.replace("""blocks""" ,     """layers"""    )
       if "attn" in name and "pre_assign" not in name:
              lowercase							:					Union[str, Any]	     =				name.replace("""attn""" ,     """self_attn"""    )
       if "proj" in name and "self_attn" in name and "text" not in name:
              lowercase							:					Dict	     =				name.replace("""proj""" ,     """out_proj"""    )
       if "pre_assign_attn.attn.proj" in name:
              lowercase							:					Dict	     =				name.replace("""pre_assign_attn.attn.proj""" ,     """pre_assign_attn.attn.out_proj"""    )
       if "norm1" in name:
              lowercase							:					Tuple	     =				name.replace("""norm1""" ,     """layer_norm1"""    )
       if "norm2" in name and "pre_assign" not in name:
              lowercase							:					Tuple	     =				name.replace("""norm2""" ,     """layer_norm2"""    )
       if "img_encoder.norm" in name:
              lowercase							:					List[Any]	     =				name.replace("""img_encoder.norm""" ,     """vision_model.layernorm"""    )
       # text encoder
       if "text_encoder.token_embedding" in name:
              lowercase							:					Tuple	     =				name.replace("""text_encoder.token_embedding""" ,     """text_model.embeddings.token_embedding"""    )
       if "text_encoder.positional_embedding" in name:
              lowercase							:					Any	     =				name.replace("""text_encoder.positional_embedding""" ,     """text_model.embeddings.position_embedding.weight"""    )
       if "text_encoder.transformer.resblocks." in name:
              lowercase							:					Dict	     =				name.replace("""text_encoder.transformer.resblocks.""" ,     """text_model.encoder.layers."""    )
       if "ln_1" in name:
              lowercase							:					List[str]	     =				name.replace("""ln_1""" ,     """layer_norm1"""    )
       if "ln_2" in name:
              lowercase							:					Tuple	     =				name.replace("""ln_2""" ,     """layer_norm2"""    )
       if "c_fc" in name:
              lowercase							:					str	     =				name.replace("""c_fc""" ,     """fc1"""    )
       if "c_proj" in name:
              lowercase							:					Union[str, Any]	     =				name.replace("""c_proj""" ,     """fc2"""    )
       if "text_encoder" in name:
              lowercase							:					Tuple	     =				name.replace("""text_encoder""" ,     """text_model"""    )
       if "ln_final" in name:
              lowercase							:					Optional[Any]	     =				name.replace("""ln_final""" ,     """final_layer_norm"""    )
       # projection layers
       if "img_projector.linear_hidden." in name:
              lowercase							:					List[str]	     =				name.replace("""img_projector.linear_hidden.""" ,     """visual_projection."""    )
       if "img_projector.linear_out." in name:
              lowercase							:					Tuple	     =				name.replace("""img_projector.linear_out.""" ,     """visual_projection.3."""    )
       if "text_projector.linear_hidden" in name:
              lowercase							:					List[Any]	     =				name.replace("""text_projector.linear_hidden""" ,     """text_projection"""    )
       if "text_projector.linear_out" in name:
              lowercase							:					List[Any]	     =				name.replace("""text_projector.linear_out""" ,     """text_projection.3"""    )

       return name







def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )			->   List[str]:
       for key in orig_state_dict.copy().keys():
              lowercase							:					List[Any]	     =				orig_state_dict.pop(SCREAMING_SNAKE_CASE__    )

              if "qkv" in key:
                     # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
                     # we need to split them up into separate matrices/vectors
                     lowercase							:					Dict	     =				key.split("""."""    )
                     lowercase     ,      lowercase							:					Optional[Any]	     =				int(key_split[2]    ), int(key_split[4]    )
                     lowercase							:					List[Any]	     =				config.vision_config.hidden_size
                     if "weight" in key:
                            lowercase							:					str	     =				val[:dim, :]
                            lowercase							:					List[str]	     =				val[dim : dim * 2, :]
                            lowercase							:					Optional[int]	     =				val[-dim:, :]
                     else:
                            lowercase							:					Dict	     =				val[:dim]
                            lowercase							:					Dict	     =				val[dim : dim * 2]
                            lowercase							:					Dict	     =				val[-dim:]
              elif "in_proj" in key:
                     # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
                     # we need to split them up into separate matrices/vectors
                     lowercase							:					int	     =				key.split("""."""    )
                     lowercase							:					Tuple	     =				int(key_split[3]    )
                     lowercase							:					str	     =				config.text_config.hidden_size
                     if "weight" in key:
                            lowercase							:					Optional[int]	     =				val[:dim, :]
                            lowercase							:					Optional[Any]	     =				val[
                                dim : dim * 2, :
                            ]
                            lowercase							:					Optional[int]	     =				val[-dim:, :]
                     else:
                            lowercase							:					Optional[int]	     =				val[:dim]
                            lowercase							:					Dict	     =				val[dim : dim * 2]
                            lowercase							:					List[str]	     =				val[-dim:]
              else:
                     lowercase							:					Tuple	     =				rename_key(SCREAMING_SNAKE_CASE__    )
                     # squeeze if necessary
                     if (
                         "text_projection.0" in new_name
                         or "text_projection.3" in new_name
                         or "visual_projection.0" in new_name
                         or "visual_projection.3" in new_name
                     ):
                            lowercase							:					str	     =				val.squeeze_()
                     else:
                            lowercase							:					Any	     =				val

       return orig_state_dict







def 						_snake_case(  )			->   List[Any]:
       lowercase							:					Tuple	     =				"""http://images.cocodataset.org/val2017/000000039769.jpg"""
       lowercase							:					Any	     =				Image.open(requests.get(SCREAMING_SNAKE_CASE__ ,     stream=SCREAMING_SNAKE_CASE__    ).raw    )
       return im







@torch.no_grad()
def 						_snake_case(  SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__="groupvit-gcc-yfcc" ,     SCREAMING_SNAKE_CASE__=False    )			->   str:
       lowercase							:					Dict	     =				GroupViTConfig()
       lowercase							:					Tuple	     =				GroupViTModel(SCREAMING_SNAKE_CASE__    ).eval()

       lowercase							:					List[str]	     =				torch.load(SCREAMING_SNAKE_CASE__ ,     map_location="""cpu"""    )["""model"""]
       lowercase							:					Optional[Any]	     =				convert_state_dict(SCREAMING_SNAKE_CASE__ ,     SCREAMING_SNAKE_CASE__    )
       lowercase     ,      lowercase							:					int	     =				model.load_state_dict(SCREAMING_SNAKE_CASE__ ,     strict=SCREAMING_SNAKE_CASE__    )
       assert missing_keys == ["text_model.embeddings.position_ids"]
       assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(SCREAMING_SNAKE_CASE__    ) == 0)

       # verify result
       lowercase							:					Tuple	     =				CLIPProcessor.from_pretrained("""openai/clip-vit-base-patch32"""    )
       lowercase							:					Optional[Any]	     =				prepare_img()
       lowercase							:					List[Any]	     =				processor(text=["""a photo of a cat""", """a photo of a dog"""] ,     images=SCREAMING_SNAKE_CASE__ ,     padding=SCREAMING_SNAKE_CASE__ ,     return_tensors="""pt"""    )

       with torch.no_grad():
              lowercase							:					Optional[Any]	     =				model(**SCREAMING_SNAKE_CASE__    )

       if model_name == "groupvit-gcc-yfcc":
              lowercase							:					Optional[int]	     =				torch.tensor([[13.3523, 6.3629]]    )
       elif model_name == "groupvit-gcc-redcaps":
              lowercase							:					int	     =				torch.tensor([[16.1873, 8.6230]]    )
       else:
              raise ValueError(f"Model name {model_name} not supported."    )
       assert torch.allclose(outputs.logits_per_image ,     SCREAMING_SNAKE_CASE__ ,     atol=1e-3    )

       processor.save_pretrained(SCREAMING_SNAKE_CASE__    )
       model.save_pretrained(SCREAMING_SNAKE_CASE__    )
       print("""Successfully saved processor and model to""" ,     SCREAMING_SNAKE_CASE__    )

       if push_to_hub:
              print("""Pushing to the hub..."""    )
              processor.push_to_hub(SCREAMING_SNAKE_CASE__ ,     organization="""nielsr"""    )
              model.push_to_hub(SCREAMING_SNAKE_CASE__ ,     organization="""nielsr"""    )


if __name__ == "__main__":
  lowercase  : List[Any]						   =							argparse.ArgumentParser()
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to dump the processor and PyTorch model."""
  )
  parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to GroupViT checkpoint""")
  parser.add_argument(
      """--model_name""",
      default="""groupvit-gccy-fcc""",
      type=str,
      help="""Name of the model. Expecting either 'groupvit-gcc-yfcc' or 'groupvit-gcc-redcaps'""",
  )
  parser.add_argument(
      """--push_to_hub""",
      action="""store_true""",
      help="""Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.""",
  )
  lowercase  : Union[str, Any]						   =							parser.parse_args()

  convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)
