"""simple docstring"""




import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
     import torch

     from transformers import (
         MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
         MODEL_MAPPING,
         LevitForImageClassification,
         LevitForImageClassificationWithTeacher,
         LevitModel,
     )
     from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import LevitImageProcessor
class 		__A				(					lowerCamelCase__						):






     def        __A    (						self    ):
       _lowerCAmelCase		:			List[str]         =	self.config_class(**self.inputs_dict    )
       self.parent.assertTrue(hasattr(a__							,	"""hidden_sizes"""    )    )
       self.parent.assertTrue(hasattr(a__							,	"""num_attention_heads"""    )    )







class 		__A				:






     def __init__(						self							,	a__							,	a__=13							,	a__=64							,	a__=3							,	a__=3							,	a__=2							,	a__=1							,	a__=16							,	a__=[128, 256, 384]							,	a__=[4, 6, 8]							,	a__=[2, 3, 4]							,	a__=[16, 16, 16]							,	a__=0							,	a__=[2, 2, 2]							,	a__=[2, 2, 2]							,	a__=0.0_2							,	a__=True							,	a__=True							,	a__=2							,	):
       _lowerCAmelCase		:			str         =	parent
       _lowerCAmelCase		:			str         =	batch_size
       _lowerCAmelCase		:			Dict         =	image_size
       _lowerCAmelCase		:			Union[str, Any]         =	num_channels
       _lowerCAmelCase		:			List[str]         =	kernel_size
       _lowerCAmelCase		:			int         =	stride
       _lowerCAmelCase		:			Tuple         =	padding
       _lowerCAmelCase		:			Optional[Any]         =	hidden_sizes
       _lowerCAmelCase		:			Union[str, Any]         =	num_attention_heads
       _lowerCAmelCase		:			Tuple         =	depths
       _lowerCAmelCase		:			int         =	key_dim
       _lowerCAmelCase		:			Any         =	drop_path_rate
       _lowerCAmelCase		:			Optional[Any]         =	patch_size
       _lowerCAmelCase		:			Tuple         =	attention_ratio
       _lowerCAmelCase		:			List[Any]         =	mlp_ratio
       _lowerCAmelCase		:			Union[str, Any]         =	initializer_range
       _lowerCAmelCase		:			List[Any]         =	[
           ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
           ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
       ]
       _lowerCAmelCase		:			List[str]         =	is_training
       _lowerCAmelCase		:			str         =	use_labels
       _lowerCAmelCase		:			Optional[Any]         =	num_labels
       _lowerCAmelCase		:			Optional[Any]         =	initializer_range






     def        __A    (						self    ):
       _lowerCAmelCase		:			Union[str, Any]         =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

       _lowerCAmelCase		:			Any         =	None
       if self.use_labels:
         _lowerCAmelCase		:			Tuple         =	ids_tensor([self.batch_size]							,	self.num_labels    )

       _lowerCAmelCase		:			int         =	self.get_config()
       return config, pixel_values, labels






     def        __A    (						self    ):
       return LevitConfig(
           image_size=self.image_size							,	num_channels=self.num_channels							,	kernel_size=self.kernel_size							,	stride=self.stride							,	padding=self.padding							,	patch_size=self.patch_size							,	hidden_sizes=self.hidden_sizes							,	num_attention_heads=self.num_attention_heads							,	depths=self.depths							,	key_dim=self.key_dim							,	drop_path_rate=self.drop_path_rate							,	mlp_ratio=self.mlp_ratio							,	attention_ratio=self.attention_ratio							,	initializer_range=self.initializer_range							,	down_ops=self.down_ops							,	)






     def        __A    (						self							,	a__							,	a__							,	a__    ):
       _lowerCAmelCase		:			Any         =	LevitModel(config=a__    )
       model.to(a__    )
       model.eval()
       _lowerCAmelCase		:			int         =	model(a__    )
       _lowerCAmelCase		:			List[Any]         =	(self.image_size, self.image_size)
       _lowerCAmelCase		:			Any         =	image_size[0], image_size[1]
       for _ in range(4    ):
         _lowerCAmelCase		:			Tuple         =	floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1    )
         _lowerCAmelCase		:			List[Any]         =	floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1    )
       self.parent.assertEqual(
           result.last_hidden_state.shape							,	(self.batch_size, ceil(height / 4    ) * ceil(width / 4    ), self.hidden_sizes[-1])							,	)






     def        __A    (						self							,	a__							,	a__							,	a__    ):
       _lowerCAmelCase		:			int         =	self.num_labels
       _lowerCAmelCase		:			Dict         =	LevitForImageClassification(a__    )
       model.to(a__    )
       model.eval()
       _lowerCAmelCase		:			Any         =	model(a__							,	labels=a__    )
       self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.num_labels)    )






     def        __A    (						self    ):
       _lowerCAmelCase		:			List[str]         =	self.prepare_config_and_inputs()
       _lowerCAmelCase		:			List[str]         =	config_and_inputs
       _lowerCAmelCase		:			Union[str, Any]         =	{'''pixel_values''': pixel_values}
       return config, inputs_dict







