





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel



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

       return name



def A_     (		A__		,				A__    )  ->		str:
       for key in orig_state_dict.copy().keys():
              a__						:     int			=    orig_state_dict.pop(A__    )

              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__						:     int			=    key.split('.'    )
                     a__			,							a__						:     List[str]			=    int(key_split[2]    ), int(key_split[4]    )
                     a__						:     Optional[int]			=    config.vision_config.hidden_size
                     if "weight" in key:
                            a__						:     Any			=    val[:dim, :]
                            a__						:     Union[str, Any]			=    val[dim : dim * 2, :]
                            a__						:     Optional[int]			=    val[-dim:, :]
                     else:
                            a__						:     Union[str, Any]			=    val[:dim]
                            a__						:     List[str]			=    val[dim : dim * 2]
                            a__						:     Optional[Any]			=    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__						:     Optional[int]			=    key.split('.'    )
                     a__						:     str			=    int(key_split[3]    )
                     a__						:     Union[str, Any]			=    config.text_config.hidden_size
                     if "weight" in key:
                            a__						:     int			=    val[:dim, :]
                            a__						:     List[Any]			=    val[
                                dim : dim * 2, :
                            ]
                            a__						:     Optional[int]			=    val[-dim:, :]
                     else:
                            a__						:     List[Any]			=    val[:dim]
                            a__						:     Dict			=    val[dim : dim * 2]
                            a__						:     str			=    val[-dim:]
              else:
                     a__						:     Any			=    rename_key(A__    )
                     # 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__						:     List[str]			=    val.squeeze_()
                     else:
                            a__						:     Any			=    val

       return orig_state_dict



def A_     (		)  ->		List[Any]:
       a__						:     List[str]			=    'http://images.cocodataset.org/val2017/000000039769.jpg'
       a__						:     Optional[Any]			=    Image.open(requests.get(A__		,				stream=A__    ).raw    )
       return im



@torch.no_grad()
def A_     (		A__		,				A__		,				A__="groupvit-gcc-yfcc"		,				A__=False    )  ->		List[Any]:
       a__						:     Optional[int]			=    GroupViTConfig()
       a__						:     List[str]			=    GroupViTModel(A__    ).eval()

       a__						:     Any			=    torch.load(A__		,				map_location='cpu'    )['model']
       a__						:     Union[str, Any]			=    convert_state_dict(A__		,				A__    )
       a__			,							a__						:     Optional[Any]			=    model.load_state_dict(A__		,				strict=A__    )
       assert missing_keys == ["text_model.embeddings.position_ids"]
       assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(A__    ) == 0)

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

       with torch.no_grad():
              a__						:     int			=    model(**A__    )

       if model_name == "groupvit-gcc-yfcc":
              a__						:     List[str]			=    torch.tensor([[13.35_23, 6.36_29]]    )
       elif model_name == "groupvit-gcc-redcaps":
              a__						:     Optional[Any]			=    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		,				A__		,				atol=1E-3    )

       processor.save_pretrained(A__    )
       model.save_pretrained(A__    )
       print('Successfully saved processor and model to'		,				A__    )

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


if __name__ == "__main__":
    lowercase				:	int      						=  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				:	Optional[int]      						=  parser.parse_args()

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









import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        NystromformerForMaskedLM,
        NystromformerForMultipleChoice,
        NystromformerForQuestionAnswering,
        NystromformerForSequenceClassification,
        NystromformerForTokenClassification,
        NystromformerModel,
    )
    from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST





