
'''simple docstring'''





from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available





def 							snake_case				(		UpperCAmelCase						)->      str:







      """simple docstring"""
      if is_torch_available():
            import torch

            if isinstance(UpperCAmelCase   ,	torch.Tensor						):
                  return True

      return isinstance(UpperCAmelCase   ,	np.ndarray						)


class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE):






 def 						lowercase_    (      self	:Optional[Any]      )					->      Tuple:







       '''simple docstring'''



       __A													=      fields(self      )

       # Safety and consistency checks
       if not len(_A      ):
             raise ValueError(F'{self.__class__.__name__} has no fields.'      )

       __A													=      getattr(self						,					class_fields[0].name      )
       __A													=      all(getattr(self						,					field.name      ) is None for field in class_fields[1:]      )

       if other_fields_are_none and isinstance(_A						,					_A      ):
             for key, value in first_field.items():
                   __A													=      value
       else:
             for field in class_fields:
                   __A													=      getattr(self						,					field.name      )
                   if v is not None:
                         __A													=      v






 def __delitem__(      self	:Optional[Any]						,					*_A	:Tuple						,					**_A	:Optional[Any]      )					->      str:







       '''simple docstring'''



       raise Exception(F'You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:Any						,					*_A	:Tuple						,					**_A	:Any      )					->      List[Any]:







       '''simple docstring'''



       raise Exception(F'You cannot use ``setdefault`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:List[Any]						,					*_A	:Tuple						,					**_A	:List[Any]      )					->      int:







       '''simple docstring'''



       raise Exception(F'You cannot use ``pop`` on a {self.__class__.__name__} instance.'      )






 def 						lowercase_    (      self	:List[str]						,					*_A	:Union[str, Any]						,					**_A	:Union[str, Any]      )					->      Any:







       '''simple docstring'''



       raise Exception(F'You cannot use ``update`` on a {self.__class__.__name__} instance.'      )






 def __getitem__(      self	:Optional[Any]						,					_A	:Union[str, Any]      )					->      Dict:







       '''simple docstring'''



       if isinstance(_A						,					_A      ):
             __A													=      dict(self.items()      )
             return inner_dict[k]
       else:
             return self.to_tuple()[k]






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







       '''simple docstring'''



       if name in self.keys() and value is not None:
             # Don't call self.__setitem__ to avoid recursion errors
             super().__setitem__(_A						,					_A      )
       super().__setattr__(_A						,					_A      )






 def __setitem__(      self	:List[str]						,					_A	:Tuple						,					_A	:List[Any]      )					->      int:







       '''simple docstring'''



       super().__setitem__(_A						,					_A      )
       # Don't call self.__setattr__ to avoid recursion errors
       super().__setattr__(_A						,					_A      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      Tuple[Any]:







       '''simple docstring'''



       return tuple(self[k] for k in self.keys()      )












import argparse

import torch

from transformers import ChineseCLIPConfig, ChineseCLIPModel




def      __magic_name__							(					A						:   str,    A						:   List[str],    A						:   int  ):






			'''simple docstring'''







			a       ,						a       ,						a       =     pt_weights[F"""{prefix}.in_proj_weight"""].chunk(3,    dim=0  )
			a       ,						a       ,						a       =     pt_weights[F"""{prefix}.in_proj_bias"""].chunk(3,    dim=0  )

			a       =     pt_weights[F"""{prefix}.out_proj.weight"""]
			a       =     pt_weights[F"""{prefix}.out_proj.bias"""]

			a       =     q_proj
			a       =     q_proj_bias

			a       =     k_proj
			a       =     k_proj_bias

			a       =     v_proj
			a       =     v_proj_bias

			a       =     out_proj_weights
			a       =     out_proj_bias




def      __magic_name__							(					A						:   Optional[int],    A						:   str,    A						:   Union[str, Any]  ):






			'''simple docstring'''







			copy_linear(hf_mlp.fca,    A,    F"""{prefix}.c_fc"""  )
			copy_linear(hf_mlp.fca,    A,    F"""{prefix}.c_proj"""  )




def      __magic_name__							(					A						:   int,    A						:   Tuple,    A						:   Optional[int]  ):






			'''simple docstring'''







			a       =     pt_weights[F"""{prefix}.weight"""].data
			a       =     pt_weights[F"""{prefix}.bias"""].data




def      __magic_name__							(					A						:   List[Any],    A						:   List[str],    A						:   Any  ):






			'''simple docstring'''







			copy_linear(hf_layer.layer_norma,    A,    F"""{prefix}.ln_1"""  )
			copy_linear(hf_layer.layer_norma,    A,    F"""{prefix}.ln_2"""  )

			# copy MLP
			copy_mlp(hf_layer.mlp,    A,    F"""{prefix}.mlp"""  )

			# copy attn
			copy_attn_layer(hf_layer.self_attn,    A,    F"""{prefix}.attn"""  )




def      __magic_name__							(					A						:   int,    A						:   List[str],    A						:   Any  ):






			'''simple docstring'''







			for layer_id, hf_layer in enumerate(A  ):
						copy_layer(A,    A,    F"""{prefix}.{layer_id}"""  )




def      __magic_name__							(					A						:   Any,    A						:   Any  ):






			'''simple docstring'''







			a       =     pt_weights["text_projection"].data.T

			# copy text encoder
			for name, param in hf_model.text_model.named_parameters():
						a       =     pt_weights[F"""bert.{name}"""].data




def      __magic_name__							(					A						:   Union[str, Any],    A						:   Optional[Any]  ):






			'''simple docstring'''







			a       =     pt_weights["visual.proj"].data.T

			# copy layer norms
			copy_linear(hf_model.vision_model.pre_layrnorm,    A,    "visual.ln_pre"  )
			copy_linear(hf_model.vision_model.post_layernorm,    A,    "visual.ln_post"  )

			# copy embeddings
			a       =     pt_weights["visual.conv1.weight"].data
			a       =     pt_weights["visual.class_embedding"].data
			a       =     pt_weights["visual.positional_embedding"].data

			# copy encoder
			copy_layers(hf_model.vision_model.encoder.layers,    A,    "visual.transformer.resblocks"  )




@torch.no_grad()
def      __magic_name__							(					A						:   Optional[Any],    A						:   List[str],    A						:   Dict=None  ):






			'''simple docstring'''







			assert config_path is not None, "Please specify the ChineseCLIP model config of the corresponding model size."
			a       =     ChineseCLIPConfig.from_pretrained(A  )

			a       =     ChineseCLIPModel(A  ).eval()

			a       =     torch.load(A,    map_location="cpu"  )["state_dict"]
			a       =     {(name[7:] if name.startswith("module."  ) else name): value for name, value in pt_weights.items()}

			copy_text_model_and_projection(A,    A  )
			copy_vision_model_and_projection(A,    A  )
			a       =     pt_weights["logit_scale"].data

			hf_model.save_pretrained(A  )


if __name__ == "__main__":
		__lowerCAmelCase						:							Dict			     =						argparse.ArgumentParser()
		parser.add_argument(
		    '--pytorch_dump_folder_path',
		    default=None,
		    type=str,
		    help='Path to the output folder storing converted hf PyTorch model.',
		)
		parser.add_argument(
		    '--checkpoint_path', default=None, type=str, help='Path to original github format ChineseCLIP checkpoint.'
		)
		parser.add_argument(
		    '--config_path', default=None, required=True, type=str, help='Path to hf config.json of model to convert.'
		)
		__lowerCAmelCase						:							Dict			     =						parser.parse_args()

		convert_chinese_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)
		print('The conversion is finished!')






