


import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel
def 							UpperCamelCase_  (				__snake_case			:						List[Any]	,			__snake_case			:						int     )->      Optional[Any]:




						'''simple docstring'''
						__magic_name__		,			__magic_name__		,			__magic_name__ 		=			pt_attn_layer.in_proj_weight.chunk(3	,			dim=0     )
						__magic_name__		,			__magic_name__		,			__magic_name__ 		=			pt_attn_layer.in_proj_bias.chunk(3	,			dim=0     )

						__magic_name__ 		=			pt_attn_layer.out_proj.weight
						__magic_name__ 		=			pt_attn_layer.out_proj.bias

						__magic_name__ 		=			q_proj
						__magic_name__ 		=			q_proj_bias

						__magic_name__ 		=			k_proj
						__magic_name__ 		=			k_proj_bias

						__magic_name__ 		=			v_proj
						__magic_name__ 		=			v_proj_bias

						__magic_name__ 		=			out_proj_weights
						__magic_name__ 		=			out_proj_bias
def 							UpperCamelCase_  (				__snake_case			:						Dict	,			__snake_case			:						Dict     )->      Optional[int]:




						'''simple docstring'''
						copy_linear(hf_mlp.fca	,			pt_mlp.c_fc     )
						copy_linear(hf_mlp.fca	,			pt_mlp.c_proj     )
def 							UpperCamelCase_  (				__snake_case			:						str	,			__snake_case			:						List[str]     )->      Union[str, Any]:




						'''simple docstring'''
						__magic_name__ 		=			pt_linear.weight
						__magic_name__ 		=			pt_linear.bias