class 			A__   :




   """simple docstring"""



   def __init__( self ,  lowercase ,  lowercase=13 ,  lowercase=7 ,  lowercase=True ,  lowercase=True ,  lowercase=True ,  lowercase=True ,  lowercase=99 ,  lowercase=32 ,  lowercase=5 ,  lowercase=4 ,  lowercase=37 ,  lowercase="gelu" ,  lowercase=0.1 ,  lowercase=0.1 ,  lowercase=512 ,  lowercase=16 ,  lowercase=2 ,  lowercase=0.02 ,  lowercase=3 ,  lowercase=4 ,  lowercase=None ,  )      ->						List[Any]:







          '''simple docstring'''

          a__						:     Any			=    parent
          a__						:     int			=    batch_size
          a__						:     Dict			=    seq_length
          a__						:     Tuple			=    is_training
          a__						:     Any			=    use_input_mask
          a__						:     Optional[Any]			=    use_token_type_ids
          a__						:     Dict			=    use_labels
          a__						:     Optional[int]			=    vocab_size
          a__						:     List[Any]			=    hidden_size
          a__						:     int			=    num_hidden_layers
          a__						:     Optional[Any]			=    num_attention_heads
          a__						:     str			=    intermediate_size
          a__						:     Optional[int]			=    hidden_act
          a__						:     Dict			=    hidden_dropout_prob
          a__						:     Optional[int]			=    attention_probs_dropout_prob
          a__						:     Tuple			=    max_position_embeddings
          a__						:     Dict			=    type_vocab_size
          a__						:     Any			=    type_sequence_label_size
          a__						:     List[str]			=    initializer_range
          a__						:     List[str]			=    num_labels
          a__						:     Optional[Any]			=    num_choices
          a__						:     str			=    scope

   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size)

          a__						:     Tuple			=    None
          if self.use_input_mask:
                 a__						:     Optional[int]			=    random_attention_mask([self.batch_size, self.seq_length])

          a__						:     Any			=    None
          if self.use_token_type_ids:
                 a__						:     List[Any]			=    ids_tensor([self.batch_size, self.seq_length] ,  self.type_vocab_size)

          a__						:     str			=    None
          a__						:     List[Any]			=    None
          a__						:     List[str]			=    None
          if self.use_labels:
                 a__						:     Any			=    ids_tensor([self.batch_size] ,  self.type_sequence_label_size)
                 a__						:     str			=    ids_tensor([self.batch_size, self.seq_length] ,  self.num_labels)
                 a__						:     str			=    ids_tensor([self.batch_size] ,  self.num_choices)

          a__						:     Union[str, Any]			=    self.get_config()

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

   def 							__lowercase		( self)      ->						Optional[int]:







          '''simple docstring'''

          return NystromformerConfig(
              vocab_size=self.vocab_size ,  hidden_size=self.hidden_size ,  num_hidden_layers=self.num_hidden_layers ,  num_attention_heads=self.num_attention_heads ,  intermediate_size=self.intermediate_size ,  hidden_act=self.hidden_act ,  hidden_dropout_prob=self.hidden_dropout_prob ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob ,  max_position_embeddings=self.max_position_embeddings ,  type_vocab_size=self.type_vocab_size ,  is_decoder=lowercase ,  initializer_range=self.initializer_range ,  )

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Optional[int]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    NystromformerModel(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     List[Any]			=    model(lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase)
          a__						:     int			=    model(lowercase ,  token_type_ids=lowercase)
          a__						:     Optional[Any]			=    model(lowercase)
          self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size))

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						str:







          '''simple docstring'''

          a__						:     List[str]			=    NystromformerForMaskedLM(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     int			=    model(lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase ,  labels=lowercase)
          self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.vocab_size))

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Any			=    NystromformerForQuestionAnswering(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     str			=    model(
              lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase ,  start_positions=lowercase ,  end_positions=lowercase ,  )
          self.parent.assertEqual(result.start_logits.shape ,  (self.batch_size, self.seq_length))
          self.parent.assertEqual(result.end_logits.shape ,  (self.batch_size, self.seq_length))

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     int			=    self.num_labels
          a__						:     Optional[Any]			=    NystromformerForSequenceClassification(lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     Tuple			=    model(lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase ,  labels=lowercase)
          self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels))

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						List[str]:







          '''simple docstring'''

          a__						:     Tuple			=    self.num_labels
          a__						:     int			=    NystromformerForTokenClassification(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     str			=    model(lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase ,  labels=lowercase)
          self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.num_labels))

   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase ,  lowercase)      ->						Any:







          '''simple docstring'''

          a__						:     Optional[int]			=    self.num_choices
          a__						:     Tuple			=    NystromformerForMultipleChoice(config=lowercase)
          model.to(lowercase)
          model.eval()
          a__						:     Optional[Any]			=    input_ids.unsqueeze(1).expand(-1 ,  self.num_choices ,  -1).contiguous()
          a__						:     Tuple			=    token_type_ids.unsqueeze(1).expand(-1 ,  self.num_choices ,  -1).contiguous()
          a__						:     str			=    input_mask.unsqueeze(1).expand(-1 ,  self.num_choices ,  -1).contiguous()
          a__						:     Optional[int]			=    model(
              lowercase ,  attention_mask=lowercase ,  token_type_ids=lowercase ,  labels=lowercase ,  )
          self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_choices))

   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     List[Any]			=    self.prepare_config_and_inputs()
          (
              (
              a__
          )			,							(
              a__
          )			,							(
              a__
          )			,							(
              a__
          )			,							(
              a__
          )			,							(
              a__
          )			,							(
              a__
          )			,							
          )						:     str			=    config_and_inputs
          a__						:     Any			=    {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
          return config, inputs_dict





@require_torch
class 			A__   (							__UpperCAmelCase			,  __UpperCAmelCase			,  unittest.TestCase     ):




   """simple docstring"""



   __A       :    Any	  =  (
       (
           NystromformerModel,
           NystromformerForMaskedLM,
           NystromformerForMultipleChoice,
           NystromformerForQuestionAnswering,
           NystromformerForSequenceClassification,
           NystromformerForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   __A       :    str	  =  (
       {
           '''feature-extraction''': NystromformerModel,
           '''fill-mask''': NystromformerForMaskedLM,
           '''question-answering''': NystromformerForQuestionAnswering,
           '''text-classification''': NystromformerForSequenceClassification,
           '''token-classification''': NystromformerForTokenClassification,
           '''zero-shot''': NystromformerForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   __A       :    Optional[Any]	  =  False
   __A       :    Tuple	  =  False

   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     int			=    NystromformerModelTester(self)
          a__						:     Any			=    ConfigTester(self ,  config_class=lowercase ,  hidden_size=37)

   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          self.config_tester.run_common_tests()

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     str			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase)

   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     Tuple			=    self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                 a__						:     Optional[Any]			=    type
                 self.model_tester.create_and_check_model(*lowercase)

   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     List[Any]			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*lowercase)

   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          a__						:     List[Any]			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*lowercase)

   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*lowercase)

   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Union[str, Any]			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*lowercase)

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     List[Any]			=    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*lowercase)

   @slow
   def 							__lowercase		( self)      ->						Optional[int]:







          '''simple docstring'''

          for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 a__						:     int			=    NystromformerModel.from_pretrained(lowercase)
                 self.assertIsNotNone(lowercase)