@require_torch
class 		__A				(					lowerCamelCase__       ,      lowerCamelCase__       ,      unittest.TestCase						):
     _UpperCamelCase				:     Tuple						   =						(
         (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
         if is_torch_available()
         else ()
     )
     _UpperCamelCase				:     Union[str, Any]						   =						(
         {
             "feature-extraction": LevitModel,
             "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
         }
         if is_torch_available()
         else {}
     )

     _UpperCamelCase				:     Union[str, Any]						   =						False
     _UpperCamelCase				:     Any						   =						False
     _UpperCamelCase				:     List[Any]						   =						False
     _UpperCamelCase				:     str						   =						False
     _UpperCamelCase				:     str						   =						False






     def        __A    (						self    ):
       _lowerCAmelCase		:			Optional[Any]         =	LevitModelTester(self    )
       _lowerCAmelCase		:			Union[str, Any]         =	ConfigTester(self							,	config_class=a__							,	has_text_modality=a__							,	hidden_size=37    )






     def        __A    (						self    ):
       self.create_and_test_config_common_properties()
       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        __A    (						self    ):
       return






     @unittest.skip(reason="""Levit does not use inputs_embeds"""    )
     def        __A    (						self    ):
       pass






     @unittest.skip(reason="""Levit does not support input and output embeddings"""    )
     def        __A    (						self    ):
       pass






     @unittest.skip(reason="""Levit does not output attentions"""    )
     def        __A    (						self    ):
       pass






     def        __A    (						self    ):
       _lowerCAmelCase		:			List[str]         =	self.model_tester.prepare_config_and_inputs_for_common()

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

         _lowerCAmelCase		:			Tuple         =	['''pixel_values''']
         self.assertListEqual(arg_names[:1]							,	a__    )






     def        __A    (						self    ):





       def check_hidden_states_output(a__							,	a__							,	a__    ):
         _lowerCAmelCase		:			Any         =	model_class(a__    )
         model.to(a__    )
         model.eval()

         with torch.no_grad():
           _lowerCAmelCase		:			str         =	model(**self._prepare_for_class(a__							,	a__    )    )

         _lowerCAmelCase		:			Optional[Any]         =	outputs.hidden_states

         _lowerCAmelCase		:			Tuple         =	len(self.model_tester.depths    ) + 1
         self.assertEqual(len(a__    )							,	a__    )

         _lowerCAmelCase		:			List[str]         =	(self.model_tester.image_size, self.model_tester.image_size)
         _lowerCAmelCase		:			Union[str, Any]         =	image_size[0], image_size[1]
         for _ in range(4    ):
           _lowerCAmelCase		:			Union[str, Any]         =	floor(
               (
                   (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                   / self.model_tester.stride
               )
               + 1    )
           _lowerCAmelCase		:			int         =	floor(
               (
                   (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                   / self.model_tester.stride
               )
               + 1    )
         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]    )							,	[
                 height * width,
                 self.model_tester.hidden_sizes[0],
             ]							,	)

       _lowerCAmelCase		:			int         =	self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         _lowerCAmelCase		:			Optional[Any]         =	True
         check_hidden_states_output(a__							,	a__							,	a__    )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         _lowerCAmelCase		:			Optional[Any]         =	True

         check_hidden_states_output(a__							,	a__							,	a__    )






     @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""    )
     def        __A    (						self    ):
       pass






     def        __A    (						self							,	a__							,	a__							,	a__=False    ):
       _lowerCAmelCase		:			Dict         =	super()._prepare_for_class(a__							,	a__							,	return_labels=a__    )

       if return_labels:
         if model_class.__name__ == "LevitForImageClassificationWithTeacher":
           del inputs_dict["labels"]

       return inputs_dict






     def        __A    (						self    ):
       _lowerCAmelCase		:			str         =	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a__    )






     def        __A    (						self    ):
       _lowerCAmelCase		:			str         =	self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*a__    )






     def        __A    (						self    ):





       if not self.model_tester.is_training:
         return

       _lowerCAmelCase		:			int         =	self.model_tester.prepare_config_and_inputs_for_common()
       _lowerCAmelCase		:			List[str]         =	True

       for model_class in self.all_model_classes:
         # LevitForImageClassificationWithTeacher supports inference-only
         if (
             model_class in get_values(a__    )
             or model_class.__name__ == "LevitForImageClassificationWithTeacher"
         ):
           continue
         _lowerCAmelCase		:			Union[str, Any]         =	model_class(a__    )
         model.to(a__    )
         model.train()
         _lowerCAmelCase		:			List[Any]         =	self._prepare_for_class(a__							,	a__							,	return_labels=a__    )
         _lowerCAmelCase		:			List[Any]         =	model(**a__    ).loss
         loss.backward()






     def        __A    (						self    ):
       _lowerCAmelCase		:			Union[str, Any]         =	self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
         return

       _lowerCAmelCase		:			Any         =	False
       _lowerCAmelCase		:			Optional[int]         =	True

       for model_class in self.all_model_classes:
         if model_class in get_values(a__    ) or not model_class.supports_gradient_checkpointing:
           continue
         # LevitForImageClassificationWithTeacher supports inference-only
         if model_class.__name__ == "LevitForImageClassificationWithTeacher":
           continue
         _lowerCAmelCase		:			int         =	model_class(a__    )
         model.gradient_checkpointing_enable()
         model.to(a__    )
         model.train()
         _lowerCAmelCase		:			Dict         =	self._prepare_for_class(a__							,	a__							,	return_labels=a__    )
         _lowerCAmelCase		:			Optional[Any]         =	model(**a__    ).loss
         loss.backward()






     def        __A    (						self    ):
       _lowerCAmelCase		:			List[str]         =	self.model_tester.prepare_config_and_inputs_for_common()

       _lowerCAmelCase		:			Tuple         =	[
           {'''title''': '''multi_label_classification''', '''num_labels''': 2, '''dtype''': torch.float},
           {'''title''': '''single_label_classification''', '''num_labels''': 1, '''dtype''': torch.long},
           {'''title''': '''regression''', '''num_labels''': 1, '''dtype''': torch.float},
       ]

       for model_class in self.all_model_classes:
         if (
             model_class
             not in [
                 *get_values(a__    ),
             ]
             or model_class.__name__ == "LevitForImageClassificationWithTeacher"
         ):
           continue

         for problem_type in problem_types:
           with self.subTest(msg=F"Testing {model_class} with {problem_type['title']}"    ):
             _lowerCAmelCase		:			Optional[int]         =	problem_type['''title''']
             _lowerCAmelCase		:			Optional[int]         =	problem_type['''num_labels''']

             _lowerCAmelCase		:			str         =	model_class(a__    )
             model.to(a__    )
             model.train()

             _lowerCAmelCase		:			Dict         =	self._prepare_for_class(a__							,	a__							,	return_labels=a__    )

             if problem_type["num_labels"] > 1:
               _lowerCAmelCase		:			Any         =	inputs['''labels'''].unsqueeze(1    ).repeat(1							,	problem_type["""num_labels"""]    )

             _lowerCAmelCase		:			Union[str, Any]         =	inputs['''labels'''].to(problem_type["""dtype"""]    )

             # This tests that we do not trigger the warning form PyTorch "Using a target size that is different
             # to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
             # they have the same size." which is a symptom something in wrong for the regression problem.
             # See https://github.com/huggingface/transformers/issues/11780
             with warnings.catch_warnings(record=a__    ) as warning_list:
               _lowerCAmelCase		:			Any         =	model(**a__    ).loss
             for w in warning_list:
               if "Using a target size that is different to the input size" in str(w.message    ):
                 raise ValueError(
                     F"Something is going wrong in the regression problem: intercepted {w.message}"    )

             loss.backward()






     @slow
     def        __A    (						self    ):





       for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase		:			Optional[int]         =	LevitModel.from_pretrained(a__    )
         self.assertIsNotNone(a__    )







