





import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel





def   lowerCamelCase__   (   UpperCamelCase__	:				int				,			UpperCamelCase__	:				Optional[int]  )	->       List[Any]:



					'''simple docstring'''




					_snake_case							,   _snake_case							,   _snake_case													= pt_attn_layer.in_proj_weight.chunk(3				,			dim=0  )
					_snake_case							,   _snake_case							,   _snake_case													= pt_attn_layer.in_proj_bias.chunk(3				,			dim=0  )

					_snake_case													= pt_attn_layer.out_proj.weight
					_snake_case													= pt_attn_layer.out_proj.bias

					_snake_case													= q_proj
					_snake_case													= q_proj_bias

					_snake_case													= k_proj
					_snake_case													= k_proj_bias

					_snake_case													= v_proj
					_snake_case													= v_proj_bias

					_snake_case													= out_proj_weights
					_snake_case													= out_proj_bias





def   lowerCamelCase__   (   UpperCamelCase__	:				List[str]				,			UpperCamelCase__	:				Optional[Any]  )	->       Union[str, Any]:



					'''simple docstring'''




					copy_linear(hf_mlp.fca				,			pt_mlp.c_fc  )
					copy_linear(hf_mlp.fca				,			pt_mlp.c_proj  )





def   lowerCamelCase__   (   UpperCamelCase__	:				List[str]				,			UpperCamelCase__	:				Optional[Any]  )	->       List[Any]:



					'''simple docstring'''




					_snake_case													= pt_linear.weight
					_snake_case													= pt_linear.bias





def   lowerCamelCase__   (   UpperCamelCase__	:				Union[str, Any]				,			UpperCamelCase__	:				List[Any]  )	->       List[Any]:



					'''simple docstring'''




					copy_linear(hf_layer.layer_norma				,			pt_layer.ln_a  )
					copy_linear(hf_layer.layer_norma				,			pt_layer.ln_a  )

					# copy MLP
					copy_mlp(hf_layer.mlp				,			pt_layer.mlp  )

					# copy attn
					copy_attn_layer(hf_layer.self_attn				,			pt_layer.attn  )





def   lowerCamelCase__   (   UpperCamelCase__	:				List[Any]				,			UpperCamelCase__	:				Optional[Any]  )	->       List[Any]:



					'''simple docstring'''




					for hf_layer, pt_layer in zip(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_  ):
										copy_layer(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_  )





def   lowerCamelCase__   (   UpperCamelCase__	:				List[Any]				,			UpperCamelCase__	:				Union[str, Any]  )	->       Optional[Any]:



					'''simple docstring'''




					_snake_case													= pt_model.token_embedding.weight
					_snake_case													= pt_model.positional_embedding

					# copy layer norm
					copy_linear(hf_encoder.final_layer_norm				,			pt_model.ln_final  )

					# copy hidden layers
					copy_layers(hf_encoder.encoder.layers				,			pt_model.transformer.resblocks  )





def   lowerCamelCase__   (   UpperCamelCase__	:				List[Any]				,			UpperCamelCase__	:				Optional[Any]  )	->       Any:



					'''simple docstring'''




					_snake_case													= pt_model.text_projection.data.T

					# copy text encoder
					copy_encoder(hf_model.text_model				,			SCREAMING_SNAKE_CASE_  )





def   lowerCamelCase__   (   UpperCamelCase__	:				Optional[Any]				,			UpperCamelCase__	:				int  )	->       Any:



					'''simple docstring'''




					_snake_case													= pt_model.visual.proj.data.T

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

					# copy embeds
					_snake_case													= pt_model.visual.conva.weight.data
					_snake_case													= pt_model.visual.class_embedding
					_snake_case													= pt_model.visual.positional_embedding.data

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





@torch.no_grad()
def   lowerCamelCase__   (   UpperCamelCase__	:				List[str]				,			UpperCamelCase__	:				Optional[int]				,			UpperCamelCase__	:				List[str]=None  )	->       List[Any]:



					'''simple docstring'''




					if config_path is not None:
										_snake_case													= CLIPConfig.from_pretrained(SCREAMING_SNAKE_CASE_  )
					else:
										_snake_case													= CLIPConfig(projection_dim=512				,			text_config={}				,			vision_config={}  )

					_snake_case													= CLIPModel(SCREAMING_SNAKE_CASE_  ).eval()

					_snake_case							,   _snake_case													= load(SCREAMING_SNAKE_CASE_				,			device='cpu'				,			jit=SCREAMING_SNAKE_CASE_  )
					_snake_case													= pt_model.eval()

					copy_text_model_and_projection(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_  )
					copy_vison_model_and_projection(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_  )
					_snake_case													= pt_model.logit_scale

					_snake_case													= torch.arange(0				,			77  ).unsqueeze(0  )
					_snake_case													= torch.randn(1				,			3				,			224				,			224  )

					_snake_case													= hf_model(input_ids=SCREAMING_SNAKE_CASE_				,			pixel_values=SCREAMING_SNAKE_CASE_				,			return_dict=SCREAMING_SNAKE_CASE_  )
					_snake_case													= hf_outputs.logits_per_image
					_snake_case													= hf_outputs.logits_per_text
					_snake_case							,   _snake_case													= pt_model(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_  )

					assert torch.allclose(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_				,			atol=1e-3  )
					assert torch.allclose(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_				,			atol=1e-3  )

					hf_model.save_pretrained(SCREAMING_SNAKE_CASE_  )


if __name__ == "__main__":
					UpperCAmelCase_												=   argparse.ArgumentParser()
					parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
					parser.add_argument("""--checkpoint_path""", default=None, type=str, help="""Path to fairseq checkpoint""")
					parser.add_argument("""--config_path""", default=None, type=str, help="""Path to hf config.json of model to convert""")
					UpperCAmelCase_												=   parser.parse_args()

					convert_clip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)






from typing import Callable




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       )->		List[Any]:



    """simple docstring"""






    def wrapper(SCREAMING_SNAKE_CASE_       ):
        UpperCamelCase_          =		function_with_docstring.__doc__
        return target_function

    return wrapper
