



'''simple docstring'''





import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
  import torch

  from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin







class 		snake_case						:



   '''simple docstring'''






   def __init__(					self							:			Tuple				,		lowerCAmelCase							:			Dict				,		lowerCAmelCase							:			Optional[int]=None				,		lowerCAmelCase							:			List[Any]=None				,		lowerCAmelCase							:			Tuple=None				,		lowerCAmelCase							:			str="resnet50"				,		lowerCAmelCase							:			Union[str, Any]=3				,		lowerCAmelCase							:			Optional[Any]=32				,		lowerCAmelCase							:			Dict=3				,		lowerCAmelCase							:			Union[str, Any]=True				,		lowerCAmelCase							:			Union[str, Any]=True				,		)				->				Dict:

    """simple docstring"""







    _snake_case    :  int					=					parent
    _snake_case    :  List[Any]					=					out_indices if out_indices is not None else [4]
    _snake_case    :  Dict					=					stage_names
    _snake_case    :  List[Any]					=					out_features
    _snake_case    :  List[str]					=					backbone
    _snake_case    :  Optional[int]					=					batch_size
    _snake_case    :  Any					=					image_size
    _snake_case    :  Dict					=					num_channels
    _snake_case    :  Tuple					=					use_pretrained_backbone
    _snake_case    :  Optional[int]					=					is_training

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

    """simple docstring"""







    _snake_case    :  Optional[Any]					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
    _snake_case    :  Any					=					self.get_config()

    return config, pixel_values

   def      UpperCamelCase_  (					self							:			Any)				->				Optional[int]:

    """simple docstring"""







    return TimmBackboneConfig(
        image_size=self.image_size				,		num_channels=self.num_channels				,		out_features=self.out_features				,		out_indices=self.out_indices				,		stage_names=self.stage_names				,		use_pretrained_backbone=self.use_pretrained_backbone				,		backbone=self.backbone				,		)

   def      UpperCamelCase_  (					self							:			Tuple				,		lowerCAmelCase							:			Dict				,		lowerCAmelCase							:			List[Any])				->				List[str]:

    """simple docstring"""







    _snake_case    :  int					=					TimmBackbone(config=__UpperCamelCase)
    model.to(__UpperCamelCase)
    model.eval()
    with torch.no_grad():
     _snake_case    :  List[str]					=					model(__UpperCamelCase)
    self.parent.assertEqual(
        result.feature_map[-1].shape				,		(self.batch_size, model.channels[-1], 14, 14)				,		)


   def      UpperCamelCase_  (					self							:			str)				->				Optional[int]:

    """simple docstring"""







    _snake_case    :  Dict					=					self.prepare_config_and_inputs()
    _snake_case	,    _snake_case    :  Dict					=					config_and_inputs
    _snake_case    :  List[Any]					=					{"""pixel_values""": pixel_values}
    return config, inputs_dict







