





'''simple docstring'''




import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							Optional[int]						=	pt_attn_layer.in_proj_weight.chunk(3	,	dim=0					)
		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							str						=	pt_attn_layer.in_proj_bias.chunk(3	,	dim=0					)

		SCREAMING_SNAKE_CASE				:							Any						=	pt_attn_layer.out_proj.weight
		SCREAMING_SNAKE_CASE				:							Any						=	pt_attn_layer.out_proj.bias

		SCREAMING_SNAKE_CASE				:							Optional[int]						=	q_proj
		SCREAMING_SNAKE_CASE				:							List[Any]						=	q_proj_bias

		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	k_proj
		SCREAMING_SNAKE_CASE				:							int						=	k_proj_bias

		SCREAMING_SNAKE_CASE				:							str						=	v_proj
		SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	v_proj_bias

		SCREAMING_SNAKE_CASE				:							Dict						=	out_proj_weights
		SCREAMING_SNAKE_CASE				:							str						=	out_proj_bias



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



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



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							List[Any]						=	pt_linear.weight
		SCREAMING_SNAKE_CASE				:							List[Any]						=	pt_linear.bias



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""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 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



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



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	pt_model.token_embedding.weight
		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	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 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							str						=	pt_model.text_projection.data.T

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



def 						__A						(       lowerCamelCase_	,	lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							str						=	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
		SCREAMING_SNAKE_CASE				:							str						=	pt_model.visual.conva.weight.data
		SCREAMING_SNAKE_CASE				:							Tuple						=	pt_model.visual.class_embedding
		SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	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 						__A						(       lowerCamelCase_	,	lowerCamelCase_	,	lowerCamelCase_=None					):


		"""simple docstring"""



		if config_path is not None:
				SCREAMING_SNAKE_CASE				:							List[str]						=	CLIPConfig.from_pretrained(lowercase_					)
		else:
				SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	CLIPConfig(projection_dim=5_12	,	text_config={}	,	vision_config={}					)

		SCREAMING_SNAKE_CASE				:							str						=	CLIPModel(lowercase_					).eval()

		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							List[Any]						=	load(lowercase_	,	device="""cpu"""	,	jit=lowercase_					)
		SCREAMING_SNAKE_CASE				:							Tuple						=	pt_model.eval()

		copy_text_model_and_projection(lowercase_	,	lowercase_					)
		copy_vison_model_and_projection(lowercase_	,	lowercase_					)
		SCREAMING_SNAKE_CASE				:							Tuple						=	pt_model.logit_scale

		SCREAMING_SNAKE_CASE				:							List[str]						=	torch.arange(0	,	77					).unsqueeze(0					)
		SCREAMING_SNAKE_CASE				:							Dict						=	torch.randn(1	,	3	,	2_24	,	2_24					)

		SCREAMING_SNAKE_CASE				:							List[Any]						=	hf_model(input_ids=lowercase_	,	pixel_values=lowercase_	,	return_dict=lowercase_					)
		SCREAMING_SNAKE_CASE				:							Dict						=	hf_outputs.logits_per_image
		SCREAMING_SNAKE_CASE				:							List[Any]						=	hf_outputs.logits_per_text
		SCREAMING_SNAKE_CASE,    SCREAMING_SNAKE_CASE				:							Dict						=	pt_model(lowercase_	,	lowercase_					)

		assert torch.allclose(lowercase_	,	lowercase_	,	atol=1E-3					)
		assert torch.allclose(lowercase_	,	lowercase_	,	atol=1E-3					)

		hf_model.save_pretrained(lowercase_					)


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)










'''simple docstring'''




import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
							from PIL import Image




class       UpperCamelCase__			(			unittest.TestCase		,			lowercase_	):




					"""simple docstring"""


					def lowerCamelCase_	(		self							:	Any		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							int						=	load_tool("""image-captioning"""		)
							self.tool.setup()
							SCREAMING_SNAKE_CASE				:							str						=	load_tool("""image-captioning"""     ,		remote=lowerCamelCase_		)


					def lowerCamelCase_	(		self							:	List[Any]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""		)		) / """000000039769.png"""		)
							SCREAMING_SNAKE_CASE				:							Optional[int]						=	self.tool(lowerCamelCase_		)
							self.assertEqual(lowerCamelCase_     ,		"""two cats sleeping on a couch"""		)


					def lowerCamelCase_	(		self							:	str		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Optional[Any]						=	Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""		)		) / """000000039769.png"""		)
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	self.remote_tool(lowerCamelCase_		)
							self.assertEqual(lowerCamelCase_     ,		"""two cats sleeping on a couch"""		)


					def lowerCamelCase_	(		self							:	List[Any]		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""		)		) / """000000039769.png"""		)
							SCREAMING_SNAKE_CASE				:							str						=	self.tool(image=lowerCamelCase_		)
							self.assertEqual(lowerCamelCase_     ,		"""two cats sleeping on a couch"""		)



					def lowerCamelCase_	(		self							:	Any		):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	Image.open(Path(get_tests_dir("""fixtures/tests_samples/COCO"""		)		) / """000000039769.png"""		)
							SCREAMING_SNAKE_CASE				:							Optional[Any]						=	self.remote_tool(image=lowerCamelCase_		)
							self.assertEqual(lowerCamelCase_     ,		"""two cats sleeping on a couch"""		)



