


'''simple docstring'''

import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel






def __UpperCamelCase   (			__lowerCamelCase		: Optional[Any]				)      ->     Dict:







     '''simple docstring'''






     if "img_encoder.pos_embed" in name:
          _a						=		name.replace("img_encoder.pos_embed"      ,  "vision_model.embeddings.position_embeddings"				)
     if "img_encoder.patch_embed.proj" in name:
          _a						=		name.replace("img_encoder.patch_embed.proj"      ,  "vision_model.embeddings.patch_embeddings.projection"				)
     if "img_encoder.patch_embed.norm" in name:
          _a						=		name.replace("img_encoder.patch_embed.norm"      ,  "vision_model.embeddings.layernorm"				)
     if "img_encoder.layers" in name:
          _a						=		name.replace("img_encoder.layers"      ,  "vision_model.encoder.stages"				)
     if "blocks" in name and "res" not in name:
          _a						=		name.replace("blocks"      ,  "layers"				)
     if "attn" in name and "pre_assign" not in name:
          _a						=		name.replace("attn"      ,  "self_attn"				)
     if "proj" in name and "self_attn" in name and "text" not in name:
          _a						=		name.replace("proj"      ,  "out_proj"				)
     if "pre_assign_attn.attn.proj" in name:
          _a						=		name.replace("pre_assign_attn.attn.proj"      ,  "pre_assign_attn.attn.out_proj"				)
     if "norm1" in name:
          _a						=		name.replace("norm1"      ,  "layer_norm1"				)
     if "norm2" in name and "pre_assign" not in name:
          _a						=		name.replace("norm2"      ,  "layer_norm2"				)
     if "img_encoder.norm" in name:
          _a						=		name.replace("img_encoder.norm"      ,  "vision_model.layernorm"				)
     # text encoder
     if "text_encoder.token_embedding" in name:
          _a						=		name.replace("text_encoder.token_embedding"      ,  "text_model.embeddings.token_embedding"				)
     if "text_encoder.positional_embedding" in name:
          _a						=		name.replace("text_encoder.positional_embedding"      ,  "text_model.embeddings.position_embedding.weight"				)
     if "text_encoder.transformer.resblocks." in name:
          _a						=		name.replace("text_encoder.transformer.resblocks."      ,  "text_model.encoder.layers."				)
     if "ln_1" in name:
          _a						=		name.replace("ln_1"      ,  "layer_norm1"				)
     if "ln_2" in name:
          _a						=		name.replace("ln_2"      ,  "layer_norm2"				)
     if "c_fc" in name:
          _a						=		name.replace("c_fc"      ,  "fc1"				)
     if "c_proj" in name:
          _a						=		name.replace("c_proj"      ,  "fc2"				)
     if "text_encoder" in name:
          _a						=		name.replace("text_encoder"      ,  "text_model"				)
     if "ln_final" in name:
          _a						=		name.replace("ln_final"      ,  "final_layer_norm"				)
     # projection layers
     if "img_projector.linear_hidden." in name:
          _a						=		name.replace("img_projector.linear_hidden."      ,  "visual_projection."				)
     if "img_projector.linear_out." in name:
          _a						=		name.replace("img_projector.linear_out."      ,  "visual_projection.3."				)
     if "text_projector.linear_hidden" in name:
          _a						=		name.replace("text_projector.linear_hidden"      ,  "text_projection"				)
     if "text_projector.linear_out" in name:
          _a						=		name.replace("text_projector.linear_out"      ,  "text_projection.3"				)

     return name






def __UpperCamelCase   (			__lowerCamelCase		: Tuple      ,  __lowerCamelCase		: Optional[Any]				)      ->     Union[str, Any]:







     '''simple docstring'''






     for key in orig_state_dict.copy().keys():
          _a						=		orig_state_dict.pop(__lowerCamelCase				)

          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
               _a						=		key.split("."				)
               _a			,			_a						=		int(key_split[2]				), int(key_split[4]				)
               _a						=		config.vision_config.hidden_size
               if "weight" in key:
                    _a						=		val[:dim, :]
                    _a						=		val[dim : dim * 2, :]
                    _a						=		val[-dim:, :]
               else:
                    _a						=		val[:dim]
                    _a						=		val[dim : dim * 2]
                    _a						=		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
               _a						=		key.split("."				)
               _a						=		int(key_split[3]				)
               _a						=		config.text_config.hidden_size
               if "weight" in key:
                    _a						=		val[:dim, :]
                    _a						=		val[
                        dim : dim * 2, :
                    ]
                    _a						=		val[-dim:, :]
               else:
                    _a						=		val[:dim]
                    _a						=		val[dim : dim * 2]
                    _a						=		val[-dim:]
          else:
               _a						=		rename_key(__lowerCamelCase				)
               # 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
               ):
                    _a						=		val.squeeze_()
               else:
                    _a						=		val

     return orig_state_dict






def __UpperCamelCase   (			)      ->     Dict:







     '''simple docstring'''






     _a						=		"http://images.cocodataset.org/val2017/000000039769.jpg"
     _a						=		Image.open(requests.get(__lowerCamelCase      ,  stream=__lowerCamelCase				).raw				)
     return im






@torch.no_grad()
def __UpperCamelCase   (			__lowerCamelCase		: Any      ,  __lowerCamelCase		: int      ,  __lowerCamelCase		: int="groupvit-gcc-yfcc"      ,  __lowerCamelCase		: List[str]=False				)      ->     Tuple:







     '''simple docstring'''






     _a						=		GroupViTConfig()
     _a						=		GroupViTModel(__lowerCamelCase				).eval()

     _a						=		torch.load(__lowerCamelCase      ,  map_location="cpu"				)["model"]
     _a						=		convert_state_dict(__lowerCamelCase      ,  __lowerCamelCase				)
     _a			,			_a						=		model.load_state_dict(__lowerCamelCase      ,  strict=__lowerCamelCase				)
     assert missing_keys == ["text_model.embeddings.position_ids"]
     assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(__lowerCamelCase				) == 0)

     # verify result
     _a						=		CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32"				)
     _a						=		prepare_img()
     _a						=		processor(text=["a photo of a cat", "a photo of a dog"]      ,  images=__lowerCamelCase      ,  padding=__lowerCamelCase      ,  return_tensors="pt"				)

     with torch.no_grad():
          _a						=		model(**__lowerCamelCase				)

     if model_name == "groupvit-gcc-yfcc":
          _a						=		torch.tensor([[13.35_23, 6.36_29]]				)
     elif model_name == "groupvit-gcc-redcaps":
          _a						=		torch.tensor([[16.18_73, 8.62_30]]				)
     else:
          raise ValueError(F"Model name {model_name} not supported."				)
     assert torch.allclose(outputs.logits_per_image      ,  __lowerCamelCase      ,  atol=1E-3				)

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

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


if __name__ == "__main__":
   lowercase__				     =		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__				     =		parser.parse_args()

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





'''simple docstring'''

lowercase__				     =		65_521






def __UpperCamelCase   (			__lowerCamelCase		: str				)      ->     int:







     '''simple docstring'''






     _a						=		1
     _a						=		0
     for plain_chr in plain_text:
          _a						=		(a + ord(__lowerCamelCase				)) % MOD_ADLER
          _a						=		(b + a) % MOD_ADLER
     return (b << 16) | a