@require_torch
@require_timm
class 		snake_case						(	SCREAMING_SNAKE_CASE_					,SCREAMING_SNAKE_CASE_					,SCREAMING_SNAKE_CASE_					,unittest.TestCase  ):



   '''simple docstring'''






   snake_case_					: Any          =		(TimmBackbone,) if is_torch_available() else ()
   snake_case_					: Union[str, Any]          =		{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
   snake_case_					: Dict          =		False
   snake_case_					: int          =		False
   snake_case_					: Any          =		False
   snake_case_					: Union[str, Any]          =		False

   def      UpperCamelCase_  (					self							:			str)				->				List[str]:

    """simple docstring"""







    _snake_case    :  Tuple					=					TimmBackboneModelTester(self)
    _snake_case    :  int					=					ConfigTester(self				,		config_class=__UpperCamelCase				,		has_text_modality=__UpperCamelCase)

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

    """simple docstring"""







    self.config_tester.create_and_test_config_to_json_string()
    self.config_tester.create_and_test_config_to_json_file()
    self.config_tester.create_and_test_config_from_and_save_pretrained()
    self.config_tester.create_and_test_config_with_num_labels()
    self.config_tester.check_config_can_be_init_without_params()
    self.config_tester.check_config_arguments_init()

   def      UpperCamelCase_  (					self							:			Any)				->				Dict:

    """simple docstring"""







    _snake_case    :  str					=					"""resnet18"""
    _snake_case    :  Optional[int]					=					"""microsoft/resnet-18"""

    _snake_case    :  List[str]					=					AutoBackbone.from_pretrained(__UpperCamelCase				,		use_timm_backbone=__UpperCamelCase)
    _snake_case    :  Optional[Any]					=					AutoBackbone.from_pretrained(__UpperCamelCase)

    self.assertEqual(len(timm_model.out_features)				,		len(transformers_model.out_features))
    self.assertEqual(len(timm_model.stage_names)				,		len(transformers_model.stage_names))
    self.assertEqual(timm_model.channels				,		transformers_model.channels)
    # Out indices are set to the last layer by default. For timm models, we don't know
    # the number of layers in advance, so we set it to (-1,), whereas for transformers
    # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
    self.assertEqual(timm_model.out_indices				,		(-1,))
    self.assertEqual(transformers_model.out_indices				,		[len(timm_model.stage_names) - 1])

    _snake_case    :  str					=					AutoBackbone.from_pretrained(__UpperCamelCase				,		use_timm_backbone=__UpperCamelCase				,		out_indices=[1, 2, 3])
    _snake_case    :  List[str]					=					AutoBackbone.from_pretrained(__UpperCamelCase				,		out_indices=[1, 2, 3])

    self.assertEqual(timm_model.out_indices				,		transformers_model.out_indices)
    self.assertEqual(len(timm_model.out_features)				,		len(transformers_model.out_features))
    self.assertEqual(timm_model.channels				,		transformers_model.channels)

   @unittest.skip("""TimmBackbone doesn't support feed forward chunking""")
   def      UpperCamelCase_  (					self							:			Optional[int])				->				Any:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute""")
   def      UpperCamelCase_  (					self							:			List[Any])				->				int:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone initialization is managed on the timm side""")
   def      UpperCamelCase_  (					self							:			Dict)				->				Dict:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone models doesn't have inputs_embeds""")
   def      UpperCamelCase_  (					self							:			Union[str, Any])				->				List[Any]:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone models doesn't have inputs_embeds""")
   def      UpperCamelCase_  (					self							:			Optional[Any])				->				str:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint""")
   def      UpperCamelCase_  (					self							:			Any)				->				List[Any]:

    """simple docstring"""







    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
   def      UpperCamelCase_  (					self							:			Any)				->				int:

    """simple docstring"""







    pass

   @unittest.skip("""model weights aren't tied in TimmBackbone.""")
   def      UpperCamelCase_  (					self							:			Optional[int])				->				List[Any]:

    """simple docstring"""







    pass

   @unittest.skip("""model weights aren't tied in TimmBackbone.""")
   def      UpperCamelCase_  (					self							:			List[Any])				->				Tuple:

    """simple docstring"""







    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
   def      UpperCamelCase_  (					self							:			str)				->				Optional[Any]:

    """simple docstring"""







    pass

   @unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone""")
   def      UpperCamelCase_  (					self							:			List[Any])				->				List[Any]:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration.""")
   def      UpperCamelCase_  (					self							:			Optional[int])				->				Dict:

    """simple docstring"""







    pass

   @unittest.skip("""TimmBackbone doesn't support output_attentions.""")
   def      UpperCamelCase_  (					self							:			List[Any])				->				int:

    """simple docstring"""







    pass

   @unittest.skip("""Safetensors is not supported by timm.""")
   def      UpperCamelCase_  (					self							:			List[Any])				->				Tuple:

    """simple docstring"""







    pass

   @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""")
   def      UpperCamelCase_  (					self							:			Optional[int])				->				Any:

    """simple docstring"""







    pass

   def      UpperCamelCase_  (					self							:			str)				->				int:

    """simple docstring"""







    _snake_case	,    _snake_case    :  Dict					=					self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
     _snake_case    :  List[str]					=					model_class(__UpperCamelCase)
     _snake_case    :  Dict					=					inspect.signature(model.forward)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     _snake_case    :  Union[str, Any]					=					[*signature.parameters.keys()]

     _snake_case    :  Optional[Any]					=					["""pixel_values"""]
     self.assertListEqual(arg_names[:1]				,		__UpperCamelCase)

   def      UpperCamelCase_  (					self							:			List[Any])				->				List[Any]:

    """simple docstring"""







    _snake_case	,    _snake_case    :  Union[str, Any]					=					self.model_tester.prepare_config_and_inputs_for_common()
    _snake_case    :  Dict					=					True
    _snake_case    :  Tuple					=					self.has_attentions

    # no need to test all models as different heads yield the same functionality
    _snake_case    :  int					=					self.all_model_classes[0]
    _snake_case    :  Dict					=					model_class(__UpperCamelCase)
    model.to(__UpperCamelCase)

    _snake_case    :  Any					=					self._prepare_for_class(__UpperCamelCase				,		__UpperCamelCase)
    _snake_case    :  str					=					model(**__UpperCamelCase)
    _snake_case    :  Any					=					outputs[0][-1]

    # Encoder-/Decoder-only models
    _snake_case    :  List[Any]					=					outputs.hidden_states[0]
    hidden_states.retain_grad()

    if self.has_attentions:
     _snake_case    :  Optional[int]					=					outputs.attentions[0]
     attentions.retain_grad()

    output.flatten()[0].backward(retain_graph=__UpperCamelCase)

    self.assertIsNotNone(hidden_states.grad)

    if self.has_attentions:
     self.assertIsNotNone(attentions.grad)


   def      UpperCamelCase_  (					self							:			Optional[int])				->				Optional[Any]:

    """simple docstring"""







    _snake_case	,    _snake_case    :  Optional[int]					=					self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
     _snake_case    :  Dict					=					model_class(__UpperCamelCase)
     model.to(__UpperCamelCase)
     model.eval()
     _snake_case    :  Dict					=					model(**__UpperCamelCase)

     self.assertEqual(len(result.feature_maps)				,		len(config.out_indices))
     self.assertEqual(len(model.channels)				,		len(config.out_indices))

     # Check output of last stage is taken if out_features=None, out_indices=None
     _snake_case    :  Optional[Any]					=					copy.deepcopy(__UpperCamelCase)
     _snake_case    :  str					=					None
     _snake_case    :  Dict					=					model_class(__UpperCamelCase)
     model.to(__UpperCamelCase)
     model.eval()
     _snake_case    :  Tuple					=					model(**__UpperCamelCase)

     self.assertEqual(len(result.feature_maps)				,		1)
     self.assertEqual(len(model.channels)				,		1)

     # Check backbone can be initialized with fresh weights
     _snake_case    :  Any					=					copy.deepcopy(__UpperCamelCase)
     _snake_case    :  Any					=					False
     _snake_case    :  List[str]					=					model_class(__UpperCamelCase)
     model.to(__UpperCamelCase)
     model.eval()
     _snake_case    :  Tuple					=					model(**__UpperCamelCase)





import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel



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

 return name



def       lowercase       (   SCREAMING_SNAKE_CASE__       :	List[str]				,       SCREAMING_SNAKE_CASE__       :	int				)  ->     List[str]:
 for key in orig_state_dict.copy().keys():
  _snake_case    :  Tuple					=					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
   _snake_case    :  Any					=					key.split("""."""				)
   _snake_case	,    _snake_case    :  List[Any]					=					int(key_split[2]				), int(key_split[4]				)
   _snake_case    :  List[Any]					=					config.vision_config.hidden_size
   if "weight" in key:
    _snake_case    :  List[Any]					=					val[:dim, :]
    _snake_case    :  Union[str, Any]					=					val[dim : dim * 2, :]
    _snake_case    :  int					=					val[-dim:, :]
   else:
    _snake_case    :  Union[str, Any]					=					val[:dim]
    _snake_case    :  str					=					val[dim : dim * 2]
    _snake_case    :  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
   _snake_case    :  int					=					key.split("""."""				)
   _snake_case    :  Optional[int]					=					int(key_split[3]				)
   _snake_case    :  Union[str, Any]					=					config.text_config.hidden_size
   if "weight" in key:
    _snake_case    :  int					=					val[:dim, :]
    _snake_case    :  Tuple					=					val[
        dim : dim * 2, :
    ]
    _snake_case    :  int					=					val[-dim:, :]
   else:
    _snake_case    :  Tuple					=					val[:dim]
    _snake_case    :  Tuple					=					val[dim : dim * 2]
    _snake_case    :  str					=					val[-dim:]
  else:
   _snake_case    :  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
   ):
    _snake_case    :  Any					=					val.squeeze_()
   else:
    _snake_case    :  Optional[int]					=					val

 return orig_state_dict



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



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

 _snake_case    :  Optional[int]					=					torch.load(SCREAMING_SNAKE_CASE__				,       map_location="""cpu"""				)["""model"""]
 _snake_case    :  Tuple					=					convert_state_dict(SCREAMING_SNAKE_CASE__				,       SCREAMING_SNAKE_CASE__				)
 _snake_case	,    _snake_case    :  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
 _snake_case    :  List[Any]					=					CLIPProcessor.from_pretrained("""openai/clip-vit-base-patch32"""				)
 _snake_case    :  List[Any]					=					prepare_img()
 _snake_case    :  int					=					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():
  _snake_case    :  Optional[int]					=					model(**SCREAMING_SNAKE_CASE__				)

 if model_name == "groupvit-gcc-yfcc":
  _snake_case    :  Union[str, Any]					=					torch.tensor([[1_3.3_5_2_3, 6.3_6_2_9]]				)
 elif model_name == "groupvit-gcc-redcaps":
  _snake_case    :  Union[str, Any]					=					torch.tensor([[1_6.1_8_7_3, 8.6_2_3_0]]				)
 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__":
  a__    =	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`.""",
  )
  a__    =	parser.parse_args()

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