def 				SCREAMING_SNAKE_CASE	(     )			-> str:
  _lowerCAmelCase		:			Dict         =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""      )
  return image






@require_torch
@require_vision
class 		__A				(					unittest.TestCase						):






     @cached_property
     def        __A    (						self    ):
       return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    )






     @slow
     def        __A    (						self    ):
       _lowerCAmelCase		:			Any         =	LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]    ).to(
           a__    )

       _lowerCAmelCase		:			Any         =	self.default_image_processor
       _lowerCAmelCase		:			Optional[Any]         =	prepare_img()
       _lowerCAmelCase		:			Any         =	image_processor(images=a__							,	return_tensors="""pt"""    ).to(a__    )

       # forward pass
       with torch.no_grad():
         _lowerCAmelCase		:			List[Any]         =	model(**a__    )

       # verify the logits
       _lowerCAmelCase		:			Union[str, Any]         =	torch.Size((1, 1000)    )
       self.assertEqual(outputs.logits.shape							,	a__    )

       _lowerCAmelCase		:			str         =	torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]    ).to(a__    )

       self.assertTrue(torch.allclose(outputs.logits[0, :3]							,	a__							,	atol=1e-4    )    )











import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel




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

       return name




def  __UpperCAmelCase(   lowercase_			,     lowercase_   ):
       for key in orig_state_dict.copy().keys():
              _lowerCamelCase				:  Optional[int]						=		orig_state_dict.pop(lowercase_   )

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

       return orig_state_dict




def  __UpperCAmelCase(   ):
       _lowerCamelCase				:  Union[str, Any]						=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
       _lowerCamelCase				:  Any						=		Image.open(requests.get(lowercase_			,     stream=lowercase_   ).raw   )
       return im




@torch.no_grad()
def  __UpperCAmelCase(   lowercase_			,     lowercase_			,     lowercase_="groupvit-gcc-yfcc"			,     lowercase_=False   ):
       _lowerCamelCase				:  Optional[Any]						=		GroupViTConfig()
       _lowerCamelCase				:  Any						=		GroupViTModel(lowercase_   ).eval()

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

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

       with torch.no_grad():
              _lowerCamelCase				:  Optional[int]						=		model(**lowercase_   )

       if model_name == "groupvit-gcc-yfcc":
              _lowerCamelCase				:  Dict						=		torch.tensor([[1_3.3_5_2_3, 6.3_6_2_9]]   )
       elif model_name == "groupvit-gcc-redcaps":
              _lowerCamelCase				:  Tuple						=		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			,     lowercase_			,     atol=1e-3   )

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

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


if __name__ == "__main__":
       _lowerCamelCase      							=   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`.',
       )
       _lowerCamelCase      							=   parser.parse_args()

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