@require_torch
class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   @slow
   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     List[str]			=    NystromformerModel.from_pretrained('uw-madison/nystromformer-512')
          a__						:     Tuple			=    torch.tensor([[0, 1, 2, 3, 4, 5]])

          with torch.no_grad():
                 a__						:     List[Any]			=    model(lowercase)[0]

          a__						:     str			=    torch.Size((1, 6, 768))
          self.assertEqual(output.shape ,  lowercase)

          a__						:     str			=    torch.tensor(
              [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]])

          self.assertTrue(torch.allclose(output[:, :3, :3] ,  lowercase ,  atol=1e-4))

   @slow
   def 							__lowercase		( self)      ->						Optional[int]:







          '''simple docstring'''

          a__						:     Any			=    'the [MASK] of Belgium is Brussels'

          a__						:     List[str]			=    AutoTokenizer.from_pretrained('uw-madison/nystromformer-512')
          a__						:     Optional[int]			=    NystromformerForMaskedLM.from_pretrained('uw-madison/nystromformer-512')

          a__						:     List[Any]			=    tokenizer(lowercase ,  return_tensors='pt')

          with torch.no_grad():
                 a__						:     Union[str, Any]			=    model(encoding.input_ids).logits

          a__						:     str			=    token_logits[:, 2, :].argmax(-1)[0]

          self.assertEqual(tokenizer.decode(lowercase) ,  'capital')


