




'''simple docstring'''





import argparse

import torch
from clip import load

from transformers import CLIPConfig, CLIPModel





def 			__a			(     _UpperCamelCase:					List[str]      ,		_UpperCamelCase:					Optional[Any]					)		->				Dict:

     """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 			__a			(     _UpperCamelCase:					List[str]      ,		_UpperCamelCase:					Dict					)		->				List[Any]:

     """simple docstring"""




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





def 			__a			(     _UpperCamelCase:					Optional[Any]      ,		_UpperCamelCase:					Dict					)		->				Union[str, Any]:

     """simple docstring"""




     _snake_case							=   pt_linear.weight
     _snake_case							=   pt_linear.bias





def 			__a			(     _UpperCamelCase:					Union[str, Any]      ,		_UpperCamelCase:					str					)		->				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 			__a			(     _UpperCamelCase:					Optional[int]      ,		_UpperCamelCase:					str					)		->				List[Any]:

     """simple docstring"""




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





def 			__a			(     _UpperCamelCase:					List[str]      ,		_UpperCamelCase:					Optional[Any]					)		->				List[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 			__a			(     _UpperCamelCase:					Tuple      ,		_UpperCamelCase:					str					)		->				Union[str, Any]:

     """simple docstring"""




     _snake_case							=   pt_model.text_projection.data.T

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





def 			__a			(     _UpperCamelCase:					List[str]      ,		_UpperCamelCase:					int					)		->				Union[str, 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 			__a			(     _UpperCamelCase:					List[Any]      ,		_UpperCamelCase:					List[Any]      ,		_UpperCamelCase:					int=None					)		->				Union[str, Any]:

     """simple docstring"""




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

     _snake_case							=   CLIPModel(_UpperCamelCase					).eval()

     _snake_case							,      _snake_case							=   load(_UpperCamelCase      ,		device="cpu"      ,		jit=_UpperCamelCase					)
     _snake_case							=   pt_model.eval()

     copy_text_model_and_projection(_UpperCamelCase      ,		_UpperCamelCase					)
     copy_vison_model_and_projection(_UpperCamelCase      ,		_UpperCamelCase					)
     _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=_UpperCamelCase      ,		pixel_values=_UpperCamelCase      ,		return_dict=_UpperCamelCase					)
     _snake_case							=   hf_outputs.logits_per_image
     _snake_case							=   hf_outputs.logits_per_text
     _snake_case							,      _snake_case							=   pt_model(_UpperCamelCase      ,		_UpperCamelCase					)

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

     hf_model.save_pretrained(_UpperCamelCase					)


if __name__ == "__main__":
   UpperCamelCase_		:    List[str]									=		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_		:    Optional[Any]									=		parser.parse_args()

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








'''simple docstring'''





import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


UpperCamelCase_		:    List[str]									=		500000

UpperCamelCase_			,			UpperCamelCase_		:    Dict									=		os.path.split(__file__)
UpperCamelCase_		:    int									=		os.path.join(RESULTS_BASEPATH, '''results''', RESULTS_FILENAME.replace('''.py''', '''.json'''))





@get_duration
def 			__a			(     _UpperCamelCase:					datasets.Dataset					)		->				List[Any]:

     """simple docstring"""




     _snake_case							=   dataset.select(range(0      ,		len(_UpperCamelCase					)      ,		2					)					)





@get_duration
def 			__a			(     _UpperCamelCase:					datasets.Dataset					)		->				List[Any]:

     """simple docstring"""




     _snake_case							=   dataset.sort("numbers"					)





@get_duration
def 			__a			(     _UpperCamelCase:					datasets.Dataset					)		->				List[Any]:

     """simple docstring"""




     _snake_case							=   dataset.shuffle()





@get_duration
def 			__a			(     _UpperCamelCase:					datasets.Dataset					)		->				Any:

     """simple docstring"""




     _snake_case							=   dataset.train_test_split(0.1					)





@get_duration
def 			__a			(     _UpperCamelCase:					datasets.Dataset      ,		_UpperCamelCase:					int=10					)		->				List[str]:

     """simple docstring"""




     for shard_id in range(_UpperCamelCase					):
          _snake_case							=   dataset.shard(_UpperCamelCase      ,		_UpperCamelCase					)





def 			__a			(     )		->				int:

     """simple docstring"""




     _snake_case							=   {"num examples": SPEED_TEST_N_EXAMPLES}
     _snake_case							=   (select, sort, shuffle, train_test_split, shard)
     with tempfile.TemporaryDirectory() as tmp_dir:
          print("generating dataset"					)
          _snake_case							=   datasets.Features({"text": datasets.Value("string"					), "numbers": datasets.Value("float32"					)}					)
          _snake_case							=   generate_example_dataset(
              os.path.join(_UpperCamelCase      ,		"dataset.arrow"					)      ,		_UpperCamelCase      ,		num_examples=_UpperCamelCase					)
          print("Functions"					)
          for func in functions:
               print(func.__name__					)
               _snake_case							=   func(_UpperCamelCase					)

     with open(_UpperCamelCase      ,		"wb"					) as f:
          f.write(json.dumps(_UpperCamelCase					).encode("utf-8"					)					)


if __name__ == "__main__":  # useful to run the profiler
   benchmark_indices_mapping()