def 							UpperCamelCase_  (				__snake_case			:						List[Any]	,			__snake_case			:						str     )->      Optional[int]:




						'''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 							UpperCamelCase_  (				__snake_case			:						int	,			__snake_case			:						Dict     )->      str:




						'''simple docstring'''
						for hf_layer, pt_layer in zip(__snake_case	,			__snake_case     ):
												copy_layer(__snake_case	,			__snake_case     )
def 							UpperCamelCase_  (				__snake_case			:						Any	,			__snake_case			:						Union[str, Any]     )->      List[Any]:




						'''simple docstring'''
						__magic_name__ 		=			pt_model.token_embedding.weight
						__magic_name__ 		=			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 							UpperCamelCase_  (				__snake_case			:						Dict	,			__snake_case			:						int     )->      List[Any]:




						'''simple docstring'''
						__magic_name__ 		=			pt_model.text_projection.data.T

						# copy text encoder
						copy_encoder(hf_model.text_model	,			__snake_case     )
def 							UpperCamelCase_  (				__snake_case			:						Dict	,			__snake_case			:						Optional[Any]     )->      List[Any]:




						'''simple docstring'''
						__magic_name__ 		=			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
						__magic_name__ 		=			pt_model.visual.conva.weight.data
						__magic_name__ 		=			pt_model.visual.class_embedding
						__magic_name__ 		=			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 							UpperCamelCase_  (				__snake_case			:						Optional[int]	,			__snake_case			:						int	,			__snake_case			:						Optional[int]=None     )->      str:




						'''simple docstring'''
						if config_path is not None:
												__magic_name__ 		=			CLIPConfig.from_pretrained(__snake_case     )
						else:
												__magic_name__ 		=			CLIPConfig(projection_dim=5_12	,			text_config={}	,			vision_config={}     )

						__magic_name__ 		=			CLIPModel(__snake_case     ).eval()

						__magic_name__		,			__magic_name__ 		=			load(__snake_case	,			device='cpu'	,			jit=__snake_case     )
						__magic_name__ 		=			pt_model.eval()

						copy_text_model_and_projection(__snake_case	,			__snake_case     )
						copy_vison_model_and_projection(__snake_case	,			__snake_case     )
						__magic_name__ 		=			pt_model.logit_scale

						__magic_name__ 		=			torch.arange(0	,			77     ).unsqueeze(0     )
						__magic_name__ 		=			torch.randn(1	,			3	,			2_24	,			2_24     )

						__magic_name__ 		=			hf_model(input_ids=__snake_case	,			pixel_values=__snake_case	,			return_dict=__snake_case     )
						__magic_name__ 		=			hf_outputs.logits_per_image
						__magic_name__ 		=			hf_outputs.logits_per_text
						__magic_name__		,			__magic_name__ 		=			pt_model(__snake_case	,			__snake_case     )

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

						hf_model.save_pretrained(__snake_case     )


if __name__ == "__main__":
					UpperCamelCase :				Optional[int]						    =       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 :				Tuple						    =       parser.parse_args()

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



import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class     __snake_case							(      _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:					Union[str, Any] 				= ["image_processor", "tokenizer"]
					SCREAMING_SNAKE_CASE_		:					Tuple 				= "AutoImageProcessor"
					SCREAMING_SNAKE_CASE_		:					Dict 				= "AutoTokenizer"
					def __init__(	self					:	List[str]  ,			_lowerCAmelCase					:	str=None  ,			_lowerCAmelCase					:	Dict=None  ,			**_lowerCAmelCase					:	List[str]     )       ->				Optional[int]:



											'''simple docstring'''





											__magic_name__ 		=			None
											if "feature_extractor" in kwargs:
																	warnings.warn(
																	    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
																	    ' instead.'  ,			_lowerCAmelCase  ,			)
																	__magic_name__ 		=			kwargs.pop('feature_extractor'     )

											__magic_name__ 		=			image_processor if image_processor is not None else feature_extractor
											if image_processor is None:
																	raise ValueError('You have to specify an image_processor.'     )
											if tokenizer is None:
																	raise ValueError('You have to specify a tokenizer.'     )

											super().__init__(_lowerCAmelCase  ,			_lowerCAmelCase     )
											__magic_name__ 		=			self.image_processor
					def __call__(	self					:	str  ,			_lowerCAmelCase					:	Any=None  ,			_lowerCAmelCase					:	int=None  ,			_lowerCAmelCase					:	List[str]=None  ,			**_lowerCAmelCase					:	int     )       ->				int:



											'''simple docstring'''





											if text is None and images is None:
																	raise ValueError('You have to specify either text or images. Both cannot be none.'     )

											if text is not None:
																	__magic_name__ 		=			self.tokenizer(_lowerCAmelCase  ,			return_tensors=_lowerCAmelCase  ,			**_lowerCAmelCase     )

											if images is not None:
																	__magic_name__ 		=			self.image_processor(_lowerCAmelCase  ,			return_tensors=_lowerCAmelCase  ,			**_lowerCAmelCase     )

											if text is not None and images is not None:
																	__magic_name__ 		=			image_features.pixel_values
																	return encoding
											elif text is not None:
																	return encoding
											else:
																	return BatchEncoding(data=dict(**_lowerCAmelCase     )  ,			tensor_type=_lowerCAmelCase     )
					def   a (	self					:	Optional[int]  ,			*_lowerCAmelCase					:	Optional[int]  ,			**_lowerCAmelCase					:	Optional[Any]     )       ->				Optional[int]:



											'''simple docstring'''





											return self.tokenizer.batch_decode(*_lowerCAmelCase  ,			**_lowerCAmelCase     )
					def   a (	self					:	Union[str, Any]  ,			*_lowerCAmelCase					:	str  ,			**_lowerCAmelCase					:	Tuple     )       ->				int:



											'''simple docstring'''





											return self.tokenizer.decode(*_lowerCAmelCase  ,			**_lowerCAmelCase     )
					@property
					def   a (	self					:	List[Any]     )       ->				Tuple:



											'''simple docstring'''





											__magic_name__ 		=			self.tokenizer.model_input_names
											__magic_name__ 		=			self.image_processor.model_input_names
											return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names     )     )
					@property
					def   a (	self					:	Optional[Any]     )       ->				Dict:



											'''simple docstring'''





											warnings.warn(
											    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'  ,			_lowerCAmelCase  ,			)
											return self.image_processor_class







					@property
					def   a (	self					:	Dict     )       ->				Tuple:



											'''simple docstring'''





											warnings.warn(
											    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'  ,			_lowerCAmelCase  ,			)
											return self.image_processor

